Merge remote-tracking branch 'origin/master' into pr-3017

# Conflicts: # include/modules/hyprland/workspaces.hpp # man/waybar-hyprland-workspaces.5.scd # src/modules/hyprland/workspaces.cpp
2026-07-04 00:55:38 +02:00
parent fe1d49518b 49f6edf67b
commit 8276f6a629
357 changed files with 22757 additions and 7219 deletions
@@ -15,15 +15,15 @@ Checks: >
  -readability-redundant-member-init,
  -readability-redundant-string-init,
  -readability-identifier-length
-CheckOptions:
-  - { key: readability-identifier-naming.NamespaceCase,          value: lower_case }
-  - { key: readability-identifier-naming.ClassCase,              value: CamelCase  }
-  - { key: readability-identifier-naming.StructCase,             value: CamelCase  }
-  - { key: readability-identifier-naming.FunctionCase,           value: camelBack  }
-  - { key: readability-identifier-naming.VariableCase,           value: camelBack  }
-  - { key: readability-identifier-naming.PrivateMemberCase,      value: camelBack  }
-  - { key: readability-identifier-naming.PrivateMemberSuffix,    value: _          }
-  - { key: readability-identifier-naming.EnumCase,               value: CamelCase  }
-  - { key: readability-identifier-naming.EnumConstantCase,       value: UPPER_CASE }
-  - { key: readability-identifier-naming.GlobalConstantCase,     value: UPPER_CASE }
-  - { key: readability-identifier-naming.StaticConstantCase,     value: UPPER_CASE }
+# CheckOptions:
+#   - { key: readability-identifier-naming.NamespaceCase,          value: lower_case }
+#   - { key: readability-identifier-naming.ClassCase,              value: CamelCase  }
+#   - { key: readability-identifier-naming.StructCase,             value: CamelCase  }
+#   - { key: readability-identifier-naming.FunctionCase,           value: camelBack  }
+#   - { key: readability-identifier-naming.VariableCase,           value: camelBack  }
+#   - { key: readability-identifier-naming.PrivateMemberCase,      value: camelBack  }
+#   - { key: readability-identifier-naming.PrivateMemberSuffix,    value: _          }
+#   - { key: readability-identifier-naming.EnumCase,               value: CamelCase  }
+#   - { key: readability-identifier-naming.EnumConstantCase,       value: UPPER_CASE }
+#   - { key: readability-identifier-naming.GlobalConstantCase,     value: UPPER_CASE }
+#   - { key: readability-identifier-naming.StaticConstantCase,     value: UPPER_CASE }
@@ -7,13 +7,12 @@ concurrency:
  cancel-in-progress: true

 jobs:
-  build:
+  lint:
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
-      - uses: DoozyX/clang-format-lint-action@v0.16.2
+      - uses: actions/checkout@v6
+      - uses: RafikFarhad/clang-format-github-action@v6
        name: clang-format
        with:
-          source: "."
-          extensions: "hpp,h,cpp,c"
-          clangFormatVersion: 16
+          sources: "src/**/*.hpp,src/**/*.cpp"
+          style: "file"
@@ -7,12 +7,12 @@ concurrency:
  cancel-in-progress: true

 jobs:
-  build:
+  lint:
    runs-on: ubuntu-latest
    container:
      image: alexays/waybar:debian
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
      - name: configure
        run: |
          meson -Dcpp_std=c++20 build  # necessary to generate compile_commands.json
@@ -0,0 +1,34 @@
+name: Build and Push Docker Image
+
+on:
+  workflow_dispatch:
+  schedule:
+    # run monthly
+    - cron: '0 0 1 * *'
+
+jobs:
+  build-and-push:
+    runs-on: ubuntu-latest
+    if: github.event_name != 'schedule' || github.repository == 'Alexays/Waybar'
+    strategy:
+      fail-fast: false # don't fail the other jobs if one of the images fails to build
+      matrix:
+        os: [ 'alpine', 'archlinux', 'debian', 'fedora', 'gentoo', 'opensuse' ]
+
+    steps:
+      - name: Checkout repository
+      - uses: actions/checkout@v6
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push Docker image
+        uses: docker/build-push-action@v5
+        with:
+          context: .
+          file: Dockerfiles/${{ matrix.os }}
+          push: true
+          tags: alexays/waybar:${{ matrix.os }}
@@ -7,30 +7,29 @@ concurrency:
  cancel-in-progress: true

 jobs:
-  clang:
+  build:
    # Run actions in a FreeBSD VM on the ubuntu runner
    # https://github.com/actions/runner/issues/385 - for FreeBSD runner support
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
      - name: Test in FreeBSD VM
-        uses: cross-platform-actions/action@v0.23.0
+        uses: cross-platform-actions/action@v0.28.0
        timeout-minutes: 180
        env:
          CPPFLAGS: '-isystem/usr/local/include'
          LDFLAGS: '-L/usr/local/lib'
        with:
          operating_system: freebsd
-          version: "13.2"
+          version: "14.2"
          environment_variables: CPPFLAGS LDFLAGS
          sync_files: runner-to-vm
          run: |
-            sudo sed -i '' 's/quarterly/latest/' /etc/pkg/FreeBSD.conf
            sudo pkg install -y git #  subprojects/date
            sudo 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 \
+              pkgconf pipewire pulseaudio scdoc sndio spdlog wayland-protocols upower \
              libinotify
-            meson build -Dman-pages=enabled
+            meson setup build -Dman-pages=enabled
            ninja -C build
            meson test -C build --no-rebuild --print-errorlogs --suite waybar
@@ -9,6 +9,7 @@ concurrency:
 jobs:
  build:
    strategy:
+      fail-fast: false
      matrix:
        distro:
          - alpine
@@ -24,9 +25,9 @@ jobs:
      image: alexays/waybar:${{ matrix.distro }}

    steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
      - name: configure
-        run: meson -Dman-pages=enabled -Dcpp_std=${{matrix.cpp_std}} build
+        run: meson setup -Dman-pages=enabled -Dcpp_std=${{matrix.cpp_std}} build
      - name: build
        run: ninja -C build
      - name: test
@@ -0,0 +1,20 @@
+name: "Nix-Tests"
+on:
+  pull_request:
+  push:
+concurrency:
+  group: ${{ github.workflow }}-nix-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+jobs:
+  nix-flake-check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - uses: cachix/install-nix-action@v31
+        with:
+          extra_nix_config: |
+            experimental-features = nix-command flakes
+            access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
+      - run: nix flake show
+      - run: nix flake check --print-build-logs
+      - run: nix build --print-build-logs
@@ -0,0 +1,22 @@
+name: update-flake-lock
+on:
+  workflow_dispatch: # allows manual triggering
+  schedule:
+    - cron: '0 0 1 * *' # Run monthly
+  push:
+    paths:
+      - 'flake.nix'
+jobs:
+  lockfile:
+    runs-on: ubuntu-latest
+    if: github.event_name != 'schedule' || github.repository == 'Alexays/Waybar'
+    steps:
+      - name: Checkout repository
+      - uses: actions/checkout@v6
+      - name: Install Nix
+        uses: cachix/install-nix-action@v31
+        with:
+          extra_nix_config: |
+            access-tokens = github.com=${{ secrets.GITHUB_TOKEN }}
+      - name: Update flake.lock
+        uses: DeterminateSystems/update-flake-lock@v28
@@ -7,6 +7,7 @@ vgcore.*
 *.swp
 packagecache
 /subprojects/**/
+/subprojects/.wraplock
 /build*
 /dist
 /meson.egg-info
@@ -48,3 +49,7 @@ packagecache
 # Nix
 result
 result-*
+
+.ccls-cache
+_codeql_detected_source_root
+heaptrack*
@@ -3,5 +3,5 @@
 FROM archlinux:base-devel

 RUN pacman -Syu --noconfirm && \
-    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 && \
+    pacman -S --noconfirm git meson base-devel libinput wayland wayland-protocols glib2-devel 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
@@ -1,6 +1,6 @@
 # vim: ft=Dockerfile

-FROM debian:sid
+FROM debian:sid-slim

 RUN apt update && \
    apt install --no-install-recommends --no-install-suggests -y \
@@ -34,7 +34,7 @@ RUN apt update && \
        libudev-dev \
        libupower-glib-dev \
        libwayland-dev \
-        libwireplumber-0.4-dev \
+        libwireplumber-0.5-dev \
        libxkbcommon-dev \
        libxkbregistry-dev \
        locales \
@@ -29,6 +29,6 @@ RUN dnf install -y @c-development \
    'pkgconfig(wayland-client)' \
    'pkgconfig(wayland-cursor)' \
    'pkgconfig(wayland-protocols)' \
-    'pkgconfig(wireplumber-0.4)' \
+    'pkgconfig(wireplumber-0.5)' \
    'pkgconfig(xkbregistry)' && \
    dnf clean all -y
@@ -6,6 +6,6 @@ RUN export FEATURES="-ipc-sandbox -network-sandbox -pid-sandbox -sandbox -usersa
 		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 \
+		USE="wayland gtk3 gtk -doc X pulseaudio minimal" emerge dev-vcs/git dev-libs/wayland dev-libs/wayland-protocols dev-cpp/gtkmm:3.0 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
@@ -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 playerctl-devel
+    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 python3-packaging
@@ -1,6 +1,6 @@
 MIT License

-Copyright (c) 2018 Alex
+Copyright (c) 2025 Alex

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -3,11 +3,11 @@
 default: build

 build:
-	meson build
+	meson setup build
 	ninja -C build

 build-debug:
-	meson build --buildtype=debug
+	meson setup build --buildtype=debug
 	ninja -C build

 install: build
@@ -20,8 +20,12 @@ debug-run: build-debug
 	./build/waybar --log-level debug

 test:
-	meson test -C build --no-rebuild --verbose --suite waybar
+	meson test -C build --verbose --suite waybar
 .PHONY: test

+test-detailed:
+	meson test -C build --verbose --print-errorlogs --test-args='--reporter console -s'
+.PHONY: test-detailed
+
 clean:
 	rm -rf build
@@ -8,7 +8,9 @@
 - Sway (Workspaces, Binding mode, Focused window name)
 - River (Mapping mode, Tags, Focused window name)
 - Hyprland (Window Icons, Workspaces, Focused window name)
