Merge remote-tracking branch 'origin/master' into idle_inhibitor-activity-detection

# Conflicts:
#	include/client.hpp

.github/workflows/clang-format.yml

@@ -10,13 +10,9 @@ jobs:
   lint:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      # TODO: bump to clang 19 release
-      # - uses: DoozyX/clang-format-lint-action@v0.18.2
-      - uses: DoozyX/clang-format-lint-action@558090054b3f39e3d6af24f0cd73b319535da809
+      - uses: actions/checkout@v6
+      - uses: RafikFarhad/clang-format-github-action@v6
         name: clang-format
         with:
-          source: "."
-          extensions: "hpp,h,cpp,c"
-          style: "file:.clang-format"
-          clangFormatVersion: 19
+          sources: "src/**/*.hpp,src/**/*.cpp"
+          style: "file"

.github/workflows/clang-tidy.yml.bak

@@ -12,7 +12,7 @@ jobs:
     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

.github/workflows/docker.yml

@@ -17,7 +17,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Login to Docker Hub
         uses: docker/login-action@v3

.github/workflows/freebsd.yml

@@ -12,7 +12,7 @@ jobs:
     # 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.28.0
         timeout-minutes: 180

.github/workflows/linux.yml

@@ -25,7 +25,7 @@ jobs:
       image: alexays/waybar:${{ matrix.distro }}
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v6
       - name: configure
         run: meson setup -Dman-pages=enabled -Dcpp_std=${{matrix.cpp_std}} build
       - name: build

.github/workflows/nix-tests.yml

@@ -2,12 +2,15 @@ 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@v4
-    - uses: cachix/install-nix-action@v27
+      - uses: actions/checkout@v6
+      - uses: cachix/install-nix-action@v31
         with:
           extra_nix_config: |
             experimental-features = nix-command flakes

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

@@ -12,11 +12,11 @@ jobs:
     if: github.event_name != 'schedule' || github.repository == 'Alexays/Waybar'
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v6
       - name: Install Nix
-        uses: cachix/install-nix-action@v27
+        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@v21
+        uses: DeterminateSystems/update-flake-lock@v28

.gitignore

@@ -7,6 +7,7 @@ vgcore.*
 *.swp
 packagecache
 /subprojects/**/
+/subprojects/.wraplock
 /build*
 /dist
 /meson.egg-info
@@ -50,3 +51,5 @@ result
 result-*
 
 .ccls-cache
+_codeql_detected_source_root
+heaptrack*

Makefile

@@ -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

README.md