- DWL (Tags) [requires dwl ipc patch](https://github.com/djpohly/dwl/wiki/ipc)
+- Niri (Workspaces, Focused window name, Language)
+- Mango (Workspaces, Focused window name, Language, Keymode)
+- DWL (Tags, Focused window name) [requires dwl ipc patch](https://codeberg.org/dwl/dwl-patches/src/branch/main/patches/ipc)
 - Tray [#21](https://github.com/Alexays/Waybar/issues/21)
 - Local time
 - Battery
@@ -48,7 +50,7 @@ An Ubuntu PPA with more recent versions is available
 ```bash
 $ git clone https://github.com/Alexays/Waybar
 $ cd Waybar
-$ meson build
+$ meson setup build
 $ ninja -C build
 $ ./build/waybar
 # If you want to install it
@@ -115,11 +117,45 @@ sudo apt install \
  libxkbregistry-dev
 ```

+On Arch, you can use this command:
+
+```
+pacman -S --asdeps \
+  gtkmm3 \
+  jsoncpp \
+  libsigc++ \
+  fmt \
+  wayland \
+  chrono-date \
+  spdlog \
+  gtk3 \
+  gobject-introspection \
+  libgirepository \
+  libpulse \
+  libnl \
+  libappindicator-gtk3 \
+  libdbusmenu-gtk3 \
+  libmpdclient \
+  sndio \
+  libevdev \
+  libxkbcommon \
+  upower \
+  meson \
+  cmake \
+  scdoc \
+  wayland-protocols \
+  glib2-devel
+```
+

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

+> [!CAUTION]
+> Distributions of Waybar are only released on the [official GitHub page](https://github.com/Alexays/Waybar).<br/>
+> Waybar does **not** have an official website. Do not trust any sites that claim to be official.
+
 ## License

 Waybar is licensed under the MIT license. [See LICENSE for more information](https://github.com/Alexays/Waybar/blob/master/LICENSE).
@@ -0,0 +1 @@
+.
@@ -0,0 +1,5 @@
+# Suppress common address sanitizer issues in dependencies, these are often non-fixable or not an issue.
+# Use it like this (when in repo root): ASAN_OPTIONS="suppressions=./asan.supp" ./build/waybar
+leak:libpangoft2-1.0.so.0
+leak:libgtk-3.so.0
+leak:libfontconfig.so.1
@@ -1,10 +1,9 @@
-(import
-  (
-    let lock = builtins.fromJSON (builtins.readFile ./flake.lock); in
+(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
+) { src = ./.; }).defaultNix
@@ -3,11 +3,11 @@
    "flake-compat": {
      "flake": false,
      "locked": {
-        "lastModified": 1696426674,
-        "narHash": "sha256-kvjfFW7WAETZlt09AgDn1MrtKzP7t90Vf7vypd3OL1U=",
+        "lastModified": 1767039857,
+        "narHash": "sha256-vNpUSpF5Nuw8xvDLj2KCwwksIbjua2LZCqhV1LNRDns=",
        "owner": "edolstra",
        "repo": "flake-compat",
-        "rev": "0f9255e01c2351cc7d116c072cb317785dd33b33",
+        "rev": "5edf11c44bc78a0d334f6334cdaf7d60d732daab",
        "type": "github"
      },
      "original": {
@@ -18,11 +18,11 @@
    },
    "nixpkgs": {
      "locked": {
-        "lastModified": 1704538339,
-        "narHash": "sha256-1734d3mQuux9ySvwf6axRWZRBhtcZA9Q8eftD6EZg6U=",
+        "lastModified": 1769461804,
+        "narHash": "sha256-msG8SU5WsBUfVVa/9RPLaymvi5bI8edTavbIq3vRlhI=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "46ae0210ce163b3cba6c7da08840c1d63de9c701",
+        "rev": "bfc1b8a4574108ceef22f02bafcf6611380c100d",
        "type": "github"
      },
      "original": {
@@ -9,59 +9,118 @@
    };
  };

-  outputs = { self, nixpkgs, ... }:
+  outputs =
+    { self, nixpkgs, ... }:
    let
      inherit (nixpkgs) lib;
-      genSystems = func: lib.genAttrs [
+      genSystems =
+        func:
+        lib.genAttrs
+          [
            "x86_64-linux"
            "aarch64-linux"
          ]
-        (system: func (import nixpkgs { inherit system; }));
+          (
+            system:
+            func (
+              import nixpkgs {
+                inherit system;
+                overlays = with self.overlays; [
+                  waybar
+                ];
+              }
+            )
+          );

-      mkDate = longDate: (lib.concatStringsSep "-" [
+      mkDate =
+        longDate:
+        (lib.concatStringsSep "-" [
          (builtins.substring 0 4 longDate)
          (builtins.substring 4 2 longDate)
          (builtins.substring 6 2 longDate)
        ]);
    in
    {
-      devShells = genSystems
-        (pkgs:
-          {
-            default =
-              pkgs.mkShell
-                {
+      devShells = genSystems (pkgs: {
+        default = pkgs.mkShell {
          name = "waybar-shell";

          # inherit attributes from upstream nixpkgs derivation
-                  inherit (pkgs.waybar) buildInputs depsBuildBuild depsBuildBuildPropagated depsBuildTarget
-                    depsBuildTargetPropagated depsHostHost depsHostHostPropagated depsTargetTarget
-                    depsTargetTargetPropagated propagatedBuildInputs propagatedNativeBuildInputs strictDeps;
+          inherit (pkgs.waybar)
+            buildInputs
+            depsBuildBuild
+            depsBuildBuildPropagated
+            depsBuildTarget
+            depsBuildTargetPropagated
+            depsHostHost
+            depsHostHostPropagated
+            depsTargetTarget
+            depsTargetTargetPropagated
+            propagatedBuildInputs
+            propagatedNativeBuildInputs
+            strictDeps
+            ;

          # overrides for local development
-                  nativeBuildInputs = pkgs.waybar.nativeBuildInputs ++ (with pkgs; [
+          nativeBuildInputs =
+            pkgs.waybar.nativeBuildInputs
+            ++ (with pkgs; [
+              nixfmt
              clang-tools
              gdb
            ]);
        };
      });

-      overlays.default = final: prev: {
+      formatter = genSystems (
+        pkgs:
+        pkgs.treefmt.withConfig {
+          settings = {
+            formatter = {
+              clang-format = {
+                options = [ "-i" ];
+                command = lib.getExe' pkgs.clang-tools "clang-format";
+                excludes = [ ];
+                includes = [
+                  "*.c"
+                  "*.cpp"
+                  "*.h"
+                  "*.hpp"
+                ];
+              };
+              nixfmt = {
+                command = lib.getExe pkgs.nixfmt;
+                includes = [ "*.nix" ];
+              };
+            };
+            tree-root-file = ".git/index";
+          };
+        }
+      );
+
+      overlays = {
+        default = self.overlays.waybar;
+        waybar = final: prev: {
          waybar = final.callPackage ./nix/default.nix {
+            waybar = prev.waybar;
            # take the first "version: '...'" from meson.build
            version =
-            (builtins.head (builtins.split "'"
-              (builtins.elemAt
-                (builtins.split " version: '" (builtins.readFile ./meson.build))
-                2)))
-            + "+date=" + (mkDate (self.lastModifiedDate or "19700101")) + "_" + (self.shortRev or "dirty");
+              (builtins.head (
+                builtins.split "'" (
+                  builtins.elemAt (builtins.split " version: '" (builtins.readFile ./meson.build)) 2
+                )
+              ))
+              + "+date="
+              + (mkDate (self.lastModifiedDate or "19700101"))
+              + "_"
+              + (self.shortRev or "dirty");
+          };
        };
      };

-      packages = genSystems (pkgs:
-        let packages = self.overlays.default pkgs pkgs;
-        in packages // {
-          default = packages.waybar;
+      packages = genSystems (pkgs: {
+        default = self.packages.${pkgs.stdenv.hostPlatform.system}.waybar;
+        inherit (pkgs) waybar;
      });
    };
 }
@@ -0,0 +1,57 @@
+#pragma once
+
+#include <glibmm/markup.h>
+#include <gtkmm/label.h>
+#include <json/json.h>
+
+#include <deque>
+#include <vector>
+
+#include "AModule.hpp"
+
+namespace waybar {
+
+enum class GraphType { LINE, BAR, GAUGE };
+
+class AGraph : public AModule {
+ public:
+  AGraph(const Json::Value&, const std::string&, const std::string&, uint16_t interval = 0,
+         bool enable_click = false, bool enable_scroll = false);
+  virtual ~AGraph() = default;
+  auto update() -> void override;
+
+ protected:
+  Gtk::DrawingArea graph_;
+  std::deque<int> values_;
+  uint16_t datapoints_ = 20;
+  GraphType graph_type_ = GraphType::LINE;
+
+  void addValue(const int n);
+
+  const std::chrono::seconds interval_;
+
+  bool onDraw(const Cairo::RefPtr<Cairo::Context>& cr);
+
+  std::map<std::string, GtkMenuItem*> submenus_;
+  std::map<std::string, std::string> menuActionsMap_;
+  static void handleGtkMenuEvent(GtkMenuItem* menuitem, gpointer data);
+
+ private:
+  void drawFilledArea(const Cairo::RefPtr<Cairo::Context>& cr,
+                      const std::vector<std::pair<double, double>>& points, double height,
+                      const Gdk::RGBA& bg_color);
+
+  void drawLine(const Cairo::RefPtr<Cairo::Context>& cr,
+                const std::vector<std::pair<double, double>>& points, const Gdk::RGBA& fg_color);
+
+  void drawPath(const Cairo::RefPtr<Cairo::Context>& cr,
+                const std::vector<std::pair<double, double>>& points);
+
+  void drawBars(const Cairo::RefPtr<Cairo::Context>& cr, double width, double height,
+                int current_value, const Gdk::RGBA& fg_color);
+
+  void drawGauge(const Cairo::RefPtr<Cairo::Context>& cr, double width, double height,
+                 int current_value, const Gdk::RGBA& fg_color);
+};
+
+}  // namespace waybar
@@ -14,10 +14,14 @@ class AIconLabel : public ALabel {
             bool enable_click = false, bool enable_scroll = false);
  virtual ~AIconLabel() = default;
  auto update() -> void override;
+  static std::tuple<std::string, std::string> extractIcon(const std::string& input);

 protected:
  Gtk::Image image_;
  Gtk::Box box_;
+  unsigned app_icon_size_{24};
+
+  bool label_contains_icon{false};

  bool iconEnabled() const;
 };
@@ -1,9 +1,15 @@
 #pragma once

+#include <fmt/args.h>
+#include <fmt/format.h>
 #include <glibmm/markup.h>
 #include <gtkmm/label.h>
 #include <json/json.h>

+#include <optional>
+#include <string>
+#include <utility>
+
 #include "AModule.hpp"

 namespace waybar {
@@ -21,12 +27,68 @@ class ALabel : public AModule {
 protected:
  Gtk::Label label_;
  std::string format_;
-  const std::chrono::seconds interval_;
+  const std::chrono::milliseconds interval_;
  bool alt_ = false;
  std::string default_format_;

+  bool setLabelMarkup(const Glib::ustring& markup);
+  bool setTooltipMarkup(const Glib::ustring& markup);
+
+  // resolveTooltipFormat() / resolveFormat() are inherited from AModule.
+
+  // Combined label + tooltip helper. Builds a single fmt argument store from
+  // `args`, renders `labelFormat` into the label and the resolved tooltip format
+  // into the tooltip, both through the dedup-aware setters. Honors the `tooltip`
+  // toggle. This replaces the label/tooltip formatting boilerplate that modules
+  // used to duplicate. `state` selects `tooltip-format-<state>` when non-empty.
+  template <typename... Args>
+  void updateLabelAndTooltipForState(const std::string& state, const std::string& labelFormat,
+                                     const std::string& tooltipDefault, Args&&... args) {
+    fmt::dynamic_format_arg_store<fmt::format_context> store;
+    (store.push_back(std::forward<Args>(args)), ...);
+    setLabelMarkup(fmt::vformat(labelFormat, store));
+    if (tooltipEnabled()) {
+      setTooltipMarkup(fmt::vformat(resolveTooltipFormat(tooltipDefault, state), store));
+    }
+  }
+
+  template <typename... Args>
+  void updateLabelAndTooltip(const std::string& labelFormat, const std::string& tooltipDefault,
+                             Args&&... args) {
+    updateLabelAndTooltipForState("", labelFormat, tooltipDefault, std::forward<Args>(args)...);
+  }
+
+  // Overloads accepting a pre-built argument store, for modules that must
+  // assemble a dynamic set of format arguments (e.g. per-core CPU stats) that
+  // cannot be expressed through a fixed variadic call.
+  // A non-const reference is used so this overload is preferred over the
+  // variadic template above (which would otherwise bind the store as a single
+  // forwarded argument).
+  void updateLabelAndTooltipForState(const std::string& state, const std::string& labelFormat,
+                                     const std::string& tooltipDefault,
+                                     fmt::dynamic_format_arg_store<fmt::format_context>& store) {
+    setLabelMarkup(fmt::vformat(labelFormat, store));
+    if (tooltipEnabled()) {
+      setTooltipMarkup(fmt::vformat(resolveTooltipFormat(tooltipDefault, state), store));
+    }
+  }
+
+  void updateLabelAndTooltip(const std::string& labelFormat, const std::string& tooltipDefault,
+                             fmt::dynamic_format_arg_store<fmt::format_context>& store) {
+    updateLabelAndTooltipForState("", labelFormat, tooltipDefault, store);
+  }
+
  bool handleToggle(GdkEventButton* const& e) override;
+  void copyToClipboard(const std::string&);
  virtual std::string getState(uint8_t value, bool lesser = false);
+
+  std::map<std::string, GtkMenuItem*> submenus_;
+  std::map<std::string, std::string> menuActionsMap_;
+  static void handleGtkMenuEvent(GtkMenuItem* menuitem, gpointer data);
+
+ private:
+  std::optional<Glib::ustring> last_label_markup_;
+  std::optional<Glib::ustring> last_tooltip_markup_;
 };

 }  // namespace waybar
@@ -1,10 +1,16 @@
 #pragma once

+#include <fmt/args.h>
+#include <fmt/format.h>
 #include <glibmm/dispatcher.h>
 #include <glibmm/markup.h>
+#include <gtkmm.h>
 #include <gtkmm/eventbox.h>
 #include <json/json.h>

+#include <string>
+#include <utility>
+
 #include "IModule.hpp"

 namespace waybar {
@@ -13,15 +19,21 @@ class AModule : public IModule {
 public:
  static constexpr const char* MODULE_CLASS = "module";

-  virtual ~AModule();
+  ~AModule() override;
  auto update() -> void override;
-  virtual auto refresh(int) -> void{};
+  virtual auto refresh(int shouldRefresh) -> void {};
  operator Gtk::Widget&() override;
  auto doAction(const std::string& name) -> void override;

  /// Emitting on this dispatcher triggers a update() call
  Glib::Dispatcher dp;

+  bool expandEnabled() const;
+
+  virtual void suspend() {};
+  virtual void resume() {};
+  bool shouldSuspend() const { return disable_on_sleep_; }
+
 protected:
  // Don't need to make an object directly
  // Derived classes are able to use it
@@ -31,22 +43,66 @@ class AModule : public IModule {
  enum SCROLL_DIR { NONE, UP, DOWN, LEFT, RIGHT };

  SCROLL_DIR getScrollDir(GdkEventScroll* e);
-  bool tooltipEnabled();
+  bool tooltipEnabled() const;

+  // --- Generic format/tooltip resolution (config-only, usable by any module,
+  // ALabel-derived or not). Prefers `<key>-<state>`, then `<key>`, then default.
+  std::string resolveFormat(const std::string& defaultFormat, const std::string& state = "") const {
+    if (!state.empty() && config_["format-" + state].isString()) {
+      return config_["format-" + state].asString();
+    }
+    if (config_["format"].isString()) {
+      return config_["format"].asString();
+    }
+    return defaultFormat;
+  }
+  std::string resolveTooltipFormat(const std::string& defaultFormat,
+                                   const std::string& state = "") const {
+    if (!state.empty() && config_["tooltip-format-" + state].isString()) {
+      return config_["tooltip-format-" + state].asString();
+    }
+    if (config_["tooltip-format"].isString()) {
+      return config_["tooltip-format"].asString();
+    }
+    return defaultFormat;
+  }
+
+  // Generic tooltip for any widget: honors the `tooltip` toggle and
+  // `tooltip-format`, formats with the given args and applies it. Lets modules
+  // that are not ALabel-derived (e.g. gamemode) reuse the shared logic.
+  template <typename... Args>
+  void updateTooltip(Gtk::Widget& widget, const std::string& defaultFormat, Args&&... args) {
+    if (!tooltipEnabled()) {
+      return;
+    }
+    widget.set_tooltip_markup(
+        fmt::format(fmt::runtime(resolveTooltipFormat(defaultFormat)), std::forward<Args>(args)...));
+  }
+
+  std::vector<int> pid_children_;
  const std::string name_;
  const Json::Value& config_;
  Gtk::EventBox event_box_;

+  virtual void setCursor(std::string const& c);
+
  virtual bool handleToggle(GdkEventButton* const& ev);
+  virtual bool handleMouseEnter(GdkEventCrossing* const& ev);
+  virtual bool handleMouseLeave(GdkEventCrossing* const& ev);
  virtual bool handleScroll(GdkEventScroll*);
  virtual bool handleRelease(GdkEventButton* const& ev);

+  bool disable_on_sleep_{false};
+  GObject* menu_ = nullptr;
+
 private:
  bool handleUserEvent(GdkEventButton* const& ev);
  const bool isTooltip;
-  std::vector<int> pid_;
+  const bool isExpand;
+  bool hasUserEvents_;
  gdouble distance_scrolled_y_;
  gdouble distance_scrolled_x_;
+  sigc::connection cursor_timeout_conn_;
  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"},
@@ -68,7 +124,8 @@ class AModule : public IModule {
      {std::make_pair(9, GdkEventType::GDK_BUTTON_PRESS), "on-click-forward"},
      {std::make_pair(9, GdkEventType::GDK_BUTTON_RELEASE), "on-click-forward-release"},
      {std::make_pair(9, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-forward"},
-      {std::make_pair(9, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click-forward"}};
+      {std::make_pair(9, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click-forward"},
+      {std::make_pair(10, GdkEventType::GDK_BUTTON_PRESS), "on-click-copy"}};
 };

 }  // namespace waybar
@@ -9,10 +9,12 @@
 #include <json/json.h>

 #include <memory>
+#include <optional>
 #include <vector>

 #include "AModule.hpp"
 #include "group.hpp"
+#include "util/kill_signal.hpp"
 #include "xdg-output-unstable-v1-client-protocol.h"

 namespace waybar {
@@ -53,7 +55,7 @@ class BarIpcClient;
 }
 #endif  // HAVE_SWAY

-class Bar {
+class Bar : public sigc::trackable {
 public:
  using bar_mode_map = std::map<std::string, struct bar_mode>;
  static const bar_mode_map PRESET_MODES;
@@ -65,9 +67,15 @@ class Bar {
  ~Bar();

  void setMode(const std::string& mode);
-  void setVisible(bool visible);
+  void setVisible(bool value);
  void toggle();
+  void show();
+  void hide();
  void handleSignal(int);
+  util::KillSignalAction getOnSigusr1Action();
+  util::KillSignalAction getOnSigusr2Action();
+
+  void toggleSuspend(bool suspend);

  struct waybar_output* output;
  Json::Value config;
@@ -93,6 +101,7 @@ class Bar {
  void setMode(const bar_mode&);
  void setPassThrough(bool passthrough);
  void setPosition(Gtk::PositionType position);
+  void forceLayerCommit();
  void onConfigure(GdkEventConfigure* ev);
  void configureGlobalOffset(int width, int height);
  void onOutputGeometryChanged();
@@ -117,6 +126,9 @@ class Bar {
  std::unique_ptr<BarIpcClient> _ipc_client;
 #endif
  std::vector<std::shared_ptr<waybar::AModule>> modules_all_;
+
+  waybar::util::KillSignalAction onSigusr1 = util::SIGNALACTION_DEFAULT_SIGUSR1;
+  waybar::util::KillSignalAction onSigusr2 = util::SIGNALACTION_DEFAULT_SIGUSR2;
 };

 }  // namespace waybar
@@ -12,6 +12,7 @@

 struct zwp_idle_inhibitor_v1;
 struct zwp_idle_inhibit_manager_v1;
+struct ext_idle_notifier_v1;

 namespace waybar {

@@ -27,6 +28,7 @@ class Client {
  struct wl_registry* registry = nullptr;
  struct zxdg_output_manager_v1* xdg_output_manager = nullptr;
  struct zwp_idle_inhibit_manager_v1* idle_inhibit_manager = nullptr;
+  struct ext_idle_notifier_v1* idle_notifier = nullptr;
  std::vector<std::unique_ptr<Bar>> bars;
  Config config;
  std::string bar_id;
@@ -44,6 +46,7 @@ class Client {
                           const char* interface, uint32_t version);
  static void handleGlobalRemove(void* data, struct wl_registry* registry, uint32_t name);
  static void handleOutputDone(void*, struct zxdg_output_v1*);
+  void createBarsBatch();
  static void handleOutputName(void*, struct zxdg_output_v1*, const char*);
  static void handleOutputDescription(void*, struct zxdg_output_v1*, const char*);
  void handleMonitorAdded(Glib::RefPtr<Gdk::Monitor> monitor);
@@ -56,6 +59,10 @@ class Client {
  std::list<struct waybar_output> outputs_;
  std::unique_ptr<CssReloadHelper> m_cssReloadHelper;
  std::string m_cssFile;
+  sigc::connection monitor_added_connection_;
+  sigc::connection monitor_removed_connection_;
+  std::list<waybar_output*> pending_outputs_;
+  bool bars_scheduled_ = false;
 };

 }  // namespace waybar
@@ -20,6 +20,9 @@ class Config {
  static std::optional<std::string> findConfigPath(
      const std::vector<std::string>& names, const std::vector<std::string>& dirs = CONFIG_DIRS);

+  static std::vector<std::string> tryExpandPath(const std::string& base,
+                                                const std::string& filename);
+
  Config() = default;

  void load(const std::string& config);
@@ -32,6 +35,8 @@ class Config {
  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_);
+  static std::vector<std::string> findIncludePath(
+      const std::string& name, const std::vector<std::string>& dirs = CONFIG_DIRS);

  std::string config_file_;

@@ -10,26 +10,33 @@
 namespace waybar {

 class Group : public AModule {
+  sigc::connection reveal_timeout_;
+
 public:
  Group(const std::string&, const std::string&, const Json::Value&, bool);
-  virtual ~Group() = default;
+  ~Group() override = default;
  auto update() -> void override;
  operator Gtk::Widget&() override;

  virtual Gtk::Box& getBox();
  void addWidget(Gtk::Widget& widget);

-  bool handleMouseHover(GdkEventCrossing* const& e);
-
 protected:
  Gtk::Box box;
  Gtk::Box revealer_box;
  Gtk::Revealer revealer;
  bool is_first_widget = true;
  bool is_drawer = false;
+  bool click_to_reveal = false;
+  bool empty_if_drawer_empty = false;
+  int reveal_delay = 0;
  std::string add_class_to_drawer_children;
-
-  void addHoverHandlerTo(Gtk::Widget& widget);
+  bool handleMouseEnter(GdkEventCrossing* const& ev) override;
+  bool handleMouseLeave(GdkEventCrossing* const& ev) override;
+  bool handleToggle(GdkEventButton* const& ev) override;
+  bool handleScroll(GdkEventScroll* e) override;
+  void show_group();
+  void hide_group();
 };

 }  // namespace waybar
@@ -6,8 +6,10 @@
 #if defined(__linux__)
 #include <sys/inotify.h>
 #endif
+#include <poll.h>

 #include <algorithm>
+#include <chrono>
 #include <fstream>
 #include <string>
 #include <vector>
@@ -15,6 +17,7 @@
 #include "ALabel.hpp"
 #include "bar.hpp"
 #include "util/sleeper_thread.hpp"
+#include "util/udev_deleter.hpp"

 namespace waybar::modules {

@@ -32,19 +35,28 @@ class Battery : public ALabel {
  void refreshBatteries();
  void worker();
  const std::string getAdapterStatus(uint8_t capacity) const;
-  const std::tuple<uint8_t, float, std::string, float> getInfos();
+  std::tuple<uint8_t, float, std::string, float, uint16_t, float> getInfos();
  const std::string formatTimeRemaining(float hoursRemaining);
  void setBarClass(std::string&);
+  void processEvents(std::string& state, std::string& status, uint8_t capacity);

-  int global_watch;
  std::map<fs::path, int> batteries_;
+  std::unique_ptr<udev, util::UdevDeleter> udev_;
+  std::array<pollfd, 1> poll_fds_;
+  std::unique_ptr<udev_monitor, util::UdevMonitorDeleter> mon_;
  fs::path adapter_;
  int battery_watch_fd_;
-  int global_watch_fd_;
  std::mutex battery_list_mutex_;
  std::string old_status_;
+  std::string last_event_;
  bool warnFirstTime_{true};
+  bool weightedAverage_{true};
  const Bar& bar_;
+  bool smoothPowerEnable_{false};
+  double time_constant_s_{260.0};
+  double smooth_power_{0.0};  // µW
+  std::chrono::steady_clock::time_point last_t_{std::chrono::steady_clock::now()};
+  std::string old_status_raw_{""};

  util::SleeperThread thread_;
  util::SleeperThread thread_battery_update_;
@@ -41,6 +41,7 @@ class Bluetooth : public ALabel {
    bool services_resolved;
    // NOTE: experimental feature in bluez
    std::optional<unsigned char> battery_percentage;
+    std::optional<unsigned char> battery_percentage_peripheral;
  };

 public:
@@ -49,6 +50,9 @@ class Bluetooth : public ALabel {
  auto update() -> void override;

 private:
+  static auto onObjectAdded(GDBusObjectManager*, GDBusObject*, gpointer) -> void;
+  static auto onObjectRemoved(GDBusObjectManager*, GDBusObject*, gpointer) -> void;
+
  static auto onInterfaceAddedOrRemoved(GDBusObjectManager*, GDBusObject*, GDBusInterface*,
                                        gpointer) -> void;
  static auto onInterfaceProxyPropertiesChanged(GDBusObjectManagerClient*, GDBusObjectProxy*,
@@ -56,6 +60,12 @@ class Bluetooth : public ALabel {
                                                gpointer) -> void;

  auto getDeviceBatteryPercentage(GDBusObject*) -> std::optional<unsigned char>;
+  auto getDeviceGattBatteryLevels(GDBusObject*, std::optional<unsigned char>&,
+                                  std::optional<unsigned char>&) -> void;
+  static auto processBatteryServiceCharacteristics(GList*, const std::string&, const std::string&,
+                                                   const std::string&,
+                                                   std::optional<unsigned char>&,
+                                                   std::optional<unsigned char>&) -> void;
  auto getDeviceProperties(GDBusObject*, DeviceInfo&) -> bool;
  auto getControllerProperties(GDBusObject*, ControllerInfo&) -> bool;

@@ -1,49 +0,0 @@
-#pragma once
-
-#include "ALabel.hpp"
-#include "util/sleeper_thread.hpp"
-
-namespace cava {
-extern "C" {
-#include <cava/common.h>
-}
-}  // namespace cava
-
-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 cava::error_s error_ {};          // cava errors
-  struct cava::config_params prm_ {};      // cava parameters
-  struct cava::audio_raw audio_raw_ {};    // cava handled raw audio data(is based on audio_data)
-  struct cava::audio_data audio_data_ {};  // cava audio data
-  struct cava::cava_plan* plan_;           //{new cava_plan{}};
-  // Cava API to read audio source
-  cava::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};
-  bool hide_on_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
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <epoxy/gl.h>
+
+#include "AModule.hpp"
+#include "cava_backend.hpp"
+
+namespace waybar::modules::cava {
+
+class CavaGLSL final : public AModule, public Gtk::GLArea {
+ public:
+  CavaGLSL(const std::string&, const Json::Value&);
+  ~CavaGLSL() = default;
+
+ private:
+  std::shared_ptr<CavaBackend> backend_;
+  struct ::cava::config_params prm_;
+  int frame_counter{0};
+  bool silence_{false};
+  bool hide_on_silence_{false};
+  // Cava method
+  auto onUpdate(const ::cava::audio_raw& input) -> void;
+  auto onSilence() -> void;
+  // Member variable to store the shared pointer
+  std::shared_ptr<::cava::audio_raw> m_data_;
+  GLuint shaderProgram_;
+  // OpenGL variables
+  GLuint fbo_;
+  GLuint texture_;
+  GLint uniform_bars_;
+  GLint uniform_previous_bars_;
+  GLint uniform_bars_count_;
+  GLint uniform_time_;
+  // Methods
+  void onRealize();
+  bool onRender(const Glib::RefPtr<Gdk::GLContext>& context);
+
+  void initShaders();
+  void initSurface();
+  void initGLSL();
+  GLuint loadShader(const std::string& fileName, GLenum type);
+};
+}  // namespace waybar::modules::cava
@@ -0,0 +1,30 @@
+#pragma once
+
+#include "ALabel.hpp"
+#include "cava_backend.hpp"
+
+namespace waybar::modules::cava {
+
+class Cava final : public ALabel, public sigc::trackable {
+ public:
+  Cava(const std::string&, const Json::Value&);
+  ~Cava() = default;
+  auto doAction(const std::string& name) -> void override;
+
+ private:
+  std::shared_ptr<CavaBackend> backend_;
+  // Text to display
+  Glib::ustring label_text_{""};
+  bool silence_{false};
+  bool hide_on_silence_{false};
+  std::string format_silent_{""};
+  int ascii_range_{0};
+  // Cava method
+  void pause_resume();
+  auto onUpdate(const std::string& input) -> void;
+  auto onSilence() -> void;
+  // ModuleActionMap
+  static inline std::map<const std::string, void (waybar::modules::cava::Cava::* const)()>
+      actionMap_{{"mode", &waybar::modules::cava::Cava::pause_resume}};
+};
+}  // namespace waybar::modules::cava
@@ -0,0 +1,84 @@
+#pragma once
+
+#include <json/json.h>
+#include <sigc++/sigc++.h>
+
+#include "util/sleeper_thread.hpp"
+
+namespace cava {
+extern "C" {
+// Need sdl_glsl output feature to be enabled on libcava
+#ifndef SDL_GLSL
+#define SDL_GLSL
+#endif
+
+#include <cava/common.h>
+
+#ifdef SDL_GLSL
+#undef SDL_GLSL
+#endif
+}
+}  // namespace cava
+
+namespace waybar::modules::cava {
+using namespace std::literals::chrono_literals;
+
+class CavaBackend final {
+ public:
+  static std::shared_ptr<CavaBackend> inst(const Json::Value& config);
+
+  virtual ~CavaBackend();
+  // Methods
+  int getAsciiRange();
+  void doPauseResume();
+  void Update();
+  const struct ::cava::config_params* getPrm();
+  std::chrono::milliseconds getFrameTimeMilsec();
+
+  // Signal accessor
+  using type_signal_update = sigc::signal<void(const std::string&)>;
+  type_signal_update signal_update();
+  using type_signal_audio_raw_update = sigc::signal<void(const ::cava::audio_raw&)>;
+  type_signal_audio_raw_update signal_audio_raw_update();
+  using type_signal_silence = sigc::signal<void()>;
+  type_signal_silence signal_silence();
+
+ private:
+  CavaBackend(const Json::Value& config);
+  util::SleeperThread read_thread_;
+  util::SleeperThread out_thread_;
+
+  // Cava API to read audio source
+  ::cava::ptr input_source_{NULL};
+
+  struct ::cava::error_s error_{};          // cava errors
+  struct ::cava::config_params prm_{};      // cava parameters
+  struct ::cava::audio_raw audio_raw_{};    // cava handled raw audio data(is based on audio_data)
+  struct ::cava::audio_data audio_data_{};  // cava audio data
+  struct ::cava::cava_plan* plan_{NULL};    //{new cava_plan{}};
+
+  std::chrono::seconds fetch_input_delay_{4};
+  // Delay to handle audio source
+  std::chrono::milliseconds frame_time_milsec_{1s};
+
+  const Json::Value& config_;
+  int re_paint_{0};
+  bool silence_{false};
+  bool silence_prev_{false};
+  std::chrono::seconds suspend_silence_delay_{0};
+  int sleep_counter_{0};
+  std::string output_{};
+  // Methods
+  void invoke();
+  void execute();
+  bool isSilence();
+  void doUpdate(bool force = false);
+  void loadConfig();
+  void freeBackend();
+
+  // Signal
+  type_signal_update m_signal_update_;
+  type_signal_audio_raw_update m_signal_audio_raw_;
+  type_signal_silence m_signal_silence_;
+};
+}  // namespace waybar::modules::cava
@@ -0,0 +1,27 @@
+#pragma once
+
+#ifdef HAVE_LIBCAVA
+#include "cavaRaw.hpp"
+#include "cava_backend.hpp"
+#ifdef HAVE_LIBCAVAGLSL
+#include "cavaGLSL.hpp"
+#endif
+#endif
+
+namespace waybar::modules::cava {
+AModule* getModule(const std::string& id, const Json::Value& config) {
+#ifdef HAVE_LIBCAVA
+  const std::shared_ptr<CavaBackend> backend_{waybar::modules::cava::CavaBackend::inst(config)};
+  switch (backend_->getPrm()->output) {
+#ifdef HAVE_LIBCAVAGLSL
+    case ::cava::output_method::OUTPUT_SDL_GLSL:
+      return new waybar::modules::cava::CavaGLSL(id, config);
+#endif
+    default:
+      return new waybar::modules::cava::Cava(id, config);
+  }
+#else
+  throw std::runtime_error("Unknown module");
+#endif
+};
+}  // namespace waybar::modules::cava
@@ -21,10 +21,12 @@ class Clock final : public ALabel {
  auto doAction(const std::string&) -> void override;

 private:
-  const std::locale locale_;
+  const std::locale m_locale_;
  // tooltip
-  const std::string tlpFmt_;
-  std::string tlpText_{""};  // tooltip text to print
+  const std::string m_tlpFmt_;
+  std::string m_tlpText_{""};                 // tooltip text to print
+  const Glib::RefPtr<Gtk::Label> m_tooltip_;  // tooltip as a separate Gtk::Label
+  bool query_tlp_cb(int, int, bool, const Glib::RefPtr<Gtk::Tooltip>& tooltip);
  // Calendar
  const bool cldInTooltip_;  // calendar in tooltip
  /*
@@ -40,44 +42,56 @@ class Clock final : public ALabel {
  int cldWnLen_{3};                    // calendar week number length
  const int cldMonColLen_{20};         // calendar month column length
  WS cldWPos_{WS::HIDDEN};             // calendar week side to print
-  months cldCurrShift_{0};       // calendar months shift
-  year_month_day cldYearShift_;  // calendar Year mode. Cached ymd
+  date::months cldCurrShift_{0};       // calendar months shift
+  int cldShift_{1};                    // calendar months shift factor
+  date::year_month_day cldYearShift_;  // calendar Year mode. Cached ymd
  std::string cldYearCached_;          // calendar Year mode. Cached calendar
-  year_month cldMonShift_;       // calendar Month mode. Cached ym
+  date::year_month cldMonShift_;       // calendar Month mode. Cached ym
  std::string cldMonCached_;           // calendar Month mode. Cached calendar
-  day cldBaseDay_{0};            // calendar Cached day. Is used when today is changing(midnight)
+  date::day cldBaseDay_{0};      // calendar Cached day. Is used when today is changing(midnight)
  std::string cldText_{""};      // calendar text to print
+  bool iso8601Calendar_{false};  // whether the calendar is in ISO8601
  CldMode cldMode_{CldMode::MONTH};
-  auto get_calendar(const year_month_day& today, const year_month_day& ymd, const time_zone* tz)
-      -> const std::string;
+  auto get_calendar(const date::year_month_day& today, const date::year_month_day& ymd,
+                    const date::time_zone* tz) -> const std::string;
+
+  // get local time zone
+  auto local_zone() -> const date::time_zone*;

  // time zoned time in tooltip
  const bool tzInTooltip_;                      // if need to print time zones text
-  std::vector<const time_zone*> tzList_;  // time zones list
+  std::vector<const date::time_zone*> tzList_;  // time zones list
  int tzCurrIdx_;                               // current time zone index for tzList_
  std::string tzText_{""};                      // time zones text to print
+  std::string tzTooltipFormat_{""};             // optional timezone tooltip format
  util::SleeperThread thread_;

  // ordinal date in tooltip
  const bool ordInTooltip_;
  std::string ordText_{""};
-  auto get_ordinal_date(const year_month_day& today) -> std::string;
+  auto get_ordinal_date(const date::year_month_day& today) -> std::string;

-  auto getTZtext(sys_seconds now) -> std::string;
-  auto first_day_of_week() -> weekday;
+  auto getTZtext(date::sys_seconds now) -> std::string;
+  auto first_day_of_week() -> date::weekday;
  // Module actions
  void cldModeSwitch();
  void cldShift_up();
  void cldShift_down();
+  void cldShift_reset();
  void tz_up();
  void tz_down();
+  void action_exec(const std::string& action);
  // Module Action Map
  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},
+      {"shift_reset", &waybar::modules::Clock::cldShift_reset},
      {"tz_up", &waybar::modules::Clock::tz_up},
      {"tz_down", &waybar::modules::Clock::tz_down}};
+  static inline std::map<const std::string,
+                         void (waybar::modules::Clock::* const)(const std::string& action)>
+      actionWithArgsMap_{{"exec", &waybar::modules::Clock::action_exec}};
 };

 }  // namespace waybar::modules
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <fmt/format.h>
+
+#include <cstdint>
+#include <fstream>
+#include <numeric>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "AGraph.hpp"
+#include "util/sleeper_thread.hpp"
+
+namespace waybar::modules {
+
+class CpuGraph : public AGraph {
+ public:
+  CpuGraph(const std::string&, const Json::Value&);
+  virtual ~CpuGraph() = default;
+  auto update() -> void override;
+
+ private:
+  static constexpr const char* MODERATE_CLASS = "cpu-moderate";
+  static constexpr const char* HIGH_CLASS = "cpu-high";
+  static constexpr const char* INTENSIVE_CLASS = "cpu-intensive";
+
+  std::vector<std::tuple<size_t, size_t>> prev_times_;
+  util::SleeperThread thread_;
+};
+
+}  // namespace waybar::modules
@@ -5,14 +5,14 @@
 #include <csignal>
 #include <string>

-#include "ALabel.hpp"
+#include "AIconLabel.hpp"
 #include "util/command.hpp"
 #include "util/json.hpp"
 #include "util/sleeper_thread.hpp"

 namespace waybar::modules {

-class Custom : public ALabel {
+class Custom : public AIconLabel {
 public:
  Custom(const std::string&, const std::string&, const Json::Value&, const std::string&);
  virtual ~Custom();
@@ -35,6 +35,11 @@ class Custom : public ALabel {
  std::string id_;
  std::string alt_;
  std::string tooltip_;
+  std::string last_tooltip_markup_;
+  std::string image_path_;
+  std::string image_name_;
+  unsigned app_icon_size_{24};
+  const bool tooltip_format_enabled_;
  std::vector<std::string> class_;
  int percentage_;
  FILE* fp_;
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <fmt/format.h>
+
+#include <csignal>
+#include <string>
+
+#include "AGraph.hpp"
+#include "util/command.hpp"
+#include "util/json.hpp"
+#include "util/sleeper_thread.hpp"
+
+namespace waybar::modules {
+
+class CustomGraph : public AGraph {
+ public:
+  CustomGraph(const std::string&, const std::string&, const Json::Value&, const std::string&);
+  virtual ~CustomGraph();
+  auto update() -> void override;
+  void refresh(int /*signal*/) override;
+
+ private:
+  void delayWorker();
+  void continuousWorker();
+  void waitingWorker();
+  void parseOutputRaw();
+  void parseOutputJson();
+  void handleEvent();
+  bool handleScroll(GdkEventScroll* e) override;
+  bool handleToggle(GdkEventButton* const& e) override;
+
+  const std::string name_;
+  const std::string output_name_;
+  std::string text_;
+  std::string id_;
+  std::string alt_;
+  std::string tooltip_;
+  const bool tooltip_format_enabled_;
+  std::vector<std::string> class_;
+  int percentage_;
+  FILE* fp_;
+  int pid_;
+  util::command::res output_;
+  util::JsonParser parser_;
+
+  util::SleeperThread thread_;
+};
+
+}  // namespace waybar::modules
@@ -4,6 +4,7 @@
 #include <sys/statvfs.h>

 #include <fstream>
+#include <vector>

 #include "ALabel.hpp"
 #include "util/format.hpp"
@@ -19,10 +20,12 @@ class Disk : public ALabel {

 private:
  util::SleeperThread thread_;
-  std::string path_;
+  std::string header_;
+  std::vector<std::string> paths_;
+  std::string separator_;
  std::string unit_;

-  float calc_specific_divisor(const std::string divisor);
+  float calc_specific_divisor(const std::string& divisor);
 };

 }  // namespace waybar::modules
@@ -21,6 +21,8 @@ class Tags : public waybar::AModule {
  void handle_primary_clicked(uint32_t tag);
  bool handle_button_press(GdkEventButton* event_button, uint32_t tag);

+  void handle_active_output(zdwl_ipc_output_v2* zdwl_output_v2, uint32_t active);
+
  struct zdwl_ipc_manager_v2* status_manager_;
  struct wl_seat* seat_;

@@ -28,6 +30,7 @@ class Tags : public waybar::AModule {
  const waybar::Bar& bar_;
  Gtk::Box box_;
  std::vector<Gtk::Button> buttons_;
+  bool hide_vacant_;
  struct zdwl_ipc_output_v2* output_status_;
 };

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <fmt/format.h>
+
+#include <string>
+
+#include "AAppIconLabel.hpp"
+#include "bar.hpp"
+#include "dwl-ipc-unstable-v2-client-protocol.h"
+#include "util/json.hpp"
+
+namespace waybar::modules::dwl {
+
+class Window : public AAppIconLabel, public sigc::trackable {
+ public:
+  Window(const std::string&, const waybar::Bar&, const Json::Value&);
+  ~Window();
+
+  void handle_layout(const uint32_t layout);
+  void handle_title(const char* title);
+  void handle_appid(const char* ppid);
+  void handle_active(const uint32_t active);
+  void handle_layout_symbol(const char* layout_symbol);
+  void handle_frame();
+
+  struct zdwl_ipc_manager_v2* status_manager_;
+
+ private:
+  const Bar& bar_;
+
+  std::string title_;
+  std::string appid_;
+  std::string layout_symbol_;
+  bool active_;
+  bool hide_inactive_;
+  bool hide_empty_;
+  uint32_t layout_;
+
+  struct zdwl_ipc_output_v2* output_status_;
+};
+
+}  // namespace waybar::modules::dwl
@@ -0,0 +1,141 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <gtkmm/button.h>
+#include <gtkmm/image.h>
+#include <gtkmm/label.h>
+
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "ext-workspace-v1-client-protocol.h"
+
+namespace waybar::modules::ext {
+
+class WorkspaceGroup;
+class Workspace;
+
+class WorkspaceManager final : public AModule {
+ public:
+  WorkspaceManager(const std::string& id, const waybar::Bar& bar, const Json::Value& config);
+  ~WorkspaceManager() override;
+  void register_manager(wl_registry* registry, uint32_t name, uint32_t version);
+  void remove_workspace_group(uint32_t id);
+  void remove_workspace(uint32_t id);
+  void set_needs_sorting() { needs_sorting_ = true; }
+
+  // wl events
+  void handle_workspace_group(ext_workspace_group_handle_v1* handle);
+  void handle_workspace(ext_workspace_handle_v1* handle);
+  void handle_done();
+  void handle_finished();
+
+  // wl requests
+  void commit() const;
+
+ private:
+  void update() override;
+  bool has_button(const Gtk::Button* button);
+  void sort_workspaces();
+  void clear_buttons();
+  void update_buttons();
+
+  static uint32_t group_global_id;
+  static uint32_t workspace_global_id;
+  uint32_t workspace_name = 0;
+
+  bool sort_by_id_ = false;
+  bool sort_by_name_ = true;
+  bool sort_by_coordinates_ = false;
+  bool all_outputs_ = false;
+
+  const waybar::Bar& bar_;
+  Gtk::Box box_;
+
+  ext_workspace_manager_v1* ext_manager_ = nullptr;
+  std::vector<std::unique_ptr<WorkspaceGroup>> groups_;
+  std::vector<std::unique_ptr<Workspace>> workspaces_;
+
+  bool needs_sorting_ = false;
+};
+
+class WorkspaceGroup {
+ public:
+  WorkspaceGroup(WorkspaceManager& manager, ext_workspace_group_handle_v1* handle, uint32_t id);
+  ~WorkspaceGroup();
+
+  u_int32_t id() const { return id_; }
+  bool has_output(const wl_output* output);
+  bool has_workspace(const ext_workspace_handle_v1* workspace);
+
+  // wl events
+  void handle_capabilities(uint32_t capabilities);
+  void handle_output_enter(wl_output* output);
+  void handle_output_leave(wl_output* output);
+  void handle_workspace_enter(ext_workspace_handle_v1* handle);
+  void handle_workspace_leave(ext_workspace_handle_v1* handle);
+  void handle_removed();
+
+ private:
+  WorkspaceManager& workspaces_manager_;
+  ext_workspace_group_handle_v1* ext_handle_;
+  uint32_t id_;
+  std::vector<wl_output*> outputs_;
+  std::vector<ext_workspace_handle_v1*> workspaces_;
+};
+
+class Workspace {
+ public:
+  Workspace(const Json::Value& config, WorkspaceManager& manager, ext_workspace_handle_v1* handle,
+            uint32_t id, const std::string& name);
+  ~Workspace();
+
+  ext_workspace_handle_v1* handle() const { return ext_handle_; }
+  u_int32_t id() const { return id_; }
+  std::string& workspace_id() { return workspace_id_; }
+  std::string& name() { return name_; }
+  std::vector<u_int32_t>& coordinates() { return coordinates_; }
+  Gtk::Button& button() { return button_; }
+  void update();
+
+  // wl events
+  void handle_id(const std::string& id);
+  void handle_name(const std::string& name);
+  void handle_coordinates(const std::vector<uint32_t>& coordinates);
+  void handle_state(uint32_t state);
+  void handle_capabilities(uint32_t capabilities);
+  void handle_removed();
+
+  // gdk events
+  bool handle_clicked(const GdkEventButton* button) const;
+
+ private:
+  bool has_state(uint32_t state) const { return (state_ & state) == state; }
+  std::string icon();
+
+  WorkspaceManager& workspace_manager_;
+  ext_workspace_handle_v1* ext_handle_ = nullptr;
+  uint32_t id_;
+  uint32_t state_ = 0;
+  std::string workspace_id_;
+  std::string name_;
+  std::vector<uint32_t> coordinates_;
+
+  bool active_only_ = false;
+  bool ignore_hidden_ = true;
+  std::string format_;
+  bool with_icon_ = false;
+  static std::map<std::string, std::string> icon_map_;
+  std::string on_click_action_;
+  std::string on_click_middle_action_;
+  std::string on_click_right_action_;
+
+  Gtk::Button button_;
+  Gtk::Box content_;
+  Gtk::Label label_;
+};
+
+}  // namespace waybar::modules::ext
@@ -0,0 +1,10 @@
+#include "ext-workspace-v1-client-protocol.h"
+
+namespace waybar::modules::ext {
+void add_registry_listener(void* data);
+void add_workspace_listener(ext_workspace_handle_v1* workspace_handle, void* data);
+void add_workspace_group_listener(ext_workspace_group_handle_v1* workspace_group_handle,
+                                  void* data);
+ext_workspace_manager_v1* workspace_manager_bind(wl_registry* registry, uint32_t name,
+                                                 uint32_t version, void* data);
+}  // namespace waybar::modules::ext
@@ -26,7 +26,7 @@ class Gamemode : public AModule {
  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 = "";
+  const std::string DEFAULT_GLYPH = "󰊴";

  void appear(const Glib::RefPtr<Gio::DBus::Connection>& connection, const Glib::ustring& name,
              const Glib::ustring& name_owner);
@@ -0,0 +1,40 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <sys/statvfs.h>
+
+#ifdef WANT_RFKILL
+#include "util/rfkill.hpp"
+#endif
+
+#include <gps.h>
+
+#include "ALabel.hpp"
+#include "util/sleeper_thread.hpp"
+
+namespace waybar::modules {
+
+class Gps : public ALabel {
+ public:
+  Gps(const std::string&, const Json::Value&);
+  virtual ~Gps();
+  auto update() -> void override;
+
+ private:
+#ifdef WANT_RFKILL
+  util::Rfkill rfkill_;
+#endif
+  const std::string getFixModeName() const;
+  const std::string getFixModeString() const;
+
+  const std::string getFixStatusString() const;
+
+  util::SleeperThread thread_, gps_thread_;
+  gps_data_t gps_data_;
+  std::string state_;
+
+  bool hideDisconnected = true;
+  bool hideNoFix = false;
+};
+
+}  // namespace waybar::modules
@@ -1,9 +1,12 @@
 #pragma once

+#include <atomic>
+#include <filesystem>
 #include <list>
-#include <memory>
 #include <mutex>
+#include <optional>
 #include <string>
+#include <thread>
 #include <utility>

 #include "util/json.hpp"
@@ -16,25 +19,50 @@ class EventHandler {
  virtual ~EventHandler() = default;
 };

+/// If you want to use the Hyprland IPC, simply use IPC::inst() to get the singleton instance.
+/// Do not create multiple instances.
 class IPC {
+ protected:
+  IPC();  // use IPC::inst() instead.
+
 public:
-  IPC() { startIPC(); }
+  ~IPC();
+  static IPC& inst();

  void registerForIPC(const std::string& ev, EventHandler* ev_handler);
  void unregisterForIPC(EventHandler* handler);

  static std::string getSocket1Reply(const std::string& rq);
  Json::Value getSocket1JsonReply(const std::string& rq);
+  static std::filesystem::path getSocketFolder(const char* instanceSig);
+
+  /// Dispatch a Hyprland command. Automatically uses the correct protocol
+  /// (legacy text or Lua-based) depending on the running Hyprland version.
+  static std::string dispatch(const std::string& dispatcher, const std::string& arg);
+
+  /// Build a Lua-format dispatch command string.
+  static std::string buildLuaDispatch(const std::string& dispatcher, const std::string& arg);
+
+ protected:
+  static std::filesystem::path socketFolder_;
+
+  /// Detect whether the running Hyprland uses the Lua-based IPC protocol.
+  /// Returns true for Hyprland >= 0.54 (Lua config), false for older versions.
+  static bool isLuaProtocol();
+
+  static std::optional<bool> s_luaProtocolDetected_;  // cached detection result

 private:
-  void startIPC();
+  void socketListener();
  void parseIPC(const std::string&);

+  std::thread ipcThread_;
  std::mutex callbackMutex_;
+  std::mutex socketMutex_;
  util::JsonParser parser_;
  std::list<std::pair<std::string, EventHandler*>> callbacks_;
+  int socketfd_ = -1;  // the hyprland socket file descriptor
+  pid_t socketOwnerPid_ = -1;
+  std::atomic<bool> running_ = true;  // the ipcThread will stop running when this is false
 };
-
-inline std::unique_ptr<IPC> gIPC;
-inline bool modulesReady = false;
 };  // namespace waybar::modules::hyprland
@@ -30,6 +30,8 @@ class Language : public waybar::ALabel, public EventHandler {
    std::string short_description;
  };

+  auto removeXkbLayoutCssClass() -> void;
+  auto addXkbLayoutCssClass() -> void;
  static auto getLayout(const std::string&) -> Layout;

  std::mutex mutex_;
@@ -37,6 +39,8 @@ class Language : public waybar::ALabel, public EventHandler {
  util::JsonParser parser_;

  Layout layout_;
+
+  IPC& m_ipc;
 };

 }  // namespace waybar::modules::hyprland
@@ -19,12 +19,20 @@ class Submap : public waybar::ALabel, public EventHandler {
  auto update() -> void override;

 private:
+  auto parseConfig(const Json::Value&) -> void;
  void onEvent(const std::string& ev) override;

  std::mutex mutex_;
  const Bar& bar_;
  util::JsonParser parser_;
  std::string submap_;
+  std::string icon_;
+  std::string prev_submap_;
+  bool always_on_ = false;
+  std::string default_submap_ = "Default";
+  std::unordered_map<std::string, std::string> icons_;
+
+  IPC& m_ipc;
 };

 }  // namespace waybar::modules::hyprland
@@ -20,8 +20,8 @@ class Window : public waybar::AAppIconLabel, public EventHandler {

 private:
  struct Workspace {
-    int id;
-    int windows;
+    int id = 0;
+    int windows = 0;
    std::string last_window;
    std::string last_window_title;

@@ -29,14 +29,14 @@ class Window : public waybar::AAppIconLabel, public EventHandler {
  };

  struct WindowData {
-    bool floating;
+    bool floating = false;
    int monitor = -1;
    std::string class_name;
    std::string initial_class_name;
    std::string title;
    std::string initial_title;
-    bool fullscreen;
-    bool grouped;
+    bool fullscreen = false;
+    bool grouped = false;

    static auto parse(const Json::Value&) -> WindowData;
  };
@@ -47,7 +47,7 @@ class Window : public waybar::AAppIconLabel, public EventHandler {
  void queryActiveWorkspace();
  void setClass(const std::string&, bool enable);

-  bool separateOutputs_;
+  bool separateOutputs_ = false;
  std::mutex mutex_;
  const Bar& bar_;
  util::JsonParser parser_;
@@ -55,11 +55,13 @@ class Window : public waybar::AAppIconLabel, public EventHandler {
  Workspace workspace_;
  std::string soloClass_;
  std::string lastSoloClass_;
-  bool solo_;
-  bool allFloating_;
-  bool swallowing_;
-  bool fullscreen_;
-  bool focused_;
+  bool solo_ = false;
+  bool allFloating_ = false;
+  bool swallowing_ = false;
+  bool fullscreen_ = false;
+  bool focused_ = false;
+
+  IPC& m_ipc;
 };

 }  // namespace waybar::modules::hyprland
@@ -0,0 +1,41 @@
+#pragma once
+
+#include <fmt/format.h>
+
+#include <string>
+
+#include "AAppIconLabel.hpp"
+#include "bar.hpp"
+#include "modules/hyprland/backend.hpp"
+
+namespace waybar::modules::hyprland {
+
+class WindowCount : public waybar::AAppIconLabel, public EventHandler {
+ public:
+  WindowCount(const std::string&, const waybar::Bar&, const Json::Value&);
+  ~WindowCount() override;
+
+  auto update() -> void override;
+
+ private:
+  struct Workspace {
+    int id;
+    int windows;
+    bool hasfullscreen;
+    static auto parse(const Json::Value& value) -> Workspace;
+  };
+
+  auto getActiveWorkspace(const std::string&) -> Workspace;
+  auto getActiveWorkspace() -> Workspace;
+  void onEvent(const std::string& ev) override;
+  void queryActiveWorkspace();
+  void setClass(const std::string&, bool enable);
+
+  bool separateOutputs_;
+  std::mutex mutex_;
+  const Bar& bar_;
+  Workspace workspace_;
+  IPC& m_ipc;
+};
+
+}  // namespace waybar::modules::hyprland
@@ -0,0 +1,76 @@
+#pragma once
+
+#include <gtkmm/button.h>
+#include <gtkmm/label.h>
+#include <json/value.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <optional>
+#include <regex>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "modules/hyprland/backend.hpp"
+#include "util/enum.hpp"
+#include "util/regex_collection.hpp"
+
+using WindowAddress = std::string;
+
+namespace waybar::modules::hyprland {
+
+class Workspaces;
+
+struct WindowRepr {
+  std::string address;
+  std::string window_class;
+  std::string window_title;
+  std::string repr_rewrite;
+  bool isActive = false;
+
+ public:
+  bool empty() const { return address.empty(); }
+  void setActive(bool value) { isActive = value; }
+};
+
+class WindowCreationPayload {
+ public:
+  WindowCreationPayload(const std::string& workspace_name, WindowAddress window_address,
+                        WindowRepr window_repr);
+  WindowCreationPayload(const std::string& workspace_name, WindowAddress window_address,
+                        const std::string& window_class, const std::string& window_title,
+                        bool is_active);
+  WindowCreationPayload(Json::Value const& client_data);
+
+  int incrementTimeSpentUncreated();
+  bool isEmpty(Workspaces& workspace_manager);
+  bool reprIsReady() const { return std::holds_alternative<Repr>(m_window); }
+  WindowRepr repr(Workspaces& workspace_manager);
+  void setActive(bool value) { m_isActive = value; }
+
+  std::string getWorkspaceName() const { return m_workspaceName; }
+  WindowAddress getAddress() const { return m_windowAddress; }
+
+  void moveToWorkspace(std::string& new_workspace_name);
+
+ private:
+  void clearAddr();
+  void clearWorkspaceName();
+
+  using Repr = WindowRepr;
+  using ClassAndTitle = std::pair<std::string, std::string>;
+  std::variant<Repr, ClassAndTitle> m_window;
+
+  WindowAddress m_windowAddress;
+  std::string m_workspaceName;
+  bool m_isActive = false;
+
+  int m_timeSpentUncreated = 0;
+};
+
+}  // namespace waybar::modules::hyprland
@@ -0,0 +1,110 @@
+#pragma once
+
+#include <gtkmm/button.h>
+#include <gtkmm/label.h>
+#include <json/value.h>
+
+#include <cstddef>
+#include <cstdint>
+#include <map>
+#include <memory>
+#include <optional>
+#include <regex>
+#include <string>
+#include <variant>
+#include <vector>
+
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "modules/hyprland/backend.hpp"
+#include "modules/hyprland/windowcreationpayload.hpp"
+#include "util/enum.hpp"
+#include "util/regex_collection.hpp"
+
+using WindowAddress = std::string;
+
+namespace waybar::modules::hyprland {
+
+class Workspaces;
+class Workspace {
+ public:
+  explicit Workspace(const Json::Value& workspace_data, Workspaces& workspace_manager,
+                     const Json::Value& clients_data = Json::Value::nullRef);
+  ~Workspace();
+  std::string& selectString(std::map<std::string, std::string>& string_map);
+  Gtk::Button& button() { return m_button; };
+
+  int id() const { return m_id; };
+  std::string name() const { return m_name; };
+  std::string output() const { return m_output; };
+  bool isActive() const { return m_isActive; };
+  bool isSpecial() const { return m_isSpecial; };
+  bool isPersistent() const { return m_isPersistentRule || m_isPersistentConfig; };
+  bool isPersistentConfig() const { return m_isPersistentConfig; };
+  bool isPersistentRule() const { return m_isPersistentRule; };
+  bool isVisible() const { return m_isVisible; };
+  bool isUrgent() const { return m_isUrgent; };
+
+  bool handleClicked(GdkEventButton* bt) const;
+
+  bool handleEnter(GdkEventCrossing* event);
+  bool handleLeave(GdkEventCrossing* event);
+
+  void startHoverCheck();
+  void stopHoverCheck();
+  bool syncHoverClass();
+  bool pointerInsideButton();
+
+  void setActive(bool value = true) { m_isActive = value; };
+  void setPersistentRule(bool value = true) { m_isPersistentRule = value; };
+  void setPersistentConfig(bool value = true) { m_isPersistentConfig = value; };
+  void setUrgent(bool value = true) { m_isUrgent = value; };
+  void setVisible(bool value = true) { m_isVisible = value; };
+  void setWindows(uint value) { m_windows = value; };
+  void setName(std::string const& value) { m_name = value; };
+  void setOutput(std::string const& value) { m_output = value; };
+  bool containsWindow(WindowAddress const& addr) const {
+    return std::ranges::any_of(m_windowMap,
+                               [&addr](const auto& window) { return window.address == addr; });
+  };
+  void insertWindow(WindowCreationPayload create_window_payload);
+  void initializeWindowMap(const Json::Value& clients_data);
+  void setActiveWindow(WindowAddress const& addr);
+
+  bool onWindowOpened(WindowCreationPayload const& create_window_payload);
+  std::optional<WindowRepr> closeWindow(WindowAddress const& addr);
+
+  void update(const std::string& workspace_icon, const std::string& workspace_tooltip);
+
+ private:
+  Workspaces& m_workspaceManager;
+
+  int m_id;
+  std::string m_name;
+  std::string m_prevNameClass;
+  std::string m_output;
+  uint m_windows;
+  bool m_isActive = false;
+  bool m_isSpecial = false;
+  bool m_isPersistentRule = false;    // represents the persistent state in hyprland
+  bool m_isPersistentConfig = false;  // represents the persistent state in the Waybar config
+  bool m_isUrgent = false;
+  bool m_isVisible = false;
+
+  sigc::connection m_hoverCheckConnection;
+
+  std::vector<WindowRepr> m_windowMap;
+
+  Gtk::Button m_button;
+  Gtk::Box m_content;
+  Gtk::Label m_labelBefore;
+  Gtk::Label m_labelAfter;
+
+  bool isEmpty() const;
+  void updateTaskbar(const std::string& workspace_icon);
+  bool handleClick(const GdkEventButton* event_button, WindowAddress const& addr) const;
+  bool shouldSkipWindow(const WindowRepr& window_repr) const;
+  IPC& m_ipc;
+};
+
+}  // namespace waybar::modules::hyprland
@@ -1,23 +1,26 @@
 #pragma once

 #include <gtkmm/button.h>
+#include <gtkmm/enums.h>
 #include <gtkmm/label.h>
 #include <json/value.h>
+#include <sigc++/connection.h>

-#include <cstddef>
 #include <cstdint>
 #include <map>
 #include <memory>
 #include <optional>
 #include <regex>
 #include <string>
-#include <variant>
 #include <vector>

 #include "AModule.hpp"
 #include "bar.hpp"
 #include "modules/hyprland/backend.hpp"
+#include "modules/hyprland/windowcreationpayload.hpp"
+#include "modules/hyprland/workspace.hpp"
 #include "util/enum.hpp"
+#include "util/icon_loader.hpp"
 #include "util/regex_collection.hpp"

 using WindowAddress = std::string;
@@ -26,97 +29,6 @@ namespace waybar::modules::hyprland {

 class Workspaces;

-class WindowCreationPayload {
- public:
-  WindowCreationPayload(std::string workspace_name, WindowAddress window_address,
-                        std::string window_repr);
-  WindowCreationPayload(std::string workspace_name, WindowAddress window_address,
-                        std::string window_class, std::string window_title);
-  WindowCreationPayload(Json::Value const& client_data);
-
-  int incrementTimeSpentUncreated();
-  bool isEmpty(Workspaces& workspace_manager);
-  bool reprIsReady() const { return std::holds_alternative<Repr>(m_window); }
-  std::string repr(Workspaces& workspace_manager);
-
-  std::string getWorkspaceName() const { return m_workspaceName; }
-  WindowAddress getAddress() const { return m_windowAddress; }
-
-  void moveToWorksace(std::string& new_workspace_name);
-
- private:
-  void clearAddr();
-  void clearWorkspaceName();
-
-  using Repr = std::string;
-  using ClassAndTitle = std::pair<std::string, std::string>;
-  std::variant<Repr, ClassAndTitle> m_window;
-
-  WindowAddress m_windowAddress;
-  std::string m_workspaceName;
-
-  int m_timeSpentUncreated = 0;
-};
-
-class Workspace {
- public:
-  explicit Workspace(const Json::Value& workspace_data, Workspaces& workspace_manager,
-                     const Json::Value& clients_data = Json::Value::nullRef);
-  std::string& selectString(std::map<std::string, std::string>& string_map);
-  Gtk::Button& button() { return m_button; };
-
-  int id() const { return m_id; };
-  std::string name() const { return m_name; };
-  std::string output() const { return m_output; };
-  bool isActive() const { return m_isActive; };
-  bool isSpecial() const { return m_isSpecial; };
-  bool isPersistent() const { return m_isPersistentRule || m_isPersistentConfig; };
-  bool isPersistentConfig() const { return m_isPersistentConfig; };
-  bool isPersistentRule() const { return m_isPersistentRule; };
-  bool isVisible() const { return m_isVisible; };
-  bool isEmpty() const { return m_windows == 0; };
-  bool isUrgent() const { return m_isUrgent; };
-
-  bool handleClicked(GdkEventButton* bt) const;
-  void setActive(bool value = true) { m_isActive = value; };
-  void setPersistentRule(bool value = true) { m_isPersistentRule = value; };
-  void setPersistentConfig(bool value = true) { m_isPersistentConfig = value; };
-  void setUrgent(bool value = true) { m_isUrgent = value; };
-  void setVisible(bool value = true) { m_isVisible = value; };
-  void setWindows(uint value) { m_windows = value; };
-  void setName(std::string const& value) { m_name = value; };
-  void setOutput(std::string const& value) { m_output = value; };
-  bool containsWindow(WindowAddress const& addr) const { return m_windowMap.contains(addr); }
-  void insertWindow(WindowCreationPayload create_window_paylod);
-  std::string removeWindow(WindowAddress const& addr);
-  void initializeWindowMap(const Json::Value& clients_data);
-
-  bool onWindowOpened(WindowCreationPayload const& create_window_paylod);
-  std::optional<std::string> closeWindow(WindowAddress const& addr);
-
-  void update(const std::string& format, const std::string& icon, const std::string &tooltipFormat);
-
- private:
-  Workspaces& m_workspaceManager;
-
-  int m_id;
-  std::string m_name;
-  std::string m_output;
-  uint m_windows;
-  bool m_isActive = false;
-  bool m_isSpecial = false;
-  bool m_isPersistentRule = false;    // represents the persistent state in hyprland
-  bool m_isPersistentConfig = false;  // represents the persistent state in the Waybar config
-  bool m_isUrgent = false;
-  bool m_isVisible = false;
-
-  std::map<WindowAddress, std::string> m_windowMap;
-
-  Gtk::Button m_button;
-  Gtk::Box m_content;
-  Gtk::Label m_label;
-};
-
 class Workspaces : public AModule, public EventHandler {
 public:
  Workspaces(const std::string&, const waybar::Bar&, const Json::Value&);
@@ -127,34 +39,74 @@ class Workspaces : public AModule, public EventHandler {
  auto allOutputs() const -> bool { return m_allOutputs; }
  auto showSpecial() const -> bool { return m_showSpecial; }
  auto activeOnly() const -> bool { return m_activeOnly; }
+  auto hideActive() const -> bool { return m_hideActive; }
+  auto specialVisibleOnly() const -> bool { return m_specialVisibleOnly; }
+  auto persistentOnly() const -> bool { return m_persistentOnly; }
+  auto moveToMonitor() const -> bool { return m_moveToMonitor; }
+  auto enableTaskbar() const -> bool { return m_enableTaskbar; }
+  auto taskbarWithIcon() const -> bool { return m_taskbarWithIcon; }
+  auto barScroll() const -> bool { return m_barScroll; }

  auto getBarOutput() const -> std::string { return m_bar.output->name; }
+  auto formatBefore() const -> std::string { return m_formatBefore; }
+  auto formatAfter() const -> std::string { return m_formatAfter; }
+  auto taskbarFormatBefore() const -> std::string { return m_taskbarFormatBefore; }
+  auto taskbarFormatAfter() const -> std::string { return m_taskbarFormatAfter; }
+  auto taskbarIconSize() const -> int { return m_taskbarIconSize; }
+  auto taskbarOrientation() const -> Gtk::Orientation { return m_taskbarOrientation; }
+  auto taskbarReverseDirection() const -> bool { return m_taskbarReverseDirection; }
+  auto onClickWindow() const -> std::string { return m_onClickWindow; }
+  auto getIgnoredWindows() const -> std::vector<std::regex> { return m_ignoreWindows; }
+  auto maxWindows() const -> int { return m_maxWindows; }

-  std::string getRewrite(std::string window_class, std::string window_title);
+  enum class ActiveWindowPosition { NONE, FIRST, LAST };
+  auto activeWindowPosition() const -> ActiveWindowPosition { return m_activeWindowPosition; }
+
+  std::string getRewrite(const std::string& window_class, const std::string& window_title);
  std::string& getWindowSeparator() { return m_formatWindowSeparator; }
+  auto windowRewriteGroupThreshold() const -> int { return m_windowRewriteGroupThreshold; }
+  auto const& getWindowRewriteGroupFormat() const { return m_windowRewriteGroupFormat; }
  bool isWorkspaceIgnored(std::string const& workspace_name);

  bool windowRewriteConfigUsesTitle() const { return m_anyWindowRewriteRuleUsesTitle; }
+  const IconLoader& iconLoader() const { return m_iconLoader; }

 private:
  void onEvent(const std::string& e) override;
  void updateWindowCount();
+  void sortSpecialCentered();
  void sortWorkspaces();
-  void createWorkspace(Json::Value const& workspaceData,
-                       Json::Value const& clientsData = Json::Value::nullRef);
-  void removeWorkspace(std::string const& name);
+  void createWorkspace(Json::Value const& workspace_data,
+                       Json::Value const& clients_data = Json::Value::nullRef);
+
+  static Json::Value createMonitorWorkspaceData(std::string const& name,
+                                                std::string const& monitor);
+  void removeWorkspace(std::string const& workspaceString);
  void setUrgentWorkspace(std::string const& windowaddress);
+
+  // Config
  void parseConfig(const Json::Value& config);
+  auto populateIconsMap(const Json::Value& formatIcons) -> void;
+  static auto populateBoolConfig(const Json::Value& config, const std::string& key, bool& member)
+      -> void;
+  auto populateSortByConfig(const Json::Value& config) -> void;
+  auto populateIgnoreWorkspacesConfig(const Json::Value& config) -> void;
+  auto populateFormatWindowSeparatorConfig(const Json::Value& config) -> void;
+  auto populateWindowRewriteConfig(const Json::Value& config) -> void;
+  auto populateMaxWindowsConfig(const Json::Value& config) -> void;
+  auto populateWorkspaceTaskbarConfig(const Json::Value& config) -> void;
+
  void registerIpc();

  // workspace events
  void onWorkspaceActivated(std::string const& payload);
  void onSpecialWorkspaceActivated(std::string const& payload);
  void onWorkspaceDestroyed(std::string const& payload);
-  void onWorkspaceCreated(std::string const& workspaceName,
+  void onWorkspaceCreated(std::string const& payload,
                          Json::Value const& clientsData = Json::Value::nullRef);
  void onWorkspaceMoved(std::string const& payload);
  void onWorkspaceRenamed(std::string const& payload);
+  static std::optional<int> parseWorkspaceId(std::string const& workspaceIdStr);

  // monitor events
  void onMonitorFocused(std::string const& payload);
@@ -165,12 +117,28 @@ class Workspaces : public AModule, public EventHandler {
  void onWindowMoved(std::string const& payload);

  void onWindowTitleEvent(std::string const& payload);
+  void onActiveWindowChanged(WindowAddress const& payload);

  void onConfigReloaded();

  int windowRewritePriorityFunction(std::string const& window_rule);

+  // event payload management
+  template <typename... Args>
+  static std::string makePayload(Args const&... args);
+  static std::pair<std::string, std::string> splitDoublePayload(std::string const& payload);
+  static std::tuple<std::string, std::string, std::string> splitTriplePayload(
+      std::string const& payload);
+  // scroll events
+  bool handleScroll(GdkEventScroll* e) override;
+
+  // Update methods
  void doUpdate();
+  void removeWorkspacesToRemove();
+  void createWorkspacesToCreate();
+  static std::vector<int> getVisibleWorkspaces();
+  void updateWorkspaceStates();
+  bool updateWindowsToCreate();

  void extendOrphans(int workspaceId, Json::Value const& clientsJson);
  void registerOrphanWindow(WindowCreationPayload create_window_payload);
@@ -183,45 +151,80 @@ class Workspaces : public AModule, public EventHandler {
  bool m_allOutputs = false;
  bool m_showSpecial = false;
  bool m_activeOnly = false;
+  bool m_hideActive = false;
+  bool m_specialVisibleOnly = false;
+  bool m_persistentOnly = false;
+  bool m_moveToMonitor = false;
+  bool m_barScroll = false;
  Json::Value m_persistentWorkspaceConfig;

  // Map for windows stored in workspaces not present in the current bar.
  // This happens when the user has multiple monitors (hence, multiple bars)
-  // and doesn't share windows accross bars (a.k.a `all-outputs` = false)
-  std::map<WindowAddress, std::string> m_orphanWindowMap;
+  // and doesn't share windows across bars (a.k.a `all-outputs` = false)
+  std::map<WindowAddress, WindowRepr, std::less<>> m_orphanWindowMap;

-  enum class SortMethod { ID, NAME, NUMBER, DEFAULT };
+  enum class SortMethod { ID, NAME, NUMBER, SPECIAL_CENTERED, DEFAULT };
  util::EnumParser<SortMethod> m_enumParser;
  SortMethod m_sortBy = SortMethod::DEFAULT;
  std::map<std::string, SortMethod> m_sortMap = {{"ID", SortMethod::ID},
                                                 {"NAME", SortMethod::NAME},
                                                 {"NUMBER", SortMethod::NUMBER},
+                                                 {"SPECIAL-CENTERED", SortMethod::SPECIAL_CENTERED},
                                                 {"DEFAULT", SortMethod::DEFAULT}};

-  std::string m_format;
-
-  std::map<std::string, std::string> m_tooltipMap;
-  bool m_withTooltip;
+  std::string m_formatBefore;
+  std::string m_formatAfter;

  std::map<std::string, std::string> m_iconsMap;
+  std::map<std::string, std::string> m_tooltipMap;
+  bool m_withTooltip = false;
  util::RegexCollection m_windowRewriteRules;
  bool m_anyWindowRewriteRuleUsesTitle = false;
  std::string m_formatWindowSeparator;
+  int m_windowRewriteGroupThreshold = 0;
+  std::string m_windowRewriteGroupFormat = "{icon}×{count}";

  bool m_withIcon;
  uint64_t m_monitorId;
-  std::string m_activeWorkspaceName;
+  int m_activeWorkspaceId;
  std::string m_activeSpecialWorkspaceName;
  std::vector<std::unique_ptr<Workspace>> m_workspaces;
  std::vector<std::pair<Json::Value, Json::Value>> m_workspacesToCreate;
  std::vector<std::string> m_workspacesToRemove;
  std::vector<WindowCreationPayload> m_windowsToCreate;

+  IconLoader m_iconLoader;
+  bool m_enableTaskbar = false;
+  bool m_updateActiveWindow = false;
+  bool m_taskbarWithIcon = false;
+  bool m_taskbarWithTitle = false;
+  std::string m_taskbarFormatBefore;
+  std::string m_taskbarFormatAfter;
+  int m_taskbarIconSize = 16;
+  Gtk::Orientation m_taskbarOrientation = Gtk::ORIENTATION_HORIZONTAL;
+  bool m_taskbarReverseDirection = false;
+  util::EnumParser<ActiveWindowPosition> m_activeWindowEnumParser;
+  ActiveWindowPosition m_activeWindowPosition = ActiveWindowPosition::NONE;
+  std::map<std::string, ActiveWindowPosition> m_activeWindowPositionMap = {
+      {"NONE", ActiveWindowPosition::NONE},
+      {"FIRST", ActiveWindowPosition::FIRST},
+      {"LAST", ActiveWindowPosition::LAST},
+  };
+  std::string m_onClickWindow;
+  std::string m_currentActiveWindowAddress;
+  int m_maxWindows = 0;
+
  std::vector<std::regex> m_ignoreWorkspaces;
+  std::vector<std::regex> m_ignoreWindows;

  std::mutex m_mutex;
  const Bar& m_bar;
  Gtk::Box m_box;
+  sigc::connection m_scrollEventConnection_;
+  IPC& m_ipc;
+
+  sigc::connection m_debounceTimer;
+  bool m_updatePending = false;
 };

 }  // namespace waybar::modules::hyprland
@@ -6,25 +6,35 @@
 #include "bar.hpp"
 #include "client.hpp"

+struct ext_idle_notification_v1;
+
 namespace waybar::modules {

 class IdleInhibitor : public ALabel {
  sigc::connection timeout_;
+  ext_idle_notification_v1* idle_notification_;
+  uint32_t idle_timeout_ms_;

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

 private:
  bool handleToggle(GdkEventButton* const& e) override;
  void toggleStatus();
+  void setupIdleNotification();
+  void teardownIdleNotification();
+  static void handleIdled(void* data, ext_idle_notification_v1* notification);
+  static void handleResumed(void* data, ext_idle_notification_v1* notification);

  const Bar& bar_;
  struct zwp_idle_inhibitor_v1* idle_inhibitor_;
  int pid_;
+  bool wait_for_activity_;
 };

 }  // namespace waybar::modules
@@ -31,7 +31,7 @@ class Image : public AModule {
  std::string path_;
  std::string tooltip_;
  int size_;
-  int interval_;
+  std::chrono::milliseconds interval_;
  util::command::res output_;

  util::SleeperThread thread_;
@@ -3,6 +3,7 @@
 #include <fmt/chrono.h>
 #include <gtkmm/label.h>

+#include <mutex>
 #include <set>
 #include <unordered_map>

@@ -35,12 +36,12 @@ class KeyboardState : public AModule {
  std::string capslock_format_;
  std::string scrolllock_format_;
  const std::chrono::seconds interval_;
-  std::string icon_locked_;
-  std::string icon_unlocked_;
+  std::unordered_map<std::string, std::vector<std::string>> key_icon_states_;
  std::string devices_path_;

  struct libinput* libinput_;
  std::unordered_map<std::string, struct libinput_device*> libinput_devices_;
+  std::mutex devices_mutex_;  // protects libinput_devices_
  std::set<int> binding_keys;

  util::SleeperThread libinput_thread_, hotplug_thread_;
@@ -0,0 +1,67 @@
+// include/modules/mango/backend.hpp
+#pragma once
+
+#include <list>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include "util/json.hpp"
+
+namespace waybar::modules::mango {
+
+class EventHandler {
+ public:
+  virtual void onEvent(const Json::Value& ev) = 0;
+  virtual ~EventHandler() = default;
+};
+
+class IPC {
+ public:
+  static IPC& getInstance();
+  IPC(const IPC&) = delete;
+  IPC& operator=(const IPC&) = delete;
+
+  void registerForIPC(const std::string& ev, EventHandler* handler);
+  void unregisterForIPC(EventHandler* handler);
+
+  static Json::Value send(const Json::Value& request);
+  static void sendAsync(const Json::Value& request);
+
+  std::unique_lock<std::mutex> lockData() { return std::unique_lock<std::mutex>(data_mutex_); }
+
+  std::unordered_map<std::string, Json::Value> getMonitors() const;
+  Json::Value getMonitor(const std::string& name);
+  Json::Value getActiveClientForMonitor(const std::string& name) const;
+  std::string getKeyboardLayout() const;
+  std::string getKeymode() const;
+  std::string getLayoutSymbolForMonitor(const std::string& name) const;
+
+ private:
+  IPC();
+  ~IPC();
+  void startIPC();
+  static int connectToSocket();
+  void parseIPC(const std::string& line);
+
+  void handleMonitorUpdate(const Json::Value& mon);
+  void updateFocusingClient(const Json::Value& client);
+  void updateKeyboardLayout(const std::string& layout);
+
+  static Json::Value sendCommand(const std::string& cmd);
+
+  int sockfd_ = -1;
+  std::thread ipc_thread_;
+  mutable std::mutex data_mutex_;
+  std::unordered_map<std::string, Json::Value> monitors_;
+  std::unordered_map<uint64_t, Json::Value> clients_;
+  uint64_t focusing_client_id_ = 0;
+  std::string keyboard_layout_;
+  std::string keymode_;
+  Json::Value active_client_;
+  std::mutex callback_mutex_;
+  std::list<std::pair<std::string, EventHandler*>> callbacks_;
+};
+}  // namespace waybar::modules::mango
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <mutex>
+#include <string>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+#include "modules/mango/backend.hpp"
+
+namespace waybar::modules::mango {
+
+class Keymode : public ALabel, public EventHandler {
+ public:
+  Keymode(const std::string&, const Bar&, const Json::Value&);
+  ~Keymode() override;
+  void update() override;
+
+ private:
+  void onEvent(const Json::Value& ev) override;
+  void doUpdate();
+
+  std::mutex mutex_;
+  const Bar& bar_;
+  std::string last_keymode_;
+};
+
+}  // namespace waybar::modules::mango
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <xkbcommon/xkbregistry.h>
+
+#include <string>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+#include "modules/mango/backend.hpp"
+
+namespace waybar::modules::mango {
+
+class Language : public ALabel, public EventHandler {
+ public:
+  Language(const std::string&, const Bar&, const Json::Value&);
+  ~Language() override;
+  void update() override;
+
+ private:
+  void updateFromIPC();
+  void onEvent(const Json::Value& ev) override;
+  void doUpdate();
+
+  struct Layout {
+    std::string full_name;
+    std::string short_name;
+    std::string variant;
+    std::string short_description;
+  };
+
+  Layout getLayout(const std::string& fullName);
+
+  std::mutex mutex_;
+  const Bar& bar_;
+
+  std::vector<Layout> layouts_;
+  unsigned current_idx_;
+  std::string last_short_name_;
+
+  struct rxkb_context* rxkb_ctx_ = nullptr;
+};
+
+}  // namespace waybar::modules::mango
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <mutex>
+#include <string>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+#include "modules/mango/backend.hpp"
+
+namespace waybar::modules::mango {
+
+class Layout : public ALabel, public EventHandler {
+ public:
+  Layout(const std::string&, const Bar&, const Json::Value&);
+  ~Layout() override;
+  void update() override;
+
+ private:
+  void onEvent(const Json::Value& ev) override;
+  void doUpdate();
+
+  std::mutex mutex_;
+  const Bar& bar_;
+  std::string last_symbol_;
+};
+
+}  // namespace waybar::modules::mango
@@ -0,0 +1,30 @@
+#pragma once
+
+#include <gtkmm/button.h>
+#include <json/value.h>
+
+#include <mutex>
+
+#include "AAppIconLabel.hpp"
+#include "bar.hpp"
+#include "modules/mango/backend.hpp"
+
+namespace waybar::modules::mango {
+
+class Window : public AAppIconLabel, public EventHandler {
+ public:
+  Window(const std::string&, const Bar&, const Json::Value&);
+  ~Window() override;
+  void update() override;
+
+ private:
+  void onEvent(const Json::Value& ev) override;
+  void doUpdate();
+  void setClass(const std::string& className, bool enable);
+
+  const Bar& bar_;
+  std::string oldAppId_;
+  std::mutex mutex_;
+};
+
+}  // namespace waybar::modules::mango
@@ -0,0 +1,40 @@
+#pragma once
+
+#include <gtkmm/button.h>
+#include <json/value.h>
+
+#include <unordered_map>
+
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "modules/mango/backend.hpp"
+
+namespace waybar::modules::mango {
+
+class Workspaces : public AModule, public EventHandler {
+ public:
+  Workspaces(const std::string&, const Bar&, const Json::Value&);
+  ~Workspaces() override;
+  void update() override;
+
+ private:
+  void onEvent(const Json::Value& ev) override;
+  void doUpdate();
+
+  Gtk::Button& addButton(uint64_t idx);
+  void updateButtonState(Gtk::Button& button, const Json::Value& tag, const Json::Value& monitor);
+  std::string getIcon(const std::string& value, const Json::Value& tag);
+  bool handleButtonClick(GdkEventButton* event, uint64_t idx, bool isOverview);
+
+  const Bar& bar_;
+  Gtk::Box box_;
+
+  std::unordered_map<uint64_t, Gtk::Button> buttons_;
+  Gtk::Button* overview_button_ = nullptr;
+
+  std::string on_click_left_;
+  std::string on_click_middle_;
+  std::string on_click_right_;
+};
+
+}  // namespace waybar::modules::mango
@@ -22,6 +22,8 @@ class Memory : public ALabel {
  std::unordered_map<std::string, unsigned long> meminfo_;

  util::SleeperThread thread_;
+
+  std::string unit_;
 };

 }  // namespace waybar::modules
@@ -28,11 +28,14 @@ class MPD : public ALabel {

  unsigned timeout_;

+  unsigned playing_interval_;
+
  detail::unique_connection connection_;

  detail::unique_status status_;
  mpd_state state_;
  detail::unique_song song_;
+  std::string ellipsis_;

 public:
  MPD(const std::string&, const Json::Value&);
@@ -44,7 +47,11 @@ class MPD : public ALabel {
  std::string getFilename() const;
  void setLabel();
  std::string getStateIcon() const;
-  std::string getOptionIcon(std::string optionName, bool activated) const;
+  std::string getOptionIcon(const std::string& optionName, bool activated) const;
+  std::string getArtistStr(bool truncated) const;
+  std::string getAlbumArtistStr(bool truncated) const;
+  std::string getAlbumStr(bool truncated) const;
+  std::string getTitleStr(bool truncated) const;

  // GUI-side methods
  bool handlePlayPause(GdkEventButton* const&);
@@ -54,11 +61,11 @@ class MPD : public ALabel {
  void tryConnect();
  void checkErrors(mpd_connection* conn);
  void fetchState();
-  void queryMPD();

  inline bool stopped() const { return connection_ && state_ == MPD_STATE_STOP; }
  inline bool playing() const { return connection_ && state_ == MPD_STATE_PLAY; }
  inline bool paused() const { return connection_ && state_ == MPD_STATE_PAUSE; }
+  inline unsigned playing_interval() const { return playing_interval_; }
 };

 #if !defined(MPD_NOINLINE)
@@ -82,6 +82,7 @@ class Idle : public State {
 class Playing : public State {
  Context* const ctx_;
  sigc::connection timer_connection_;
+  sigc::connection idle_connection_;

 public:
  Playing(Context* const ctx) : ctx_{ctx} {}
@@ -98,7 +99,10 @@ class Playing : public State {
  Playing(Playing const&) = delete;
  Playing& operator=(Playing const&) = delete;

+  void timer() noexcept;
+  void idle() noexcept;
  bool on_timer();
+  bool on_io(Glib::IOCondition const&);
 };

 class Paused : public State {
@@ -194,10 +198,10 @@ class Context {
  bool is_paused() const;
  bool is_stopped() const;
  constexpr std::size_t interval() const;
+  unsigned playing_interval() const;
  void tryConnect() const;
  void checkErrors(mpd_connection*) const;
  void do_update();
-  void queryMPD() const;
  void fetchState() const;
  constexpr mpd_state state() const;
  void emit() const;
@@ -1,13 +1,15 @@
 #pragma once

 namespace detail {
+using namespace std::literals::chrono_literals;

 inline bool Context::is_connected() const { return mpd_module_->connection_ != nullptr; }
 inline bool Context::is_playing() const { return mpd_module_->playing(); }
 inline bool Context::is_paused() const { return mpd_module_->paused(); }
 inline bool Context::is_stopped() const { return mpd_module_->stopped(); }

-constexpr inline std::size_t Context::interval() const { return mpd_module_->interval_.count(); }
+constexpr inline std::size_t Context::interval() const { return mpd_module_->interval_ / 1s; }
+inline unsigned Context::playing_interval() const { return mpd_module_->playing_interval(); }
 inline void Context::tryConnect() const { mpd_module_->tryConnect(); }
 inline unique_connection& Context::connection() { return mpd_module_->connection_; }
 constexpr inline mpd_state Context::state() const { return mpd_module_->state_; }
@@ -15,7 +17,6 @@ constexpr inline mpd_state Context::state() const { return mpd_module_->state_;
 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(); }
 inline void Context::fetchState() const { mpd_module_->fetchState(); }
 inline void Context::emit() const { mpd_module_->emit(); }

@@ -38,6 +38,7 @@ class Mpris : public ALabel {

    std::optional<std::string> artist;
    std::optional<std::string> album;
+    std::optional<std::string> album_artist;
    std::optional<std::string> title;
    std::optional<std::string> length;    // as HH:MM:SS
    std::optional<std::string> position;  // same format
@@ -76,8 +77,11 @@ class Mpris : public ALabel {
  std::string player_;
  std::vector<std::string> ignored_players_;

+  bool prefer_album_artist_;
+
  PlayerctlPlayerManager* manager;
  PlayerctlPlayer* player;
+  PlayerctlPlayer* last_active_player_ = nullptr;
  std::string lastStatus;
  std::string lastPlayer;

@@ -9,6 +9,7 @@
 #include <sys/epoll.h>

 #include <optional>
+#include <vector>

 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
@@ -16,6 +17,8 @@
 #include "util/rfkill.hpp"
 #endif

+enum ip_addr_pref : uint8_t { IPV4, IPV6, IPV4_6 };
+
 namespace waybar::modules {

 class Network : public ALabel {
@@ -25,8 +28,8 @@ class Network : public ALabel {
  auto update() -> void override;

 private:
-  static const uint8_t MAX_RETRY = 5;
-  static const uint8_t EPOLL_MAX = 200;
+  static const uint8_t MAX_RETRY{5};
+  static const uint8_t EPOLL_MAX{200};

  static int handleEvents(struct nl_msg*, void*);
  static int handleEventsDone(struct nl_msg*, void*);
@@ -40,41 +43,49 @@ class Network : public ALabel {
  void parseEssid(struct nlattr**);
  void parseSignal(struct nlattr**);
  void parseFreq(struct nlattr**);
+  void parseBssid(struct nlattr**);
  bool associatedOrJoined(struct nlattr**);
-  bool checkInterface(std::string name);
+  bool matchInterface(const std::string& ifname, const std::vector<std::string>& altnames,
+                      std::string& matched) const;
  auto getInfo() -> void;
  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_;
-  struct sockaddr_nl nladdr_ = {0};
-  struct nl_sock* sock_ = nullptr;
-  struct nl_sock* ev_sock_ = nullptr;
-  int efd_;
-  int ev_fd_;
-  int nl80211_id_;
+  int ifid_{-1};
+  ip_addr_pref addr_pref_{ip_addr_pref::IPV4};
+  struct sockaddr_nl nladdr_{0};
+  struct nl_sock* sock_{nullptr};
+  struct nl_sock* ev_sock_{nullptr};
+  int efd_{-1};
+  int ev_fd_{-1};
+  int nl80211_id_{-1};
  std::mutex mutex_;

-  bool want_route_dump_;
-  bool want_link_dump_;
-  bool want_addr_dump_;
-  bool dump_in_progress_;
-  bool is_p2p_;
+  bool want_route_dump_{false};
+  bool want_link_dump_{false};
+  bool want_addr_dump_{false};
+  bool dump_in_progress_{false};
+  bool is_p2p_{false};

-  unsigned long long bandwidth_down_total_;
-  unsigned long long bandwidth_up_total_;
+  unsigned long long bandwidth_down_total_{0};
+  unsigned long long bandwidth_up_total_{0};
+  unsigned long long bandwidth_down_prev_{0};
+  unsigned long long bandwidth_up_prev_{0};
+  std::chrono::steady_clock::time_point bandwidth_last_sample_time_;

  std::string state_;
  std::string essid_;
-  bool carrier_;
+  std::string bssid_;
+  bool carrier_{false};
  std::string ifname_;
  std::string ipaddr_;
+  std::string ipaddr6_;
  std::string gwaddr_;
  std::string netmask_;
-  int cidr_;
+  std::string netmask6_;
+  int cidr_{0};
+  int cidr6_{0};
  int32_t signal_strength_dbm_;
  uint8_t signal_strength_;
  std::string signal_strength_app_;
@@ -83,9 +94,9 @@ class Network : public ALabel {
  util::SleeperThread thread_;
  util::SleeperThread thread_timer_;
 #ifdef WANT_RFKILL
-  util::Rfkill rfkill_;
+  util::Rfkill rfkill_{RFKILL_TYPE_WLAN};
 #endif
-  float frequency_;
+  float frequency_{0};
 };

 }  // namespace waybar::modules
@@ -0,0 +1,52 @@
+#pragma once
+
+#include <list>
+#include <mutex>
+#include <string>
+#include <utility>
+
+#include "util/json.hpp"
+
+namespace waybar::modules::niri {
+
+class EventHandler {
+ public:
+  virtual void onEvent(const Json::Value& ev) = 0;
+  virtual ~EventHandler() = default;
+};
+
+class IPC {
+ public:
+  IPC();
+
+  void registerForIPC(const std::string& ev, EventHandler* ev_handler);
+  void unregisterForIPC(EventHandler* handler);
+
+  static Json::Value send(const Json::Value& request);
+
+  // The data members are only safe to access while dataMutex_ is locked.
+  std::lock_guard<std::mutex> lockData() { return std::lock_guard(dataMutex_); }
+  const std::vector<Json::Value>& workspaces() const { return workspaces_; }
+  const std::vector<Json::Value>& windows() const { return windows_; }
+  const std::vector<std::string>& keyboardLayoutNames() const { return keyboardLayoutNames_; }
+  unsigned keyboardLayoutCurrent() const { return keyboardLayoutCurrent_; }
+
+ private:
+  void startIPC();
+  static int connectToSocket();
+  void parseIPC(const std::string&);
+
+  std::mutex dataMutex_;
+  std::vector<Json::Value> workspaces_;
+  std::vector<Json::Value> windows_;
+  std::vector<std::string> keyboardLayoutNames_;
+  unsigned keyboardLayoutCurrent_;
+
+  util::JsonParser parser_;
+  std::mutex callbackMutex_;
+  std::list<std::pair<std::string, EventHandler*>> callbacks_;
+};
+
+inline std::unique_ptr<IPC> gIPC;
+
+};  // namespace waybar::modules::niri
@@ -0,0 +1,39 @@
+#pragma once
+
+#include <string>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+#include "modules/niri/backend.hpp"
+
+namespace waybar::modules::niri {
+
+class Language : public ALabel, public EventHandler {
+ public:
+  Language(const std::string&, const Bar&, const Json::Value&);
+  ~Language() override;
+  void update() override;
+
+ private:
+  void updateFromIPC();
+  void onEvent(const Json::Value& ev) override;
+  void doUpdate();
+
+  struct Layout {
+    std::string full_name;
+    std::string short_name;
+    std::string variant;
+    std::string short_description;
+  };
+
+  static Layout getLayout(const std::string& fullName);
+
+  std::mutex mutex_;
+  const Bar& bar_;
+
+  std::vector<Layout> layouts_;
+  unsigned current_idx_;
+  std::string last_short_name_;
+};
+
+}  // namespace waybar::modules::niri
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <gtkmm/button.h>
+#include <json/value.h>
+
+#include "AAppIconLabel.hpp"
+#include "bar.hpp"
+#include "modules/niri/backend.hpp"
+
+namespace waybar::modules::niri {
+
+class Window : public AAppIconLabel, public EventHandler {
+ public:
+  Window(const std::string&, const Bar&, const Json::Value&);
+  ~Window() override;
+  void update() override;
+
+ private:
+  void onEvent(const Json::Value& ev) override;
+  void doUpdate();
+  void setClass(const std::string& className, bool enable);
+
+  const Bar& bar_;
+
+  std::string oldAppId_;
+};
+
+}  // namespace waybar::modules::niri
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <gtkmm/button.h>
+#include <json/value.h>
+
+#include <vector>
+
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "modules/niri/backend.hpp"
+
+namespace waybar::modules::niri {
+
+class Workspaces : public AModule, public EventHandler {
+ public:
+  Workspaces(const std::string&, const Bar&, const Json::Value&);
+  ~Workspaces() override;
+  void update() override;
+
+ private:
+  void onEvent(const Json::Value& ev) override;
+  void doUpdate();
+  void sortWorkspaces(std::vector<Json::Value>& workspaces) const;
+  Gtk::Button& addButton(const Json::Value& ws);
+  std::string getIcon(const std::string& value, const Json::Value& ws);
+  bool handleScroll(GdkEventScroll* /*unused*/) override;
+
+  const Bar& bar_;
+  Gtk::Box box_;
+  // Map from niri workspace id to button.
+  std::unordered_map<uint64_t, Gtk::Button> buttons_;
+
+  bool sort_by_id_ = false;
+  bool sort_by_name_ = false;
+  bool sort_by_coordinates_ = false;
+};
+
+}  // namespace waybar::modules::niri
@@ -9,7 +9,18 @@ namespace waybar::modules {

 struct Profile {
  std::string name;
+  // Legacy driver field, kept for backward compatibility with the
+  // `{driver}` format placeholder and with older power-profiles-daemon
+  // versions that only expose a single `Driver` DBus property.
  std::string driver;
+  std::string cpuDriver;
+  std::string platformDriver;
+
+  Profile(std::string n, std::string d, std::string cd, std::string pd)
+      : name(std::move(n)),
+        driver(std::move(d)),
+        cpuDriver(std::move(cd)),
+        platformDriver(std::move(pd)) {}
 };

 class PowerProfilesDaemon : public ALabel {
@@ -1,10 +1,7 @@
 #pragma once

-#include <iostream>
-#include <map>
 #include <string>

-#include "ALabel.hpp"
 #include "gtkmm/box.h"
 #include "modules/privacy/privacy_item.hpp"
 #include "util/pipewire/pipewire_backend.hpp"
@@ -16,7 +13,7 @@ namespace waybar::modules::privacy {

 class Privacy : public AModule {
 public:
-  Privacy(const std::string &, const Json::Value &, const std::string &pos);
+  Privacy(const std::string&, const Json::Value&, Gtk::Orientation, const std::string& pos);
  auto update() -> void override;

  void onPrivacyNodesChanged();
@@ -31,9 +28,12 @@ class Privacy : public AModule {

  // Config
  Gtk::Box box_;
+  std::vector<PrivacyItem*> modules_;
  uint iconSpacing = 4;
  uint iconSize = 20;
  uint transition_duration = 250;
+  std::set<std::pair<PrivacyNodeType, std::string>> ignore;
+  bool ignore_monitor = true;

  std::shared_ptr<util::PipewireBackend::PipewireBackend> backend = nullptr;
 };
@@ -2,9 +2,6 @@

 #include <json/value.h>

-#include <iostream>
-#include <map>
-#include <mutex>
 #include <string>

 #include "gtkmm/box.h"
@@ -20,8 +17,8 @@ namespace waybar::modules::privacy {
 class PrivacyItem : public Gtk::Revealer {
 public:
  PrivacyItem(const Json::Value& config_, enum PrivacyNodeType privacy_type_,
-              std::list<PrivacyNodeInfo *> *nodes, const std::string &pos, const uint icon_size,
-              const uint transition_duration);
+              std::list<PrivacyNodeInfo*>* nodes, Gtk::Orientation orientation,
+              const std::string& pos, const uint icon_size, const uint transition_duration);

  enum PrivacyNodeType privacy_type;

@@ -22,6 +22,7 @@ class Pulseaudio : public ALabel {
  const std::vector<std::string> getPulseIcon() const;

  std::shared_ptr<util::AudioBackend> backend = nullptr;
+  util::PulseaudioTarget target = util::PulseaudioTarget::Sink;
 };

 }  // namespace waybar::modules
@@ -6,11 +6,6 @@
 #include "util/audio_backend.hpp"
 namespace waybar::modules {

-enum class PulseaudioSliderTarget {
-  Sink,
-  Source,
-};
-
 class PulseaudioSlider : public ASlider {
 public:
  PulseaudioSlider(const std::string&, const Json::Value&);
@@ -21,7 +16,15 @@ class PulseaudioSlider : public ASlider {

 private:
  std::shared_ptr<util::AudioBackend> backend = nullptr;
-  PulseaudioSliderTarget target = PulseaudioSliderTarget::Sink;
+  util::PulseaudioTarget target = util::PulseaudioTarget::Sink;
+
+  bool zero_on_mute = true;
+  bool unmute_on_volume_change = true;
+  // zero_on_mute and unmute_on_volume_change default to true
+  // in order to maintain previous behaviour when using a
+  // config in which these values are undefined
+
+  bool previously_muted = false;
 };

 }  // namespace waybar::modules
@@ -24,6 +24,7 @@ class Layout : public waybar::ALabel {

 private:
  const waybar::Bar& bar_;
+  std::string name_;
  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_;
@@ -20,7 +20,10 @@ class Tags : public waybar::AModule {
  void handle_focused_tags(uint32_t tags);
  void handle_view_tags(struct wl_array* tags);
  void handle_urgent_tags(uint32_t tags);
+  void handle_focused_output(struct wl_output* output);
+  void handle_unfocused_output(struct wl_output* output);

+  void handle_show();
  void handle_primary_clicked(uint32_t tag);
  bool handle_button_press(GdkEventButton* event_button, uint32_t tag);

@@ -30,9 +33,11 @@ class Tags : public waybar::AModule {

 private:
  const waybar::Bar& bar_;
+  struct wl_output* output_;  // stores the output this module belongs to
  Gtk::Box box_;
  std::vector<Gtk::Button> buttons_;
  struct zriver_output_status_v1* output_status_;
+  struct zriver_seat_status_v1* seat_status_;
 };

 } /* namespace waybar::modules::river */
@@ -14,11 +14,14 @@ namespace waybar::modules::SNI {

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

+  void checkIgnoreList(const std::vector<std::string>& ignore_list,
+                       const std::function<void(std::unique_ptr<Item>&)>& on_remove);
+
 private:
  void busAcquired(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring);
  void nameAppeared(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring,
@@ -28,9 +31,13 @@ class Host {
  static void registerHost(GObject*, GAsyncResult*, gpointer);
  static void itemRegistered(SnWatcher*, const gchar*, gpointer);
  static void itemUnregistered(SnWatcher*, const gchar*, gpointer);
+  void itemReady(Item&);
+  void itemInvalidated(Item&);
+  void removeItem(std::vector<std::unique_ptr<Item>>::iterator);
+  void clearItems();

  std::tuple<std::string, std::string> getBusNameAndObjectPath(const std::string);
-  void addRegisteredItem(std::string service);
+  void addRegisteredItem(const std::string& service);

  std::vector<std::unique_ptr<Item>> items_;
  const std::string bus_name_;
@@ -39,10 +46,14 @@ class Host {
  std::size_t watcher_id_;
  GCancellable* cancellable_ = nullptr;
  SnWatcher* watcher_ = nullptr;
+  sigc::connection retry_connection_;
+  unsigned retry_count_ = 0;
  const Json::Value& config_;
  const Bar& bar_;
+  const std::vector<std::string> ignore_list_;
  const std::function<void(std::unique_ptr<Item>&)> on_add_;
  const std::function<void(std::unique_ptr<Item>&)> on_remove_;
+  const std::function<void()> on_update_;
 };

 }  // namespace waybar::modules::SNI
@@ -0,0 +1,43 @@
+#pragma once
+
+#include <json/json.h>
+#include <spdlog/spdlog.h>
+
+#include <string>
+#include <unordered_map>
+
+class IconManager {
+ public:
+  static IconManager& instance() {
+    static IconManager instance;
+    return instance;
+  }
+
+  void setIconsConfig(const Json::Value& icons_config) {
+    if (icons_config.isObject()) {
+      for (const auto& key : icons_config.getMemberNames()) {
+        std::string app_name = key;
+        const Json::Value& icon_value = icons_config[key];
+
+        if (icon_value.isString()) {
+          std::string icon_path = icon_value.asString();
+          icons_map_[app_name] = icon_path;
+        }
+      }
+    } else {
+      spdlog::warn("Invalid icon config format.");
+    }
+  }
+
+  std::string getIconForApp(const std::string& app_name) const {
+    auto it = icons_map_.find(app_name);
+    if (it != icons_map_.end()) {
+      return it->second;
+    }
+    return "";
+  }
+
+ private:
+  IconManager() = default;
+  std::unordered_map<std::string, std::string> icons_map_;
+};
@@ -11,6 +11,7 @@
 #include <libdbusmenu-gtk/dbusmenu-gtk.h>
 #include <sigc++/trackable.h>

+#include <functional>
 #include <set>
 #include <string_view>

@@ -25,8 +26,12 @@ struct ToolTip {

 class Item : public sigc::trackable {
 public:
-  Item(const std::string&, const std::string&, const Json::Value&, const Bar&);
-  ~Item() = default;
+  Item(const std::string&, const std::string&, const Json::Value&, const Bar&,
+       const std::function<void(Item&)>&, const std::function<void(Item&)>&,
+       const std::function<void()>&);
+  ~Item();
+
+  bool isReady() const;

  std::string bus_name;
  std::string object_path;
@@ -41,9 +46,12 @@ class Item : public sigc::trackable {
  std::string title;
  std::string icon_name;
  Glib::RefPtr<Gdk::Pixbuf> icon_pixmap;
+  bool has_custom_icon_ = false;
  Glib::RefPtr<Gtk::IconTheme> icon_theme;
  std::string overlay_icon_name;
+  Glib::RefPtr<Gdk::Pixbuf> overlay_icon_pixmap;
  std::string attention_icon_name;
+  Glib::RefPtr<Gdk::Pixbuf> attention_icon_pixmap;
  std::string attention_movie_name;
  std::string icon_theme_path;
  std::string menu;
@@ -62,20 +70,30 @@ class Item : public sigc::trackable {
  void proxyReady(Glib::RefPtr<Gio::AsyncResult>& result);
  void setProperty(const Glib::ustring& name, Glib::VariantBase& value);
  void setStatus(const Glib::ustring& value);
+  void setReady();
+  void invalidate();
+  void setCustomIcon(const std::string& id);
  void getUpdatedProperties();
  void processUpdatedProperties(Glib::RefPtr<Gio::AsyncResult>& result);
  void onSignal(const Glib::ustring& sender_name, const Glib::ustring& signal_name,
                const Glib::VariantContainerBase& arguments);

  void updateImage();
-  Glib::RefPtr<Gdk::Pixbuf> extractPixBuf(GVariant* variant);
+  static Glib::RefPtr<Gdk::Pixbuf> extractPixBuf(GVariant* variant);
  Glib::RefPtr<Gdk::Pixbuf> getIconPixbuf();
+  Glib::RefPtr<Gdk::Pixbuf> getAttentionIconPixbuf();
+  Glib::RefPtr<Gdk::Pixbuf> getOverlayIconPixbuf();
+  Glib::RefPtr<Gdk::Pixbuf> loadIconFromNameOrFile(const std::string& name, bool log_failure);
+  static Glib::RefPtr<Gdk::Pixbuf> overlayPixbufs(const Glib::RefPtr<Gdk::Pixbuf>&,
+                                                  const Glib::RefPtr<Gdk::Pixbuf>&);
  Glib::RefPtr<Gdk::Pixbuf> getIconByName(const std::string& name, int size);
  double getScaledIconSize();
  static void onMenuDestroyed(Item* self, GObject* old_menu_pointer);
  void makeMenu();
  bool handleClick(GdkEventButton* const& /*ev*/);
  bool handleScroll(GdkEventScroll* const&);
+  bool handleMouseEnter(GdkEventCrossing* const&);
+  bool handleMouseLeave(GdkEventCrossing* const&);

  // smooth scrolling threshold
  gdouble scroll_threshold_ = 0;
@@ -83,8 +101,13 @@ class Item : public sigc::trackable {
  gdouble distance_scrolled_y_ = 0;
  // visibility of items with Status == Passive
  bool show_passive_ = false;
+  bool ready_ = false;
+  Glib::ustring status_ = "active";

  const Bar& bar_;
+  const std::function<void(Item&)> on_ready_;
+  const std::function<void(Item&)> on_invalidate_;
+  const std::function<void()> on_updated_;

  Glib::RefPtr<Gio::DBus::Proxy> proxy_;
  Glib::RefPtr<Gio::Cancellable> cancellable_;
@@ -19,10 +19,14 @@ class Tray : public AModule {
 private:
  void onAdd(std::unique_ptr<Item>& item);
  void onRemove(std::unique_ptr<Item>& item);
+  void checkIgnoreList(std::unique_ptr<Item>* item);
+  std::vector<std::string> parseIgnoreList(const Json::Value& config);
+  void queueUpdate();

  static inline std::size_t nb_hosts_ = 0;
  Gtk::Box box_;
  SNI::Watcher::singleton watcher_;
+  std::vector<std::string> ignore_list_;
  SNI::Host host_;
 };

@@ -37,7 +37,7 @@ class BarIpcClient {
  void onModeUpdate(bool visible_by_modifier);
  void onUrgencyUpdate(bool visible_by_urgency);
  void update();
-  bool isModuleEnabled(std::string name);
+  bool isModuleEnabled(const std::string& name);

  Bar& bar_;
  util::JsonParser parser_;
@@ -1,17 +1,15 @@
 #pragma once

 #include <sigc++/sigc++.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-#include <unistd.h>

-#include <cstring>
-#include <memory>
+#include <cstdint>
+#include <functional>
 #include <mutex>
-#include <stdexcept>
 #include <string>

 #include "ipc.hpp"
+#include "util/SafeSignal.hpp"
+#include "util/scoped_fd.hpp"
 #include "util/sleeper_thread.hpp"

 namespace waybar::modules::sway {
@@ -27,8 +25,8 @@ class Ipc {
    std::string payload;
  };

-  sigc::signal<void, const struct ipc_response &> signal_event;
-  sigc::signal<void, const struct ipc_response &> signal_cmd;
+  ::waybar::SafeSignal<const struct ipc_response&> signal_event;
+  ::waybar::SafeSignal<const struct ipc_response&> signal_cmd;

  void sendCmd(uint32_t type, const std::string& payload = "");
  void subscribe(const std::string& payload);
@@ -39,13 +37,14 @@ class Ipc {
  static inline const std::string ipc_magic_ = "i3-ipc";
  static inline const size_t ipc_header_size_ = ipc_magic_.size() + 8;

-  const std::string getSocketPath() const;
-  int open(const std::string &) const;
+  static std::string getSocketPath();
+  static int open(const std::string&);
+
  struct ipc_response send(int fd, uint32_t type, const std::string& payload = "");
  struct ipc_response recv(int fd);

-  int fd_;
-  int fd_event_;
+  util::ScopedFd fd_;
+  util::ScopedFd fd_event_;
  std::mutex mutex_;
  util::SleeperThread thread_;
 };
@@ -21,7 +21,7 @@ class Language : public ALabel, public sigc::trackable {
  auto update() -> void override;

 private:
-  enum class DispayedShortFlag { None = 0, ShortName = 1, ShortDescription = 1 << 1 };
+  enum class DisplayedShortFlag { None = 0, ShortName = 1, ShortDescription = 1 << 1 };

  struct Layout {
    std::string full_name;
@@ -47,7 +47,7 @@ class Language : public ALabel, public sigc::trackable {
  void onEvent(const struct Ipc::ipc_response&);
  void onCmd(const struct Ipc::ipc_response&);

-  auto set_current_layout(std::string current_layout) -> void;
+  auto set_current_layout(const std::string& current_layout) -> void;
  auto init_layouts_map(const std::vector<std::string>& used_layouts) -> void;

  const static std::string XKB_LAYOUT_NAMES_KEY;
@@ -58,7 +58,7 @@ class Language : public ALabel, public sigc::trackable {
  std::map<std::string, Layout> layouts_map_;
  bool hide_single_;
  bool is_variant_displayed;
-  std::byte displayed_short_flag = static_cast<std::byte>(DispayedShortFlag::None);
+  std::byte displayed_short_flag = static_cast<std::byte>(DisplayedShortFlag::None);

  util::JsonParser parser_;
  std::mutex mutex_;
@@ -19,10 +19,11 @@ class Window : public AAppIconLabel, public sigc::trackable {
  auto update() -> void override;

 private:
-  void setClass(std::string classname, bool enable);
+  void setClass(const 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, int, std::string, std::string, std::string, std::string, std::string>
+  std::tuple<std::size_t, int, int, std::string, std::string, std::string, std::string, std::string,
+             std::string>
  getFocusedNode(const Json::Value& nodes, std::string& output);
  void getTree();

@@ -35,6 +36,7 @@ class Window : public AAppIconLabel, public sigc::trackable {
  std::string old_app_id_;
  std::size_t app_nb_;
  std::string shell_;
+  std::string marks_;
  int floating_count_;
  util::JsonParser parser_;
  std::mutex mutex_;
@@ -19,17 +19,20 @@ namespace waybar::modules::sway {
 class Workspaces : public AModule, public sigc::trackable {
 public:
  Workspaces(const std::string&, const waybar::Bar&, const Json::Value&);
-  virtual ~Workspaces() = default;
+  ~Workspaces() override = default;
  auto update() -> void override;

 private:
  static constexpr std::string_view workspace_switch_cmd_ = "workspace {} \"{}\"";
+  static constexpr std::string_view workspace_switch_number_cmd_ = "workspace {} number {}";
  static constexpr std::string_view persistent_workspace_switch_cmd_ =
      R"(workspace {} "{}"; move workspace to output "{}"; workspace {} "{}")";

-  static int convertWorkspaceNameToNum(std::string name);
+  static int convertWorkspaceNameToNum(const std::string& name);
  static int windowRewritePriorityFunction(std::string const& window_rule);

+  auto populateIgnoreWorkspacesConfig(const Json::Value& config) -> void;
+  bool isWorkspaceIgnored(std::string const& name);
  void onCmd(const struct Ipc::ipc_response&);
  void onEvent(const struct Ipc::ipc_response&);
  bool filterButtons();
@@ -38,18 +41,18 @@ class Workspaces : public AModule, public sigc::trackable {
  Gtk::Button& addButton(const Json::Value&);
  void onButtonReady(const Json::Value&, Gtk::Button&);
  std::string getIcon(const std::string&, const Json::Value&);
-  const std::string getCycleWorkspace(std::vector<Json::Value>::iterator, bool prev) 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*) override;
+  static std::string trimWorkspaceName(const std::string&);
+  bool handleScroll(GdkEventScroll* /*unused*/) 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_;
-  std::string m_formatWindowSeperator;
-  std::string m_windowRewriteDefault;
+  std::string m_formatWindowSeparator;
+  std::vector<std::regex> m_ignoreWorkspaces;
  util::RegexCollection m_windowRewriteRules;
  util::JsonParser parser_;
  std::unordered_map<std::string, Gtk::Button> buttons_;
@@ -3,6 +3,7 @@
 #include <giomm/dbusproxy.h>

 #include <string>
+#include <vector>

 #include "ALabel.hpp"

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

 private:
-  bool hide_on_ok;
-  std::string format_ok;
+  struct FailedUnit {
+    std::string name;
+    std::string description;
+    std::string load_state;
+    std::string active_state;
+    std::string sub_state;
+    std::string scope;
+  };

-  bool update_pending;
-  uint32_t nr_failed_system, nr_failed_user;
-  std::string last_status;
-  Glib::RefPtr<Gio::DBus::Proxy> system_proxy, user_proxy;
+  bool hide_on_ok_;
+  std::string format_ok_;
+  std::string tooltip_format_;
+  std::string tooltip_format_ok_;
+  std::string tooltip_unit_format_;
+
+  bool update_pending_;
+  std::string system_state_, user_state_, overall_state_;
+  uint32_t nr_failed_system_, nr_failed_user_, nr_failed_;
+  std::string last_status_;
+  Glib::RefPtr<Gio::DBus::Proxy> system_props_proxy_, user_props_proxy_;
+  Glib::RefPtr<Gio::DBus::Proxy> system_manager_proxy_, user_manager_proxy_;
+  std::vector<FailedUnit> failed_units_;

  void notify_cb(const Glib::ustring& sender_name, const Glib::ustring& signal_name,
                 const Glib::VariantContainerBase& arguments);
+  void RequestFailedUnits();
+  void RequestFailedUnitsList();
+  void RequestSystemState();
+  std::vector<FailedUnit> LoadFailedUnitsList(const char* kind,
+                                              Glib::RefPtr<Gio::DBus::Proxy>& proxy,
+                                              const std::string& scope);
+  std::string BuildTooltipFailedList() const;
  void updateData();
 };

@@ -14,10 +14,13 @@ class Temperature : public ALabel {
  Temperature(const std::string&, const Json::Value&);
  virtual ~Temperature() = default;
  auto update() -> void override;
+  void suspend() override;
+  void resume() override;

 private:
  float getTemperature();
  bool isCritical(uint16_t);
+  bool isWarning(uint16_t);

  std::string file_path_;
  util::SleeperThread thread_;
@@ -0,0 +1,94 @@
+#pragma once
+
+#include <giomm/dbusconnection.h>
+#include <gtkmm/icontheme.h>
+#include <libupower-glib/upower.h>
+
+#include <unordered_map>
+
+#include "AIconLabel.hpp"
+
+namespace waybar::modules {
+
+class UPower final : public AIconLabel {
+ public:
+  UPower(const std::string&, const Json::Value&);
+  virtual ~UPower();
+  auto update() -> void override;
+
+ private:
+  const std::string NO_BATTERY{"battery-missing-symbolic"};
+
+  // Config
+  bool showIcon_{true};
+  bool hideIfEmpty_{true};
+  int iconSize_{20};
+  int tooltip_spacing_{4};
+  int tooltip_padding_{4};
+  Gtk::Box contentBox_;  // tooltip box
+  std::string tooltipFormat_;
+
+  // UPower device info
+  struct upDevice_output {
+    UpDevice* upDevice{NULL};
+    double percentage{0.0};
+    double temperature{0.0};
+    guint64 time_full{0u};
+    guint64 time_empty{0u};
+    gchar* icon_name{(char*)'\0'};
+    bool upDeviceValid{false};
+    UpDeviceState state;
+    UpDeviceKind kind;
+    char* nativePath{(char*)'\0'};
+    char* model{(char*)'\0'};
+  };
+
+  // Technical variables
+  std::string nativePath_;
+  std::string model_;
+  std::string lastStatus_;
+  Glib::ustring label_markup_;
+  std::mutex mutex_;
+  Glib::RefPtr<Gtk::IconTheme> gtkTheme_;
+  bool sleeping_;
+
+  // Technical functions
+  void addDevice(UpDevice*);
+  void removeDevice(const gchar*);
+  void removeDevices();
+  void resetDevices();
+  void setDisplayDevice();
+  const Glib::ustring getText(const upDevice_output& upDevice_, const std::string& format);
+  bool queryTooltipCb(int, int, bool, const Glib::RefPtr<Gtk::Tooltip>&);
+
+  // DBUS variables
+  guint watcherID_;
+  Glib::RefPtr<Gio::DBus::Connection> conn_;
+  guint subscrID_{0u};
+
+  // UPower variables
+  UpClient* upClient_;
+  upDevice_output upDevice_;  // Device to display
+  typedef std::unordered_map<std::string, upDevice_output> Devices;
+  Devices devices_;
+  bool upRunning_{true};
+
+  // DBus callbacks
+  void getConn_cb(Glib::RefPtr<Gio::AsyncResult>& result);
+  void onAppear(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&,
+                const Glib::ustring&);
+  void onVanished(const Glib::RefPtr<Gio::DBus::Connection>&, const Glib::ustring&);
+  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);
+
+  // UPower callbacks
+  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);
+  // UPower secondary functions
+  void getUpDeviceInfo(upDevice_output& upDevice_);
+};
+
+}  // namespace waybar::modules
@@ -1,81 +0,0 @@
-#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 = nullptr;
-  guint login1_id;
-  GDBusConnection *login1_connection;
-  std::unique_ptr<UPowerTooltip> upower_tooltip;
-  std::string lastStatus;
-  bool showAltText;
-  bool showIcon = true;
-  bool upowerRunning;
-  guint upowerWatcher_id;
-  std::string nativePath_;
-};
-
-}  // namespace waybar::modules::upower
@@ -1,33 +0,0 @@
-#pragma once
-
-#include <libupower-glib/upower.h>
-
-#include <memory>
-#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);
-
-  std::unique_ptr<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
@@ -0,0 +1,108 @@
+#pragma once
+
+#include <json/json.h>
+#include <unistd.h>
+
+#include <functional>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <optional>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+#include "util/scoped_fd.hpp"
+
+namespace waybar::modules::wayfire {
+
+using EventHandler = std::function<void(const std::string& event)>;
+
+struct State {
+  /*
+    ┌───────────┐ ┌───────────┐
+    │ output #1 │ │ output #2 │
+    └─────┬─────┘ └─────┬─────┘
+          └─┐           └─────┐─ ─ ─ ─ ─ ─ ─ ─ ┐
+    ┌───────┴───────┐ ┌───────┴──────┐ ┌───────┴───────┐
+    │ wset #1       │ │ wset #2      │ │ wset #3       │
+    │┌────────────┐ │ │┌────────────┐│ │┌────────────┐ │
+    ││ workspaces │ │ ││ workspaces ││ ││ workspaces │ │
+    │└─┬──────────┘ │ │└────────────┘│ │└─┬──────────┘ │
+    │  │ ┌─────────┐│ └──────────────┘ │  │ ┌─────────┐│
+    │  ├─┤ view #1 ││                  │  └─┤ view #3 ││
+    │  │ └─────────┘│                  │    └─────────┘│
+    │  │ ┌─────────┐│                  └───────────────┘
+    │  └─┤ view #2 ││
+    │    └─────────┘│
+    └───────────────┘
+  */
+
+  struct Output {
+    size_t id;
+    size_t w, h;
+    size_t wset_idx;
+  };
+
+  struct Workspace {
+    size_t num_views;
+    size_t num_sticky_views;
+  };
+
+  struct Wset {
+    std::optional<std::reference_wrapper<Output>> output;
+    std::vector<Workspace> wss;
+    size_t ws_w, ws_h, ws_x, ws_y;
+    size_t focused_view_id;
+
+    auto ws_idx() const { return ws_w * ws_y + ws_x; }
+    auto count_ws(const Json::Value& pos) -> Workspace&;
+    auto locate_ws(const Json::Value& geo) -> Workspace&;
+    auto locate_ws(const Json::Value& geo) const -> const Workspace&;
+  };
+
+  std::unordered_map<std::string, Output> outputs;
+  std::unordered_map<size_t, Wset> wsets;
+  std::unordered_map<size_t, Json::Value> views;
+  std::string focused_output_name;
+  size_t maybe_empty_focus_wset_idx = {};
+  size_t vswitch_sticky_view_id = {};
+  bool new_output_detected = {};
+  bool vswitching = {};
+
+  auto update_view(const Json::Value& view) -> void;
+};
+
+using Sock = util::ScopedFd;
+
+class IPC : public std::enable_shared_from_this<IPC> {
+  static std::weak_ptr<IPC> instance;
+  Json::CharReaderBuilder reader_builder;
+  Json::StreamWriterBuilder writer_builder;
+  std::list<std::pair<std::string, std::reference_wrapper<const EventHandler>>> handlers;
+  std::mutex handlers_mutex;
+  State state;
+  std::mutex state_mutex;
+
+  IPC() = default;
+
+  static auto connect() -> Sock;
+  auto receive(Sock& sock) -> Json::Value;
+  auto start() -> void;
+  auto root_event_handler(const std::string& event, const Json::Value& data) -> void;
+  auto update_state_handler(const std::string& event, const Json::Value& data) -> void;
+
+ public:
+  static auto get_instance() -> std::shared_ptr<IPC>;
+  auto send(const std::string& method, Json::Value&& data) -> Json::Value;
+  auto register_handler(const std::string& event, const EventHandler& handler) -> void;
+  auto unregister_handler(EventHandler& handler) -> void;
+
+  auto lock_state() -> std::lock_guard<std::mutex> { return std::lock_guard{state_mutex}; }
+  auto& get_outputs() const { return state.outputs; }
+  auto& get_wsets() const { return state.wsets; }
+  auto& get_views() const { return state.views; }
+  auto& get_focused_output_name() const { return state.focused_output_name; }
+};
+
+}  // namespace waybar::modules::wayfire
@@ -0,0 +1,24 @@
+#pragma once
+
+#include "AAppIconLabel.hpp"
+#include "bar.hpp"
+#include "modules/wayfire/backend.hpp"
+
+namespace waybar::modules::wayfire {
+
+class Window : public AAppIconLabel {
+  std::shared_ptr<IPC> ipc;
+  EventHandler handler;
+
+  const Bar& bar_;
+  std::string old_app_id_;
+
+ public:
+  Window(const std::string& id, const Bar& bar, const Json::Value& config);
+  ~Window() override;
+
+  auto update() -> void override;
+  auto update_icon_label() -> void;
+};
+
+}  // namespace waybar::modules::wayfire
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <gtkmm/button.h>
+#include <json/json.h>
+
+#include <memory>
+#include <vector>
+
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "modules/wayfire/backend.hpp"
+
+namespace waybar::modules::wayfire {
+
+class Workspaces : public AModule {
+  std::shared_ptr<IPC> ipc;
+  EventHandler handler;
+
+  const Bar& bar_;
+  Gtk::Box box_;
+  std::vector<Gtk::Button> buttons_;
+
+  auto handleScroll(GdkEventScroll* e) -> bool override;
+  auto update() -> void override;
+  auto update_box() -> void;
+
+ public:
+  Workspaces(const std::string& id, const Bar& bar, const Json::Value& config);
+  ~Workspaces() override;
+};
+
+}  // namespace waybar::modules::wayfire
@@ -17,17 +17,25 @@ class Wireplumber : public ALabel {
  auto update() -> void override;

 private:
-  void loadRequiredApiModules();
-  void prepare();
+  void asyncLoadRequiredApiModules();
+  void prepare(waybar::modules::Wireplumber* self);
  void activatePlugins();
  static void updateVolume(waybar::modules::Wireplumber* self, uint32_t id);
  static void updateNodeName(waybar::modules::Wireplumber* self, uint32_t id);
+  static void updateSourceVolume(waybar::modules::Wireplumber* self, uint32_t id);
+  static void updateSourceName(waybar::modules::Wireplumber* self, uint32_t id);  // NEW
  static void onPluginActivated(WpObject* p, GAsyncResult* res, waybar::modules::Wireplumber* self);
+  static void onDefaultNodesApiLoaded(WpObject* p, GAsyncResult* res,
+                                      waybar::modules::Wireplumber* self);
+  static void onMixerApiLoaded(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;
+  std::vector<std::string> getWPIcon();
+
+  static std::list<waybar::modules::Wireplumber*> modules;

  WpCore* wp_core_;
  GPtrArray* apis_;
@@ -41,6 +49,13 @@ class Wireplumber : public ALabel {
  double min_step_;
  uint32_t node_id_{0};
  std::string node_name_;
+  std::string source_name_;
+  gchar* type_;
+  uint32_t source_node_id_;
+  bool source_muted_;
+  double source_volume_;
+  gchar* default_source_name_;
+  std::string form_factor_;
 };

 }  // namespace waybar::modules
--- a/Show More
+++ b/Show More