@@ -119,7 +119,7 @@ sudo apt install \
 On Arch, you can use this command:
 
 ```
-pacman -S \
+pacman -S --asdeps \
   gtkmm3 \
   jsoncpp \
   libsigc++ \
@@ -151,6 +151,10 @@ 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).

_codeql_detected_source_root

@@ -0,0 +1 @@
+.

asan.supp

@@ -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

flake.lock

@@ -3,11 +3,11 @@
     "flake-compat": {
       "flake": false,
       "locked": {
-        "lastModified": 1747046372,
-        "narHash": "sha256-CIVLLkVgvHYbgI2UpXvIIBJ12HWgX+fjA8Xf8PUmqCY=",
+        "lastModified": 1767039857,
+        "narHash": "sha256-vNpUSpF5Nuw8xvDLj2KCwwksIbjua2LZCqhV1LNRDns=",
         "owner": "edolstra",
         "repo": "flake-compat",
-        "rev": "9100a0f413b0c601e0533d1d94ffd501ce2e7885",
+        "rev": "5edf11c44bc78a0d334f6334cdaf7d60d732daab",
         "type": "github"
       },
       "original": {
@@ -18,11 +18,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1753694789,
-        "narHash": "sha256-cKgvtz6fKuK1Xr5LQW/zOUiAC0oSQoA9nOISB0pJZqM=",
+        "lastModified": 1769461804,
+        "narHash": "sha256-msG8SU5WsBUfVVa/9RPLaymvi5bI8edTavbIq3vRlhI=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "dc9637876d0dcc8c9e5e22986b857632effeb727",
+        "rev": "bfc1b8a4574108ceef22f02bafcf6611380c100d",
         "type": "github"
       },
       "original": {

flake.nix

@@ -65,7 +65,7 @@
           nativeBuildInputs =
             pkgs.waybar.nativeBuildInputs
             ++ (with pkgs; [
-              nixfmt-rfc-style
+              nixfmt
               clang-tools
               gdb
             ]);
@@ -75,8 +75,7 @@
       formatter = genSystems (
         pkgs:
         pkgs.treefmt.withConfig {
-          settings = [
-            {
+          settings = {
             formatter = {
               clang-format = {
                 options = [ "-i" ];
@@ -90,13 +89,12 @@
                 ];
               };
               nixfmt = {
-                  command = lib.getExe pkgs.nixfmt-rfc-style;
+                command = lib.getExe pkgs.nixfmt;
                 includes = [ "*.nix" ];
               };
             };
             tree-root-file = ".git/index";
-            }
-          ];
+          };
         }
       );
 

include/AAppIconLabel.hpp

@@ -9,15 +9,15 @@ namespace waybar {
 
 class AAppIconLabel : public AIconLabel {
  public:
-  AAppIconLabel(const Json::Value &config, const std::string &name, const std::string &id,
-                const std::string &format, uint16_t interval = 0, bool ellipsize = false,
+  AAppIconLabel(const Json::Value& config, const std::string& name, const std::string& id,
+                const std::string& format, uint16_t interval = 0, bool ellipsize = false,
                 bool enable_click = false, bool enable_scroll = false);
   virtual ~AAppIconLabel() = default;
   auto update() -> void override;
 
  protected:
-  void updateAppIconName(const std::string &app_identifier,
-                         const std::string &alternative_app_identifier);
+  void updateAppIconName(const std::string& app_identifier,
+                         const std::string& alternative_app_identifier);
   void updateAppIcon();
   unsigned app_icon_size_{24};
   bool update_app_icon_{true};

include/AIconLabel.hpp

@@ -9,15 +9,19 @@ namespace waybar {
 
 class AIconLabel : public ALabel {
  public:
-  AIconLabel(const Json::Value &config, const std::string &name, const std::string &id,
-             const std::string &format, uint16_t interval = 0, bool ellipsize = false,
+  AIconLabel(const Json::Value& config, const std::string& name, const std::string& id,
+             const std::string& format, uint16_t interval = 0, bool ellipsize = false,
              bool enable_click = false, bool enable_scroll = false);
   virtual ~AIconLabel() = default;
   auto update() -> void override;
+  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;
 };

include/ALabel.hpp

@@ -4,33 +4,42 @@
 #include <gtkmm/label.h>
 #include <json/json.h>
 
+#include <optional>
+
 #include "AModule.hpp"
 
 namespace waybar {
 
 class ALabel : public AModule {
  public:
-  ALabel(const Json::Value &, const std::string &, const std::string &, const std::string &format,
+  ALabel(const Json::Value&, const std::string&, const std::string&, const std::string& format,
          uint16_t interval = 0, bool ellipsize = false, bool enable_click = false,
          bool enable_scroll = false);
   virtual ~ALabel() = default;
   auto update() -> void override;
-  virtual std::string getIcon(uint16_t, const std::string &alt = "", uint16_t max = 0);
-  virtual std::string getIcon(uint16_t, const std::vector<std::string> &alts, uint16_t max = 0);
+  virtual std::string getIcon(uint16_t, const std::string& alt = "", uint16_t max = 0);
+  virtual std::string getIcon(uint16_t, const std::vector<std::string>& alts, uint16_t max = 0);
 
  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 handleToggle(GdkEventButton *const &e) override;
+  bool setLabelMarkup(const Glib::ustring& markup);
+  bool setTooltipMarkup(const Glib::ustring& markup);
+
+  bool handleToggle(GdkEventButton* const& e) override;
   virtual std::string getState(uint8_t value, bool lesser = false);
 
-  std::map<std::string, GtkMenuItem *> submenus_;
+  std::map<std::string, GtkMenuItem*> submenus_;
   std::map<std::string, std::string> menuActionsMap_;
-  static void handleGtkMenuEvent(GtkMenuItem *menuitem, gpointer data);
+  static void handleGtkMenuEvent(GtkMenuItem* menuitem, gpointer data);
+
+ private:
+  std::optional<Glib::ustring> last_label_markup_;
+  std::optional<Glib::ustring> last_tooltip_markup_;
 };
 
 }  // namespace waybar

include/AModule.hpp

@@ -12,51 +12,58 @@ namespace waybar {
 
 class AModule : public IModule {
  public:
-  static constexpr const char *MODULE_CLASS = "module";
+  static constexpr const char* MODULE_CLASS = "module";
 
   ~AModule() override;
   auto update() -> void override;
   virtual auto refresh(int shouldRefresh) -> void {};
-  operator Gtk::Widget &() override;
-  auto doAction(const std::string &name) -> void override;
+  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
-  AModule(const Json::Value &, const std::string &, const std::string &, bool enable_click = false,
+  AModule(const Json::Value&, const std::string&, const std::string&, bool enable_click = false,
           bool enable_scroll = false);
 
   enum SCROLL_DIR { NONE, UP, DOWN, LEFT, RIGHT };
 
-  SCROLL_DIR getScrollDir(GdkEventScroll *e);
+  SCROLL_DIR getScrollDir(GdkEventScroll* e);
   bool tooltipEnabled() const;
 
   std::vector<int> pid_children_;
   const std::string name_;
-  const Json::Value &config_;
+  const Json::Value& config_;
   Gtk::EventBox event_box_;
 
-  virtual void setCursor(Gdk::CursorType const &c);
+  virtual void setCursor(Gdk::CursorType 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);
-  GObject *menu_;
+  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);
+  bool handleUserEvent(GdkEventButton* const& ev);
   const bool isTooltip;
   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"},

include/bar.hpp

@@ -62,11 +62,11 @@ class Bar : public sigc::trackable {
   static const std::string MODE_DEFAULT;
   static const std::string MODE_INVISIBLE;
 
-  Bar(struct waybar_output *w_output, const Json::Value &);
-  Bar(const Bar &) = delete;
+  Bar(struct waybar_output* w_output, const Json::Value&);
+  Bar(const Bar&) = delete;
   ~Bar();
 
-  void setMode(const std::string &mode);
+  void setMode(const std::string& mode);
   void setVisible(bool value);
   void toggle();
   void show();
@@ -75,9 +75,11 @@ class Bar : public sigc::trackable {
   util::KillSignalAction getOnSigusr1Action();
   util::KillSignalAction getOnSigusr2Action();
 
-  struct waybar_output *output;
+  void toggleSuspend(bool suspend);
+
+  struct waybar_output* output;
   Json::Value config;
-  struct wl_surface *surface;
+  struct wl_surface* surface;
   bool visible = true;
   Gtk::Window window;
   Gtk::Orientation orientation = Gtk::ORIENTATION_HORIZONTAL;
@@ -91,15 +93,16 @@ class Bar : public sigc::trackable {
 #endif
 
  private:
-  void onMap(GdkEventAny *);
+  void onMap(GdkEventAny*);
   auto setupWidgets() -> void;
-  void getModules(const Factory &, const std::string &, waybar::Group *);
-  void setupAltFormatKeyForModule(const std::string &module_name);
-  void setupAltFormatKeyForModuleList(const char *module_list_name);
-  void setMode(const bar_mode &);
+  void getModules(const Factory&, const std::string&, waybar::Group*);
+  void setupAltFormatKeyForModule(const std::string& module_name);
+  void setupAltFormatKeyForModuleList(const char* module_list_name);
+  void setMode(const bar_mode&);
   void setPassThrough(bool passthrough);
   void setPosition(Gtk::PositionType position);
-  void onConfigure(GdkEventConfigure *ev);
+  void forceLayerCommit();
+  void onConfigure(GdkEventConfigure* ev);
   void configureGlobalOffset(int width, int height);
   void onOutputGeometryChanged();
 

include/client.hpp

@@ -18,36 +18,37 @@ namespace waybar {
 
 class Client {
  public:
-  static Client *inst();
-  int main(int argc, char *argv[]);
+  static Client* inst();
+  int main(int argc, char* argv[]);
   void reset();
 
   Glib::RefPtr<Gtk::Application> gtk_app;
   Glib::RefPtr<Gdk::Display> gdk_display;
-  struct wl_display *wl_display = nullptr;
-  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;
+  struct wl_display* wl_display = nullptr;
+  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;
 
  private:
   Client() = default;
-  const std::string getStyle(const std::string &style, std::optional<Appearance> appearance);
+  const std::string getStyle(const std::string& style, std::optional<Appearance> appearance);
   void bindInterfaces();
-  void handleOutput(struct waybar_output &output);
-  auto setupCss(const std::string &css_file) -> void;
-  struct waybar_output &getOutput(void *);
-  std::vector<Json::Value> getOutputConfigs(struct waybar_output &output);
+  void handleOutput(struct waybar_output& output);
+  auto setupCss(const std::string& css_file) -> void;
+  struct waybar_output& getOutput(void*);
+  std::vector<Json::Value> getOutputConfigs(struct waybar_output& output);
 
-  static void handleGlobal(void *data, struct wl_registry *registry, uint32_t name,
-                           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 *);
-  static void handleOutputName(void *, struct zxdg_output_v1 *, const char *);
-  static void handleOutputDescription(void *, struct zxdg_output_v1 *, const char *);
+  static void handleGlobal(void* data, struct wl_registry* registry, uint32_t name,
+                           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);
   void handleMonitorRemoved(Glib::RefPtr<Gdk::Monitor> monitor);
   void handleDeferredMonitorRemoval(Glib::RefPtr<Gdk::Monitor> monitor);
@@ -58,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

include/config.hpp

@@ -14,28 +14,29 @@ namespace waybar {
 class Config {
  public:
   static const std::vector<std::string> CONFIG_DIRS;
-  static const char *CONFIG_PATH_ENV;
+  static const char* CONFIG_PATH_ENV;
 
   /* Try to find any of provided names in the supported set of config directories */
   static std::optional<std::string> findConfigPath(
-      const std::vector<std::string> &names, const std::vector<std::string> &dirs = CONFIG_DIRS);
+      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);
+  static std::vector<std::string> tryExpandPath(const std::string& base,
+                                                const std::string& filename);
 
   Config() = default;
 
-  void load(const std::string &config);
+  void load(const std::string& config);
 
-  Json::Value &getConfig() { return config_; }
+  Json::Value& getConfig() { return config_; }
 
-  std::vector<Json::Value> getOutputConfigs(const std::string &name, const std::string &identifier);
+  std::vector<Json::Value> getOutputConfigs(const std::string& name, const std::string& identifier);
 
  private:
-  void setupConfig(Json::Value &dst, const std::string &config_file, int depth);
-  void resolveConfigIncludes(Json::Value &config, int depth);
-  void mergeConfig(Json::Value &a_config_, Json::Value &b_config_);
-  static std::optional<std::string> findIncludePath(const std::string &name);
+  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_;
 

include/group.hpp

@@ -10,14 +10,16 @@
 namespace waybar {
 
 class Group : public AModule {
+ sigc::connection reveal_timeout_;
+
  public:
-  Group(const std::string &, const std::string &, const Json::Value &, bool);
+  Group(const std::string&, const std::string&, const Json::Value&, bool);
   ~Group() override = default;
   auto update() -> void override;
-  operator Gtk::Widget &() override;
+  operator Gtk::Widget&() override;
 
-  virtual Gtk::Box &getBox();
-  void addWidget(Gtk::Widget &widget);
+  virtual Gtk::Box& getBox();
+  void addWidget(Gtk::Widget& widget);
 
  protected:
   Gtk::Box box;
@@ -26,10 +28,12 @@ class Group : public AModule {
   bool is_first_widget = true;
   bool is_drawer = false;
   bool click_to_reveal = false;
+  int reveal_delay = 0;
   std::string add_class_to_drawer_children;
-  bool handleMouseEnter(GdkEventCrossing *const &ev) override;
-  bool handleMouseLeave(GdkEventCrossing *const &ev) override;
-  bool handleToggle(GdkEventButton *const &ev) override;
+  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();
 };

include/modules/backlight.hpp

@@ -17,11 +17,11 @@ namespace waybar::modules {
 
 class Backlight : public ALabel {
  public:
-  Backlight(const std::string &, const Json::Value &);
+  Backlight(const std::string&, const Json::Value&);
   virtual ~Backlight() = default;
   auto update() -> void override;
 
-  bool handleScroll(GdkEventScroll *e) override;
+  bool handleScroll(GdkEventScroll* e) override;
 
   const std::string preferred_device_;
 

include/modules/battery.hpp

@@ -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 {
 
@@ -37,16 +40,23 @@ class Battery : public ALabel {
   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_;

include/modules/cava.hpp

@@ -1,59 +0,0 @@
-#pragma once
-
-#include "ALabel.hpp"
-#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 {
-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};
-  std::string format_silent_{""};
-  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

include/modules/cava/cavaGLSL.hpp

@@ -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

include/modules/cava/cavaRaw.hpp

@@ -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

include/modules/cava/cava_backend.hpp

@@ -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

include/modules/cava/cava_frontend.hpp

@@ -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

include/modules/clock.hpp

@@ -50,6 +50,7 @@ class Clock final : public ALabel {
   std::string cldMonCached_;           // calendar Month mode. Cached calendar
   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 date::year_month_day& today, const date::year_month_day& ymd,
                     const date::time_zone* tz) -> const std::string;

include/modules/custom.hpp

@@ -35,6 +35,7 @@ class Custom : public ALabel {
   std::string id_;
   std::string alt_;
   std::string tooltip_;
+  std::string last_tooltip_markup_;
   const bool tooltip_format_enabled_;
   std::vector<std::string> class_;
   int percentage_;

include/modules/disk.hpp

@@ -22,7 +22,7 @@ class Disk : public ALabel {
   std::string path_;
   std::string unit_;
 
-  float calc_specific_divisor(const std::string divisor);
+  float calc_specific_divisor(const std::string& divisor);
 };
 
 }  // namespace waybar::modules

include/modules/dwl/tags.hpp

@@ -12,23 +12,23 @@ namespace waybar::modules::dwl {
 
 class Tags : public waybar::AModule {
  public:
-  Tags(const std::string &, const waybar::Bar &, const Json::Value &);
+  Tags(const std::string&, const waybar::Bar&, const Json::Value&);
   virtual ~Tags();
 
   // Handlers for wayland events
   void handle_view_tags(uint32_t tag, uint32_t state, uint32_t clients, uint32_t focused);
 
   void handle_primary_clicked(uint32_t tag);
-  bool handle_button_press(GdkEventButton *event_button, uint32_t tag);
+  bool handle_button_press(GdkEventButton* event_button, uint32_t tag);
 
-  struct zdwl_ipc_manager_v2 *status_manager_;
-  struct wl_seat *seat_;
+  struct zdwl_ipc_manager_v2* status_manager_;
+  struct wl_seat* seat_;
 
  private:
-  const waybar::Bar &bar_;
+  const waybar::Bar& bar_;
   Gtk::Box box_;
   std::vector<Gtk::Button> buttons_;
-  struct zdwl_ipc_output_v2 *output_status_;
+  struct zdwl_ipc_output_v2* output_status_;
 };
 
 } /* namespace waybar::modules::dwl */

include/modules/dwl/window.hpp

@@ -13,26 +13,26 @@ namespace waybar::modules::dwl {
 
 class Window : public AAppIconLabel, public sigc::trackable {
  public:
-  Window(const std::string &, const waybar::Bar &, const Json::Value &);
+  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_layout_symbol(const char *layout_symbol);
+  void handle_title(const char* title);
+  void handle_appid(const char* ppid);
+  void handle_layout_symbol(const char* layout_symbol);
   void handle_frame();
 
-  struct zdwl_ipc_manager_v2 *status_manager_;
+  struct zdwl_ipc_manager_v2* status_manager_;
 
  private:
-  const Bar &bar_;
+  const Bar& bar_;
 
   std::string title_;
   std::string appid_;
   std::string layout_symbol_;
   uint32_t layout_;
 
-  struct zdwl_ipc_output_v2 *output_status_;
+  struct zdwl_ipc_output_v2* output_status_;
 };
 
 }  // namespace waybar::modules::dwl

include/modules/ext/workspace_manager.hpp

@@ -20,16 +20,16 @@ class Workspace;
 
 class WorkspaceManager final : public AModule {
  public:
-  WorkspaceManager(const std::string &id, const waybar::Bar &bar, const Json::Value &config);
+  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 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_workspace_group(ext_workspace_group_handle_v1* handle);
+  void handle_workspace(ext_workspace_handle_v1* handle);
   void handle_done();
   void handle_finished();
 
@@ -38,7 +38,7 @@ class WorkspaceManager final : public AModule {
 
  private:
   void update() override;
-  bool has_button(const Gtk::Button *button);
+  bool has_button(const Gtk::Button* button);
   void sort_workspaces();
   void clear_buttons();
   void update_buttons();
@@ -52,10 +52,10 @@ class WorkspaceManager final : public AModule {
   bool sort_by_coordinates_ = false;
   bool all_outputs_ = false;
 
-  const waybar::Bar &bar_;
+  const waybar::Bar& bar_;
   Gtk::Box box_;
 
-  ext_workspace_manager_v1 *ext_manager_ = nullptr;
+  ext_workspace_manager_v1* ext_manager_ = nullptr;
   std::vector<std::unique_ptr<WorkspaceGroup>> groups_;
   std::vector<std::unique_ptr<Workspace>> workspaces_;
 
@@ -64,60 +64,60 @@ class WorkspaceManager final : public AModule {
 
 class WorkspaceGroup {
  public:
-  WorkspaceGroup(WorkspaceManager &manager, ext_workspace_group_handle_v1 *handle, uint32_t id);
+  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);
+  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_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_;
+  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_;
+  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(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_; }
+  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_; }
+  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_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;
+  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;
+  WorkspaceManager& workspace_manager_;
+  ext_workspace_handle_v1* ext_handle_ = nullptr;
   uint32_t id_;
   uint32_t state_ = 0;
   std::string workspace_id_;
@@ -136,8 +136,6 @@ class Workspace {
   Gtk::Button button_;
   Gtk::Box content_;
   Gtk::Label label_;
-
-  bool needs_updating_ = false;
 };
 
 }  // namespace waybar::modules::ext

include/modules/ext/workspace_manager_binding.hpp

@@ -1,10 +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);
+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

include/modules/gamemode.hpp

@@ -17,7 +17,7 @@ namespace waybar::modules {
 
 class Gamemode : public AModule {
  public:
-  Gamemode(const std::string &, const Json::Value &);
+  Gamemode(const std::string&, const Json::Value&);
   virtual ~Gamemode();
   auto update() -> void override;
 
@@ -26,20 +26,20 @@ 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);
-  void disappear(const Glib::RefPtr<Gio::DBus::Connection> &connection, const Glib::ustring &name);
-  void prepareForSleep_cb(const Glib::RefPtr<Gio::DBus::Connection> &connection,
-                          const Glib::ustring &sender_name, const Glib::ustring &object_path,
-                          const Glib::ustring &interface_name, const Glib::ustring &signal_name,
-                          const Glib::VariantContainerBase &parameters);
-  void notify_cb(const Glib::ustring &sender_name, const Glib::ustring &signal_name,
-                 const Glib::VariantContainerBase &arguments);
+  void appear(const Glib::RefPtr<Gio::DBus::Connection>& connection, const Glib::ustring& name,
+              const Glib::ustring& name_owner);
+  void disappear(const Glib::RefPtr<Gio::DBus::Connection>& connection, const Glib::ustring& name);
+  void prepareForSleep_cb(const Glib::RefPtr<Gio::DBus::Connection>& connection,
+                          const Glib::ustring& sender_name, const Glib::ustring& object_path,
+                          const Glib::ustring& interface_name, const Glib::ustring& signal_name,
+                          const Glib::VariantContainerBase& parameters);
+  void notify_cb(const Glib::ustring& sender_name, const Glib::ustring& signal_name,
+                 const Glib::VariantContainerBase& arguments);
 
   void getData();
-  bool handleToggle(GdkEventButton *const &) override;
+  bool handleToggle(GdkEventButton* const&) override;
 
   // Config
   std::string format = DEFAULT_FORMAT;

include/modules/hyprland/backend.hpp

@@ -1,8 +1,10 @@
 #pragma once
 
+#include <atomic>
 #include <filesystem>
 #include <list>
 #include <mutex>
+#include <optional>
 #include <string>
 #include <thread>
 #include <utility>
@@ -17,9 +19,13 @@ 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();
   ~IPC();
   static IPC& inst();
 
@@ -30,21 +36,33 @@ class IPC {
   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 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_;  // the hyprland socket file descriptor
-  bool running_ = true;
+  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 bool modulesReady = false;
-inline std::unique_ptr<IPC> gIPC;
 };  // namespace waybar::modules::hyprland

include/modules/hyprland/submap.hpp

@@ -26,6 +26,7 @@ class Submap : public waybar::ALabel, public EventHandler {
   const Bar& bar_;
   util::JsonParser parser_;
   std::string submap_;
+  std::string prev_submap_;
   bool always_on_ = false;
   std::string default_submap_ = "Default";
 

include/modules/hyprland/window.hpp

@@ -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,11 @@ 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;
 };

include/modules/hyprland/windowcount.hpp

@@ -7,7 +7,6 @@
 #include "AAppIconLabel.hpp"
 #include "bar.hpp"
 #include "modules/hyprland/backend.hpp"
-#include "util/json.hpp"
 
 namespace waybar::modules::hyprland {
 
@@ -26,8 +25,8 @@ class WindowCount : public waybar::AAppIconLabel, public EventHandler {
     static auto parse(const Json::Value& value) -> Workspace;
   };
 
-  static auto getActiveWorkspace(const std::string&) -> Workspace;
-  static auto getActiveWorkspace() -> 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);
@@ -36,6 +35,7 @@ class WindowCount : public waybar::AAppIconLabel, public EventHandler {
   std::mutex mutex_;
   const Bar& bar_;
   Workspace workspace_;
+  IPC& m_ipc;
 };
 
 }  // namespace waybar::modules::hyprland

include/modules/hyprland/windowcreationpayload.hpp

@@ -40,10 +40,11 @@ struct WindowRepr {
 
 class WindowCreationPayload {
  public:
-  WindowCreationPayload(std::string workspace_name, WindowAddress window_address,
+  WindowCreationPayload(const std::string& workspace_name, WindowAddress window_address,
                         WindowRepr window_repr);
-  WindowCreationPayload(std::string workspace_name, WindowAddress window_address,
-                        std::string window_class, std::string window_title, bool is_active);
+  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();

include/modules/hyprland/workspace.hpp

@@ -30,6 +30,7 @@ class Workspace {
  public:
   explicit Workspace(const Json::Value& workspace_data, Workspaces& workspace_manager,
                      const Json::Value& clients_data = Json::Value::nullRef);
+  ~Workspace();
   std::string& selectIcon(std::map<std::string, std::string>& icons_map);
   Gtk::Button& button() { return m_button; };
 
@@ -42,10 +43,18 @@ class Workspace {
   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;
+
+  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; };
@@ -81,6 +90,8 @@ class Workspace {
   bool m_isUrgent = false;
   bool m_isVisible = false;
 
+  sigc::connection m_hoverCheckConnection;
+
   std::vector<WindowRepr> m_windowMap;
 
   Gtk::Button m_button;
@@ -88,6 +99,7 @@ class Workspace {
   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;

include/modules/hyprland/workspaces.hpp

@@ -4,6 +4,7 @@
 #include <gtkmm/enums.h>
 #include <gtkmm/label.h>
 #include <json/value.h>
+#include <sigc++/connection.h>
 
 #include <cstdint>
 #include <map>
@@ -43,6 +44,7 @@ class Workspaces : public AModule, public EventHandler {
   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; }
@@ -51,10 +53,14 @@ class Workspaces : public AModule, public EventHandler {
   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; }
 
-  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; }
   bool isWorkspaceIgnored(std::string const& workspace_name);
 
@@ -118,6 +124,8 @@ class Workspaces : public AModule, public EventHandler {
   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();
@@ -141,6 +149,7 @@ class Workspaces : public AModule, public EventHandler {
   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.
@@ -183,6 +192,14 @@ class Workspaces : public AModule, public EventHandler {
   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;
 
@@ -192,6 +209,7 @@ class Workspaces : public AModule, public EventHandler {
   std::mutex m_mutex;
   const Bar& m_bar;
   Gtk::Box m_box;
+  sigc::connection m_scrollEventConnection_;
   IPC& m_ipc;
 };
 

include/modules/image.hpp

@@ -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_;

include/modules/jack.hpp

@@ -13,7 +13,7 @@ namespace waybar::modules {
 
 class JACK : public ALabel {
  public:
-  JACK(const std::string &, const Json::Value &);
+  JACK(const std::string&, const Json::Value&);
   virtual ~JACK() = default;
   auto update() -> void override;
 
@@ -25,7 +25,7 @@ class JACK : public ALabel {
  private:
   std::string JACKState();
 
-  jack_client_t *client_;
+  jack_client_t* client_;
   jack_nframes_t bufsize_;
   jack_nframes_t samplerate_;
   unsigned int xruns_;
@@ -38,7 +38,7 @@ class JACK : public ALabel {
 
 }  // namespace waybar::modules
 
-int bufSizeCallback(jack_nframes_t size, void *obj);
-int sampleRateCallback(jack_nframes_t rate, void *obj);
-int xrunCallback(void *obj);
-void shutdownCallback(void *obj);
+int bufSizeCallback(jack_nframes_t size, void* obj);
+int sampleRateCallback(jack_nframes_t rate, void* obj);
+int xrunCallback(void* obj);
+void shutdownCallback(void* obj);

include/modules/keyboard_state.hpp

@@ -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_;

include/modules/memory.hpp

@@ -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

include/modules/mpd/mpd.hpp

@@ -33,6 +33,7 @@ class MPD : public ALabel {
   detail::unique_status status_;
   mpd_state state_;
   detail::unique_song song_;
+  std::string ellipsis_;
 
  public:
   MPD(const std::string&, const Json::Value&);
@@ -44,7 +45,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,7 +59,6 @@ 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; }

include/modules/mpd/state.hpp

@@ -197,7 +197,6 @@ class Context {
   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;

include/modules/mpd/state.inl.hpp

@@ -1,13 +1,14 @@
 #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 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 +16,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(); }
 

include/modules/mpris/mpris.hpp

@@ -78,6 +78,7 @@ class Mpris : public ALabel {
 
   PlayerctlPlayerManager* manager;
   PlayerctlPlayer* player;
+  PlayerctlPlayer* last_active_player_ = nullptr;
   std::string lastStatus;
   std::string lastPlayer;
 

include/modules/network.hpp

@@ -70,6 +70,9 @@ class Network : public ALabel {
 
   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_;

include/modules/niri/backend.hpp

@@ -17,7 +17,7 @@ class EventHandler {
 
 class IPC {
  public:
-  IPC() { startIPC(); }
+  IPC();
 
   void registerForIPC(const std::string& ev, EventHandler* ev_handler);
   void unregisterForIPC(EventHandler* handler);

include/modules/niri/language.hpp

@@ -10,13 +10,13 @@ namespace waybar::modules::niri {
 
 class Language : public ALabel, public EventHandler {
  public:
-  Language(const std::string &, const Bar &, const Json::Value &);
+  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 onEvent(const Json::Value& ev) override;
   void doUpdate();
 
   struct Layout {
@@ -26,13 +26,14 @@ class Language : public ALabel, public EventHandler {
     std::string short_description;
   };
 
-  static Layout getLayout(const std::string &fullName);
+  static Layout getLayout(const std::string& fullName);
 
   std::mutex mutex_;
-  const Bar &bar_;
+  const Bar& bar_;
 
   std::vector<Layout> layouts_;
   unsigned current_idx_;
+  std::string last_short_name_;
 };
 
 }  // namespace waybar::modules::niri

include/modules/niri/window.hpp

@@ -11,16 +11,16 @@ namespace waybar::modules::niri {
 
 class Window : public AAppIconLabel, public EventHandler {
  public:
-  Window(const std::string &, const Bar &, const Json::Value &);
+  Window(const std::string&, const Bar&, const Json::Value&);
   ~Window() override;
   void update() override;
 
  private:
-  void onEvent(const Json::Value &ev) override;
+  void onEvent(const Json::Value& ev) override;
   void doUpdate();
-  void setClass(const std::string &className, bool enable);
+  void setClass(const std::string& className, bool enable);
 
-  const Bar &bar_;
+  const Bar& bar_;
 
   std::string oldAppId_;
 };

include/modules/niri/workspaces.hpp

@@ -11,17 +11,17 @@ namespace waybar::modules::niri {
 
 class Workspaces : public AModule, public EventHandler {
  public:
-  Workspaces(const std::string &, const Bar &, const Json::Value &);
+  Workspaces(const std::string&, const Bar&, const Json::Value&);
   ~Workspaces() override;
   void update() override;
 
  private:
-  void onEvent(const Json::Value &ev) override;
+  void onEvent(const Json::Value& ev) override;
   void doUpdate();
-  Gtk::Button &addButton(const Json::Value &ws);
-  std::string getIcon(const std::string &value, const Json::Value &ws);
+  Gtk::Button& addButton(const Json::Value& ws);
+  std::string getIcon(const std::string& value, const Json::Value& ws);
 
-  const Bar &bar_;
+  const Bar& bar_;
   Gtk::Box box_;
   // Map from niri workspace id to button.
   std::unordered_map<uint64_t, Gtk::Button> buttons_;

include/modules/power_profiles_daemon.hpp

@@ -9,22 +9,31 @@ 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) : name(std::move(n)), driver(std::move(d)) {}
+  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 {
  public:
-  PowerProfilesDaemon(const std::string &, const Json::Value &);
+  PowerProfilesDaemon(const std::string&, const Json::Value&);
   auto update() -> void override;
-  void profileChangedCb(const Gio::DBus::Proxy::MapChangedProperties &,
-                        const std::vector<Glib::ustring> &);
-  void busConnectedCb(Glib::RefPtr<Gio::AsyncResult> &r);
-  void getAllPropsCb(Glib::RefPtr<Gio::AsyncResult> &r);
-  void setPropCb(Glib::RefPtr<Gio::AsyncResult> &r);
+  void profileChangedCb(const Gio::DBus::Proxy::MapChangedProperties&,
+                        const std::vector<Glib::ustring>&);
+  void busConnectedCb(Glib::RefPtr<Gio::AsyncResult>& r);
+  void getAllPropsCb(Glib::RefPtr<Gio::AsyncResult>& r);
+  void setPropCb(Glib::RefPtr<Gio::AsyncResult>& r);
   void populateInitState();
-  bool handleToggle(GdkEventButton *const &e) override;
+  bool handleToggle(GdkEventButton* const& e) override;
 
  private:
   // True if we're connected to the dbug interface. False if we're
@@ -32,7 +41,7 @@ class PowerProfilesDaemon : public ALabel {
   bool connected_;
   // Look for a profile name in the list of available profiles and
   // switch activeProfile_ to it.
-  void switchToProfile(std::string const &);
+  void switchToProfile(std::string const&);
   // Used to toggle/display the profiles
   std::vector<Profile> availableProfiles_;
   // Points to the active profile in the profiles list

include/modules/privacy/privacy.hpp

@@ -13,21 +13,22 @@ namespace waybar::modules::privacy {
 
 class Privacy : public AModule {
  public:
-  Privacy(const std::string &, const Json::Value &, Gtk::Orientation, const std::string &pos);
+  Privacy(const std::string&, const Json::Value&, Gtk::Orientation, const std::string& pos);
   auto update() -> void override;
 
   void onPrivacyNodesChanged();
 
  private:
-  std::list<PrivacyNodeInfo *> nodes_screenshare;  // Screen is being shared
-  std::list<PrivacyNodeInfo *> nodes_audio_in;     // Application is using the microphone
-  std::list<PrivacyNodeInfo *> nodes_audio_out;    // Application is outputting audio
+  std::list<PrivacyNodeInfo*> nodes_screenshare;  // Screen is being shared
+  std::list<PrivacyNodeInfo*> nodes_audio_in;     // Application is using the microphone
+  std::list<PrivacyNodeInfo*> nodes_audio_out;    // Application is outputting audio
 
   std::mutex mutex_;
   sigc::connection visibility_conn;
 
   // Config
   Gtk::Box box_;
+  std::vector<PrivacyItem*> modules_;
   uint iconSpacing = 4;
   uint iconSize = 20;
   uint transition_duration = 250;

include/modules/privacy/privacy_item.hpp

@@ -16,16 +16,16 @@ namespace waybar::modules::privacy {
 
 class PrivacyItem : public Gtk::Revealer {
  public:
-  PrivacyItem(const Json::Value &config_, enum PrivacyNodeType privacy_type_,
-              std::list<PrivacyNodeInfo *> *nodes, Gtk::Orientation orientation,
-              const std::string &pos, const uint icon_size, const uint transition_duration);
+  PrivacyItem(const Json::Value& config_, enum PrivacyNodeType privacy_type_,
+              std::list<PrivacyNodeInfo*>* nodes, Gtk::Orientation orientation,
+              const std::string& pos, const uint icon_size, const uint transition_duration);
 
   enum PrivacyNodeType privacy_type;
 
   void set_in_use(bool in_use);
 
  private:
-  std::list<PrivacyNodeInfo *> *nodes;
+  std::list<PrivacyNodeInfo*>* nodes;
 
   sigc::connection signal_conn;
 

include/modules/pulseaudio_slider.hpp

@@ -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

include/modules/river/layout.hpp

@@ -10,25 +10,25 @@ namespace waybar::modules::river {
 
 class Layout : public waybar::ALabel {
  public:
-  Layout(const std::string &, const waybar::Bar &, const Json::Value &);
+  Layout(const std::string&, const waybar::Bar&, const Json::Value&);
   virtual ~Layout();
 
   // Handlers for wayland events
-  void handle_name(const char *name);
+  void handle_name(const char* name);
   void handle_clear();
-  void handle_focused_output(struct wl_output *output);
-  void handle_unfocused_output(struct wl_output *output);
+  void handle_focused_output(struct wl_output* output);
+  void handle_unfocused_output(struct wl_output* output);
 
-  struct zriver_status_manager_v1 *status_manager_;
-  struct wl_seat *seat_;
+  struct zriver_status_manager_v1* status_manager_;
+  struct wl_seat* seat_;
 
  private:
-  const waybar::Bar &bar_;
+  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_;
-  struct zriver_seat_status_v1 *seat_status_;
+  struct wl_output* output_;          // stores the output this module belongs to
+  struct wl_output* focused_output_;  // stores the currently focused output
+  struct zriver_output_status_v1* output_status_;
+  struct zriver_seat_status_v1* seat_status_;
 };
 
 } /* namespace waybar::modules::river */

include/modules/river/mode.hpp

@@ -10,19 +10,19 @@ namespace waybar::modules::river {
 
 class Mode : public waybar::ALabel {
  public:
-  Mode(const std::string &, const waybar::Bar &, const Json::Value &);
+  Mode(const std::string&, const waybar::Bar&, const Json::Value&);
   virtual ~Mode();
 
   // Handlers for wayland events
-  void handle_mode(const char *mode);
+  void handle_mode(const char* mode);
 
-  struct zriver_status_manager_v1 *status_manager_;
-  struct wl_seat *seat_;
+  struct zriver_status_manager_v1* status_manager_;
+  struct wl_seat* seat_;
 
  private:
-  const waybar::Bar &bar_;
+  const waybar::Bar& bar_;
   std::string mode_;
-  struct zriver_seat_status_v1 *seat_status_;
+  struct zriver_seat_status_v1* seat_status_;
 };
 
 } /* namespace waybar::modules::river */

include/modules/river/tags.hpp

@@ -13,26 +13,27 @@ namespace waybar::modules::river {
 
 class Tags : public waybar::AModule {
  public:
-  Tags(const std::string &, const waybar::Bar &, const Json::Value &);
+  Tags(const std::string&, const waybar::Bar&, const Json::Value&);
   virtual ~Tags();
 
   // Handlers for wayland events
   void handle_focused_tags(uint32_t tags);
-  void handle_view_tags(struct wl_array *tags);
+  void handle_view_tags(struct wl_array* tags);
   void handle_urgent_tags(uint32_t tags);
 
+  void handle_show();
   void handle_primary_clicked(uint32_t tag);
-  bool handle_button_press(GdkEventButton *event_button, uint32_t tag);
+  bool handle_button_press(GdkEventButton* event_button, uint32_t tag);
 
-  struct zriver_status_manager_v1 *status_manager_;
-  struct zriver_control_v1 *control_;
-  struct wl_seat *seat_;
+  struct zriver_status_manager_v1* status_manager_;
+  struct zriver_control_v1* control_;
+  struct wl_seat* seat_;
 
  private:
-  const waybar::Bar &bar_;
+  const waybar::Bar& bar_;
   Gtk::Box box_;
   std::vector<Gtk::Button> buttons_;
-  struct zriver_output_status_v1 *output_status_;
+  struct zriver_output_status_v1* output_status_;
 };
 
 } /* namespace waybar::modules::river */

include/modules/river/window.hpp

@@ -12,22 +12,22 @@ namespace waybar::modules::river {
 
 class Window : public waybar::ALabel {
  public:
-  Window(const std::string &, const waybar::Bar &, const Json::Value &);
+  Window(const std::string&, const waybar::Bar&, const Json::Value&);
   virtual ~Window();
 
   // Handlers for wayland events
-  void handle_focused_view(const char *title);
-  void handle_focused_output(struct wl_output *output);
-  void handle_unfocused_output(struct wl_output *output);
+  void handle_focused_view(const char* title);
+  void handle_focused_output(struct wl_output* output);
+  void handle_unfocused_output(struct wl_output* output);
 
-  struct zriver_status_manager_v1 *status_manager_;
-  struct wl_seat *seat_;
+  struct zriver_status_manager_v1* status_manager_;
+  struct wl_seat* seat_;
 
  private:
-  const waybar::Bar &bar_;
-  struct wl_output *output_;          // stores the output this module belongs to
-  struct wl_output *focused_output_;  // stores the currently focused output
-  struct zriver_seat_status_v1 *seat_status_;
+  const waybar::Bar& bar_;
+  struct wl_output* output_;          // stores the output this module belongs to
+  struct wl_output* focused_output_;  // stores the currently focused output
+  struct zriver_seat_status_v1* seat_status_;
 };
 
 } /* namespace waybar::modules::river */

include/modules/sndio.hpp

@@ -11,18 +11,18 @@ namespace waybar::modules {
 
 class Sndio : public ALabel {
  public:
-  Sndio(const std::string &, const Json::Value &);
+  Sndio(const std::string&, const Json::Value&);
   virtual ~Sndio();
   auto update() -> void override;
-  auto set_desc(struct sioctl_desc *, unsigned int) -> void;
+  auto set_desc(struct sioctl_desc*, unsigned int) -> void;
   auto put_val(unsigned int, unsigned int) -> void;
-  bool handleScroll(GdkEventScroll *) override;
-  bool handleToggle(GdkEventButton *const &) override;
+  bool handleScroll(GdkEventScroll*) override;
+  bool handleToggle(GdkEventButton* const&) override;
 
  private:
   auto connect_to_sndio() -> void;
   util::SleeperThread thread_;
-  struct sioctl_hdl *hdl_;
+  struct sioctl_hdl* hdl_;
   std::vector<struct pollfd> pfds_;
   unsigned int addr_;
   unsigned int volume_, old_volume_, maxval_;

include/modules/sni/host.hpp

@@ -16,7 +16,7 @@ class Host {
  public:
   Host(const std::size_t id, const Json::Value&, const Bar&,
        const std::function<void(std::unique_ptr<Item>&)>&,
-       const std::function<void(std::unique_ptr<Item>&)>&);
+       const std::function<void(std::unique_ptr<Item>&)>&, const std::function<void()>&);
   ~Host();
 
  private:
@@ -28,9 +28,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 +43,13 @@ 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::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

include/modules/sni/item.hpp

@@ -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,6 +70,8 @@ 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);
@@ -69,8 +79,13 @@ class Item : public sigc::trackable {
                 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);
@@ -86,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_;

include/modules/sni/tray.hpp

@@ -19,9 +19,9 @@ class Tray : public AModule {
  private:
   void onAdd(std::unique_ptr<Item>& item);
   void onRemove(std::unique_ptr<Item>& item);
+  void queueUpdate();
 
   static inline std::size_t nb_hosts_ = 0;
-  bool show_passive_ = false;
   Gtk::Box box_;
   SNI::Watcher::singleton watcher_;
   SNI::Host host_;

include/modules/sni/watcher.hpp

@@ -30,27 +30,27 @@ class Watcher {
 
   typedef struct {
     GfWatchType type;
-    Watcher *watcher;
-    gchar *service;
-    gchar *bus_name;
-    gchar *object_path;
+    Watcher* watcher;
+    gchar* service;
+    gchar* bus_name;
+    gchar* object_path;
     guint watch_id;
   } GfWatch;
 
-  void busAcquired(const Glib::RefPtr<Gio::DBus::Connection> &, Glib::ustring);
-  static gboolean handleRegisterHost(Watcher *, GDBusMethodInvocation *, const gchar *);
-  static gboolean handleRegisterItem(Watcher *, GDBusMethodInvocation *, const gchar *);
-  static GfWatch *gfWatchFind(GSList *list, const gchar *bus_name, const gchar *object_path);
-  static GfWatch *gfWatchNew(GfWatchType, const gchar *, const gchar *, const gchar *, Watcher *);
-  static void nameVanished(GDBusConnection *connection, const char *name, gpointer data);
+  void busAcquired(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring);
+  static gboolean handleRegisterHost(Watcher*, GDBusMethodInvocation*, const gchar*);
+  static gboolean handleRegisterItem(Watcher*, GDBusMethodInvocation*, const gchar*);
+  static GfWatch* gfWatchFind(GSList* list, const gchar* bus_name, const gchar* object_path);
+  static GfWatch* gfWatchNew(GfWatchType, const gchar*, const gchar*, const gchar*, Watcher*);
+  static void nameVanished(GDBusConnection* connection, const char* name, gpointer data);
   static void gfWatchFree(gpointer data);
 
-  void updateRegisteredItems(SnWatcher *obj);
+  void updateRegisteredItems(SnWatcher* obj);
 
   uint32_t bus_name_id_;
-  GSList *hosts_ = nullptr;
-  GSList *items_ = nullptr;
-  SnWatcher *watcher_ = nullptr;
+  GSList* hosts_ = nullptr;
+  GSList* items_ = nullptr;
+  SnWatcher* watcher_ = nullptr;
 };
 
 }  // namespace waybar::modules::SNI

include/modules/sway/bar.hpp

@@ -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_;

include/modules/sway/ipc/client.hpp

@@ -12,6 +12,8 @@
 #include <string>
 
 #include "ipc.hpp"
+#include "util/SafeSignal.hpp"
+#include "util/scoped_fd.hpp"
 #include "util/sleeper_thread.hpp"
 
 namespace waybar::modules::sway {
@@ -27,25 +29,25 @@ 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);
+  void sendCmd(uint32_t type, const std::string& payload = "");
+  void subscribe(const std::string& payload);
   void handleEvent();
-  void setWorker(std::function<void()> &&func);
+  void setWorker(std::function<void()>&& func);
 
  protected:
   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;
-  struct ipc_response send(int fd, uint32_t type, const std::string &payload = "");
+  int open(const std::string&) const;
+  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_;
 };

include/modules/sway/language.hpp

@@ -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;

include/modules/sway/workspaces.hpp

@@ -24,10 +24,11 @@ class Workspaces : public AModule, public sigc::trackable {
 
  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);
 
   void onCmd(const struct Ipc::ipc_response&);
@@ -40,7 +41,7 @@ class Workspaces : public AModule, public sigc::trackable {
   std::string getIcon(const std::string&, const Json::Value&);
   std::string getCycleWorkspace(std::vector<Json::Value>::iterator, bool prev) const;
   uint16_t getWorkspaceIndex(const std::string& name) const;
-  static std::string trimWorkspaceName(std::string);
+  static std::string trimWorkspaceName(const std::string&);
   bool handleScroll(GdkEventScroll* /*unused*/) override;
 
   const Bar& bar_;

include/modules/systemd_failed_units.hpp

@@ -3,6 +3,7 @@
 #include <giomm/dbusproxy.h>
 
 #include <string>
+#include <vector>
 
 #include "ALabel.hpp"
 
@@ -10,24 +11,43 @@ namespace waybar::modules {
 
 class SystemdFailedUnits : public ALabel {
  public:
-  SystemdFailedUnits(const std::string &, const Json::Value &);
-  virtual ~SystemdFailedUnits();
+  SystemdFailedUnits(const std::string&, const Json::Value&);
+  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;
-  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_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_;
 
-  void notify_cb(const Glib::ustring &sender_name, const Glib::ustring &signal_name,
-                 const Glib::VariantContainerBase &arguments);
+  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();
 };
 

include/modules/temperature.hpp

@@ -14,6 +14,8 @@ 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();

include/modules/upower.hpp

@@ -12,7 +12,7 @@ namespace waybar::modules {
 
 class UPower final : public AIconLabel {
  public:
-  UPower(const std::string &, const Json::Value &);
+  UPower(const std::string&, const Json::Value&);
   virtual ~UPower();
   auto update() -> void override;
 
@@ -30,17 +30,17 @@ class UPower final : public AIconLabel {
 
   // UPower device info
   struct upDevice_output {
-    UpDevice *upDevice{NULL};
+    UpDevice* upDevice{NULL};
     double percentage{0.0};
     double temperature{0.0};
     guint64 time_full{0u};
     guint64 time_empty{0u};
-    gchar *icon_name{(char *)'\0'};
+    gchar* icon_name{(char*)'\0'};
     bool upDeviceValid{false};
     UpDeviceState state;
     UpDeviceKind kind;
-    char *nativePath{(char *)'\0'};
-    char *model{(char *)'\0'};
+    char* nativePath{(char*)'\0'};
+    char* model{(char*)'\0'};
   };
 
   // Technical variables
@@ -53,13 +53,13 @@ class UPower final : public AIconLabel {
   bool sleeping_;
 
   // Technical functions
-  void addDevice(UpDevice *);
-  void removeDevice(const gchar *);
+  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> &);
+  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_;
@@ -67,28 +67,28 @@ class UPower final : public AIconLabel {
   guint subscrID_{0u};
 
   // UPower variables
-  UpClient *upClient_;
+  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);
+  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);
+  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_);
+  void getUpDeviceInfo(upDevice_output& upDevice_);
 };
 
 }  // namespace waybar::modules

include/modules/wayfire/backend.hpp

@@ -12,6 +12,8 @@
 #include <unordered_map>
 #include <utility>
 
+#include "util/scoped_fd.hpp"
+
 namespace waybar::modules::wayfire {
 
 using EventHandler = std::function<void(const std::string& event)>;
@@ -71,25 +73,9 @@ struct State {
   auto update_view(const Json::Value& view) -> void;
 };
 
-struct Sock {
-  int fd;
+using Sock = util::ScopedFd;
 
-  Sock(int fd) : fd{fd} {}
-  ~Sock() { close(fd); }
-  Sock(const Sock&) = delete;
-  auto operator=(const Sock&) = delete;
-  Sock(Sock&& rhs) noexcept {
-    fd = rhs.fd;
-    rhs.fd = -1;
-  }
-  auto& operator=(Sock&& rhs) noexcept {
-    fd = rhs.fd;
-    rhs.fd = -1;
-    return *this;
-  }
-};
-
-class IPC {
+class IPC : public std::enable_shared_from_this<IPC> {
   static std::weak_ptr<IPC> instance;
   Json::CharReaderBuilder reader_builder;
   Json::StreamWriterBuilder writer_builder;
@@ -98,7 +84,7 @@ class IPC {
   State state;
   std::mutex state_mutex;
 
-  IPC() { start(); }
+  IPC() = default;
 
   static auto connect() -> Sock;
   auto receive(Sock& sock) -> Json::Value;

include/modules/wlr/taskbar.hpp

@@ -18,6 +18,7 @@
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "client.hpp"
+#include "ext-workspace-v1-client-protocol.h"
 #include "giomm/desktopappinfo.h"
 #include "util/icon_loader.hpp"
 #include "util/json.hpp"
@@ -33,8 +34,8 @@ class Taskbar;
 
 class Task {
  public:
-  Task(const waybar::Bar &, const Json::Value &, Taskbar *,
-       struct zwlr_foreign_toplevel_handle_v1 *, struct wl_seat *);
+  Task(const waybar::Bar&, const Json::Value&, Taskbar*, struct zwlr_foreign_toplevel_handle_v1*,
+       struct wl_seat*);
   ~Task();
 
  public:
@@ -53,11 +54,11 @@ class Task {
   static uint32_t global_id;
 
  private:
-  const waybar::Bar &bar_;
-  const Json::Value &config_;
-  Taskbar *tbar_;
-  struct zwlr_foreign_toplevel_handle_v1 *handle_;
-  struct wl_seat *seat_;
+  const waybar::Bar& bar_;
+  const Json::Value& config_;
+  Taskbar* tbar_;
+  struct zwlr_foreign_toplevel_handle_v1* handle_;
+  struct wl_seat* seat_;
 
   uint32_t id_;
 
@@ -80,6 +81,7 @@ class Task {
   std::string title_;
   std::string app_id_;
   uint32_t state_ = 0;
+  struct ext_workspace_handle_v1* workspace_ = nullptr;
 
   int32_t drag_start_x;
   int32_t drag_start_y;
@@ -89,7 +91,7 @@ class Task {
   std::string repr() const;
   std::string state_string(bool = false) const;
   void set_minimize_hint();
-  void on_button_size_allocated(Gtk::Allocation &alloc);
+  void on_button_size_allocated(Gtk::Allocation& alloc);
   void hide_if_ignored();
 
  public:
@@ -102,29 +104,32 @@ class Task {
   bool minimized() const { return state_ & MINIMIZED; }
   bool active() const { return state_ & ACTIVE; }
   bool fullscreen() const { return state_ & FULLSCREEN; }
+  bool visible() const { return button_visible_; }
+  struct ext_workspace_handle_v1* workspace() const { return workspace_; }
+  void set_workspace(struct ext_workspace_handle_v1* workspace) { workspace_ = workspace; }
 
  public:
   /* Callbacks for the wlr protocol */
-  void handle_title(const char *);
-  void handle_app_id(const char *);
-  void handle_output_enter(struct wl_output *);
-  void handle_output_leave(struct wl_output *);
-  void handle_state(struct wl_array *);
+  void handle_title(const char*);
+  void handle_app_id(const char*);
+  void handle_output_enter(struct wl_output*);
+  void handle_output_leave(struct wl_output*);
+  void handle_state(struct wl_array*);
   void handle_done();
   void handle_closed();
 
   /* Callbacks for Gtk events */
-  bool handle_clicked(GdkEventButton *);
-  bool handle_button_release(GdkEventButton *);
-  bool handle_motion_notify(GdkEventMotion *);
-  void handle_drag_data_get(const Glib::RefPtr<Gdk::DragContext> &context,
-                            Gtk::SelectionData &selection_data, guint info, guint time);
-  void handle_drag_data_received(const Glib::RefPtr<Gdk::DragContext> &context, int x, int y,
+  bool handle_clicked(GdkEventButton*);
+  bool handle_button_release(GdkEventButton*);
+  bool handle_motion_notify(GdkEventMotion*);
+  void handle_drag_data_get(const Glib::RefPtr<Gdk::DragContext>& context,
+                            Gtk::SelectionData& selection_data, guint info, guint time);
+  void handle_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y,
                                  Gtk::SelectionData selection_data, guint info, guint time);
 
  public:
-  bool operator==(const Task &) const;
-  bool operator!=(const Task &) const;
+  bool operator==(const Task&) const;
+  bool operator!=(const Task&) const;
 
  public:
   void update();
@@ -142,12 +147,18 @@ using TaskPtr = std::unique_ptr<Task>;
 
 class Taskbar : public waybar::AModule {
  public:
-  Taskbar(const std::string &, const waybar::Bar &, const Json::Value &);
+  struct WorkspaceState {
+    Taskbar* taskbar;
+    struct ext_workspace_handle_v1* handle;
+    uint32_t state = 0;
+  };
+
+  Taskbar(const std::string&, const waybar::Bar&, const Json::Value&);
   ~Taskbar();
   void update();
 
  private:
-  const waybar::Bar &bar_;
+  const waybar::Bar& bar_;
   Gtk::Box box_;
   std::vector<TaskPtr> tasks_;
 
@@ -155,30 +166,46 @@ class Taskbar : public waybar::AModule {
   std::unordered_set<std::string> ignore_list_;
   std::map<std::string, std::string> app_ids_replace_map_;
 
-  struct zwlr_foreign_toplevel_manager_v1 *manager_;
-  struct wl_seat *seat_;
+  struct zwlr_foreign_toplevel_manager_v1* manager_;
+  struct ext_workspace_manager_v1* workspace_manager_;
+  struct wl_seat* seat_;
+  std::vector<struct ext_workspace_group_handle_v1*> workspace_groups_;
+  std::vector<std::unique_ptr<WorkspaceState>> workspaces_;
+  struct ext_workspace_handle_v1* current_workspace_ = nullptr;
 
  public:
   /* Callbacks for global registration */
-  void register_manager(struct wl_registry *, uint32_t name, uint32_t version);
-  void register_seat(struct wl_registry *, uint32_t name, uint32_t version);
+  void register_manager(struct wl_registry*, uint32_t name, uint32_t version);
+  void register_workspace_manager(struct wl_registry*, uint32_t name, uint32_t version);
+  void register_seat(struct wl_registry*, uint32_t name, uint32_t version);
 
   /* Callbacks for the wlr protocol */
-  void handle_toplevel_create(struct zwlr_foreign_toplevel_handle_v1 *);
+  void handle_toplevel_create(struct zwlr_foreign_toplevel_handle_v1*);
   void handle_finished();
+  void handle_workspace_group_create(struct ext_workspace_group_handle_v1*);
+  void handle_workspace_group_removed(struct ext_workspace_group_handle_v1*);
+  void handle_workspace_create(struct ext_workspace_handle_v1*);
+  void handle_workspace_done();
+  void handle_workspace_finished();
+  void handle_workspace_removed(struct ext_workspace_handle_v1*);
 
  public:
-  void add_button(Gtk::Button &);
-  void move_button(Gtk::Button &, int);
-  void remove_button(Gtk::Button &);
+  void add_button(Gtk::Button&);
+  void move_button(Gtk::Button&, int);
+  void remove_button(Gtk::Button&);
   void remove_task(uint32_t);
+  void assign_current_workspace(Task&);
+  void update_bar_css_classes();
 
-  bool show_output(struct wl_output *) const;
+  bool show_output(struct wl_output*) const;
   bool all_outputs() const;
 
-  const IconLoader &icon_loader() const;
-  const std::unordered_set<std::string> &ignore_list() const;
-  const std::map<std::string, std::string> &app_ids_replace_map() const;
+  const IconLoader& icon_loader() const;
+  const std::unordered_set<std::string>& ignore_list() const;
+  const std::map<std::string, std::string>& app_ids_replace_map() const;
+
+ private:
+  void set_bar_css_class(const std::string&, bool);
 };
 
 } /* namespace waybar::modules::wlr */

include/util/SafeSignal.hpp

@@ -3,6 +3,7 @@
 #include <glibmm/dispatcher.h>
 #include <sigc++/signal.h>
 
+#include <cstddef>
 #include <functional>
 #include <mutex>
 #include <queue>
@@ -11,11 +12,6 @@
 #include <type_traits>
 #include <utility>
 
-#ifdef __OpenBSD__
-#define SIGRTMIN SIGUSR1 - 1
-#define SIGRTMAX SIGUSR1 + 1
-#endif
-
 namespace waybar {
 
 /**
@@ -27,6 +23,12 @@ struct SafeSignal : sigc::signal<void(std::decay_t<Args>...)> {
  public:
   SafeSignal() { dp_.connect(sigc::mem_fun(*this, &SafeSignal::handle_event)); }
 
+  void set_max_queued_events(std::size_t max_queued_events) {
+    std::unique_lock lock(mutex_);
+    max_queued_events_ = max_queued_events;
+    trim_queue_locked();
+  }
+
   template <typename... EmitArgs>
   void emit(EmitArgs&&... args) {
     if (main_tid_ == std::this_thread::get_id()) {
@@ -41,6 +43,9 @@ struct SafeSignal : sigc::signal<void(std::decay_t<Args>...)> {
     } else {
       {
         std::unique_lock lock(mutex_);
+        if (max_queued_events_ != 0 && queue_.size() >= max_queued_events_) {
+          queue_.pop();
+        }
         queue_.emplace(std::forward<EmitArgs>(args)...);
       }
       dp_.emit();
@@ -60,6 +65,15 @@ struct SafeSignal : sigc::signal<void(std::decay_t<Args>...)> {
   using signal_t::emit_reverse;
   using signal_t::make_slot;
 
+  void trim_queue_locked() {
+    if (max_queued_events_ == 0) {
+      return;
+    }
+    while (queue_.size() > max_queued_events_) {
+      queue_.pop();
+    }
+  }
+
   void handle_event() {
     for (std::unique_lock lock(mutex_); !queue_.empty(); lock.lock()) {
       auto args = queue_.front();
@@ -72,6 +86,7 @@ struct SafeSignal : sigc::signal<void(std::decay_t<Args>...)> {
   Glib::Dispatcher dp_;
   std::mutex mutex_;
   std::queue<arg_tuple_t> queue_;
+  std::size_t max_queued_events_ = 4096;
   const std::thread::id main_tid_ = std::this_thread::get_id();
   // cache functor for signal emission to avoid recreating it on each event
   const slot_t cached_fn_ = make_slot();

include/util/audio_backend.hpp

@@ -14,6 +14,11 @@
 
 namespace waybar::util {
 
+enum class PulseaudioTarget {
+  Sink,
+  Source,
+};
+
 class AudioBackend {
  private:
   static void subscribeCb(pa_context*, pa_subscription_event_type_t, uint32_t, void*);
@@ -92,6 +97,10 @@ class AudioBackend {
   void toggleSourceMute();
   void toggleSourceMute(bool);
 
+  uint16_t getVolume(PulseaudioTarget) const;
+  bool getMuted(PulseaudioTarget) const;
+  void unmute(PulseaudioTarget);
+
   bool isBluetooth();
 };
 

include/util/backlight_backend.hpp

@@ -36,7 +36,7 @@ class BacklightDevice {
   void set_max(int max);
   bool get_powered() const;
   void set_powered(bool powered);
-  friend inline bool operator==(const BacklightDevice &lhs, const BacklightDevice &rhs) {
+  friend inline bool operator==(const BacklightDevice& lhs, const BacklightDevice& rhs) {
     return lhs.name_ == rhs.name_ && lhs.actual_ == rhs.actual_ && lhs.max_ == rhs.max_;
   }
 
@@ -52,25 +52,25 @@ class BacklightBackend {
   BacklightBackend(std::chrono::milliseconds interval, std::function<void()> on_updated_cb = NOOP);
 
   // const inline BacklightDevice *get_best_device(std::string_view preferred_device);
-  const BacklightDevice *get_previous_best_device();
+  const BacklightDevice* get_previous_best_device();
 
-  void set_previous_best_device(const BacklightDevice *device);
+  void set_previous_best_device(const BacklightDevice* device);
 
-  void set_brightness(const std::string &preferred_device, ChangeType change_type, double step);
+  void set_brightness(const std::string& preferred_device, ChangeType change_type, double step);
 
-  void set_scaled_brightness(const std::string &preferred_device, int brightness);
-  int get_scaled_brightness(const std::string &preferred_device);
+  void set_scaled_brightness(const std::string& preferred_device, int brightness);
+  int get_scaled_brightness(const std::string& preferred_device);
 
   bool is_login_proxy_initialized() const { return static_cast<bool>(login_proxy_); }
 
-  static const BacklightDevice *best_device(const std::vector<BacklightDevice> &devices,
+  static const BacklightDevice* best_device(const std::vector<BacklightDevice>& devices,
                                             std::string_view);
 
   std::vector<BacklightDevice> devices_;
   std::mutex udev_thread_mutex_;
 
  private:
-  void set_brightness_internal(const std::string &device_name, int brightness, int max_brightness);
+  void set_brightness_internal(const std::string& device_name, int brightness, int max_brightness);
 
   std::function<void()> on_updated_cb_;
   std::chrono::milliseconds polling_interval_;

include/util/clara.hpp

@@ -78,7 +78,7 @@ class Column {
   class iterator {
     friend Column;
 
-    Column const &m_column;
+    Column const& m_column;
     size_t m_stringIndex = 0;
     size_t m_pos = 0;
 
@@ -86,10 +86,10 @@ class Column {
     size_t m_end = 0;
     bool m_suffix = false;
 
-    iterator(Column const &column, size_t stringIndex)
+    iterator(Column const& column, size_t stringIndex)
         : m_column(column), m_stringIndex(stringIndex) {}
 
-    auto line() const -> std::string const & { return m_column.m_strings[m_stringIndex]; }
+    auto line() const -> std::string const& { return m_column.m_strings[m_stringIndex]; }
 
     auto isBoundary(size_t at) const -> bool {
       assert(at > 0);
@@ -129,18 +129,18 @@ class Column {
       return initial == std::string::npos ? m_column.m_indent : initial;
     }
 
-    auto addIndentAndSuffix(std::string const &plain) const -> std::string {
+    auto addIndentAndSuffix(std::string const& plain) const -> std::string {
       return std::string(indent(), ' ') + (m_suffix ? plain + "-" : plain);
     }
 
    public:
     using difference_type = std::ptrdiff_t;
     using value_type = std::string;
-    using pointer = value_type *;
-    using reference = value_type &;
+    using pointer = value_type*;
+    using reference = value_type&;
     using iterator_category = std::forward_iterator_tag;
 
-    explicit iterator(Column const &column) : m_column(column) {
+    explicit iterator(Column const& column) : m_column(column) {
       assert(m_column.m_width > m_column.m_indent);
       assert(m_column.m_initialIndent == std::string::npos ||
              m_column.m_width > m_column.m_initialIndent);
@@ -154,7 +154,7 @@ class Column {
       return addIndentAndSuffix(line().substr(m_pos, m_len));
     }
 
-    auto operator++() -> iterator & {
+    auto operator++() -> iterator& {
       m_pos += m_len;
       if (m_pos < line().size() && line()[m_pos] == '\n')
         m_pos += 1;
@@ -174,26 +174,26 @@ class Column {
       return prev;
     }
 
-    auto operator==(iterator const &other) const -> bool {
+    auto operator==(iterator const& other) const -> bool {
       return m_pos == other.m_pos && m_stringIndex == other.m_stringIndex &&
              &m_column == &other.m_column;
     }
-    auto operator!=(iterator const &other) const -> bool { return !operator==(other); }
+    auto operator!=(iterator const& other) const -> bool { return !operator==(other); }
   };
   using const_iterator = iterator;
 
-  explicit Column(std::string const &text) { m_strings.push_back(text); }
+  explicit Column(std::string const& text) { m_strings.push_back(text); }
 
-  auto width(size_t newWidth) -> Column & {
+  auto width(size_t newWidth) -> Column& {
     assert(newWidth > 0);
     m_width = newWidth;
     return *this;
   }
-  auto indent(size_t newIndent) -> Column & {
+  auto indent(size_t newIndent) -> Column& {
     m_indent = newIndent;
     return *this;
   }
-  auto initialIndent(size_t newIndent) -> Column & {
+  auto initialIndent(size_t newIndent) -> Column& {
     m_initialIndent = newIndent;
     return *this;
   }
@@ -202,7 +202,7 @@ class Column {
   auto begin() const -> iterator { return iterator(*this); }
   auto end() const -> iterator { return {*this, m_strings.size()}; }
 
-  inline friend std::ostream &operator<<(std::ostream &os, Column const &col) {
+  inline friend std::ostream& operator<<(std::ostream& os, Column const& col) {
     bool first = true;
     for (auto line : col) {
       if (first)
@@ -214,7 +214,7 @@ class Column {
     return os;
   }
 
-  auto operator+(Column const &other) -> Columns;
+  auto operator+(Column const& other) -> Columns;
 
   auto toString() const -> std::string {
     std::ostringstream oss;
@@ -236,34 +236,34 @@ class Columns {
     friend Columns;
     struct EndTag {};
 
-    std::vector<Column> const &m_columns;
+    std::vector<Column> const& m_columns;
     std::vector<Column::iterator> m_iterators;
     size_t m_activeIterators;
 
-    iterator(Columns const &columns, EndTag) : m_columns(columns.m_columns), m_activeIterators(0) {
+    iterator(Columns const& columns, EndTag) : m_columns(columns.m_columns), m_activeIterators(0) {
       m_iterators.reserve(m_columns.size());
 
-      for (auto const &col : m_columns) m_iterators.push_back(col.end());
+      for (auto const& col : m_columns) m_iterators.push_back(col.end());
     }
 
    public:
     using difference_type = std::ptrdiff_t;
     using value_type = std::string;
-    using pointer = value_type *;
-    using reference = value_type &;
+    using pointer = value_type*;
+    using reference = value_type&;
     using iterator_category = std::forward_iterator_tag;
 
-    explicit iterator(Columns const &columns)
+    explicit iterator(Columns const& columns)
         : m_columns(columns.m_columns), m_activeIterators(m_columns.size()) {
       m_iterators.reserve(m_columns.size());
 
-      for (auto const &col : m_columns) m_iterators.push_back(col.begin());
+      for (auto const& col : m_columns) m_iterators.push_back(col.begin());
     }
 
-    auto operator==(iterator const &other) const -> bool {
+    auto operator==(iterator const& other) const -> bool {
       return m_iterators == other.m_iterators;
     }
-    auto operator!=(iterator const &other) const -> bool {
+    auto operator!=(iterator const& other) const -> bool {
       return m_iterators != other.m_iterators;
     }
     auto operator*() const -> std::string {
@@ -284,7 +284,7 @@ class Columns {
       }
       return row;
     }
-    auto operator++() -> iterator & {
+    auto operator++() -> iterator& {
       for (size_t i = 0; i < m_columns.size(); ++i) {
         if (m_iterators[i] != m_columns[i].end()) ++m_iterators[i];
       }
@@ -301,17 +301,17 @@ class Columns {
   auto begin() const -> iterator { return iterator(*this); }
   auto end() const -> iterator { return {*this, iterator::EndTag()}; }
 
-  auto operator+=(Column const &col) -> Columns & {
+  auto operator+=(Column const& col) -> Columns& {
     m_columns.push_back(col);
     return *this;
   }
-  auto operator+(Column const &col) -> Columns {
+  auto operator+(Column const& col) -> Columns {
     Columns combined = *this;
     combined += col;
     return combined;
   }
 
-  inline friend std::ostream &operator<<(std::ostream &os, Columns const &cols) {
+  inline friend std::ostream& operator<<(std::ostream& os, Columns const& cols) {
     bool first = true;
     for (auto line : cols) {
       if (first)
@@ -330,7 +330,7 @@ class Columns {
   }
 };
 
-inline auto Column::operator+(Column const &other) -> Columns {
+inline auto Column::operator+(Column const& other) -> Columns {
   Columns cols;
   cols += *this;
   cols += other;
@@ -381,7 +381,7 @@ class Args {
   std::vector<std::string> m_args;
 
  public:
-  Args(int argc, char const *const *argv) : m_exeName(argv[0]), m_args(argv + 1, argv + argc) {}
+  Args(int argc, char const* const* argv) : m_exeName(argv[0]), m_args(argv + 1, argv + argc) {}
 
   Args(std::initializer_list<std::string> args)
       : m_exeName(*args.begin()), m_args(args.begin() + 1, args.end()) {}
@@ -419,7 +419,7 @@ class TokenStream {
     while (it != itEnd && it->empty()) ++it;
 
     if (it != itEnd) {
-      auto const &next = *it;
+      auto const& next = *it;
       if (isOptPrefix(next[0])) {
         auto delimiterPos = next.find_first_of(" :=");
         if (delimiterPos != std::string::npos) {
@@ -443,7 +443,7 @@ class TokenStream {
   }
 
  public:
-  explicit TokenStream(Args const &args) : TokenStream(args.m_args.begin(), args.m_args.end()) {}
+  explicit TokenStream(Args const& args) : TokenStream(args.m_args.begin(), args.m_args.end()) {}
 
   TokenStream(Iterator it, Iterator itEnd) : it(it), itEnd(itEnd) { loadBuffer(); }
 
@@ -456,12 +456,12 @@ class TokenStream {
     return m_tokenBuffer.front();
   }
 
-  auto operator->() const -> Token const * {
+  auto operator->() const -> Token const* {
     assert(!m_tokenBuffer.empty());
     return &m_tokenBuffer.front();
   }
 
-  auto operator++() -> TokenStream & {
+  auto operator++() -> TokenStream& {
     if (m_tokenBuffer.size() >= 2) {
       m_tokenBuffer.erase(m_tokenBuffer.begin());
     } else {
@@ -488,7 +488,7 @@ class ResultBase {
 template <typename T>
 class ResultValueBase : public ResultBase {
  public:
-  auto value() const -> T const & {
+  auto value() const -> T const& {
     enforceOk();
     return m_value;
   }
@@ -496,13 +496,13 @@ class ResultValueBase : public ResultBase {
  protected:
   ResultValueBase(Type type) : ResultBase(type) {}
 
-  ResultValueBase(ResultValueBase const &other) : ResultBase(other) {
+  ResultValueBase(ResultValueBase const& other) : ResultBase(other) {
     if (m_type == ResultBase::Ok) new (&m_value) T(other.m_value);
   }
 
-  ResultValueBase(Type, T const &value) : ResultBase(Ok) { new (&m_value) T(value); }
+  ResultValueBase(Type, T const& value) : ResultBase(Ok) { new (&m_value) T(value); }
 
-  auto operator=(ResultValueBase const &other) -> ResultValueBase & {
+  auto operator=(ResultValueBase const& other) -> ResultValueBase& {
     if (m_type == ResultBase::Ok) m_value.~T();
     ResultBase::operator=(other);
     if (m_type == ResultBase::Ok) new (&m_value) T(other.m_value);
@@ -528,20 +528,20 @@ template <typename T = void>
 class BasicResult : public ResultValueBase<T> {
  public:
   template <typename U>
-  explicit BasicResult(BasicResult<U> const &other)
+  explicit BasicResult(BasicResult<U> const& other)
       : ResultValueBase<T>(other.type()), m_errorMessage(other.errorMessage()) {
     assert(type() != ResultBase::Ok);
   }
 
   template <typename U>
-  static auto ok(U const &value) -> BasicResult {
+  static auto ok(U const& value) -> BasicResult {
     return {ResultBase::Ok, value};
   }
   static auto ok() -> BasicResult { return {ResultBase::Ok}; }
-  static auto logicError(std::string const &message) -> BasicResult {
+  static auto logicError(std::string const& message) -> BasicResult {
     return {ResultBase::LogicError, message};
   }
-  static auto runtimeError(std::string const &message) -> BasicResult {
+  static auto runtimeError(std::string const& message) -> BasicResult {
     return {ResultBase::RuntimeError, message};
   }
 
@@ -560,7 +560,7 @@ class BasicResult : public ResultValueBase<T> {
 
   std::string m_errorMessage;  // Only populated if resultType is an error
 
-  BasicResult(ResultBase::Type type, std::string const &message)
+  BasicResult(ResultBase::Type type, std::string const& message)
       : ResultValueBase<T>(type), m_errorMessage(message) {
     assert(m_type != ResultBase::Ok);
   }
@@ -573,7 +573,7 @@ enum class ParseResultType { Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
 
 class ParseState {
  public:
-  ParseState(ParseResultType type, TokenStream const &remainingTokens)
+  ParseState(ParseResultType type, TokenStream const& remainingTokens)
       : m_type(type), m_remainingTokens(remainingTokens) {}
 
   auto type() const -> ParseResultType { return m_type; }
@@ -594,7 +594,7 @@ struct HelpColumns {
 };
 
 template <typename T>
-inline auto convertInto(std::string const &source, T &target) -> ParserResult {
+inline auto convertInto(std::string const& source, T& target) -> ParserResult {
   std::stringstream ss;
   ss << source;
   ss >> target;
@@ -603,11 +603,11 @@ inline auto convertInto(std::string const &source, T &target) -> ParserResult {
   else
     return ParserResult::ok(ParseResultType::Matched);
 }
-inline auto convertInto(std::string const &source, std::string &target) -> ParserResult {
+inline auto convertInto(std::string const& source, std::string& target) -> ParserResult {
   target = source;
   return ParserResult::ok(ParseResultType::Matched);
 }
-inline auto convertInto(std::string const &source, bool &target) -> ParserResult {
+inline auto convertInto(std::string const& source, bool& target) -> ParserResult {
   std::string srcLC = source;
   std::transform(srcLC.begin(), srcLC.end(), srcLC.begin(),
                  [](char c) { return static_cast<char>(::tolower(c)); });
@@ -622,7 +622,7 @@ inline auto convertInto(std::string const &source, bool &target) -> ParserResult
 }
 #ifdef CLARA_CONFIG_OPTIONAL_TYPE
 template <typename T>
-inline auto convertInto(std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T> &target)
+inline auto convertInto(std::string const& source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target)
     -> ParserResult {
   T temp;
   auto result = convertInto(source, temp);
@@ -633,10 +633,10 @@ inline auto convertInto(std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>
 
 struct NonCopyable {
   NonCopyable() = default;
-  NonCopyable(NonCopyable const &) = delete;
-  NonCopyable(NonCopyable &&) = delete;
-  NonCopyable &operator=(NonCopyable const &) = delete;
-  NonCopyable &operator=(NonCopyable &&) = delete;
+  NonCopyable(NonCopyable const&) = delete;
+  NonCopyable(NonCopyable&&) = delete;
+  NonCopyable& operator=(NonCopyable const&) = delete;
+  NonCopyable& operator=(NonCopyable&&) = delete;
 };
 
 struct BoundRef : NonCopyable {
@@ -645,7 +645,7 @@ struct BoundRef : NonCopyable {
   virtual auto isFlag() const -> bool { return false; }
 };
 struct BoundValueRefBase : BoundRef {
-  virtual auto setValue(std::string const &arg) -> ParserResult = 0;
+  virtual auto setValue(std::string const& arg) -> ParserResult = 0;
 };
 struct BoundFlagRefBase : BoundRef {
   virtual auto setFlag(bool flag) -> ParserResult = 0;
@@ -654,22 +654,22 @@ struct BoundFlagRefBase : BoundRef {
 
 template <typename T>
 struct BoundValueRef : BoundValueRefBase {
-  T &m_ref;
+  T& m_ref;
 
-  explicit BoundValueRef(T &ref) : m_ref(ref) {}
+  explicit BoundValueRef(T& ref) : m_ref(ref) {}
 
-  auto setValue(std::string const &arg) -> ParserResult override { return convertInto(arg, m_ref); }
+  auto setValue(std::string const& arg) -> ParserResult override { return convertInto(arg, m_ref); }
 };
 
 template <typename T>
 struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
-  std::vector<T> &m_ref;
+  std::vector<T>& m_ref;
 
-  explicit BoundValueRef(std::vector<T> &ref) : m_ref(ref) {}
+  explicit BoundValueRef(std::vector<T>& ref) : m_ref(ref) {}
 
   auto isContainer() const -> bool override { return true; }
 
-  auto setValue(std::string const &arg) -> ParserResult override {
+  auto setValue(std::string const& arg) -> ParserResult override {
     T temp;
     auto result = convertInto(arg, temp);
     if (result) m_ref.push_back(temp);
@@ -678,9 +678,9 @@ struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
 };
 
 struct BoundFlagRef : BoundFlagRefBase {
-  bool &m_ref;
+  bool& m_ref;
 
-  explicit BoundFlagRef(bool &ref) : m_ref(ref) {}
+  explicit BoundFlagRef(bool& ref) : m_ref(ref) {}
 
   auto setFlag(bool flag) -> ParserResult override {
     m_ref = flag;
@@ -694,7 +694,7 @@ struct LambdaInvoker {
                 "Lambda must return void or clara::ParserResult");
 
   template <typename L, typename ArgType>
-  static auto invoke(L const &lambda, ArgType const &arg) -> ParserResult {
+  static auto invoke(L const& lambda, ArgType const& arg) -> ParserResult {
     return lambda(arg);
   }
 };
@@ -702,14 +702,14 @@ struct LambdaInvoker {
 template <>
 struct LambdaInvoker<void> {
   template <typename L, typename ArgType>
-  static auto invoke(L const &lambda, ArgType const &arg) -> ParserResult {
+  static auto invoke(L const& lambda, ArgType const& arg) -> ParserResult {
     lambda(arg);
     return ParserResult::ok(ParseResultType::Matched);
   }
 };
 
 template <typename ArgType, typename L>
-inline auto invokeLambda(L const &lambda, std::string const &arg) -> ParserResult {
+inline auto invokeLambda(L const& lambda, std::string const& arg) -> ParserResult {
   ArgType temp{};
   auto result = convertInto(arg, temp);
   return !result ? result
@@ -721,9 +721,9 @@ struct BoundLambda : BoundValueRefBase {
   L m_lambda;
 
   static_assert(UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument");
-  explicit BoundLambda(L const &lambda) : m_lambda(lambda) {}
+  explicit BoundLambda(L const& lambda) : m_lambda(lambda) {}
 
-  auto setValue(std::string const &arg) -> ParserResult override {
+  auto setValue(std::string const& arg) -> ParserResult override {
     return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>(m_lambda, arg);
   }
 };
@@ -736,7 +736,7 @@ struct BoundFlagLambda : BoundFlagRefBase {
   static_assert(std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value,
                 "flags must be boolean");
 
-  explicit BoundFlagLambda(L const &lambda) : m_lambda(lambda) {}
+  explicit BoundFlagLambda(L const& lambda) : m_lambda(lambda) {}
 
   auto setFlag(bool flag) -> ParserResult override {
     return LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke(m_lambda, flag);
@@ -751,11 +751,11 @@ class ParserBase {
  public:
   virtual ~ParserBase() = default;
   virtual auto validate() const -> Result { return Result::ok(); }
-  virtual auto parse(std::string const &exeName, TokenStream const &tokens) const
+  virtual auto parse(std::string const& exeName, TokenStream const& tokens) const
       -> InternalParseResult = 0;
   virtual auto cardinality() const -> size_t { return 1; }
 
-  auto parse(Args const &args) const -> InternalParseResult {
+  auto parse(Args const& args) const -> InternalParseResult {
     return parse(args.exeName(), TokenStream(args));
   }
 };
@@ -764,10 +764,10 @@ template <typename DerivedT>
 class ComposableParserImpl : public ParserBase {
  public:
   template <typename T>
-  auto operator|(T const &other) const -> Parser;
+  auto operator|(T const& other) const -> Parser;
 
   template <typename T>
-  auto operator+(T const &other) const -> Parser;
+  auto operator+(T const& other) const -> Parser;
 };
 
 // Common code and state for Args and Opts
@@ -779,30 +779,30 @@ class ParserRefImpl : public ComposableParserImpl<DerivedT> {
   std::string m_hint;
   std::string m_description;
 
-  explicit ParserRefImpl(std::shared_ptr<BoundRef> const &ref) : m_ref(ref) {}
+  explicit ParserRefImpl(std::shared_ptr<BoundRef> const& ref) : m_ref(ref) {}
 
  public:
   template <typename T>
-  ParserRefImpl(T &ref, std::string const &hint)
+  ParserRefImpl(T& ref, std::string const& hint)
       : m_ref(std::make_shared<BoundValueRef<T>>(ref)), m_hint(hint) {}
 
   template <typename LambdaT>
-  ParserRefImpl(LambdaT const &ref, std::string const &hint)
+  ParserRefImpl(LambdaT const& ref, std::string const& hint)
       : m_ref(std::make_shared<BoundLambda<LambdaT>>(ref)), m_hint(hint) {}
 
-  auto operator()(std::string const &description) -> DerivedT & {
+  auto operator()(std::string const& description) -> DerivedT& {
     m_description = description;
-    return static_cast<DerivedT &>(*this);
+    return static_cast<DerivedT&>(*this);
   }
 
-  auto optional() -> DerivedT & {
+  auto optional() -> DerivedT& {
     m_optionality = Optionality::Optional;
-    return static_cast<DerivedT &>(*this);
+    return static_cast<DerivedT&>(*this);
   };
 
-  auto required() -> DerivedT & {
+  auto required() -> DerivedT& {
     m_optionality = Optionality::Required;
-    return static_cast<DerivedT &>(*this);
+    return static_cast<DerivedT&>(*this);
   };
 
   auto isOptional() const -> bool { return m_optionality == Optionality::Optional; }
@@ -822,29 +822,29 @@ class ExeName : public ComposableParserImpl<ExeName> {
   std::shared_ptr<BoundValueRefBase> m_ref;
 
   template <typename LambdaT>
-  static auto makeRef(LambdaT const &lambda) -> std::shared_ptr<BoundValueRefBase> {
+  static auto makeRef(LambdaT const& lambda) -> std::shared_ptr<BoundValueRefBase> {
     return std::make_shared<BoundLambda<LambdaT>>(lambda);
   }
 
  public:
   ExeName() : m_name(std::make_shared<std::string>("<executable>")) {}
 
-  explicit ExeName(std::string &ref) : ExeName() {
+  explicit ExeName(std::string& ref) : ExeName() {
     m_ref = std::make_shared<BoundValueRef<std::string>>(ref);
   }
 
   template <typename LambdaT>
-  explicit ExeName(LambdaT const &lambda) : ExeName() {
+  explicit ExeName(LambdaT const& lambda) : ExeName() {
     m_ref = std::make_shared<BoundLambda<LambdaT>>(lambda);
   }
 
   // The exe name is not parsed out of the normal tokens, but is handled specially
-  auto parse(std::string const &, TokenStream const &tokens) const -> InternalParseResult override {
+  auto parse(std::string const&, TokenStream const& tokens) const -> InternalParseResult override {
     return InternalParseResult::ok(ParseState(ParseResultType::NoMatch, tokens));
   }
 
   auto name() const -> std::string { return *m_name; }
-  auto set(std::string const &newName) -> ParserResult {
+  auto set(std::string const& newName) -> ParserResult {
     auto lastSlash = newName.find_last_of("\\/");
     auto filename = (lastSlash == std::string::npos) ? newName : newName.substr(lastSlash + 1);
 
@@ -860,17 +860,17 @@ class Arg : public ParserRefImpl<Arg> {
  public:
   using ParserRefImpl::ParserRefImpl;
 
-  auto parse(std::string const &, TokenStream const &tokens) const -> InternalParseResult override {
+  auto parse(std::string const&, TokenStream const& tokens) const -> InternalParseResult override {
     auto validationResult = validate();
     if (!validationResult) return InternalParseResult(validationResult);
 
     auto remainingTokens = tokens;
-    auto const &token = *remainingTokens;
+    auto const& token = *remainingTokens;
     if (token.type != TokenType::Argument)
       return InternalParseResult::ok(ParseState(ParseResultType::NoMatch, remainingTokens));
 
     assert(!m_ref->isFlag());
-    auto valueRef = static_cast<detail::BoundValueRefBase *>(m_ref.get());
+    auto valueRef = static_cast<detail::BoundValueRefBase*>(m_ref.get());
 
     auto result = valueRef->setValue(remainingTokens->token);
     if (!result)
@@ -880,7 +880,7 @@ class Arg : public ParserRefImpl<Arg> {
   }
 };
 
-inline auto normaliseOpt(std::string const &optName) -> std::string {
+inline auto normaliseOpt(std::string const& optName) -> std::string {
 #ifdef CLARA_PLATFORM_WINDOWS
   if (optName[0] == '/')
     return "-" + optName.substr(1);
@@ -895,18 +895,18 @@ class Opt : public ParserRefImpl<Opt> {
 
  public:
   template <typename LambdaT>
-  explicit Opt(LambdaT const &ref)
+  explicit Opt(LambdaT const& ref)
       : ParserRefImpl(std::make_shared<BoundFlagLambda<LambdaT>>(ref)) {}
 
-  explicit Opt(bool &ref) : ParserRefImpl(std::make_shared<BoundFlagRef>(ref)) {}
+  explicit Opt(bool& ref) : ParserRefImpl(std::make_shared<BoundFlagRef>(ref)) {}
 
   template <typename LambdaT>
-  Opt(LambdaT const &ref, std::string const &hint) : ParserRefImpl(ref, hint) {}
+  Opt(LambdaT const& ref, std::string const& hint) : ParserRefImpl(ref, hint) {}
 
   template <typename T>
-  Opt(T &ref, std::string const &hint) : ParserRefImpl(ref, hint) {}
+  Opt(T& ref, std::string const& hint) : ParserRefImpl(ref, hint) {}
 
-  auto operator[](std::string const &optName) -> Opt & {
+  auto operator[](std::string const& optName) -> Opt& {
     m_optNames.push_back(optName);
     return *this;
   }
@@ -914,7 +914,7 @@ class Opt : public ParserRefImpl<Opt> {
   auto getHelpColumns() const -> std::vector<HelpColumns> {
     std::ostringstream oss;
     bool first = true;
-    for (auto const &opt : m_optNames) {
+    for (auto const& opt : m_optNames) {
       if (first)
         first = false;
       else
@@ -925,9 +925,9 @@ class Opt : public ParserRefImpl<Opt> {
     return {{oss.str(), m_description}};
   }
 
-  auto isMatch(std::string const &optToken) const -> bool {
+  auto isMatch(std::string const& optToken) const -> bool {
     auto normalisedToken = normaliseOpt(optToken);
-    for (auto const &name : m_optNames) {
+    for (auto const& name : m_optNames) {
       if (normaliseOpt(name) == normalisedToken) return true;
     }
     return false;
@@ -935,26 +935,26 @@ class Opt : public ParserRefImpl<Opt> {
 
   using ParserBase::parse;
 
-  auto parse(std::string const &, TokenStream const &tokens) const -> InternalParseResult override {
+  auto parse(std::string const&, TokenStream const& tokens) const -> InternalParseResult override {
     auto validationResult = validate();
     if (!validationResult) return InternalParseResult(validationResult);
 
     auto remainingTokens = tokens;
     if (remainingTokens && remainingTokens->type == TokenType::Option) {
-      auto const &token = *remainingTokens;
+      auto const& token = *remainingTokens;
       if (isMatch(token.token)) {
         if (m_ref->isFlag()) {
-          auto flagRef = static_cast<detail::BoundFlagRefBase *>(m_ref.get());
+          auto flagRef = static_cast<detail::BoundFlagRefBase*>(m_ref.get());
           auto result = flagRef->setFlag(true);
           if (!result) return InternalParseResult(result);
           if (result.value() == ParseResultType::ShortCircuitAll)
             return InternalParseResult::ok(ParseState(result.value(), remainingTokens));
         } else {
-          auto valueRef = static_cast<detail::BoundValueRefBase *>(m_ref.get());
+          auto valueRef = static_cast<detail::BoundValueRefBase*>(m_ref.get());
           ++remainingTokens;
           if (!remainingTokens)
             return InternalParseResult::runtimeError("Expected argument following " + token.token);
-          auto const &argToken = *remainingTokens;
+          auto const& argToken = *remainingTokens;
           if (argToken.type != TokenType::Argument)
             return InternalParseResult::runtimeError("Expected argument following " + token.token);
           auto result = valueRef->setValue(argToken.token);
@@ -970,7 +970,7 @@ class Opt : public ParserRefImpl<Opt> {
 
   auto validate() const -> Result override {
     if (m_optNames.empty()) return Result::logicError("No options supplied to Opt");
-    for (auto const &name : m_optNames) {
+    for (auto const& name : m_optNames) {
       if (name.empty()) return Result::logicError("Option name cannot be empty");
 #ifdef CLARA_PLATFORM_WINDOWS
       if (name[0] != '-' && name[0] != '/')
@@ -984,12 +984,12 @@ class Opt : public ParserRefImpl<Opt> {
 };
 
 struct Help : Opt {
-  Help(bool &showHelpFlag)
+  Help(bool& showHelpFlag)
       : Opt([&](bool flag) {
           showHelpFlag = flag;
           return ParserResult::ok(ParseResultType::ShortCircuitAll);
         }) {
-    static_cast<Opt &>(*this)("display usage information")["-?"]["-h"]["--help"].optional();
+    static_cast<Opt&>(*this)("display usage information")["-?"]["-h"]["--help"].optional();
   }
 };
 
@@ -998,57 +998,57 @@ struct Parser : ParserBase {
   std::vector<Opt> m_options;
   std::vector<Arg> m_args;
 
-  auto operator|=(ExeName const &exeName) -> Parser & {
+  auto operator|=(ExeName const& exeName) -> Parser& {
     m_exeName = exeName;
     return *this;
   }
 
-  auto operator|=(Arg const &arg) -> Parser & {
+  auto operator|=(Arg const& arg) -> Parser& {
     m_args.push_back(arg);
     return *this;
   }
 
-  auto operator|=(Opt const &opt) -> Parser & {
+  auto operator|=(Opt const& opt) -> Parser& {
     m_options.push_back(opt);
     return *this;
   }
 
-  auto operator|=(Parser const &other) -> Parser & {
+  auto operator|=(Parser const& other) -> Parser& {
     m_options.insert(m_options.end(), other.m_options.begin(), other.m_options.end());
     m_args.insert(m_args.end(), other.m_args.begin(), other.m_args.end());
     return *this;
   }
 
   template <typename T>
-  auto operator|(T const &other) const -> Parser {
+  auto operator|(T const& other) const -> Parser {
     return Parser(*this) |= other;
   }
 
   // Forward deprecated interface with '+' instead of '|'
   template <typename T>
-  auto operator+=(T const &other) -> Parser & {
+  auto operator+=(T const& other) -> Parser& {
     return operator|=(other);
   }
   template <typename T>
-  auto operator+(T const &other) const -> Parser {
+  auto operator+(T const& other) const -> Parser {
     return operator|(other);
   }
 
   auto getHelpColumns() const -> std::vector<HelpColumns> {
     std::vector<HelpColumns> cols;
-    for (auto const &o : m_options) {
+    for (auto const& o : m_options) {
       auto childCols = o.getHelpColumns();
       cols.insert(cols.end(), childCols.begin(), childCols.end());
     }
     return cols;
   }
 
-  void writeToStream(std::ostream &os) const {
+  void writeToStream(std::ostream& os) const {
     if (!m_exeName.name().empty()) {
       os << "usage:\n"
          << "  " << m_exeName.name() << " ";
       bool required = true, first = true;
-      for (auto const &arg : m_args) {
+      for (auto const& arg : m_args) {
         if (first)
           first = false;
         else
@@ -1068,28 +1068,28 @@ struct Parser : ParserBase {
     auto rows = getHelpColumns();
     size_t consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH;
     size_t optWidth = 0;
-    for (auto const &cols : rows) optWidth = (std::max)(optWidth, cols.left.size() + 2);
+    for (auto const& cols : rows) optWidth = (std::max)(optWidth, cols.left.size() + 2);
 
     optWidth = (std::min)(optWidth, consoleWidth / 2);
 
-    for (auto const &cols : rows) {
+    for (auto const& cols : rows) {
       auto row = TextFlow::Column(cols.left).width(optWidth).indent(2) + TextFlow::Spacer(4) +
                  TextFlow::Column(cols.right).width(consoleWidth - 7 - optWidth);
       os << row << std::endl;
     }
   }
 
-  friend auto operator<<(std::ostream &os, Parser const &parser) -> std::ostream & {
+  friend auto operator<<(std::ostream& os, Parser const& parser) -> std::ostream& {
     parser.writeToStream(os);
     return os;
   }
 
   auto validate() const -> Result override {
-    for (auto const &opt : m_options) {
+    for (auto const& opt : m_options) {
       auto result = opt.validate();
       if (!result) return result;
     }
-    for (auto const &arg : m_args) {
+    for (auto const& arg : m_args) {
       auto result = arg.validate();
       if (!result) return result;
     }
@@ -1098,10 +1098,10 @@ struct Parser : ParserBase {
 
   using ParserBase::parse;
 
-  auto parse(std::string const &exeName, TokenStream const &tokens) const
+  auto parse(std::string const& exeName, TokenStream const& tokens) const
       -> InternalParseResult override {
     struct ParserInfo {
-      ParserBase const *parser = nullptr;
+      ParserBase const* parser = nullptr;
       size_t count = 0;
     };
     const size_t totalParsers = m_options.size() + m_args.size();
@@ -1111,8 +1111,8 @@ struct Parser : ParserBase {
 
     {
       size_t i = 0;
-      for (auto const &opt : m_options) parseInfos[i++].parser = &opt;
-      for (auto const &arg : m_args) parseInfos[i++].parser = &arg;
+      for (auto const& opt : m_options) parseInfos[i++].parser = &opt;
+      for (auto const& arg : m_args) parseInfos[i++].parser = &arg;
     }
 
     m_exeName.set(exeName);
@@ -1122,7 +1122,7 @@ struct Parser : ParserBase {
       bool tokenParsed = false;
 
       for (size_t i = 0; i < totalParsers; ++i) {
-        auto &parseInfo = parseInfos[i];
+        auto& parseInfo = parseInfos[i];
         if (parseInfo.parser->cardinality() == 0 ||
             parseInfo.count < parseInfo.parser->cardinality()) {
           result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
@@ -1147,8 +1147,8 @@ struct Parser : ParserBase {
 
 template <typename DerivedT>
 template <typename T>
-auto ComposableParserImpl<DerivedT>::operator|(T const &other) const -> Parser {
-  return Parser() | static_cast<DerivedT const &>(*this) | other;
+auto ComposableParserImpl<DerivedT>::operator|(T const& other) const -> Parser {
+  return Parser() | static_cast<DerivedT const&>(*this) | other;
 }
 }  // namespace detail
 

include/util/command.hpp

@@ -20,6 +20,8 @@ extern std::list<pid_t> reap;
 
 namespace waybar::util::command {
 
+constexpr int kExecFailureExitCode = 127;
+
 struct res {
   int exit_code;
   std::string out;
@@ -59,6 +61,7 @@ inline int close(FILE* fp, pid_t pid) {
       spdlog::debug("Cmd continued");
     } else if (ret == -1) {
       spdlog::debug("waitpid failed: {}", strerror(errno));
+      break;
     } else {
       break;
     }
@@ -109,11 +112,13 @@ inline FILE* open(const std::string& cmd, int& pid, const std::string& output_na
     ::close(fd[0]);
     dup2(fd[1], 1);
     setpgid(child_pid, child_pid);
-    if (output_name != "") {
+    if (!output_name.empty()) {
       setenv("WAYBAR_OUTPUT_NAME", output_name.c_str(), 1);
     }
     execlp("/bin/sh", "sh", "-c", cmd.c_str(), (char*)0);
-    exit(0);
+    const int saved_errno = errno;
+    spdlog::error("execlp(/bin/sh) failed in open: {}", strerror(saved_errno));
+    _exit(kExecFailureExitCode);
   } else {
     ::close(fd[1]);
   }
@@ -138,7 +143,7 @@ inline struct res execNoRead(const std::string& cmd) {
   return {WEXITSTATUS(stat), ""};
 }
 
-inline int32_t forkExec(const std::string& cmd) {
+inline int32_t forkExec(const std::string& cmd, const std::string& output_name) {
   if (cmd == "") return -1;
 
   pid_t pid = fork();
@@ -157,8 +162,13 @@ inline int32_t forkExec(const std::string& cmd) {
     err = pthread_sigmask(SIG_UNBLOCK, &mask, nullptr);
     if (err != 0) spdlog::error("pthread_sigmask in forkExec failed: {}", strerror(err));
     setpgid(pid, pid);
+    if (!output_name.empty()) {
+      setenv("WAYBAR_OUTPUT_NAME", output_name.c_str(), 1);
+    }
     execl("/bin/sh", "sh", "-c", cmd.c_str(), (char*)0);
-    exit(0);
+    const int saved_errno = errno;
+    spdlog::error("execl(/bin/sh) failed in forkExec: {}", strerror(saved_errno));
+    _exit(kExecFailureExitCode);
   } else {
     reap_mtx.lock();
     reap.push_back(pid);
@@ -169,4 +179,6 @@ inline int32_t forkExec(const std::string& cmd) {
   return pid;
 }
 
+inline int32_t forkExec(const std::string& cmd) { return forkExec(cmd, ""); }
+
 }  // namespace waybar::util::command

include/util/css_reload_helper.hpp

@@ -14,12 +14,14 @@ struct pollfd;
 namespace waybar {
 class CssReloadHelper {
  public:
-  CssReloadHelper(std::string cssFile, std::function<void()> callback);
+  CssReloadHelper(std::string cssFile, std::function<void(const std::string&)> callback);
 
   virtual ~CssReloadHelper() = default;
 
   virtual void monitorChanges();
 
+  virtual void changeCssFile(const std::string& newCssFile);
+
  protected:
   std::vector<std::string> parseImports(const std::string& cssFile);
 
@@ -42,7 +44,7 @@ class CssReloadHelper {
  private:
   std::string m_cssFile;
 
-  std::function<void()> m_callback;
+  std::function<void(const std::string&)> m_callback;
 
   std::vector<std::tuple<Glib::RefPtr<Gio::FileMonitor>>> m_fileMonitors;
 };

include/util/hex_checker.hpp

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <string>
+
+/**
+ * Result of transforming 8-bit hex codes to rgba().
+ */
+struct TransformResult {
+  std::string css;
+  bool was_transformed;
+};
+
+/**
+ * Reads a CSS file, searches for 8-bit hex codes (#RRGGBBAA),
+ * and transforms them into GTK-compatible rgba() syntax.
+ */
+TransformResult transform_8bit_to_hex(const std::string& file_path);

include/util/icon_loader.hpp

@@ -17,18 +17,18 @@ class IconLoader {
   std::vector<Glib::RefPtr<Gtk::IconTheme>> custom_icon_themes_;
   Glib::RefPtr<Gtk::IconTheme> default_icon_theme_ = Gtk::IconTheme::get_default();
   static std::vector<std::string> search_prefix();
-  static Glib::RefPtr<Gio::DesktopAppInfo> get_app_info_by_name(const std::string &app_id);
-  static Glib::RefPtr<Gio::DesktopAppInfo> get_desktop_app_info(const std::string &app_id);
-  static Glib::RefPtr<Gdk::Pixbuf> load_icon_from_file(std::string const &icon_path, int size);
-  static std::string get_icon_name_from_icon_theme(const Glib::RefPtr<Gtk::IconTheme> &icon_theme,
-                                                   const std::string &app_id);
-  static bool image_load_icon(Gtk::Image &image, const Glib::RefPtr<Gtk::IconTheme> &icon_theme,
+  static Glib::RefPtr<Gio::DesktopAppInfo> get_app_info_by_name(const std::string& app_id);
+  static Glib::RefPtr<Gio::DesktopAppInfo> get_desktop_app_info(const std::string& app_id);
+  static Glib::RefPtr<Gdk::Pixbuf> load_icon_from_file(std::string const& icon_path, int size);
+  static std::string get_icon_name_from_icon_theme(const Glib::RefPtr<Gtk::IconTheme>& icon_theme,
+                                                   const std::string& app_id);
+  static bool image_load_icon(Gtk::Image& image, const Glib::RefPtr<Gtk::IconTheme>& icon_theme,
                               Glib::RefPtr<Gio::DesktopAppInfo> app_info, int size);
 
  public:
-  void add_custom_icon_theme(const std::string &theme_name);
-  bool image_load_icon(Gtk::Image &image, Glib::RefPtr<Gio::DesktopAppInfo> app_info,
+  void add_custom_icon_theme(const std::string& theme_name);
+  bool image_load_icon(Gtk::Image& image, Glib::RefPtr<Gio::DesktopAppInfo> app_info,
                        int size) const;
   static Glib::RefPtr<Gio::DesktopAppInfo> get_app_info_from_app_id_list(
-      const std::string &app_id_list);
+      const std::string& app_id_list);
 };

include/util/json.hpp

@@ -7,6 +7,7 @@
 #include <codecvt>
 #include <iostream>
 #include <locale>
+#include <memory>
 #include <regex>
 
 #if (FMT_VERSION >= 90000)
@@ -26,19 +27,25 @@ class JsonParser {
     Json::Value root;
 
     // replace all occurrences of "\x" with "\u00", because JSON doesn't allow "\x" escape sequences
-    std::string modifiedJsonStr = replaceHexadecimalEscape(jsonStr);
+    std::string modifiedJsonStr;
+    const std::string* json = &jsonStr;
+    if (jsonStr.find("\\x") != std::string::npos) {
+      modifiedJsonStr = replaceHexadecimalEscape(jsonStr);
+      json = &modifiedJsonStr;
+    }
 
-    std::istringstream jsonStream(modifiedJsonStr);
     std::string errs;
-    if (!Json::parseFromStream(m_readerBuilder, jsonStream, &root, &errs)) {
+    // Use local CharReaderBuilder for thread safety - the IPC singleton's
+    // parser can be called concurrently from multiple module threads
+    Json::CharReaderBuilder readerBuilder;
+    auto reader = std::unique_ptr<Json::CharReader>(readerBuilder.newCharReader());
+    if (!reader->parse(json->data(), json->data() + json->size(), &root, &errs)) {
       throw std::runtime_error("Error parsing JSON: " + errs);
     }
     return root;
   }
 
  private:
-  Json::CharReaderBuilder m_readerBuilder;
-
   static std::string replaceHexadecimalEscape(const std::string& str) {
     static std::regex re("\\\\x");
     return std::regex_replace(str, re, "\\u00");

include/util/pipewire/privacy_node_info.hpp

@@ -33,14 +33,14 @@ class PrivacyNodeInfo {
   struct spa_hook object_listener;
   struct spa_hook proxy_listener;
 
-  void *data;
+  void* data;
 
   std::string getName();
   std::string getIconName();
 
   // Handlers for PipeWire events
   void handleProxyEventDestroy();
-  void handleNodeEventInfo(const struct pw_node_info *info);
+  void handleNodeEventInfo(const struct pw_node_info* info);
 };
 
 }  // namespace waybar::util::PipewireBackend

include/util/scoped_fd.hpp

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <unistd.h>
+
+namespace waybar::util {
+
+class ScopedFd {
+ public:
+  explicit ScopedFd(int fd = -1) : fd_(fd) {}
+  ~ScopedFd() {
+    if (fd_ != -1) {
+      close(fd_);
+    }
+  }
+
+  // ScopedFd is non-copyable
+  ScopedFd(const ScopedFd&) = delete;
+  ScopedFd& operator=(const ScopedFd&) = delete;
+
+  // ScopedFd is moveable
+  ScopedFd(ScopedFd&& other) noexcept : fd_(other.fd_) { other.fd_ = -1; }
+  ScopedFd& operator=(ScopedFd&& other) noexcept {
+    if (this != &other) {
+      if (fd_ != -1) {
+        close(fd_);
+      }
+      fd_ = other.fd_;
+      other.fd_ = -1;
+    }
+    return *this;
+  }
+
+  int get() const { return fd_; }
+
+  operator int() const { return fd_; }
+
+  void reset(int fd = -1) {
+    if (fd_ != -1) {
+      close(fd_);
+    }
+    fd_ = fd;
+  }
+
+  int release() {
+    int fd = fd_;
+    fd_ = -1;
+    return fd;
+  }
+
+ private:
+  int fd_;
+};
+
+}  // namespace waybar::util

include/util/sleeper_thread.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <atomic>
 #include <chrono>
 #include <condition_variable>
 #include <ctime>
@@ -31,8 +32,8 @@ class SleeperThread {
 
   SleeperThread(std::function<void()> func)
       : thread_{[this, func] {
-          while (do_run_) {
-            signal_ = false;
+          while (do_run_.load(std::memory_order_relaxed)) {
+            signal_.store(false, std::memory_order_relaxed);
             func();
           }
         }} {
@@ -42,9 +43,18 @@ class SleeperThread {
   }
 
   SleeperThread& operator=(std::function<void()> func) {
+    if (thread_.joinable()) {
+      stop();
+      thread_.join();
+    }
+    {
+      std::lock_guard<std::mutex> lck(mutex_);
+      do_run_.store(true, std::memory_order_relaxed);
+      signal_.store(false, std::memory_order_relaxed);
+    }
     thread_ = std::thread([this, func] {
-      while (do_run_) {
-        signal_ = false;
+      while (do_run_.load(std::memory_order_relaxed)) {
+        signal_.store(false, std::memory_order_relaxed);
         func();
       }
     });
@@ -56,24 +66,34 @@ class SleeperThread {
     return *this;
   }
 
-  bool isRunning() const { return do_run_; }
+  bool isRunning() const { return do_run_.load(std::memory_order_relaxed); }
 
   auto sleep() {
     std::unique_lock lk(mutex_);
     CancellationGuard cancel_lock;
-    return condvar_.wait(lk, [this] { return signal_ || !do_run_; });
+    return condvar_.wait(lk, [this] {
+      return signal_.load(std::memory_order_relaxed) || !do_run_.load(std::memory_order_relaxed);
+    });
   }
 
   auto sleep_for(std::chrono::system_clock::duration dur) {
     std::unique_lock lk(mutex_);
     CancellationGuard cancel_lock;
+
+    condvar_.wait(lk, [this] {
+      return !is_paused_ || signal_.load(std::memory_order_relaxed) ||
+             !do_run_.load(std::memory_order_relaxed);
+    });
+
     constexpr auto max_time_point = std::chrono::steady_clock::time_point::max();
     auto wait_end = max_time_point;
     auto now = std::chrono::steady_clock::now();
     if (now < max_time_point - dur) {
       wait_end = now + dur;
     }
-    return condvar_.wait_until(lk, wait_end, [this] { return signal_ || !do_run_; });
+    return condvar_.wait_until(lk, wait_end, [this] {
+      return signal_.load(std::memory_order_relaxed) || !do_run_.load(std::memory_order_relaxed);
+    });
   }
 
   auto sleep_until(
@@ -81,22 +101,30 @@ class SleeperThread {
           time_point) {
     std::unique_lock lk(mutex_);
     CancellationGuard cancel_lock;
-    return condvar_.wait_until(lk, time_point, [this] { return signal_ || !do_run_; });
+
+    condvar_.wait(lk, [this] {
+      return !is_paused_ || signal_.load(std::memory_order_relaxed) ||
+             !do_run_.load(std::memory_order_relaxed);
+    });
+
+    return condvar_.wait_until(lk, time_point, [this] {
+      return signal_.load(std::memory_order_relaxed) || !do_run_.load(std::memory_order_relaxed);
+    });
   }
 
   void wake_up() {
     {
       std::lock_guard<std::mutex> lck(mutex_);
-      signal_ = true;
+      signal_.store(true, std::memory_order_relaxed);
     }
     condvar_.notify_all();
   }
 
-  auto stop() {
+  void stop() {
     {
       std::lock_guard<std::mutex> lck(mutex_);
-      signal_ = true;
-      do_run_ = false;
+      signal_.store(true, std::memory_order_relaxed);
+      do_run_.store(false, std::memory_order_relaxed);
     }
     condvar_.notify_all();
     auto handle = thread_.native_handle();
@@ -106,6 +134,17 @@ class SleeperThread {
     }
   }
 
+  void pause() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    is_paused_ = true;
+  }
+
+  void resume() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    is_paused_ = false;
+    condvar_.notify_all();
+  }
+
   ~SleeperThread() {
     connection_.disconnect();
     stop();
@@ -118,9 +157,10 @@ class SleeperThread {
   std::thread thread_;
   std::condition_variable condvar_;
   std::mutex mutex_;
-  bool do_run_ = true;
-  bool signal_ = false;
+  std::atomic<bool> do_run_ = true;
+  std::atomic<bool> signal_ = false;
   sigc::connection connection_;
+  bool is_paused_{false};
 };
 
 }  // namespace waybar::util

include/util/udev_deleter.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <libudev.h>
+
+namespace waybar::util {
+struct UdevDeleter {
+  void operator()(udev* ptr) const { udev_unref(ptr); }
+};
+
+struct UdevDeviceDeleter {
+  void operator()(udev_device* ptr) const { udev_device_unref(ptr); }
+};
+
+struct UdevEnumerateDeleter {
+  void operator()(udev_enumerate* ptr) const { udev_enumerate_unref(ptr); }
+};
+
+struct UdevMonitorDeleter {
+  void operator()(udev_monitor* ptr) const { udev_monitor_unref(ptr); }
+};
+}  // namespace waybar::util

include/util/ustring_clen.hpp

@@ -2,4 +2,4 @@
 #include <glibmm/ustring.h>
 
 // calculate column width of ustring
-int ustring_clen(const Glib::ustring &str);
+int ustring_clen(const Glib::ustring& str);

include/util/utf8_string.hpp

@@ -0,0 +1,7 @@
+#pragma once
+#include <string>
+
+namespace waybar::util {
+size_t utf8_width(const std::string& str);
+void utf8_truncate(std::string& s, const std::string& ellipsis, size_t max_len);
+}  // namespace waybar::util

man/waybar-battery.5.scd

@@ -27,6 +27,11 @@ The *battery* module displays the current capacity and state (eg. charging) of y
 	default: false ++
 	Option to use the battery design capacity instead of its current maximal capacity.
 
+*full-at-plugged*: ++
+	typeof: bool ++
+	default: false ++
+	When enabled, a battery that is *Full* while the adapter is online is reported with the *Plugged* status instead of *Full* (so you can style/format it separately). Disabled by default to preserve the existing *Full* behaviour.
+
 *interval*: ++
 	typeof: integer ++
 	default: 60 ++
@@ -91,6 +96,11 @@ The *battery* module displays the current capacity and state (eg. charging) of y
 	typeof: string ++
 	Command to execute when scrolling up on the module.
 
+*weighted-average*: ++
+    typeof: bool ++
+    default: true ++
+    Option to combine multiple batteries with different capacities.
+
 *on-scroll-down*: ++
 	typeof: string ++
 	Command to execute when scrolling down on the module.
@@ -177,6 +187,7 @@ Every entry in the *events* object consists of a *<event-name>* (typeof: *string
 
 - *on-<status>-<state>*
 - *on-<status>-<capacity>*
+- *on-<status>*
 
 Where:
 
@@ -198,7 +209,9 @@ Where:
 	"events": {
 		"on-discharging-warning": "notify-send -u normal 'Low Battery'",
 		"on-discharging-critical": "notify-send -u critical 'Very Low Battery'",
-		"on-charging-100": "notify-send -u normal 'Battery Full!'"
+		"on-charging-100": "notify-send -u normal 'Battery Full!'",
+		"on-discharging": "notify-send -u normal 'Power Switch' Discharging",
+		"on-charging": "notify-send -u normal 'Power Switch' Charging'"
 	},
 	"format": "{capacity}% {icon}",
 	"format-icons": ["", "", "", "", ""],

man/waybar-cava.5.scd

@@ -8,6 +8,8 @@ waybar - cava module
 
 *cava* module for karlstav/cava project. See it on github: https://github.com/karlstav/cava.
 
+Module supports two different frontends starting from the 0.15.0 release. The frontend that
+will be used is managed by the method parameter in the [output] section of the cava configuration file.
 
 # FILES
 
@@ -32,6 +34,10 @@ libcava lives in:
 :[ string
 :[
 :< Path where cava configuration file is placed to
+|[ *method* \[output\]
+:[ string
+:[
+:< Manages which frontend Waybar cava module should use. Values: raw, sdl_glsl
 |[ *framerate*
 :[ integer
 :[ 30
@@ -43,7 +49,7 @@ libcava lives in:
 |[ *sensitivity*
 :[ integer
 :[ 100
-:[ Manual sensitivity in %. It's recommended to be omitted when *autosens* = 1
+:[ Manual sensitivity in %. If autosens is enabled, this will only be the initial value. 200 means double height. Accepts only non-negative values
 |[ *bars*
 :[ integer
 :[ 12
@@ -68,7 +74,7 @@ libcava lives in:
 :[ string
 :[
 :[ Widget's text after sleep_timer elapsed (hide_on_silence has to be false)
-|[ *method*
+|[ *method* \[input\]
 :[ string
 :[ pulse
 :[ Audio capturing method. Possible methods are: pipewire, pulse, alsa, fifo, sndio or shmem
@@ -105,9 +111,9 @@ libcava lives in:
 :[ false
 :[ Disables or enables the so-called "Monstercat smoothing" with or without "waves"
 |[ *noise_reduction*
-:[ double
-:[ 0.77
-:[ Range between 0 - 1. The raw visualization is very noisy, this factor adjusts the integral and gravity filters to keep the signal smooth. 1 - will be very slow and smooth, 0 - will be fast but noisy
+:[ integer
+:[ 77
+:[ Range between 0 - 100. The raw visualization is very noisy, this factor adjusts the integral and gravity filters to keep the signal smooth. 100 will be very slow and smooth, 0 will be fast but noisy
 |[ *input_delay*
 :[ integer
 :[ 2
@@ -119,11 +125,11 @@ libcava lives in:
 |[ *data_format*
 :[ string
 :[ asci
-:[ It's impossible to set it. Waybar sets it to = asci for internal needs
+:[ Raw data format. Can be 'binary' or 'ascii'
 |[ *raw_target*
 :[ string
 :[ /dev/stdout
-:[ It's impossible to set it. Waybar sets it to = /dev/stdout for internal needs
+:[ Raw output target. A fifo will be created if target does not exist
 |[ *menu*
 :[ string
 :[
@@ -136,6 +142,50 @@ libcava lives in:
 :[ array
 :[
 :[ The actions corresponding to the buttons of the menu.
+|[ *bar_spacing*
+:[ integer
+:[
+:[ Bars' space between bars in number of characters
+|[ *bar_width*
+:[ integer
+:[
+:[ Bars' width between bars in number of characters
+|[ *bar_height*
+:[ integer
+:[
+:[ Useless. bar_height is only used for output in "noritake" format
+|[ *background*
+:[ string
+:[
+:[ GLSL actual. Support hex code colors only. Must be within ''
+|[ *foreground*
+:[ string
+:[
+:[ GLSL actual. Support hex code colors only. Must be within ''
+|[ *gradient*
+:[ integer
+:[ 0
+:[ GLSL actual. Gradient mode(0/1 - on/off)
+|[ *gradient_count*
+:[ integer
+:[ 0
+:[ GLSL actual. The count of colors for the gradient
+|[ *gradient_color_N*
+:[ string
+:[
+:[ GLSL actual. N - the number of the gradient color between 1 and 8. Only hex defined colors are supported. Must be within ''
+|[ *sdl_width*
+:[ integer
+:[
+:[ GLSL actual. Manages the width of the waybar cava GLSL frontend module
+|[ *sdl_height*
+:[ integer
+:[
+:[ GLSL actual. Manages the height of the waybar cava GLSL frontend module
+|[ *continuous_rendering*
+:[ integer
+:[ 0
+:[ GLSL actual. Keep rendering even if no audio. Recommended to set to 1
 
 Configuration can be provided as:
 - The only cava configuration file which is provided through *cava_config*. The rest configuration can be skipped
@@ -153,6 +203,7 @@ Configuration can be provided as:
 
 - iniparser
 - fftw3
+- epoxy (GLSL frontend only)
 
 # SOLVING ISSUES
 
@@ -205,3 +256,453 @@ In case when cava releases new version and you're wanna get it, it should be rai
 - *#cava*
 - *#cava.silent* Applied after no sound has been detected for sleep_timer seconds
 - *#cava.updated* Applied when a new frame is shown
+# FRONTENDS
+
+## RAW
+The cava raw frontend uses ASCII characters to visualize incoming audio data. Each ASCII symbol position corresponds to the value of the audio power pulse.
+
+Under the hood:
+```
+. Incoming audio power pulse list is : 12684
+. Configured array of ASCII codes is: ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█" ]. See `format-icons` https://github.com/Alexays/Waybar/wiki/Module:-Cava#example 
+```
+As a result cava frontend will give ▁▂▆█▄
+
+Examples:
+
+waybar config
+```
+"cava": {
+        "cava_config": "$XDG_CONFIG_HOME/cava/waybar_raw.conf",
+        "input_delay": 2,
+        "format-icons" : ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█" ],
+        "actions": {
+                   "on-click-right": "mode"
+                   }
+        },
+```
+
+waybar_raw.conf
+```
+## Configuration file for CAVA.
+# Remove the ; to change parameters.
+
+
+[general]
+
+# Smoothing mode. Can be 'normal', 'scientific' or 'waves'. DEPRECATED as of 0.6.0
+
+# Accepts only non-negative values.
+
+# 'autosens' will attempt to decrease sensitivity if the bars peak. 1 = on, 0 = off
+# new as of 0.6.0 autosens of low values (dynamic range)
+# 'overshoot' allows bars to overshoot (in % of terminal height) without initiating autosens. DEPRECATED as of 0.6.0
+
+# Manual sensitivity in %. If autosens is enabled, this will only be the initial value.
+# 200 means double height. Accepts only non-negative values.
+
+# The number of bars (0-512). 0 sets it to auto (fill up console).
+# Bars' width and space between bars in number of characters.
+bars = 12
+# bar_height is only used for output in "noritake" format
+
+# For SDL width and space between bars is in pixels, defaults are:
+
+# sdl_glsl have these default values, they are only used to calculate max number of bars.
+
+
+# Lower and higher cutoff frequencies for lowest and highest bars
+# the bandwidth of the visualizer.
+# Note: there is a minimum total bandwidth of 43Mhz x number of bars.
+# Cava will automatically increase the higher cutoff if a too low band is specified.
+
+# Seconds with no input before cava goes to sleep mode. Cava will not perform FFT or drawing and
+# only check for input once per second. Cava will wake up once input is detected. 0 = disable.
+sleep_timer = 5
+
+
+[input]
+
+# Audio capturing method. Possible methods are: 'fifo', 'portaudio', 'pipewire', 'alsa', 'pulse', 'sndio', 'oss', 'jack' or 'shmem'
+# Defaults to 'oss', 'pipewire', 'sndio', 'jack', 'pulse', 'alsa', 'portaudio' or 'fifo', in that order, dependent on what support cava was built with.
+# On Mac it defaults to 'portaudio' or 'fifo'
+# On windows this is automatic and no input settings are needed.
+#
+# All input methods uses the same config variable 'source'
+# to define where it should get the audio.
+#
+# For pulseaudio and pipewire 'source' will be the source. Default: 'auto', which uses the monitor source of the default sink
+# (all pulseaudio sinks(outputs) have 'monitor' sources(inputs) associated with them).
+#
+# For pipewire 'source' will be the object name or object.serial of the device to capture from.
+# Both input and output devices are supported.
+#
+# For alsa 'source' will be the capture device.
+# For fifo 'source' will be the path to fifo-file.
+# For shmem 'source' will be /squeezelite-AA:BB:CC:DD:EE:FF where 'AA:BB:CC:DD:EE:FF' will be squeezelite's MAC address
+#
+# For sndio 'source' will be a raw recording audio descriptor or a monitoring sub-device, e.g. 'rsnd/2' or 'snd/1'. Default: 'default'.
+# README.md contains further information on how to setup CAVA for sndio.
+#
+# For oss 'source' will be the path to a audio device, e.g. '/dev/dsp2'. Default: '/dev/dsp', i.e. the default audio device.
+# README.md contains further information on how to setup CAVA for OSS on FreeBSD.
+#
+# For jack 'source' will be the name of the JACK server to connect to, e.g. 'foobar'. Default: 'default'.
+# README.md contains further information on how to setup CAVA for JACK.
+#
+
+# The options 'sample_rate', 'sample_bits', 'channels' and 'autoconnect' can be configured for some input methods:
+#   sample_rate: fifo, pipewire, sndio, oss
+#   sample_bits: fifo, pipewire, sndio, oss
+#   channels:    sndio, oss, jack
+#   autoconnect: jack
+# Other methods ignore these settings.
+#
+# For 'sndio' and 'oss' they are only preferred values, i.e. if the values are not supported
+# by the chosen audio device, the device will use other supported values instead.
+# Example: 48000, 32 and 2, but the device only supports 44100, 16 and 1, then it
+# will use 44100, 16 and 1.
+#
+
+
+[output]
+
+# Output method. Can be 'ncurses', 'noncurses', 'raw', 'noritake', 'sdl'
+# or 'sdl_glsl'.
+# 'noncurses' (default) uses a buffer and cursor movements to only print
+# changes from frame to frame in the terminal. Uses less resources and is less
+# prone to tearing (vsync issues) than 'ncurses'.
+#
+# 'raw' is an 8 or 16 bit (configurable via the 'bit_format' option) data
+# stream of the bar heights that can be used to send to other applications.
+# 'raw' defaults to 200 bars, which can be adjusted in the 'bars' option above.
+#
+# 'noritake' outputs a bitmap in the format expected by a Noritake VFD display
+#  in graphic mode. It only support the 3000 series graphical VFDs for now.
+#
+# 'sdl' uses the Simple DirectMedia Layer to render in a graphical context.
+# 'sdl_glsl' uses SDL to create an OpenGL context. Write your own shaders or
+# use one of the predefined ones.
+method = raw
+
+# Orientation of the visualization. Can be 'bottom', 'top', 'left', 'right' or
+# 'horizontal'. Default is 'bottom'. 'left and 'right' are only supported on sdl
+# and ncruses output. 'horizontal' (bars go up and down from center) is only supported
+# on noncurses output.
+# Note: many fonts have weird or missing glyphs for characters used in orientations
+# other than 'bottom', which can make output not look right.
+
+# Visual channels. Can be 'stereo' or 'mono'.
+# 'stereo' mirrors both channels with low frequencies in center.
+# 'mono' outputs left to right lowest to highest frequencies.
+# 'mono_option' set mono to either take input from 'left', 'right' or 'average'.
+# set 'reverse' to 1 to display frequencies the other way around.
+
+# Raw output target. A fifo will be created if target does not exist.
+raw_target = /dev/stdout
+
+# Raw data format. Can be 'binary' or 'ascii'.
+data_format = ascii
+
+# Binary bit format, can be '8bit' (0-255) or '16bit' (0-65530).
+
+# Ascii max value. In 'ascii' mode range will run from 0 to value specified here
+
+# Ascii delimiters. In ascii format each bar and frame is separated by a delimiters.
+# Use decimal value in ascii table (i.e. 59 = ';' and 10 = '\n' (line feed)).
+bar_delimiter = 0
+
+# sdl window size and position. -1,-1 is centered.
+
+# set label on bars on the x-axis. Can be 'frequency' or 'none'. Default: 'none'
+# 'frequency' displays the lower cut off frequency of the bar above.
+# Only supported on ncurses and noncurses output.
+
+# enable synchronized sync. 1 = on, 0 = off
+# removes flickering in alacritty terminal emulator.
+# defaults to off since the behaviour in other terminal emulators is unknown
+
+# Shaders for sdl_glsl, located in $HOME/.config/cava/shaders
+
+; for glsl output mode, keep rendering even if no audio
+
+# disable console blank (screen saver) in tty
+# (Not supported on FreeBSD)
+
+# show a flat bar at the bottom of the screen when idle, 1 = on, 0 = off
+
+# show waveform instead of frequency spectrum, 1 = on, 0 = off
+
+[color]
+
+# Colors can be one of seven predefined: black, blue, cyan, green, magenta, red, white, yellow.
+# Or defined by hex code '#xxxxxx' (hex code must be within ''). User defined colors requires
+# a terminal that can change color definitions such as Gnome-terminal or rxvt.
+# default is to keep current terminal color
+
+# SDL and sdl_glsl only support hex code colors, these are the default:
+
+# Gradient mode, only hex defined colors are supported,
+# background must also be defined in hex or remain commented out. 1 = on, 0 = off.
+# You can define as many as 8 different colors. They range from bottom to top of screen
+
+[smoothing]
+
+# Disables or enables the so-called "Monstercat smoothing" with or without "waves". Set to 0 to disable.
+
+# Noise reduction, int 0 - 100. default 77
+# the raw visualization is very noisy, this factor adjusts the integral and gravity filters to keep the signal smooth
+# 100 will be very slow and smooth, 0 will be fast but noisy.
+
+
+[eq]
+
+# This one is tricky. You can have as much keys as you want.
+# Remember to uncomment more than one key! More keys = more precision.
+# Look at readme.md on github for further explanations and examples.
+```
+## GLSL
+The Cava GLSL frontend delegates the visualization of incoming audio data to the GPU via OpenGL.
+
+There are some mandatory dependencies that need to be satisfied in order for Cava GLSL to be built and function properly:
+
+. epoxy library must be installed on the system
+. Vertex and fragment shaders from the original project must be used. They should be downloaded, and the file paths must be configured correctly in the Waybar Cava configuration:
+   1. cava shaders [cava shaders](https://github.com/karlstav/cava/tree/master/output/shaders)
+   2. libcava shaders [libcava shaders](https://github.com/LukashonakV/cava/tree/master/output/shaders)
+. It is highly recommended to have a separate cava configuration for the Waybar Cava GLSL module and to use this as the cava_config in the Waybar configuration.
+. It is common for cava configurations to be placed in the XDG_CONFIG_HOME directory, including shaders as well. Consider keeping them in the $XDG_CONFIG_HOME/cava/shaders folder.
+
+Key configuration options:
+
+. bars. The more values the parameter has, the more interesting the visualization becomes.
+. method in output section must be set to sdl_glsl
+. sdl_width and sdl_height manage the size of the module. Adjust them according to your needs.
+. Shaders for sdl_glsl, located in $HOME/.config/cava/shaders. Example: "vertex_shader" = "pass_through.vert" "fragment_shader" = "spectrogram.frag"
+. Set continuous_rendering to 1 to enable smooth rendering; set it to 0 otherwise. It is recommended to keep it set to 1.
+. background, foreground, and gradient_color_N (where N is a number between 1 and 8) must be defined using hex code
+
+Example:
+
+waybar config
+```
+"cava": {
+        "cava_config": "$XDG_CONFIG_HOME/cava/waybar_cava#3.conf",
+        "input_delay": 2,
+        "actions": {
+                   "on-click-right": "mode"
+                   }
+        },
+```
+
+waybar_raw.conf
+```
+## Configuration file for CAVA.
+# Remove the ; to change parameters.
+
+
+[general]
+
+# Smoothing mode. Can be 'normal', 'scientific' or 'waves'. DEPRECATED as of 0.6.0
+
+# Accepts only non-negative values.
+
+# 'autosens' will attempt to decrease sensitivity if the bars peak. 1 = on, 0 = off
+# new as of 0.6.0 autosens of low values (dynamic range)
+# 'overshoot' allows bars to overshoot (in % of terminal height) without initiating autosens. DEPRECATED as of 0.6.0
+
+# Manual sensitivity in %. If autosens is enabled, this will only be the initial value.
+# 200 means double height. Accepts only non-negative values.
+
+# The number of bars (0-512). 0 sets it to auto (fill up console).
+# Bars' width and space between bars in number of characters.
+bars = 50
+
+# bar_height is only used for output in "noritake" format
+
+# For SDL width and space between bars is in pixels, defaults are:
+
+# sdl_glsl have these default values, they are only used to calculate max number of bars.
+
+# Lower and higher cutoff frequencies for lowest and highest bars
+# the bandwidth of the visualizer.
+# Note: there is a minimum total bandwidth of 43Mhz x number of bars.
+# Cava will automatically increase the higher cutoff if a too low band is specified.
+
+# Seconds with no input before cava goes to sleep mode. Cava will not perform FFT or drawing and
+# only check for input once per second. Cava will wake up once input is detected. 0 = disable.
+sleep_timer = 5
+
+
+[input]
+
+# Audio capturing method. Possible methods are: 'fifo', 'portaudio', 'pipewire', 'alsa', 'pulse', 'sndio', 'oss', 'jack' or 'shmem'
+# Defaults to 'oss', 'pipewire', 'sndio', 'jack', 'pulse', 'alsa', 'portaudio' or 'fifo', in that order, dependent on what support cava was built with.
+# On Mac it defaults to 'portaudio' or 'fifo'
+# On windows this is automatic and no input settings are needed.
+#
+# All input methods uses the same config variable 'source'
+# to define where it should get the audio.
+#
+# For pulseaudio and pipewire 'source' will be the source. Default: 'auto', which uses the monitor source of the default sink
+# (all pulseaudio sinks(outputs) have 'monitor' sources(inputs) associated with them).
+#
+# For pipewire 'source' will be the object name or object.serial of the device to capture from.
+# Both input and output devices are supported.
+#
+# For alsa 'source' will be the capture device.
+# For fifo 'source' will be the path to fifo-file.
+# For shmem 'source' will be /squeezelite-AA:BB:CC:DD:EE:FF where 'AA:BB:CC:DD:EE:FF' will be squeezelite's MAC address
+#
+# For sndio 'source' will be a raw recording audio descriptor or a monitoring sub-device, e.g. 'rsnd/2' or 'snd/1'. Default: 'default'.
+# README.md contains further information on how to setup CAVA for sndio.
+#
+# For oss 'source' will be the path to a audio device, e.g. '/dev/dsp2'. Default: '/dev/dsp', i.e. the default audio device.
+# README.md contains further information on how to setup CAVA for OSS on FreeBSD.
+#
+# For jack 'source' will be the name of the JACK server to connect to, e.g. 'foobar'. Default: 'default'.
+# README.md contains further information on how to setup CAVA for JACK.
+#
+
+
+# The options 'sample_rate', 'sample_bits', 'channels' and 'autoconnect' can be configured for some input methods:
+#   sample_rate: fifo, pipewire, sndio, oss
+#   sample_bits: fifo, pipewire, sndio, oss
+#   channels:    sndio, oss, jack
+#   autoconnect: jack
+# Other methods ignore these settings.
+#
+# For 'sndio' and 'oss' they are only preferred values, i.e. if the values are not supported
+# by the chosen audio device, the device will use other supported values instead.
+# Example: 48000, 32 and 2, but the device only supports 44100, 16 and 1, then it
+# will use 44100, 16 and 1.
+#
+
+
+[output]
+
+# Output method. Can be 'ncurses', 'noncurses', 'raw', 'noritake', 'sdl'
+# or 'sdl_glsl'.
+# 'noncurses' (default) uses a buffer and cursor movements to only print
+# changes from frame to frame in the terminal. Uses less resources and is less
+# prone to tearing (vsync issues) than 'ncurses'.
+#
+# 'raw' is an 8 or 16 bit (configurable via the 'bit_format' option) data
+# stream of the bar heights that can be used to send to other applications.
+# 'raw' defaults to 200 bars, which can be adjusted in the 'bars' option above.
+#
+# 'noritake' outputs a bitmap in the format expected by a Noritake VFD display
+#  in graphic mode. It only support the 3000 series graphical VFDs for now.
+#
+# 'sdl' uses the Simple DirectMedia Layer to render in a graphical context.
+# 'sdl_glsl' uses SDL to create an OpenGL context. Write your own shaders or
+# use one of the predefined ones.
+method = sdl_glsl
+
+# Orientation of the visualization. Can be 'bottom', 'top', 'left', 'right' or
+# 'horizontal'. Default is 'bottom'. 'left and 'right' are only supported on sdl
+# and ncruses output. 'horizontal' (bars go up and down from center) is only supported
+# on noncurses output.
+# Note: many fonts have weird or missing glyphs for characters used in orientations
+# other than 'bottom', which can make output not look right.
+
+# Visual channels. Can be 'stereo' or 'mono'.
+# 'stereo' mirrors both channels with low frequencies in center.
+# 'mono' outputs left to right lowest to highest frequencies.
+# 'mono_option' set mono to either take input from 'left', 'right' or 'average'.
+# set 'reverse' to 1 to display frequencies the other way around.
+
+# Raw output target. A fifo will be created if target does not exist.
+
+# Raw data format. Can be 'binary' or 'ascii'.
+
+# Binary bit format, can be '8bit' (0-255) or '16bit' (0-65530).
+
+# Ascii max value. In 'ascii' mode range will run from 0 to value specified here
+
+# Ascii delimiters. In ascii format each bar and frame is separated by a delimiters.
+# Use decimal value in ascii table (i.e. 59 = ';' and 10 = '\n' (line feed)).
+bar_delimiter = 0
+
+# sdl window size and position. -1,-1 is centered.
+sdl_width = 150
+sdl_height = 39
+
+# set label on bars on the x-axis. Can be 'frequency' or 'none'. Default: 'none'
+# 'frequency' displays the lower cut off frequency of the bar above.
+# Only supported on ncurses and noncurses output.
+
+# enable synchronized sync. 1 = on, 0 = off
+# removes flickering in alacritty terminal emulator.
+# defaults to off since the behaviour in other terminal emulators is unknown
+
+# Shaders for sdl_glsl, located in $HOME/.config/cava/shaders
+vertex_shader = pass_through.vert
+fragment_shader = bar_spectrum.frag
+
+; for glsl output mode, keep rendering even if no audio
+continuous_rendering = 1;
+
+# disable console blank (screen saver) in tty
+# (Not supported on FreeBSD)
+
+# show a flat bar at the bottom of the screen when idle, 1 = on, 0 = off
+
+# show waveform instead of frequency spectrum, 1 = on, 0 = off
+
+[color]
+
+
+# Colors can be one of seven predefined: black, blue, cyan, green, magenta, red, white, yellow.
+# Or defined by hex code '#xxxxxx' (hex code must be within ''). User defined colors requires
+# a terminal that can change color definitions such as Gnome-terminal or rxvt.
+# default is to keep current terminal color
+
+# SDL and sdl_glsl only support hex code colors, these are the default:
+background = '#282C34'
+
+# Gradient mode, only hex defined colors are supported,
+# background must also be defined in hex or remain commented out. 1 = on, 0 = off.
+# You can define as many as 8 different colors. They range from bottom to top of screen
+gradient = 1
+gradient_count = 2
+gradient_color_1 = '#282C34'
+gradient_color_2 = '#45475A'
+
+; gradient_color_1 = '#59cc33'
+; gradient_color_2 = '#80cc33'
+ gradient_color_3 = '#a6cc33'
+ gradient_color_4 = '#cccc33'
+ gradient_color_5 = '#cca633'
+ gradient_color_6 = '#cc8033'
+ gradient_color_7 = '#cc5933'
+ gradient_color_8 = '#cc3333'
+
+[smoothing]
+
+# Percentage value for integral smoothing. Takes values from 0 - 100.
+# Higher values means smoother, but less precise. 0 to disable.
+# DEPRECATED as of 0.8.0, use noise_reduction instead
+
+# Disables or enables the so-called "Monstercat smoothing" with or without "waves". Set to 0 to disable.
+
+# Set gravity percentage for "drop off". Higher values means bars will drop faster.
+# Accepts only non-negative values. 50 means half gravity, 200 means double. Set to 0 to disable "drop off".
+# DEPRECATED as of 0.8.0, use noise_reduction instead
+
+
+# In bar height, bars that would have been lower that this will not be drawn.
+# DEPRECATED as of 0.8.0
+
+# Noise reduction, int 0 - 100. default 77
+# the raw visualization is very noisy, this factor adjusts the integral and gravity filters to keep the signal smooth
+# 100 will be very slow and smooth, 0 will be fast but noisy.
+
+[eq]
+
+# This one is tricky. You can have as much keys as you want.
+# Remember to uncomment more than one key! More keys = more precision.
+# Look at readme.md on github for further explanations and examples.
+```
+
+Different waybar_cava#N.conf see at [cava GLSL](https://github.com/Alexays/Waybar/wiki/Module:-Cava:-GLSL)

man/waybar-clock.5.scd

@@ -132,6 +132,12 @@ View all valid format options in *strftime(3)* or have a look https://en.cpprefe
 :[ 1
 :[ Value to scroll months/years forward/backward. Can be negative. Is
    configured under *on-scroll* option
+|[ *iso8601*
+:[ bool
+:[ false
+:[ When enabled, the calendar follows the ISO 8601 standard: weeks begin on
+   Monday, and the first week of the year is numbered 1. The default week format is
+   '{:%V}'.
 
 3. Addressed by *clock: calendar: format*
 [- *Option*
@@ -198,7 +204,7 @@ View all valid format options in *strftime(3)* or have a look https://en.cpprefe
 ```
 "clock": {
 	"format": "{:%H:%M}  ",
-	"format-alt": "{:%A, %B %d, %Y (%R)}  ",
+	"format-alt": "{:%A, %B %d, %Y (%R)} 󰃰 ",
 	"tooltip-format": "<tt><small>{calendar}</small></tt>",
 	"calendar": {
 		"mode"          : "year",
@@ -253,7 +259,19 @@ View all valid format options in *strftime(3)* or have a look https://en.cpprefe
 	"tooltip-format": "{tz_list}"
 }
 ```
+5. Simple calendar tooltip
 
+```
+"clock": {
+"format": "{:%H:%M}",
+"tooltip-format": "<tt>{calendar}</tt>",
+"calendar": {
+"format": {
+"today": "<span color='#ffcc66'><b>{}</b></span>"
+}
+}
+}
+```
 # STYLE
 
 - *#clock*
@@ -281,7 +299,7 @@ Example of working config
 ```
 "clock": {
 	"format": "{:%H:%M}  ",
-	"format-alt": "{:%A, %B %d, %Y (%R)}  ",
+	"format-alt": "{:%A, %B %d, %Y (%R)} 󰃰 ",
 	"tooltip-format": "\n<span size='9pt' font='WenQuanYi Zen Hei Mono'>{calendar}</span>",
 	"calendar": {
 		"mode"          : "year",

man/waybar-cpu.5.scd

@@ -11,9 +11,10 @@ The *cpu* module displays the current CPU utilization.
 # CONFIGURATION
 
 *interval*: ++
-	typeof: integer ++
+	typeof: integer or float ++
 	default: 10 ++
-	The interval in which the information gets polled.
+	The interval in which the information gets polled. ++
+	Minimum value is 0.001 (1ms). Values smaller than 1ms will be set to 1ms.
 
 *format*: ++
 	typeof: string  ++
@@ -91,6 +92,12 @@ The *cpu* module displays the current CPU utilization.
 
 *{load}*: Current CPU load.
 
+*{load1}*: CPU load average over the last minute.
+
+*{load5}*: CPU load average over the last 5 minutes.
+
+*{load15}*: CPU load average over the last 15 minutes.
+
 *{usage}*: Current overall CPU usage.
 
 *{usage*{n}*}*: Current CPU core n usage. Cores are numbered from zero, so first core will be {usage0} and 4th will be {usage3}.

man/waybar-custom.5.scd

@@ -35,15 +35,17 @@ Addressed by *custom/<name>*
 	See *return-type*
 
 *interval*: ++
-	typeof: integer ++
+	typeof: integer or float ++
 	The interval (in seconds) in which the information gets polled. ++
+	Minimum value is 0.001 (1ms). Values smaller than 1ms will be set to 1ms. ++
 	Use *once* if you want to execute the module only on startup. ++
 	You can update it manually with a signal. If no *interval* or *signal* is defined, it is assumed that the out script loops itself. ++
 	If a *signal* is defined then the script will run once on startup and will only update with a signal.
 
 *restart-interval*: ++
-	typeof: integer ++
+	typeof: integer or float ++
 	The restart interval (in seconds). ++
+	Minimum value is 0.001 (1ms). Values smaller than 1ms will be set to 1ms. ++
 	Can't be used with the *interval* option, so only with continuous scripts. ++
 	Once the script exits, it'll be re-executed after the *restart-interval*.
 
@@ -232,7 +234,6 @@ $text\\n$tooltip\\n$class*
 ```
 "custom/pacman": {
 	"format": "{text}  ",
-	"interval": 3600,                     // every hour
 	"exec": "checkupdates | wc -l",       // # of updates
 	"exec-if": "exit 0",                  // always run; consider advanced run conditions
 	"on-click": "termite -e 'sudo pacman -Syu'; pkill -SIGRTMIN+8 waybar", // update system
@@ -240,7 +241,7 @@ $text\\n$tooltip\\n$class*
 }
 ```
 
-You can use the signal and update the number of available packages with *pkill -RTMIN+8 waybar*.
+Under the premise that interval is not defined, you can use the signal and update the number of available packages with *pkill -RTMIN+8 waybar*.
 
 # STYLE
 

man/waybar-dwl-tags.5.scd

@@ -43,6 +43,7 @@ Addressed by *dwl/tags*
 
 - *#tags button*
 - *#tags button.occupied*
+- *#tags button.empty*
 - *#tags button.focused*
 - *#tags button.urgent*