chore: 0.9.17

Fixes https://github.com/Alexays/Waybar/issues/1783

.clang-format

@@ -1,6 +1,5 @@
 ---
 BasedOnStyle: Google
-AlignConsecutiveDeclarations: true
-BinPackArguments: false
+AlignConsecutiveDeclarations: false
 ColumnLimit: 100
 ...

.github/workflows/freebsd.yml

@@ -4,14 +4,14 @@ on: [ push, pull_request ]
 
 jobs:
   clang:
-    # Run actions in a FreeBSD vm on the macos-10.15 runner
+    # Run actions in a FreeBSD VM on the macos-12 runner
     # https://github.com/actions/runner/issues/385 - for FreeBSD runner support
     # https://github.com/actions/virtual-environments/issues/4060 - for lack of VirtualBox on MacOS 11 runners
-    runs-on: macos-10.15
+    runs-on: macos-12
     steps:
     - uses: actions/checkout@v2
     - name: Test in FreeBSD VM
-      uses: vmactions/freebsd-vm@v0.1.6 # aka FreeBSD 13.0
+      uses: vmactions/freebsd-vm@v0
       with:
         mem: 2048
         usesh: true
@@ -21,7 +21,8 @@ jobs:
           pkg install -y git #  subprojects/date
           pkg install -y catch evdev-proto gtk-layer-shell gtkmm30 jsoncpp \
             libdbusmenu libevdev libfmt libmpdclient libudev-devd meson \
-            pkgconf pulseaudio scdoc sndio spdlog wayland-protocols
+            pkgconf pulseaudio scdoc sndio spdlog wayland-protocols upower \
+            libinotify
         run: |
           meson build -Dman-pages=enabled
           ninja -C build

.github/workflows/lint.yml

@@ -0,0 +1,14 @@
+name: Linter
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: DoozyX/clang-format-lint-action@v0.13
+      with:
+        source: '.'
+        extensions: 'h,cpp,c'
+        clangFormatVersion: 12

.github/workflows/linux.yml

@@ -12,6 +12,7 @@ jobs:
           - debian
           - fedora
           - opensuse
+          - gentoo
 
     runs-on: ubuntu-latest
     container:

.gitignore

@@ -2,6 +2,8 @@
 *~
 vgcore.*
 /.vscode
+/.idea
+/.cache
 *.swp
 packagecache
 /subprojects/**/

Dockerfiles/alpine

@@ -2,4 +2,4 @@
 
 FROM alpine:latest
 
-RUN apk add --no-cache git meson alpine-sdk libinput-dev wayland-dev wayland-protocols mesa-dev libxkbcommon-dev eudev-dev pixman-dev gtkmm3-dev jsoncpp-dev pugixml-dev libnl3-dev pulseaudio-dev libmpdclient-dev sndio-dev scdoc libxkbcommon tzdata
+RUN apk add --no-cache git meson alpine-sdk libinput-dev wayland-dev wayland-protocols mesa-dev libxkbcommon-dev eudev-dev pixman-dev gtkmm3-dev jsoncpp-dev pugixml-dev libnl3-dev pulseaudio-dev libmpdclient-dev sndio-dev scdoc libxkbcommon tzdata playerctl-dev

Dockerfiles/archlinux

@@ -3,4 +3,4 @@
 FROM archlinux:base-devel
 
 RUN pacman -Syu --noconfirm && \
-    pacman -S git meson base-devel libinput wayland wayland-protocols pixman libxkbcommon mesa gtkmm3 jsoncpp pugixml scdoc libpulse libdbusmenu-gtk3 libmpdclient gobject-introspection --noconfirm libxkbcommon
+    pacman -S --noconfirm git meson base-devel libinput wayland wayland-protocols pixman libxkbcommon mesa gtkmm3 jsoncpp pugixml scdoc libpulse libdbusmenu-gtk3 libmpdclient gobject-introspection libxkbcommon playerctl

Dockerfiles/debian

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

Dockerfiles/fedora

@@ -8,5 +8,6 @@ RUN dnf install -y @c-development git-core meson scdoc 'pkgconfig(date)' \
     'pkgconfig(jsoncpp)' 'pkgconfig(libinput)' 'pkgconfig(libmpdclient)' \
     'pkgconfig(libnl-3.0)' 'pkgconfig(libnl-genl-3.0)' 'pkgconfig(libpulse)' \
     'pkgconfig(libudev)' 'pkgconfig(pugixml)' 'pkgconfig(sigc++-2.0)' 'pkgconfig(spdlog)' \
-    'pkgconfig(wayland-client)' 'pkgconfig(wayland-cursor)' 'pkgconfig(wayland-protocols)' 'pkgconfig(xkbregistry)' && \
+    'pkgconfig(wayland-client)' 'pkgconfig(wayland-cursor)' 'pkgconfig(wayland-protocols)' 'pkgconfig(xkbregistry)' \
+    'pkgconfig(playerctl)' && \
     dnf clean all -y

Dockerfiles/gentoo

@@ -0,0 +1,11 @@
+# vim: ft=Dockerfile
+
+FROM gentoo/stage3:latest
+
+RUN export FEATURES="-ipc-sandbox -network-sandbox -pid-sandbox -sandbox -usersandbox" && \
+		emerge --sync && \
+		eselect news read --quiet new 1>/dev/null 2>&1 && \
+		emerge --verbose --update --deep --with-bdeps=y --backtrack=30 --newuse @world && \
+		USE="wayland gtk3 gtk -doc X" emerge dev-vcs/git dev-libs/wayland dev-libs/wayland-protocols =dev-cpp/gtkmm-3.24.6 x11-libs/libxkbcommon \
+		x11-libs/gtk+:3 dev-libs/libdbusmenu dev-libs/libnl sys-power/upower media-libs/libpulse dev-libs/libevdev media-libs/libmpdclient \
+		media-sound/sndio gui-libs/gtk-layer-shell app-text/scdoc media-sound/playerctl

Dockerfiles/opensuse

@@ -6,4 +6,4 @@ RUN zypper -n up && \
     zypper addrepo https://download.opensuse.org/repositories/X11:Wayland/openSUSE_Tumbleweed/X11:Wayland.repo | echo 'a' && \
     zypper -n refresh && \
     zypper -n install -t pattern devel_C_C++ && \
-    zypper -n install git meson clang libinput10 libinput-devel pugixml-devel libwayland-client0 libwayland-cursor0 wayland-protocols-devel wayland-devel Mesa-libEGL-devel Mesa-libGLESv2-devel libgbm-devel libxkbcommon-devel libudev-devel libpixman-1-0-devel gtkmm3-devel jsoncpp-devel libxkbregistry-devel scdoc
+    zypper -n install git meson clang libinput10 libinput-devel pugixml-devel libwayland-client0 libwayland-cursor0 wayland-protocols-devel wayland-devel Mesa-libEGL-devel Mesa-libGLESv2-devel libgbm-devel libxkbcommon-devel libudev-devel libpixman-1-0-devel gtkmm3-devel jsoncpp-devel libxkbregistry-devel scdoc playerctl-devel

README.md

@@ -7,18 +7,23 @@
 
 #### Current features
 - Sway (Workspaces, Binding mode, Focused window name)
+- River (Mapping mode, Tags, Focused window name)
+- Hyprland (Focused window name)
 - Tray [#21](https://github.com/Alexays/Waybar/issues/21)
 - Local time
 - Battery
+- UPower
 - Network
 - Bluetooth
 - Pulseaudio
+- Wireplumber
 - Disk
 - Memory
 - Cpu load average
 - Temperature
 - MPD
 - Custom scripts
+- Custom image
 - Multiple output configuration
 - And many more customizations
 
@@ -70,6 +75,7 @@ libmpdclient [MPD module]
 libsndio [sndio module]
 libevdev [KeyboardState module]
 xkbregistry
+upower [UPower battery module]
 ```
 
 **Build dependencies**
@@ -103,6 +109,7 @@ sudo apt install \
   libspdlog-dev \
   libwayland-dev \
   scdoc \
+  upower \
   libxkbregistry-dev
 ```
 

include/AIconLabel.hpp

@@ -13,11 +13,11 @@ class AIconLabel : public ALabel {
              const std::string &format, uint16_t interval = 0, bool ellipsize = false,
              bool enable_click = false, bool enable_scroll = false);
   virtual ~AIconLabel() = default;
-  virtual auto        update() -> void;
+  virtual auto update() -> void;
 
  protected:
   Gtk::Image image_;
-  Gtk::Box   box_;
+  Gtk::Box box_;
 
   bool iconEnabled() const;
 };

include/ALabel.hpp

@@ -3,6 +3,7 @@
 #include <glibmm/markup.h>
 #include <gtkmm/label.h>
 #include <json/json.h>
+
 #include "AModule.hpp"
 
 namespace waybar {
@@ -10,20 +11,21 @@ namespace waybar {
 class ALabel : public AModule {
  public:
   ALabel(const Json::Value &, const std::string &, const std::string &, const std::string &format,
-         uint16_t interval = 0, bool ellipsize = false, bool enable_click = false, bool enable_scroll = false);
+         uint16_t interval = 0, bool ellipsize = false, bool enable_click = false,
+         bool enable_scroll = false);
   virtual ~ALabel() = default;
-  virtual auto        update() -> void;
+  virtual auto update() -> void;
   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_;
+  Gtk::Label label_;
+  std::string format_;
   const std::chrono::seconds interval_;
-  bool                       alt_ = false;
-  std::string                default_format_;
+  bool alt_ = false;
+  std::string default_format_;
 
-  virtual bool        handleToggle(GdkEventButton *const &e);
+  virtual bool handleToggle(GdkEventButton *const &e);
   virtual std::string getState(uint8_t value, bool lesser = false);
 };
 

include/AModule.hpp

@@ -15,7 +15,7 @@ class AModule : public IModule {
           bool enable_scroll = false);
   virtual ~AModule();
   virtual auto update() -> void;
-  virtual      operator Gtk::Widget &();
+  virtual operator Gtk::Widget &();
 
   Glib::Dispatcher dp;
 
@@ -23,19 +23,35 @@ class AModule : public IModule {
   enum SCROLL_DIR { NONE, UP, DOWN, LEFT, RIGHT };
 
   SCROLL_DIR getScrollDir(GdkEventScroll *e);
-  bool       tooltipEnabled();
+  bool tooltipEnabled();
 
-  const std::string  name_;
+  const std::string name_;
   const Json::Value &config_;
-  Gtk::EventBox      event_box_;
+  Gtk::EventBox event_box_;
 
   virtual bool handleToggle(GdkEventButton *const &ev);
   virtual bool handleScroll(GdkEventScroll *);
 
  private:
   std::vector<int> pid_;
-  gdouble          distance_scrolled_y_;
-  gdouble          distance_scrolled_x_;
+  gdouble distance_scrolled_y_;
+  gdouble distance_scrolled_x_;
+  static const inline std::map<std::pair<uint, GdkEventType>, std::string> eventMap_{
+      {std::make_pair(1, GdkEventType::GDK_BUTTON_PRESS), "on-click"},
+      {std::make_pair(1, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click"},
+      {std::make_pair(1, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click"},
+      {std::make_pair(2, GdkEventType::GDK_BUTTON_PRESS), "on-click-middle"},
+      {std::make_pair(2, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-middle"},
+      {std::make_pair(2, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click-middle"},
+      {std::make_pair(3, GdkEventType::GDK_BUTTON_PRESS), "on-click-right"},
+      {std::make_pair(3, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-right"},
+      {std::make_pair(3, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click-right"},
+      {std::make_pair(8, GdkEventType::GDK_BUTTON_PRESS), "on-click-backward"},
+      {std::make_pair(8, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-backward"},
+      {std::make_pair(8, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click-backward"},
+      {std::make_pair(9, GdkEventType::GDK_BUTTON_PRESS), "on-click-forward"},
+      {std::make_pair(9, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-forward"},
+      {std::make_pair(9, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click-forward"}};
 };
 
 }  // namespace waybar

include/IModule.hpp

@@ -7,8 +7,8 @@ namespace waybar {
 class IModule {
  public:
   virtual ~IModule() = default;
-  virtual auto     update() -> void = 0;
-  virtual          operator Gtk::Widget &() = 0;
+  virtual auto update() -> void = 0;
+  virtual operator Gtk::Widget&() = 0;
 };
 
 }  // namespace waybar

include/bar.hpp

@@ -19,8 +19,8 @@ namespace waybar {
 class Factory;
 struct waybar_output {
   Glib::RefPtr<Gdk::Monitor> monitor;
-  std::string                name;
-  std::string                identifier;
+  std::string name;
+  std::string identifier;
 
   std::unique_ptr<struct zxdg_output_v1, decltype(&zxdg_output_v1_destroy)> xdg_output = {
       nullptr, &zxdg_output_v1_destroy};
@@ -41,9 +41,9 @@ struct bar_margins {
 
 struct bar_mode {
   bar_layer layer;
-  bool      exclusive;
-  bool      passthrough;
-  bool      visible;
+  bool exclusive;
+  bool passthrough;
+  bool visible;
 };
 
 #ifdef HAVE_SWAY
@@ -71,7 +71,7 @@ class BarSurface {
 class Bar {
  public:
   using bar_mode_map = std::map<std::string_view, struct bar_mode>;
-  static const bar_mode_map     PRESET_MODES;
+  static const bar_mode_map PRESET_MODES;
   static const std::string_view MODE_DEFAULT;
   static const std::string_view MODE_INVISIBLE;
 
@@ -85,11 +85,11 @@ class Bar {
   void handleSignal(int);
 
   struct waybar_output *output;
-  Json::Value           config;
-  struct wl_surface    *surface;
-  bool                  visible = true;
-  bool                  vertical = false;
-  Gtk::Window           window;
+  Json::Value config;
+  struct wl_surface *surface;
+  bool visible = true;
+  bool vertical = false;
+  Gtk::Window window;
 
 #ifdef HAVE_SWAY
   std::string bar_id;
@@ -98,20 +98,20 @@ class Bar {
  private:
   void onMap(GdkEventAny *);
   auto setupWidgets() -> void;
-  void getModules(const Factory &, const std::string &, Gtk::Box*);
+  void getModules(const Factory &, const std::string &, Gtk::Box *);
   void setupAltFormatKeyForModule(const std::string &module_name);
   void setupAltFormatKeyForModuleList(const char *module_list_name);
   void setMode(const bar_mode &);
 
   /* Copy initial set of modes to allow customization */
   bar_mode_map configured_modes = PRESET_MODES;
-  std::string  last_mode_{MODE_DEFAULT};
+  std::string last_mode_{MODE_DEFAULT};
 
-  std::unique_ptr<BarSurface>                   surface_impl_;
-  Gtk::Box                                      left_;
-  Gtk::Box                                      center_;
-  Gtk::Box                                      right_;
-  Gtk::Box                                      box_;
+  std::unique_ptr<BarSurface> surface_impl_;
+  Gtk::Box left_;
+  Gtk::Box center_;
+  Gtk::Box right_;
+  Gtk::Box box_;
   std::vector<std::shared_ptr<waybar::AModule>> modules_left_;
   std::vector<std::shared_ptr<waybar::AModule>> modules_center_;
   std::vector<std::shared_ptr<waybar::AModule>> modules_right_;

include/client.hpp

@@ -17,27 +17,27 @@ namespace waybar {
 class Client {
  public:
   static Client *inst();
-  int            main(int argc, char *argv[]);
-  void           reset();
+  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 zwlr_layer_shell_v1 *        layer_shell = nullptr;
-  struct zxdg_output_manager_v1 *     xdg_output_manager = nullptr;
+  Glib::RefPtr<Gtk::Application> gtk_app;
+  Glib::RefPtr<Gdk::Display> gdk_display;
+  struct wl_display *wl_display = nullptr;
+  struct wl_registry *registry = nullptr;
+  struct zwlr_layer_shell_v1 *layer_shell = nullptr;
+  struct zxdg_output_manager_v1 *xdg_output_manager = nullptr;
   struct zwp_idle_inhibit_manager_v1 *idle_inhibit_manager = nullptr;
-  std::vector<std::unique_ptr<Bar>>   bars;
-  Config                              config;
-  std::string                         bar_id;
+  std::vector<std::unique_ptr<Bar>> bars;
+  Config config;
+  std::string bar_id;
 
  private:
   Client() = default;
-  const std::string        getStyle(const std::string &style);
-  void                     bindInterfaces();
-  void                     handleOutput(struct waybar_output &output);
-  auto                     setupCss(const std::string &css_file) -> void;
-  struct waybar_output &   getOutput(void *);
+  const std::string getStyle(const std::string &style);
+  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);
 
   static void handleGlobal(void *data, struct wl_registry *registry, uint32_t name,
@@ -46,12 +46,12 @@ class Client {
   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 *);
-  void        handleMonitorAdded(Glib::RefPtr<Gdk::Monitor> monitor);
-  void        handleMonitorRemoved(Glib::RefPtr<Gdk::Monitor> monitor);
-  void        handleDeferredMonitorRemoval(Glib::RefPtr<Gdk::Monitor> monitor);
+  void handleMonitorAdded(Glib::RefPtr<Gdk::Monitor> monitor);
+  void handleMonitorRemoved(Glib::RefPtr<Gdk::Monitor> monitor);
+  void handleDeferredMonitorRemoval(Glib::RefPtr<Gdk::Monitor> monitor);
 
   Glib::RefPtr<Gtk::StyleContext> style_context_;
-  Glib::RefPtr<Gtk::CssProvider>  css_provider_;
+  Glib::RefPtr<Gtk::CssProvider> css_provider_;
   std::list<struct waybar_output> outputs_;
 };
 

include/config.hpp

@@ -14,6 +14,7 @@ namespace waybar {
 class Config {
  public:
   static const std::vector<std::string> CONFIG_DIRS;
+  static const char *CONFIG_PATH_ENV;
 
   /* Try to find any of provided names in the supported set of config directories */
   static std::optional<std::string> findConfigPath(

include/factory.hpp

@@ -7,19 +7,28 @@
 #include "modules/simpleclock.hpp"
 #endif
 #ifdef HAVE_SWAY
+#include "modules/sway/language.hpp"
 #include "modules/sway/mode.hpp"
+#include "modules/sway/scratchpad.hpp"
 #include "modules/sway/window.hpp"
 #include "modules/sway/workspaces.hpp"
-#include "modules/sway/language.hpp"
 #endif
 #ifdef HAVE_WLR
 #include "modules/wlr/taskbar.hpp"
 #include "modules/wlr/workspace_manager.hpp"
 #endif
 #ifdef HAVE_RIVER
+#include "modules/river/mode.hpp"
 #include "modules/river/tags.hpp"
+#include "modules/river/window.hpp"
 #endif
-#if defined(__linux__) && !defined(NO_FILESYSTEM)
+#ifdef HAVE_HYPRLAND
+#include "modules/hyprland/backend.hpp"
+#include "modules/hyprland/language.hpp"
+#include "modules/hyprland/submap.hpp"
+#include "modules/hyprland/window.hpp"
+#endif
+#if defined(__FreeBSD__) || (defined(__linux__) && !defined(NO_FILESYSTEM))
 #include "modules/battery.hpp"
 #endif
 #if defined(HAVE_CPU_LINUX) || defined(HAVE_CPU_BSD)
@@ -33,6 +42,9 @@
 #ifdef HAVE_DBUSMENU
 #include "modules/sni/tray.hpp"
 #endif
+#ifdef HAVE_MPRIS
+#include "modules/mpris/mpris.hpp"
+#endif
 #ifdef HAVE_LIBNL
 #include "modules/network.hpp"
 #endif
@@ -42,6 +54,12 @@
 #ifdef HAVE_LIBEVDEV
 #include "modules/keyboard_state.hpp"
 #endif
+#ifdef HAVE_GAMEMODE
+#include "modules/gamemode.hpp"
+#endif
+#ifdef HAVE_UPOWER
+#include "modules/upower/upower.hpp"
+#endif
 #ifdef HAVE_LIBPULSE
 #include "modules/pulseaudio.hpp"
 #endif
@@ -52,16 +70,20 @@
 #include "modules/sndio.hpp"
 #endif
 #ifdef HAVE_GIO_UNIX
+#include "modules/bluetooth.hpp"
 #include "modules/inhibitor.hpp"
 #endif
+#ifdef HAVE_LIBJACK
+#include "modules/jack.hpp"
+#endif
+#ifdef HAVE_LIBWIREPLUMBER
+#include "modules/wireplumber.hpp"
+#endif
 #include "bar.hpp"
 #include "modules/custom.hpp"
+#include "modules/image.hpp"
 #include "modules/temperature.hpp"
-#if defined(__linux__)
-#  ifdef WANT_RFKILL
-#    include "modules/bluetooth.hpp"
-#  endif
-#endif
+#include "modules/user.hpp"
 
 namespace waybar {
 
@@ -71,7 +93,7 @@ class Factory {
   AModule* makeModule(const std::string& name) const;
 
  private:
-  const Bar&         bar_;
+  const Bar& bar_;
   const Json::Value& config_;
 };
 

include/group.hpp

@@ -1,8 +1,9 @@
 #pragma once
 
-#include <gtkmm/widget.h>
 #include <gtkmm/box.h>
+#include <gtkmm/widget.h>
 #include <json/json.h>
+
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "factory.hpp"
@@ -14,7 +15,7 @@ class Group : public AModule {
   Group(const std::string&, const Bar&, const Json::Value&);
   ~Group() = default;
   auto update() -> void;
-  operator Gtk::Widget &();
+  operator Gtk::Widget&();
   Gtk::Box box;
 };
 

include/modules/backlight.hpp

@@ -18,20 +18,23 @@ class Backlight : public ALabel {
   class BacklightDev {
    public:
     BacklightDev() = default;
-    BacklightDev(std::string name, int actual, int max);
-    std::string_view   name() const;
-    int                get_actual() const;
-    void               set_actual(int actual);
-    int                get_max() const;
-    void               set_max(int max);
+    BacklightDev(std::string name, int actual, int max, bool powered);
+    std::string_view name() const;
+    int get_actual() const;
+    void set_actual(int actual);
+    int get_max() const;
+    void set_max(int max);
+    bool get_powered() const;
+    void set_powered(bool powered);
     friend inline bool operator==(const BacklightDev &lhs, const BacklightDev &rhs) {
       return lhs.name_ == rhs.name_ && lhs.actual_ == rhs.actual_ && lhs.max_ == rhs.max_;
     }
 
    private:
     std::string name_;
-    int         actual_ = 1;
-    int         max_ = 1;
+    int actual_ = 1;
+    int max_ = 1;
+    bool powered_ = true;
   };
 
  public:
@@ -47,13 +50,13 @@ class Backlight : public ALabel {
   template <class ForwardIt, class Inserter>
   static void enumerate_devices(ForwardIt first, ForwardIt last, Inserter inserter, udev *udev);
 
-  const std::string    preferred_device_;
+  const std::string preferred_device_;
   static constexpr int EPOLL_MAX_EVENTS = 16;
 
   std::optional<BacklightDev> previous_best_;
-  std::string                 previous_format_;
+  std::string previous_format_;
 
-  std::mutex                udev_thread_mutex_;
+  std::mutex udev_thread_mutex_;
   std::vector<BacklightDev> devices_;
   // thread must destruct before shared data
   util::SleeperThread udev_thread_;

include/modules/battery.hpp

@@ -6,11 +6,15 @@
 #include <filesystem>
 #endif
 #include <fmt/format.h>
+#if defined(__linux__)
 #include <sys/inotify.h>
+#endif
+
 #include <algorithm>
 #include <fstream>
 #include <string>
 #include <vector>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 
@@ -31,23 +35,24 @@ class Battery : public ALabel {
  private:
   static inline const fs::path data_dir_ = "/sys/class/power_supply/";
 
-  void                                                 refreshBatteries();
-  void                                                 worker();
-  const std::string                                    getAdapterStatus(uint8_t capacity) const;
+  void refreshBatteries();
+  void worker();
+  const std::string getAdapterStatus(uint8_t capacity) const;
   const std::tuple<uint8_t, float, std::string, float> getInfos();
-  const std::string                                    formatTimeRemaining(float hoursRemaining);
+  const std::string formatTimeRemaining(float hoursRemaining);
 
-  int                   global_watch;
-  std::map<fs::path,int> batteries_;
-  fs::path              adapter_;
-  int                   battery_watch_fd_;
-  int                   global_watch_fd_;
-  std::mutex            battery_list_mutex_;
-  std::string           old_status_;
+  int global_watch;
+  std::map<fs::path, int> batteries_;
+  fs::path adapter_;
+  int battery_watch_fd_;
+  int global_watch_fd_;
+  std::mutex battery_list_mutex_;
+  std::string old_status_;
+  bool warnFirstTime_{true};
 
-  util::SleeperThread   thread_;
-  util::SleeperThread   thread_battery_update_;
-  util::SleeperThread   thread_timer_;
+  util::SleeperThread thread_;
+  util::SleeperThread thread_battery_update_;
+  util::SleeperThread thread_timer_;
 };
 
 }  // namespace waybar::modules

include/modules/bluetooth.hpp

@@ -1,18 +1,79 @@
 #pragma once
 
 #include "ALabel.hpp"
+#ifdef WANT_RFKILL
 #include "util/rfkill.hpp"
+#endif
+#include <gio/gio.h>
+
+#include <optional>
+#include <string>
+#include <vector>
 
 namespace waybar::modules {
 
 class Bluetooth : public ALabel {
+  struct ControllerInfo {
+    std::string path;
+    std::string address;
+    std::string address_type;
+    // std::string name; // just use alias instead
+    std::string alias;
+    bool powered;
+    bool discoverable;
+    bool pairable;
+    bool discovering;
+  };
+
+  // NOTE: there are some properties that not all devices provide
+  struct DeviceInfo {
+    std::string path;
+    std::string paired_controller;
+    std::string address;
+    std::string address_type;
+    // std::optional<std::string> name; // just use alias instead
+    std::string alias;
+    std::optional<std::string> icon;
+    bool paired;
+    bool trusted;
+    bool blocked;
+    bool connected;
+    bool services_resolved;
+    // NOTE: experimental feature in bluez
+    std::optional<unsigned char> battery_percentage;
+  };
+
  public:
   Bluetooth(const std::string&, const Json::Value&);
   ~Bluetooth() = default;
   auto update() -> void;
 
  private:
+  static auto onInterfaceAddedOrRemoved(GDBusObjectManager*, GDBusObject*, GDBusInterface*,
+                                        gpointer) -> void;
+  static auto onInterfaceProxyPropertiesChanged(GDBusObjectManagerClient*, GDBusObjectProxy*,
+                                                GDBusProxy*, GVariant*, const gchar* const*,
+                                                gpointer) -> void;
+
+  auto getDeviceBatteryPercentage(GDBusObject*) -> std::optional<unsigned char>;
+  auto getDeviceProperties(GDBusObject*, DeviceInfo&) -> bool;
+  auto getControllerProperties(GDBusObject*, ControllerInfo&) -> bool;
+
+  auto findCurController(ControllerInfo&) -> bool;
+  auto findConnectedDevices(const std::string&, std::vector<DeviceInfo>&) -> void;
+
+#ifdef WANT_RFKILL
   util::Rfkill rfkill_;
+#endif
+  const std::unique_ptr<GDBusObjectManager, void (*)(GDBusObjectManager*)> manager_;
+
+  std::string state_;
+  ControllerInfo cur_controller_;
+  std::vector<DeviceInfo> connected_devices_;
+  DeviceInfo cur_focussed_device_;
+  std::string device_enumerate_;
+
+  std::vector<std::string> device_preference_;
 };
 
 }  // namespace waybar::modules

include/modules/clock.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <date/tz.h>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 
@@ -24,20 +25,23 @@ class Clock : public ALabel {
   std::locale locale_;
   std::vector<const date::time_zone*> time_zones_;
   int current_time_zone_idx_;
-  date::year_month_day cached_calendar_ymd_ = date::January/1/0;
-  std::string cached_calendar_text_;
+  date::year_month_day calendar_cached_ymd_{date::January / 1 / 0};
+  date::months calendar_shift_{0}, calendar_shift_init_{0};
+  std::string calendar_cached_text_;
   bool is_calendar_in_tooltip_;
   bool is_timezoned_list_in_tooltip_;
 
   bool handleScroll(GdkEventScroll* e);
 
+  std::string fmt_str_weeks_;
+  std::string fmt_str_calendar_;
+  int fmt_weeks_left_pad_{0};
   auto calendar_text(const waybar_time& wtime) -> std::string;
   auto weekdays_header(const date::weekday& first_dow, std::ostream& os) -> void;
   auto first_day_of_week() -> date::weekday;
   const date::time_zone* current_timezone();
   bool is_timezone_fixed();
-  auto timezones_text(std::chrono::_V2::system_clock::time_point *now) -> std::string;
+  auto timezones_text(std::chrono::system_clock::time_point* now) -> std::string;
 };
-
 }  // namespace modules
 }  // namespace waybar

include/modules/cpu.hpp

@@ -1,12 +1,14 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include <cstdint>
 #include <fstream>
 #include <numeric>
 #include <string>
 #include <utility>
 #include <vector>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 
@@ -19,11 +21,11 @@ class Cpu : public ALabel {
   auto update() -> void;
 
  private:
-  double                                         getCpuLoad();
+  double getCpuLoad();
   std::tuple<std::vector<uint16_t>, std::string> getCpuUsage();
-  std::tuple<float, float, float>                getCpuFrequency();
-  std::vector<std::tuple<size_t, size_t>>        parseCpuinfo();
-  std::vector<float>                             parseCpuFrequencies();
+  std::tuple<float, float, float> getCpuFrequency();
+  std::vector<std::tuple<size_t, size_t>> parseCpuinfo();
+  std::vector<float> parseCpuFrequencies();
 
   std::vector<std::tuple<size_t, size_t>> prev_times_;
 

include/modules/custom.hpp

@@ -1,8 +1,10 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include <csignal>
 #include <string>
+
 #include "ALabel.hpp"
 #include "util/command.hpp"
 #include "util/json.hpp"
@@ -26,16 +28,17 @@ class Custom : public ALabel {
   bool handleScroll(GdkEventScroll* e);
   bool handleToggle(GdkEventButton* const& e);
 
-  const std::string        name_;
-  std::string              text_;
-  std::string              alt_;
-  std::string              tooltip_;
+  const std::string name_;
+  std::string text_;
+  std::string id_;
+  std::string alt_;
+  std::string tooltip_;
   std::vector<std::string> class_;
-  int                      percentage_;
-  FILE*                    fp_;
-  int                      pid_;
-  util::command::res       output_;
-  util::JsonParser         parser_;
+  int percentage_;
+  FILE* fp_;
+  int pid_;
+  util::command::res output_;
+  util::JsonParser parser_;
 
   util::SleeperThread thread_;
 };

include/modules/disk.hpp

@@ -1,11 +1,13 @@
 #pragma once
 
 #include <fmt/format.h>
-#include <fstream>
 #include <sys/statvfs.h>
+
+#include <fstream>
+
 #include "ALabel.hpp"
-#include "util/sleeper_thread.hpp"
 #include "util/format.hpp"
+#include "util/sleeper_thread.hpp"
 
 namespace waybar::modules {
 

include/modules/gamemode.hpp

@@ -0,0 +1,77 @@
+#pragma once
+
+#include <iostream>
+#include <map>
+#include <string>
+
+#include "ALabel.hpp"
+#include "giomm/dbusconnection.h"
+#include "giomm/dbusproxy.h"
+#include "glibconfig.h"
+#include "gtkmm/box.h"
+#include "gtkmm/image.h"
+#include "gtkmm/label.h"
+#include "gtkmm/overlay.h"
+
+namespace waybar::modules {
+
+class Gamemode : public AModule {
+ public:
+  Gamemode(const std::string &, const Json::Value &);
+  ~Gamemode();
+  auto update() -> void;
+
+ private:
+  const std::string DEFAULT_ICON_NAME = "input-gaming-symbolic";
+  const std::string DEFAULT_FORMAT = "{glyph}";
+  const std::string DEFAULT_FORMAT_ALT = "{glyph} {count}";
+  const std::string DEFAULT_TOOLTIP_FORMAT = "Games running: {count}";
+  const std::string DEFAULT_GLYPH = "";
+
+  void appear(const Glib::RefPtr<Gio::DBus::Connection> &connection, const Glib::ustring &name,
+              const Glib::ustring &name_owner);
+  void disappear(const Glib::RefPtr<Gio::DBus::Connection> &connection, const Glib::ustring &name);
+  void prepareForSleep_cb(const Glib::RefPtr<Gio::DBus::Connection> &connection,
+                          const Glib::ustring &sender_name, const Glib::ustring &object_path,
+                          const Glib::ustring &interface_name, const Glib::ustring &signal_name,
+                          const Glib::VariantContainerBase &parameters);
+  void notify_cb(const Glib::ustring &sender_name, const Glib::ustring &signal_name,
+                 const Glib::VariantContainerBase &arguments);
+
+  void getData();
+  bool handleToggle(GdkEventButton *const &);
+
+  // Config
+  std::string format = DEFAULT_FORMAT;
+  std::string format_alt = DEFAULT_FORMAT_ALT;
+  std::string tooltip_format = DEFAULT_TOOLTIP_FORMAT;
+  std::string glyph = DEFAULT_GLYPH;
+  bool tooltip = true;
+  bool hideNotRunning = true;
+  bool useIcon = true;
+  uint iconSize = 20;
+  uint iconSpacing = 4;
+  std::string iconName = DEFAULT_ICON_NAME;
+
+  Gtk::Box box_;
+  Gtk::Image icon_;
+  Gtk::Label label_;
+
+  const std::string dbus_name = "com.feralinteractive.GameMode";
+  const std::string dbus_obj_path = "/com/feralinteractive/GameMode";
+  const std::string dbus_interface = "org.freedesktop.DBus.Properties";
+  const std::string dbus_get_interface = "com.feralinteractive.GameMode";
+
+  uint gameCount = 0;
+
+  std::string lastStatus;
+  bool showAltText = false;
+
+  guint login1_id;
+  Glib::RefPtr<Gio::DBus::Proxy> gamemode_proxy;
+  Glib::RefPtr<Gio::DBus::Connection> system_connection;
+  bool gamemodeRunning;
+  guint gamemodeWatcher_id;
+};
+
+}  // namespace waybar::modules

include/modules/hyprland/backend.hpp

@@ -0,0 +1,36 @@
+#pragma once
+#include <functional>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <thread>
+
+namespace waybar::modules::hyprland {
+
+class EventHandler {
+ public:
+  virtual void onEvent(const std::string& ev) = 0;
+  virtual ~EventHandler() = default;
+};
+
+class IPC {
+ public:
+  IPC() { startIPC(); }
+
+  void registerForIPC(const std::string&, EventHandler*);
+  void unregisterForIPC(EventHandler*);
+
+  std::string getSocket1Reply(const std::string& rq);
+
+ private:
+  void startIPC();
+  void parseIPC(const std::string&);
+
+  std::mutex callbackMutex;
+  std::list<std::pair<std::string, EventHandler*>> callbacks;
+};
+
+inline std::unique_ptr<IPC> gIPC;
+inline bool modulesReady = false;
+};  // namespace waybar::modules::hyprland

include/modules/hyprland/language.hpp

@@ -0,0 +1,29 @@
+#include <fmt/format.h>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+#include "modules/hyprland/backend.hpp"
+#include "util/json.hpp"
+
+namespace waybar::modules::hyprland {
+
+class Language : public waybar::ALabel, public EventHandler {
+ public:
+  Language(const std::string&, const waybar::Bar&, const Json::Value&);
+  ~Language();
+
+  auto update() -> void;
+
+ private:
+  void onEvent(const std::string&);
+
+  void initLanguage();
+  std::string getShortFrom(const std::string&);
+
+  std::mutex mutex_;
+  const Bar& bar_;
+  util::JsonParser parser_;
+  std::string layoutName_;
+};
+
+}  // namespace waybar::modules::hyprland

include/modules/hyprland/submap.hpp

@@ -0,0 +1,26 @@
+#include <fmt/format.h>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+#include "modules/hyprland/backend.hpp"
+#include "util/json.hpp"
+
+namespace waybar::modules::hyprland {
+
+class Submap : public waybar::ALabel, public EventHandler {
+ public:
+  Submap(const std::string&, const waybar::Bar&, const Json::Value&);
+  ~Submap();
+
+  auto update() -> void;
+
+ private:
+  void onEvent(const std::string&);
+
+  std::mutex mutex_;
+  const Bar& bar_;
+  util::JsonParser parser_;
+  std::string submap_;
+};
+
+}  // namespace waybar::modules::hyprland

include/modules/hyprland/window.hpp

@@ -0,0 +1,31 @@
+#include <fmt/format.h>
+
+#include <tuple>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+#include "modules/hyprland/backend.hpp"
+#include "util/json.hpp"
+
+namespace waybar::modules::hyprland {
+
+class Window : public waybar::ALabel, public EventHandler {
+ public:
+  Window(const std::string&, const waybar::Bar&, const Json::Value&);
+  ~Window();
+
+  auto update() -> void;
+
+ private:
+  int getActiveWorkspaceID(std::string);
+  std::string getLastWindowTitle(int);
+  void onEvent(const std::string&);
+
+  bool separate_outputs;
+  std::mutex mutex_;
+  const Bar& bar_;
+  util::JsonParser parser_;
+  std::string lastView;
+};
+
+}  // namespace waybar::modules::hyprland

include/modules/idle_inhibitor.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include "ALabel.hpp"
 #include "bar.hpp"
 #include "client.hpp"
@@ -8,19 +9,22 @@
 namespace waybar::modules {
 
 class IdleInhibitor : public ALabel {
+  sigc::connection timeout_;
+
  public:
   IdleInhibitor(const std::string&, const waybar::Bar&, const Json::Value&);
   ~IdleInhibitor();
   auto update() -> void;
   static std::list<waybar::AModule*> modules;
-  static bool                        status;
+  static bool status;
 
  private:
   bool handleToggle(GdkEventButton* const& e);
+  void toggleStatus();
 
-  const Bar&                    bar_;
+  const Bar& bar_;
   struct zwp_idle_inhibitor_v1* idle_inhibitor_;
-  int                           pid_;
+  int pid_;
 };
 
 }  // namespace waybar::modules

include/modules/image.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <gtkmm/image.h>
+
+#include <csignal>
+#include <string>
+
+#include "ALabel.hpp"
+#include "util/command.hpp"
+#include "util/json.hpp"
+#include "util/sleeper_thread.hpp"
+
+namespace waybar::modules {
+
+class Image : public AModule {
+ public:
+  Image(const std::string&, const std::string&, const Json::Value&);
+  auto update() -> void;
+  void refresh(int /*signal*/);
+
+ private:
+  void delayWorker();
+  void handleEvent();
+
+  Gtk::Image image_;
+  std::string path_;
+  int size_;
+  int interval_;
+
+  util::SleeperThread thread_;
+};
+
+}  // namespace waybar::modules

include/modules/inhibitor.hpp

@@ -1,9 +1,9 @@
 #pragma once
 
-#include <memory>
-
 #include <gio/gio.h>
 
+#include <memory>
+
 #include "ALabel.hpp"
 #include "bar.hpp"
 
@@ -19,9 +19,9 @@ class Inhibitor : public ALabel {
  private:
   auto handleToggle(::GdkEventButton* const& e) -> bool;
 
-  const std::unique_ptr<::GDBusConnection, void(*)(::GDBusConnection*)> dbus_;
+  const std::unique_ptr<::GDBusConnection, void (*)(::GDBusConnection*)> dbus_;
   const std::string inhibitors_;
   int handle_ = -1;
 };
 
-} // namespace waybar::modules
+}  // namespace waybar::modules

include/modules/jack.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <jack/jack.h>
+#include <jack/thread.h>
+
+#include <fstream>
+
+#include "ALabel.hpp"
+#include "util/sleeper_thread.hpp"
+
+namespace waybar::modules {
+
+class JACK : public ALabel {
+ public:
+  JACK(const std::string &, const Json::Value &);
+  ~JACK() = default;
+  auto update() -> void;
+
+  int bufSize(jack_nframes_t size);
+  int sampleRate(jack_nframes_t rate);
+  int xrun();
+  void shutdown();
+
+ private:
+  std::string JACKState();
+
+  jack_client_t *client_;
+  jack_nframes_t bufsize_;
+  jack_nframes_t samplerate_;
+  unsigned int xruns_;
+  float load_;
+  bool running_;
+  std::mutex mutex_;
+  std::string state_;
+  util::SleeperThread thread_;
+};
+
+}  // namespace waybar::modules
+
+int bufSizeCallback(jack_nframes_t size, void *obj);
+int sampleRateCallback(jack_nframes_t rate, void *obj);
+int xrunCallback(void *obj);
+void shutdownCallback(void *obj);

include/modules/keyboard_state.hpp

@@ -1,18 +1,17 @@
 #pragma once
 
-#include <fmt/format.h>
-#if FMT_VERSION < 60000
-#include <fmt/time.h>
-#else
 #include <fmt/chrono.h>
-#endif
+#include <gtkmm/label.h>
+
+#include <unordered_map>
+
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "util/sleeper_thread.hpp"
-#include <gtkmm/label.h>
 
 extern "C" {
 #include <libevdev/libevdev.h>
+#include <libinput.h>
 }
 
 namespace waybar::modules {
@@ -24,10 +23,12 @@ class KeyboardState : public AModule {
   auto update() -> void;
 
  private:
-  Gtk::Box    box_;
-  Gtk::Label  numlock_label_;
-  Gtk::Label  capslock_label_;
-  Gtk::Label  scrolllock_label_;
+  auto tryAddDevice(const std::string&) -> void;
+
+  Gtk::Box box_;
+  Gtk::Label numlock_label_;
+  Gtk::Label capslock_label_;
+  Gtk::Label scrolllock_label_;
 
   std::string numlock_format_;
   std::string capslock_format_;
@@ -35,11 +36,12 @@ class KeyboardState : public AModule {
   const std::chrono::seconds interval_;
   std::string icon_locked_;
   std::string icon_unlocked_;
+  std::string devices_path_;
 
-  int         fd_;
-  libevdev*   dev_;
+  struct libinput* libinput_;
+  std::unordered_map<std::string, struct libinput_device*> libinput_devices_;
 
-  util::SleeperThread thread_;
+  util::SleeperThread libinput_thread_, hotplug_thread_;
 };
 
 }  // namespace waybar::modules

include/modules/memory.hpp

@@ -1,8 +1,10 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include <fstream>
 #include <unordered_map>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 
@@ -15,7 +17,7 @@ class Memory : public ALabel {
   auto update() -> void;
 
  private:
-  void                            parseMeminfo();
+  void parseMeminfo();
 
   std::unordered_map<std::string, unsigned long> meminfo_;
 

include/modules/mpd/mpd.hpp

@@ -22,8 +22,8 @@ class MPD : public ALabel {
 
   // Not using unique_ptr since we don't manage the pointer
   // (It's either nullptr, or from the config)
-  const char*       server_;
-  const unsigned    port_;
+  const char* server_;
+  const unsigned port_;
   const std::string password_;
 
   unsigned timeout_;
@@ -31,8 +31,8 @@ class MPD : public ALabel {
   detail::unique_connection connection_;
 
   detail::unique_status status_;
-  mpd_state             state_;
-  detail::unique_song   song_;
+  mpd_state state_;
+  detail::unique_song song_;
 
  public:
   MPD(const std::string&, const Json::Value&);
@@ -41,7 +41,8 @@ class MPD : public ALabel {
 
  private:
   std::string getTag(mpd_tag_type type, unsigned idx = 0) const;
-  void        setLabel();
+  std::string getFilename() const;
+  void setLabel();
   std::string getStateIcon() const;
   std::string getOptionIcon(std::string optionName, bool activated) const;
 

include/modules/mpd/state.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <mpd/client.h>
 #include <fmt/format.h>
+#include <mpd/client.h>
 #include <spdlog/spdlog.h>
 
 #include <condition_variable>
@@ -57,7 +57,7 @@ class State {
 };
 
 class Idle : public State {
-  Context* const   ctx_;
+  Context* const ctx_;
   sigc::connection idle_connection_;
 
  public:
@@ -80,7 +80,7 @@ class Idle : public State {
 };
 
 class Playing : public State {
-  Context* const   ctx_;
+  Context* const ctx_;
   sigc::connection timer_connection_;
 
  public:
@@ -102,7 +102,7 @@ class Playing : public State {
 };
 
 class Paused : public State {
-  Context* const   ctx_;
+  Context* const ctx_;
   sigc::connection timer_connection_;
 
  public:
@@ -124,7 +124,7 @@ class Paused : public State {
 };
 
 class Stopped : public State {
-  Context* const   ctx_;
+  Context* const ctx_;
   sigc::connection timer_connection_;
 
  public:
@@ -146,7 +146,7 @@ class Stopped : public State {
 };
 
 class Disconnected : public State {
-  Context* const   ctx_;
+  Context* const ctx_;
   sigc::connection timer_connection_;
 
  public:
@@ -170,7 +170,7 @@ class Disconnected : public State {
 
 class Context {
   std::unique_ptr<State> state_;
-  waybar::modules::MPD*  mpd_module_;
+  waybar::modules::MPD* mpd_module_;
 
   friend class State;
   friend class Playing;
@@ -188,18 +188,18 @@ class Context {
     state_->entry();
   }
 
-  bool                             is_connected() const;
-  bool                             is_playing() const;
-  bool                             is_paused() const;
-  bool                             is_stopped() const;
-  constexpr std::size_t            interval() const;
-  void                             tryConnect() const;
-  void                             checkErrors(mpd_connection*) const;
-  void                             do_update();
-  void                             queryMPD() const;
-  void                             fetchState() const;
-  constexpr mpd_state              state() const;
-  void                             emit() const;
+  bool is_connected() const;
+  bool is_playing() const;
+  bool is_paused() const;
+  bool is_stopped() const;
+  constexpr std::size_t interval() const;
+  void tryConnect() const;
+  void checkErrors(mpd_connection*) const;
+  void do_update();
+  void queryMPD() const;
+  void fetchState() const;
+  constexpr mpd_state state() const;
+  void emit() const;
   [[nodiscard]] unique_connection& connection();
 
  public:

include/modules/mpd/state.inl.hpp

@@ -8,13 +8,11 @@ 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(); }
-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_; }
+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_; }
 
-inline void Context::do_update() {
-  mpd_module_->setLabel();
-}
+inline void Context::do_update() { mpd_module_->setLabel(); }
 
 inline void Context::checkErrors(mpd_connection* conn) const { mpd_module_->checkErrors(conn); }
 inline void Context::queryMPD() const { mpd_module_->queryMPD(); }

include/modules/mpris/mpris.hpp

@@ -0,0 +1,68 @@
+#pragma once
+
+#include <iostream>
+#include <optional>
+#include <string>
+
+#include "gtkmm/box.h"
+#include "gtkmm/label.h"
+
+extern "C" {
+#include <playerctl/playerctl.h>
+}
+
+#include "ALabel.hpp"
+#include "util/sleeper_thread.hpp"
+
+namespace waybar::modules::mpris {
+
+class Mpris : public AModule {
+ public:
+  Mpris(const std::string&, const Json::Value&);
+  ~Mpris();
+  auto update() -> void;
+  bool handleToggle(GdkEventButton* const&);
+
+ private:
+  static auto onPlayerNameAppeared(PlayerctlPlayerManager*, PlayerctlPlayerName*, gpointer) -> void;
+  static auto onPlayerNameVanished(PlayerctlPlayerManager*, PlayerctlPlayerName*, gpointer) -> void;
+  static auto onPlayerPlay(PlayerctlPlayer*, gpointer) -> void;
+  static auto onPlayerPause(PlayerctlPlayer*, gpointer) -> void;
+  static auto onPlayerStop(PlayerctlPlayer*, gpointer) -> void;
+  static auto onPlayerMetadata(PlayerctlPlayer*, GVariant*, gpointer) -> void;
+
+  struct PlayerInfo {
+    std::string name;
+    PlayerctlPlaybackStatus status;
+    std::string status_string;
+
+    std::optional<std::string> artist;
+    std::optional<std::string> album;
+    std::optional<std::string> title;
+    std::optional<std::string> length;  // as HH:MM:SS
+  };
+
+  auto getPlayerInfo() -> std::optional<PlayerInfo>;
+  auto getIcon(const Json::Value&, const std::string&) -> std::string;
+
+  Gtk::Box box_;
+  Gtk::Label label_;
+
+  // config
+  std::string format_;
+  std::string format_playing_;
+  std::string format_paused_;
+  std::string format_stopped_;
+  std::chrono::seconds interval_;
+  std::string player_;
+  std::vector<std::string> ignored_players_;
+
+  PlayerctlPlayerManager* manager;
+  PlayerctlPlayer* player;
+  std::string lastStatus;
+  std::string lastPlayer;
+
+  util::SleeperThread thread_;
+};
+
+}  // namespace waybar::modules::mpris

include/modules/network.hpp

@@ -7,6 +7,9 @@
 #include <netlink/genl/genl.h>
 #include <netlink/netlink.h>
 #include <sys/epoll.h>
+
+#include <optional>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 #ifdef WANT_RFKILL
@@ -31,51 +34,51 @@ class Network : public ALabel {
 
   void askForStateDump(void);
 
-  void              worker();
-  void              createInfoSocket();
-  void              createEventSocket();
-  void              parseEssid(struct nlattr**);
-  void              parseSignal(struct nlattr**);
-  void              parseFreq(struct nlattr**);
-  bool              associatedOrJoined(struct nlattr**);
-  bool              checkInterface(std::string name);
-  auto              getInfo() -> void;
+  void worker();
+  void createInfoSocket();
+  void createEventSocket();
+  void parseEssid(struct nlattr**);
+  void parseSignal(struct nlattr**);
+  void parseFreq(struct nlattr**);
+  bool associatedOrJoined(struct nlattr**);
+  bool checkInterface(std::string name);
+  auto getInfo() -> void;
   const std::string getNetworkState() const;
-  void              clearIface();
-  bool              wildcardMatch(const std::string& pattern, const std::string& text) const;
+  void clearIface();
+  bool wildcardMatch(const std::string& pattern, const std::string& text) const;
   std::optional<std::pair<unsigned long long, unsigned long long>> readBandwidthUsage();
 
-  int                ifid_;
-  sa_family_t        family_;
+  int ifid_;
+  sa_family_t family_;
   struct sockaddr_nl nladdr_ = {0};
-  struct nl_sock*    sock_ = nullptr;
-  struct nl_sock*    ev_sock_ = nullptr;
-  int                efd_;
-  int                ev_fd_;
-  int                nl80211_id_;
-  std::mutex         mutex_;
+  struct nl_sock* sock_ = nullptr;
+  struct nl_sock* ev_sock_ = nullptr;
+  int efd_;
+  int ev_fd_;
+  int nl80211_id_;
+  std::mutex mutex_;
 
-  bool               want_route_dump_;
-  bool               want_link_dump_;
-  bool               want_addr_dump_;
-  bool               dump_in_progress_;
+  bool want_route_dump_;
+  bool want_link_dump_;
+  bool want_addr_dump_;
+  bool dump_in_progress_;
 
   unsigned long long bandwidth_down_total_;
   unsigned long long bandwidth_up_total_;
 
   std::string state_;
   std::string essid_;
-  bool        carrier_;
+  bool carrier_;
   std::string ifname_;
   std::string ipaddr_;
   std::string gwaddr_;
   std::string netmask_;
-  int         cidr_;
-  int32_t     signal_strength_dbm_;
-  uint8_t     signal_strength_;
+  int cidr_;
+  int32_t signal_strength_dbm_;
+  uint8_t signal_strength_;
   std::string signal_strength_app_;
-  float       frequency_;
-  uint32_t    route_priority;
+  float frequency_;
+  uint32_t route_priority;
 
   util::SleeperThread thread_;
   util::SleeperThread thread_timer_;

include/modules/pulseaudio.hpp

@@ -3,8 +3,10 @@
 #include <fmt/format.h>
 #include <pulse/pulseaudio.h>
 #include <pulse/volume.h>
+
 #include <algorithm>
 #include <array>
+
 #include "ALabel.hpp"
 
 namespace waybar::modules {
@@ -23,27 +25,27 @@ class Pulseaudio : public ALabel {
   static void serverInfoCb(pa_context*, const pa_server_info*, void*);
   static void volumeModifyCb(pa_context*, int, void*);
 
-  bool              handleScroll(GdkEventScroll* e);
+  bool handleScroll(GdkEventScroll* e);
   const std::vector<std::string> getPulseIcon() const;
 
   pa_threaded_mainloop* mainloop_;
-  pa_mainloop_api*      mainloop_api_;
-  pa_context*           context_;
+  pa_mainloop_api* mainloop_api_;
+  pa_context* context_;
   // SINK
-  uint32_t    sink_idx_{0};
-  uint16_t    volume_;
-  pa_cvolume  pa_volume_;
-  bool        muted_;
+  uint32_t sink_idx_{0};
+  uint16_t volume_;
+  pa_cvolume pa_volume_;
+  bool muted_;
   std::string port_name_;
   std::string form_factor_;
   std::string desc_;
   std::string monitor_;
   std::string current_sink_name_;
-  bool        current_sink_running_;
+  bool current_sink_running_;
   // SOURCE
-  uint32_t    source_idx_{0};
-  uint16_t    source_volume_;
-  bool        source_muted_;
+  uint32_t source_idx_{0};
+  uint16_t source_volume_;
+  bool source_muted_;
   std::string source_port_name_;
   std::string source_desc_;
   std::string default_source_name_;

include/modules/river/mode.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <wayland-client.h>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+#include "river-status-unstable-v1-client-protocol.h"
+
+namespace waybar::modules::river {
+
+class Mode : public waybar::ALabel {
+ public:
+  Mode(const std::string &, const waybar::Bar &, const Json::Value &);
+  ~Mode();
+
+  // Handlers for wayland events
+  void handle_mode(const char *mode);
+
+  struct zriver_status_manager_v1 *status_manager_;
+  struct wl_seat *seat_;
+
+ private:
+  const waybar::Bar &bar_;
+  std::string mode_;
+  struct zriver_seat_status_v1 *seat_status_;
+};
+
+} /* namespace waybar::modules::river */

include/modules/river/tags.hpp

@@ -5,8 +5,8 @@
 
 #include "AModule.hpp"
 #include "bar.hpp"
-#include "river-status-unstable-v1-client-protocol.h"
 #include "river-control-unstable-v1-client-protocol.h"
+#include "river-status-unstable-v1-client-protocol.h"
 #include "xdg-output-unstable-v1-client-protocol.h"
 
 namespace waybar::modules::river {
@@ -29,8 +29,8 @@ class Tags : public waybar::AModule {
   struct wl_seat *seat_;
 
  private:
-  const waybar::Bar &      bar_;
-  Gtk::Box                 box_;
+  const waybar::Bar &bar_;
+  Gtk::Box box_;
   std::vector<Gtk::Button> buttons_;
   struct zriver_output_status_v1 *output_status_;
 };

include/modules/river/window.hpp

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

include/modules/simpleclock.hpp

@@ -1,11 +1,7 @@
 #pragma once
 
-#include <fmt/format.h>
-#if FMT_VERSION < 60000
-#include <fmt/time.h>
-#else
 #include <fmt/chrono.h>
-#endif
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 

include/modules/sndio.hpp

@@ -1,7 +1,9 @@
 #pragma once
 
 #include <sndio.h>
+
 #include <vector>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 
@@ -9,13 +11,13 @@ namespace waybar::modules {
 
 class Sndio : public ALabel {
  public:
-  Sndio(const std::string&, const Json::Value&);
+  Sndio(const std::string &, const Json::Value &);
   ~Sndio();
   auto update() -> void;
   auto set_desc(struct sioctl_desc *, unsigned int) -> void;
   auto put_val(unsigned int, unsigned int) -> void;
   bool handleScroll(GdkEventScroll *);
-  bool handleToggle(GdkEventButton* const&);
+  bool handleToggle(GdkEventButton *const &);
 
  private:
   auto connect_to_sndio() -> void;

include/modules/sni/host.hpp

@@ -4,7 +4,9 @@
 #include <giomm.h>
 #include <glibmm/refptr.h>
 #include <json/json.h>
+
 #include <tuple>
+
 #include "bar.hpp"
 #include "modules/sni/item.hpp"
 
@@ -18,27 +20,27 @@ class Host {
   ~Host();
 
  private:
-  void        busAcquired(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring);
-  void        nameAppeared(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring,
-                           const Glib::ustring&);
-  void        nameVanished(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring);
+  void busAcquired(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring);
+  void nameAppeared(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring,
+                    const Glib::ustring&);
+  void nameVanished(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring);
   static void proxyReady(GObject*, GAsyncResult*, gpointer);
   static void registerHost(GObject*, GAsyncResult*, gpointer);
   static void itemRegistered(SnWatcher*, const gchar*, gpointer);
   static void itemUnregistered(SnWatcher*, const gchar*, gpointer);
 
   std::tuple<std::string, std::string> getBusNameAndObjectPath(const std::string);
-  void                                 addRegisteredItem(std::string service);
+  void addRegisteredItem(std::string service);
 
-  std::vector<std::unique_ptr<Item>>                items_;
-  const std::string                                 bus_name_;
-  const std::string                                 object_path_;
-  std::size_t                                       bus_name_id_;
-  std::size_t                                       watcher_id_;
-  GCancellable*                                     cancellable_ = nullptr;
-  SnWatcher*                                        watcher_ = nullptr;
-  const Json::Value&                                config_;
-  const Bar&                                        bar_;
+  std::vector<std::unique_ptr<Item>> items_;
+  const std::string bus_name_;
+  const std::string object_path_;
+  std::size_t bus_name_id_;
+  std::size_t watcher_id_;
+  GCancellable* cancellable_ = nullptr;
+  SnWatcher* watcher_ = nullptr;
+  const Json::Value& config_;
+  const Bar& bar_;
   const std::function<void(std::unique_ptr<Item>&)> on_add_;
   const std::function<void(std::unique_ptr<Item>&)> on_remove_;
 };

include/modules/sni/item.hpp

@@ -31,25 +31,25 @@ class Item : public sigc::trackable {
   std::string bus_name;
   std::string object_path;
 
-  int           icon_size;
-  int           effective_icon_size;
-  Gtk::Image    image;
+  int icon_size;
+  int effective_icon_size;
+  Gtk::Image image;
   Gtk::EventBox event_box;
-  std::string   category;
-  std::string   id;
+  std::string category;
+  std::string id;
 
-  std::string                  title;
-  std::string                  icon_name;
-  Glib::RefPtr<Gdk::Pixbuf>    icon_pixmap;
+  std::string title;
+  std::string icon_name;
+  Glib::RefPtr<Gdk::Pixbuf> icon_pixmap;
   Glib::RefPtr<Gtk::IconTheme> icon_theme;
-  std::string                  overlay_icon_name;
-  std::string                  attention_icon_name;
-  std::string                  attention_movie_name;
-  std::string                  icon_theme_path;
-  std::string                  menu;
-  ToolTip                      tooltip;
-  DbusmenuGtkMenu*             dbus_menu = nullptr;
-  Gtk::Menu*                   gtk_menu = nullptr;
+  std::string overlay_icon_name;
+  std::string attention_icon_name;
+  std::string attention_movie_name;
+  std::string icon_theme_path;
+  std::string menu;
+  ToolTip tooltip;
+  DbusmenuGtkMenu* dbus_menu = nullptr;
+  Gtk::Menu* gtk_menu = nullptr;
   /**
    * ItemIsMenu flag means that the item only supports the context menu.
    * Default value is true because libappindicator supports neither ItemIsMenu nor Activate method
@@ -67,15 +67,15 @@ class Item : public sigc::trackable {
   void onSignal(const Glib::ustring& sender_name, const Glib::ustring& signal_name,
                 const Glib::VariantContainerBase& arguments);
 
-  void                      updateImage();
+  void updateImage();
   Glib::RefPtr<Gdk::Pixbuf> extractPixBuf(GVariant* variant);
   Glib::RefPtr<Gdk::Pixbuf> getIconPixbuf();
   Glib::RefPtr<Gdk::Pixbuf> getIconByName(const std::string& name, int size);
-  double                    getScaledIconSize();
-  static void               onMenuDestroyed(Item* self, GObject* old_menu_pointer);
-  void                      makeMenu();
-  bool                      handleClick(GdkEventButton* const& /*ev*/);
-  bool                      handleScroll(GdkEventScroll* const&);
+  double getScaledIconSize();
+  static void onMenuDestroyed(Item* self, GObject* old_menu_pointer);
+  void makeMenu();
+  bool handleClick(GdkEventButton* const& /*ev*/);
+  bool handleScroll(GdkEventScroll* const&);
 
   // smooth scrolling threshold
   gdouble scroll_threshold_ = 0;
@@ -86,7 +86,7 @@ class Item : public sigc::trackable {
 
   Glib::RefPtr<Gio::DBus::Proxy> proxy_;
   Glib::RefPtr<Gio::Cancellable> cancellable_;
-  std::set<std::string_view>     update_pending_;
+  std::set<std::string_view> update_pending_;
 };
 
 }  // namespace waybar::modules::SNI

include/modules/sni/tray.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "modules/sni/host.hpp"
@@ -20,9 +21,9 @@ class Tray : public AModule {
   void onRemove(std::unique_ptr<Item>& item);
 
   static inline std::size_t nb_hosts_ = 0;
-  Gtk::Box                  box_;
-  SNI::Watcher::singleton   watcher_;
-  SNI::Host                 host_;
+  Gtk::Box box_;
+  SNI::Watcher::singleton watcher_;
+  SNI::Host host_;
 };
 
 }  // namespace waybar::modules::SNI

include/modules/sni/watcher.hpp

@@ -30,26 +30,26 @@ class Watcher {
 
   typedef struct {
     GfWatchType type;
-    Watcher *   watcher;
-    gchar *     service;
-    gchar *     bus_name;
-    gchar *     object_path;
-    guint       watch_id;
+    Watcher *watcher;
+    gchar *service;
+    gchar *bus_name;
+    gchar *object_path;
+    guint watch_id;
   } GfWatch;
 
-  void            busAcquired(const Glib::RefPtr<Gio::DBus::Connection> &, Glib::ustring);
+  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);
+  static void nameVanished(GDBusConnection *connection, const char *name, gpointer data);
+  static void gfWatchFree(gpointer data);
 
   void updateRegisteredItems(SnWatcher *obj);
 
-  uint32_t   bus_name_id_;
-  GSList *   hosts_ = nullptr;
-  GSList *   items_ = nullptr;
+  uint32_t bus_name_id_;
+  GSList *hosts_ = nullptr;
+  GSList *items_ = nullptr;
   SnWatcher *watcher_ = nullptr;
 };
 

include/modules/sway/bar.hpp

@@ -1,4 +1,5 @@
 #pragma once
+#include <atomic>
 #include <string>
 
 #include "modules/sway/ipc/client.hpp"
@@ -30,18 +31,28 @@ class BarIpcClient {
  private:
   void onInitialConfig(const struct Ipc::ipc_response& res);
   void onIpcEvent(const struct Ipc::ipc_response&);
+  void onCmd(const struct Ipc::ipc_response&);
   void onConfigUpdate(const swaybar_config& config);
   void onVisibilityUpdate(bool visible_by_modifier);
+  void onModeUpdate(bool visible_by_modifier);
+  void onUrgencyUpdate(bool visible_by_urgency);
   void update();
+  bool isModuleEnabled(std::string name);
 
-  Bar&             bar_;
+  Bar& bar_;
   util::JsonParser parser_;
-  Ipc              ipc_;
+  Ipc ipc_;
 
   swaybar_config bar_config_;
-  bool           visible_by_modifier_ = false;
+  std::string modifier_reset_;
+  bool visible_by_mode_ = false;
+  bool visible_by_modifier_ = false;
+  bool visible_by_urgency_ = false;
+  std::atomic<bool> modifier_no_action_ = false;
 
-  SafeSignal<bool>           signal_visible_;
+  SafeSignal<bool> signal_mode_;
+  SafeSignal<bool> signal_visible_;
+  SafeSignal<bool> signal_urgency_;
   SafeSignal<swaybar_config> signal_config_;
 };
 

include/modules/sway/ipc/client.hpp

@@ -4,9 +4,11 @@
 #include <sys/socket.h>
 #include <sys/un.h>
 #include <unistd.h>
+
 #include <cstring>
 #include <memory>
 #include <mutex>
+
 #include "ipc.hpp"
 #include "util/sleeper_thread.hpp"
 
@@ -18,8 +20,8 @@ class Ipc {
   ~Ipc();
 
   struct ipc_response {
-    uint32_t    size;
-    uint32_t    type;
+    uint32_t size;
+    uint32_t type;
     std::string payload;
   };
 
@@ -33,16 +35,16 @@ class Ipc {
 
  protected:
   static inline const std::string ipc_magic_ = "i3-ipc";
-  static inline const size_t      ipc_header_size_ = ipc_magic_.size() + 8;
+  static inline const size_t ipc_header_size_ = ipc_magic_.size() + 8;
 
-  const std::string   getSocketPath() const;
-  int                 open(const std::string &) const;
+  const std::string getSocketPath() const;
+  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_;
-  std::mutex          mutex_;
+  int fd_;
+  int fd_event_;
+  std::mutex mutex_;
   util::SleeperThread thread_;
 };
 

include/modules/sway/ipc/ipc.hpp

@@ -1,8 +1,10 @@
 #pragma once
 
+#include <cstdint>
+
 #define event_mask(ev) (1u << (ev & 0x7F))
 
-enum ipc_command_type {
+enum ipc_command_type : uint32_t {
   // i3 command types - see i3's I3_REPLY_TYPE constants
   IPC_COMMAND = 0,
   IPC_GET_WORKSPACES = 1,
@@ -21,16 +23,16 @@ enum ipc_command_type {
   IPC_GET_SEATS = 101,
 
   // Events sent from sway to clients. Events have the highest bits set.
-  IPC_EVENT_WORKSPACE = ((1 << 31) | 0),
-  IPC_EVENT_OUTPUT = ((1 << 31) | 1),
-  IPC_EVENT_MODE = ((1 << 31) | 2),
-  IPC_EVENT_WINDOW = ((1 << 31) | 3),
-  IPC_EVENT_BARCONFIG_UPDATE = ((1 << 31) | 4),
-  IPC_EVENT_BINDING = ((1 << 31) | 5),
-  IPC_EVENT_SHUTDOWN = ((1 << 31) | 6),
-  IPC_EVENT_TICK = ((1 << 31) | 7),
+  IPC_EVENT_WORKSPACE = ((1U << 31) | 0),
+  IPC_EVENT_OUTPUT = ((1U << 31) | 1),
+  IPC_EVENT_MODE = ((1U << 31) | 2),
+  IPC_EVENT_WINDOW = ((1U << 31) | 3),
+  IPC_EVENT_BARCONFIG_UPDATE = ((1U << 31) | 4),
+  IPC_EVENT_BINDING = ((1U << 31) | 5),
+  IPC_EVENT_SHUTDOWN = ((1U << 31) | 6),
+  IPC_EVENT_TICK = ((1U << 31) | 7),
 
-	// sway-specific event types
-	IPC_EVENT_BAR_STATE_UPDATE = ((1<<31) | 20),
-	IPC_EVENT_INPUT = ((1<<31) | 21),
+  // sway-specific event types
+  IPC_EVENT_BAR_STATE_UPDATE = ((1U << 31) | 20),
+  IPC_EVENT_INPUT = ((1U << 31) | 21),
 };

include/modules/sway/language.hpp

@@ -21,11 +21,7 @@ class Language : public ALabel, public sigc::trackable {
   auto update() -> void;
 
  private:
-  enum class DispayedShortFlag {
-	  None = 0,
-	  ShortName = 1,
-	  ShortDescription = 1 << 1
-  };
+  enum class DispayedShortFlag { None = 0, ShortName = 1, ShortDescription = 1 << 1 };
 
   struct Layout {
     std::string full_name;
@@ -37,14 +33,15 @@ class Language : public ALabel, public sigc::trackable {
 
   class XKBContext {
    public:
-	   XKBContext();
-	   ~XKBContext();
-	   auto next_layout() -> Layout*;
+    XKBContext();
+    ~XKBContext();
+    auto next_layout() -> Layout*;
+
    private:
-	rxkb_context* context_ = nullptr;
-	rxkb_layout* xkb_layout_ = nullptr;
-	Layout* layout_ = nullptr;
-	std::map<std::string, rxkb_layout*> base_layouts_by_name_;
+    rxkb_context* context_ = nullptr;
+    rxkb_layout* xkb_layout_ = nullptr;
+    Layout* layout_ = nullptr;
+    std::map<std::string, rxkb_layout*> base_layouts_by_name_;
   };
 
   void onEvent(const struct Ipc::ipc_response&);
@@ -56,15 +53,15 @@ class Language : public ALabel, public sigc::trackable {
   const static std::string XKB_LAYOUT_NAMES_KEY;
   const static std::string XKB_ACTIVE_LAYOUT_NAME_KEY;
 
-  Layout                        layout_;
+  Layout layout_;
   std::string tooltip_format_ = "";
   std::map<std::string, Layout> layouts_map_;
   bool is_variant_displayed;
   std::byte displayed_short_flag = static_cast<std::byte>(DispayedShortFlag::None);
 
-  util::JsonParser         parser_;
-  std::mutex               mutex_;
-  Ipc                      ipc_;
+  util::JsonParser parser_;
+  std::mutex mutex_;
+  Ipc ipc_;
 };
 
 }  // namespace waybar::modules::sway

include/modules/sway/mode.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include "ALabel.hpp"
 #include "bar.hpp"
 #include "client.hpp"
@@ -18,10 +19,10 @@ class Mode : public ALabel, public sigc::trackable {
  private:
   void onEvent(const struct Ipc::ipc_response&);
 
-  std::string      mode_;
+  std::string mode_;
   util::JsonParser parser_;
-  std::mutex       mutex_;
-  Ipc              ipc_;
+  std::mutex mutex_;
+  Ipc ipc_;
 };
 
 }  // namespace waybar::modules::sway

include/modules/sway/scratchpad.hpp

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

include/modules/sway/window.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include <tuple>
 
 #include "AIconLabel.hpp"
@@ -18,23 +19,28 @@ class Window : public AIconLabel, public sigc::trackable {
   auto update() -> void;
 
  private:
-  void                                                   onEvent(const struct Ipc::ipc_response&);
-  void                                                   onCmd(const struct Ipc::ipc_response&);
-  std::tuple<std::size_t, int, std::string, std::string> getFocusedNode(const Json::Value& nodes,
-                                                                        std::string&       output);
-  void                                                   getTree();
-  std::string                                            rewriteTitle(const std::string& title);
-  void                                                   updateAppIcon();
+  void onEvent(const struct Ipc::ipc_response&);
+  void onCmd(const struct Ipc::ipc_response&);
+  std::tuple<std::size_t, int, std::string, std::string, std::string, std::string> getFocusedNode(
+      const Json::Value& nodes, std::string& output);
+  void getTree();
+  void updateAppIconName();
+  void updateAppIcon();
 
-  const Bar&       bar_;
-  std::string      window_;
-  int              windowId_;
-  std::string      app_id_;
-  std::string      old_app_id_;
-  std::size_t      app_nb_;
+  const Bar& bar_;
+  std::string window_;
+  int windowId_;
+  std::string app_id_;
+  std::string app_class_;
+  std::string old_app_id_;
+  std::size_t app_nb_;
+  std::string shell_;
+  unsigned app_icon_size_{24};
+  bool update_app_icon_{true};
+  std::string app_icon_name_;
   util::JsonParser parser_;
-  std::mutex       mutex_;
-  Ipc              ipc_;
+  std::mutex mutex_;
+  Ipc ipc_;
 };
 
 }  // namespace waybar::modules::sway

include/modules/sway/workspaces.hpp

@@ -1,10 +1,11 @@
 #pragma once
 
-#include <unordered_map>
 #include <fmt/format.h>
 #include <gtkmm/button.h>
 #include <gtkmm/label.h>
+
 #include <unordered_map>
+
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "client.hpp"
@@ -24,25 +25,25 @@ class Workspaces : public AModule, public sigc::trackable {
 
   static int convertWorkspaceNameToNum(std::string name);
 
-  void              onCmd(const struct Ipc::ipc_response&);
-  void              onEvent(const struct Ipc::ipc_response&);
-  bool              filterButtons();
-  Gtk::Button&      addButton(const Json::Value&);
-  void              onButtonReady(const Json::Value&, Gtk::Button&);
-  std::string       getIcon(const std::string&, const Json::Value&);
+  void onCmd(const struct Ipc::ipc_response&);
+  void onEvent(const struct Ipc::ipc_response&);
+  bool filterButtons();
+  Gtk::Button& addButton(const Json::Value&);
+  void onButtonReady(const Json::Value&, Gtk::Button&);
+  std::string getIcon(const std::string&, const Json::Value&);
   const std::string getCycleWorkspace(std::vector<Json::Value>::iterator, bool prev) const;
-  uint16_t          getWorkspaceIndex(const std::string& name) const;
-  std::string       trimWorkspaceName(std::string);
-  bool              handleScroll(GdkEventScroll*);
+  uint16_t getWorkspaceIndex(const std::string& name) const;
+  std::string trimWorkspaceName(std::string);
+  bool handleScroll(GdkEventScroll*);
 
-  const Bar&                                   bar_;
-  std::vector<Json::Value>                     workspaces_;
-  std::vector<std::string>                     workspaces_order_;
-  Gtk::Box                                     box_;
-  util::JsonParser                             parser_;
+  const Bar& bar_;
+  std::vector<Json::Value> workspaces_;
+  std::vector<std::string> workspaces_order_;
+  Gtk::Box box_;
+  util::JsonParser parser_;
   std::unordered_map<std::string, Gtk::Button> buttons_;
-  std::mutex                                   mutex_;
-  Ipc                                          ipc_;
+  std::mutex mutex_;
+  Ipc ipc_;
 };
 
 }  // namespace waybar::modules::sway

include/modules/temperature.hpp

@@ -1,7 +1,9 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include <fstream>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 
@@ -14,10 +16,10 @@ class Temperature : public ALabel {
   auto update() -> void;
 
  private:
-  float               getTemperature();
-  bool                isCritical(uint16_t);
+  float getTemperature();
+  bool isCritical(uint16_t);
 
-  std::string         file_path_;
+  std::string file_path_;
   util::SleeperThread thread_;
 };
 

include/modules/upower/upower.hpp

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <libupower-glib/upower.h>
+
+#include <iostream>
+#include <map>
+#include <string>
+#include <unordered_map>
+
+#include "ALabel.hpp"
+#include "glibconfig.h"
+#include "gtkmm/box.h"
+#include "gtkmm/image.h"
+#include "gtkmm/label.h"
+#include "modules/upower/upower_tooltip.hpp"
+
+namespace waybar::modules::upower {
+
+class UPower : public AModule {
+ public:
+  UPower(const std::string &, const Json::Value &);
+  ~UPower();
+  auto update() -> void;
+
+ private:
+  typedef std::unordered_map<std::string, UpDevice *> Devices;
+
+  const std::string DEFAULT_FORMAT = "{percentage}";
+  const std::string DEFAULT_FORMAT_ALT = "{percentage} {time}";
+
+  static void deviceAdded_cb(UpClient *client, UpDevice *device, gpointer data);
+  static void deviceRemoved_cb(UpClient *client, const gchar *objectPath, gpointer data);
+  static void deviceNotify_cb(UpDevice *device, GParamSpec *pspec, gpointer user_data);
+  static void prepareForSleep_cb(GDBusConnection *system_bus, const gchar *sender_name,
+                                 const gchar *object_path, const gchar *interface_name,
+                                 const gchar *signal_name, GVariant *parameters,
+                                 gpointer user_data);
+  static void upowerAppear(GDBusConnection *conn, const gchar *name, const gchar *name_owner,
+                           gpointer data);
+  static void upowerDisappear(GDBusConnection *connection, const gchar *name, gpointer user_data);
+
+  void removeDevice(const gchar *objectPath);
+  void addDevice(UpDevice *device);
+  void setDisplayDevice();
+  void resetDevices();
+  void removeDevices();
+  bool show_tooltip_callback(int, int, bool, const Glib::RefPtr<Gtk::Tooltip> &tooltip);
+  bool handleToggle(GdkEventButton *const &);
+  std::string timeToString(gint64 time);
+
+  const std::string getDeviceStatus(UpDeviceState &state);
+
+  Gtk::Box box_;
+  Gtk::Image icon_;
+  Gtk::Label label_;
+
+  // Config
+  bool hideIfEmpty = true;
+  bool tooltip_enabled = true;
+  uint tooltip_spacing = 4;
+  uint tooltip_padding = 4;
+  uint iconSize = 20;
+  std::string format = DEFAULT_FORMAT;
+  std::string format_alt = DEFAULT_FORMAT_ALT;
+
+  Devices devices;
+  std::mutex m_Mutex;
+  UpClient *client;
+  UpDevice *displayDevice;
+  guint login1_id;
+  GDBusConnection *login1_connection;
+  UPowerTooltip *upower_tooltip;
+  std::string lastStatus;
+  bool showAltText;
+  bool upowerRunning;
+  guint upowerWatcher_id;
+};
+
+}  // namespace waybar::modules::upower

include/modules/upower/upower_tooltip.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <libupower-glib/upower.h>
+
+#include <unordered_map>
+
+#include "gtkmm/box.h"
+#include "gtkmm/label.h"
+#include "gtkmm/window.h"
+
+namespace waybar::modules::upower {
+
+class UPowerTooltip : public Gtk::Window {
+ private:
+  typedef std::unordered_map<std::string, UpDevice*> Devices;
+
+  const std::string getDeviceIcon(UpDeviceKind& kind);
+
+  Gtk::Box* contentBox;
+
+  uint iconSize;
+  uint tooltipSpacing;
+  uint tooltipPadding;
+
+ public:
+  UPowerTooltip(uint iconSize, uint tooltipSpacing, uint tooltipPadding);
+  ~UPowerTooltip();
+
+  uint updateTooltip(Devices& devices);
+};
+
+}  // namespace waybar::modules::upower

include/modules/user.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <fmt/chrono.h>
+#include <gdkmm/pixbuf.h>
+#include <glibmm/refptr.h>
+
+#include "AIconLabel.hpp"
+#include "util/sleeper_thread.hpp"
+
+namespace waybar::modules {
+class User : public AIconLabel {
+ public:
+  User(const std::string&, const Json::Value&);
+  ~User() = default;
+  auto update() -> void;
+
+  bool handleToggle(GdkEventButton* const& e) override;
+
+ private:
+  util::SleeperThread thread_;
+
+  static constexpr inline int defaultUserImageWidth_ = 20;
+  static constexpr inline int defaultUserImageHeight_ = 20;
+
+  long uptime_as_seconds();
+  std::string get_user_login() const;
+  std::string get_user_home_dir() const;
+  std::string get_default_user_avatar_path() const;
+  void init_default_user_avatar(int width, int height);
+  void init_user_avatar(const std::string& path, int width, int height);
+  void init_avatar(const Json::Value& config);
+  void init_update_worker();
+};
+}  // namespace waybar::modules

include/modules/wireplumber.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <wp/wp.h>
+
+#include <algorithm>
+#include <array>
+
+#include "ALabel.hpp"
+
+namespace waybar::modules {
+
+class Wireplumber : public ALabel {
+ public:
+  Wireplumber(const std::string&, const Json::Value&);
+  ~Wireplumber();
+  auto update() -> void;
+
+ private:
+  void loadRequiredApiModules();
+  void prepare();
+  void activatePlugins();
+  static void updateVolume(waybar::modules::Wireplumber* self);
+  static void updateNodeName(waybar::modules::Wireplumber* self);
+  static uint32_t getDefaultNodeId(waybar::modules::Wireplumber* self);
+  static void onPluginActivated(WpObject* p, GAsyncResult* res, waybar::modules::Wireplumber* self);
+  static void onObjectManagerInstalled(waybar::modules::Wireplumber* self);
+
+  WpCore* wp_core_;
+  GPtrArray* apis_;
+  WpObjectManager* om_;
+  uint32_t pending_plugins_;
+  bool muted_;
+  double volume_;
+  uint32_t node_id_{0};
+  std::string node_name_;
+};
+
+}  // namespace waybar::modules

include/modules/wlr/taskbar.hpp

@@ -1,174 +1,178 @@
 #pragma once
 
+#include <gdk/gdk.h>
+#include <glibmm/refptr.h>
+#include <gtkmm/box.h>
+#include <gtkmm/button.h>
+#include <gtkmm/icontheme.h>
+#include <gtkmm/image.h>
+#include <gtkmm/label.h>
+#include <wayland-client.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "client.hpp"
 #include "giomm/desktopappinfo.h"
 #include "util/json.hpp"
-
-#include <memory>
-#include <string>
-#include <vector>
-#include <map>
-#include <unordered_set>
-
-#include <gdk/gdk.h>
-
-#include <glibmm/refptr.h>
-
-#include <gtkmm/box.h>
-#include <gtkmm/button.h>
-#include <gtkmm/image.h>
-#include <gtkmm/label.h>
-#include <gtkmm/icontheme.h>
-
-#include <wayland-client.h>
 #include "wlr-foreign-toplevel-management-unstable-v1-client-protocol.h"
 
-
 namespace waybar::modules::wlr {
 
 class Taskbar;
 
-class Task
-{
-   public:
-    Task(const waybar::Bar&, const Json::Value&, Taskbar*,
-         struct zwlr_foreign_toplevel_handle_v1 *, struct wl_seat*);
-    ~Task();
+class Task {
+ public:
+  Task(const waybar::Bar &, const Json::Value &, Taskbar *,
+       struct zwlr_foreign_toplevel_handle_v1 *, struct wl_seat *);
+  ~Task();
 
-   public:
-    enum State {
-        MAXIMIZED = (1 << 0),
-        MINIMIZED = (1 << 1),
-        ACTIVE = (1 << 2),
-        FULLSCREEN = (1 << 3),
-        INVALID = (1 << 4)
-    };
+ public:
+  enum State {
+    MAXIMIZED = (1 << 0),
+    MINIMIZED = (1 << 1),
+    ACTIVE = (1 << 2),
+    FULLSCREEN = (1 << 3),
+    INVALID = (1 << 4)
+  };
 
-   private:
-    static uint32_t global_id;
+ private:
+  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_;
+ private:
+  const waybar::Bar &bar_;
+  const Json::Value &config_;
+  Taskbar *tbar_;
+  struct zwlr_foreign_toplevel_handle_v1 *handle_;
+  struct wl_seat *seat_;
 
-    uint32_t id_;
+  uint32_t id_;
 
-    Gtk::Button button_;
-    Gtk::Box content_;
-    Gtk::Image icon_;
-    Gtk::Label text_before_;
-    Gtk::Label text_after_;
-    Glib::RefPtr<Gio::DesktopAppInfo> app_info_;
-    bool button_visible_ = false;
-    bool ignored_ = false;
+  Gtk::Button button_;
+  Gtk::Box content_;
+  Gtk::Image icon_;
+  Gtk::Label text_before_;
+  Gtk::Label text_after_;
+  Glib::RefPtr<Gio::DesktopAppInfo> app_info_;
+  bool button_visible_ = false;
+  bool ignored_ = false;
 
-    bool with_icon_ = false;
-    bool with_name_ = false;
-    std::string format_before_;
-    std::string format_after_;
+  bool with_icon_ = false;
+  bool with_name_ = false;
+  std::string format_before_;
+  std::string format_after_;
 
-    std::string format_tooltip_;
+  std::string format_tooltip_;
 
-    std::string name_;
-    std::string title_;
-    std::string app_id_;
-    uint32_t state_ = 0;
+  std::string name_;
+  std::string title_;
+  std::string app_id_;
+  uint32_t state_ = 0;
 
-   private:
-    std::string repr() const;
-    std::string state_string(bool = false) const;
-    void set_app_info_from_app_id_list(const std::string& app_id_list);
-    bool image_load_icon(Gtk::Image& image, const Glib::RefPtr<Gtk::IconTheme>& icon_theme, Glib::RefPtr<Gio::DesktopAppInfo> app_info, int size);
-    void hide_if_ignored();
+  int32_t drag_start_x;
+  int32_t drag_start_y;
+  int32_t drag_start_button = -1;
 
-   public:
-    /* Getter functions */
-    uint32_t id() const { return id_; }
-    std::string title() const { return title_; }
-    std::string app_id() const { return app_id_; }
-    uint32_t state() const { return state_; }
-    bool maximized() const { return state_ & MAXIMIZED; }
-    bool minimized() const { return state_ & MINIMIZED; }
-    bool active() const { return state_ & ACTIVE; }
-    bool fullscreen() const { return state_ & FULLSCREEN; }
+ private:
+  std::string repr() const;
+  std::string state_string(bool = false) const;
+  void set_app_info_from_app_id_list(const std::string &app_id_list);
+  bool image_load_icon(Gtk::Image &image, const Glib::RefPtr<Gtk::IconTheme> &icon_theme,
+                       Glib::RefPtr<Gio::DesktopAppInfo> app_info, int size);
+  void hide_if_ignored();
 
-   public:
-    /* 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_done();
-    void handle_closed();
+ public:
+  /* Getter functions */
+  uint32_t id() const { return id_; }
+  std::string title() const { return title_; }
+  std::string app_id() const { return app_id_; }
+  uint32_t state() const { return state_; }
+  bool maximized() const { return state_ & MAXIMIZED; }
+  bool minimized() const { return state_ & MINIMIZED; }
+  bool active() const { return state_ & ACTIVE; }
+  bool fullscreen() const { return state_ & FULLSCREEN; }
 
-    /* Callbacks for Gtk events */
-    bool handle_clicked(GdkEventButton *);
+ 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_done();
+  void handle_closed();
 
-  public:
-    bool operator==(const Task&) const;
-    bool operator!=(const Task&) const;
+  /* Callbacks for Gtk events */
+  bool handle_clicked(GdkEventButton *);
+  bool handle_button_release(GdkEventButton *);
+  bool handle_motion_notify(GdkEventMotion *);
+  void handle_drag_data_get(const Glib::RefPtr<Gdk::DragContext> &context,
+                            Gtk::SelectionData &selection_data, guint info, guint time);
+  void handle_drag_data_received(const Glib::RefPtr<Gdk::DragContext> &context, int x, int y,
+                                 Gtk::SelectionData selection_data, guint info, guint time);
 
-  public:
-    void update();
+ public:
+  bool operator==(const Task &) const;
+  bool operator!=(const Task &) const;
 
-  public:
-    /* Interaction with the tasks */
-    void maximize(bool);
-    void minimize(bool);
-    void activate();
-    void fullscreen(bool);
-    void close();
+ public:
+  void update();
+
+ public:
+  /* Interaction with the tasks */
+  void maximize(bool);
+  void minimize(bool);
+  void activate();
+  void fullscreen(bool);
+  void close();
 };
 
 using TaskPtr = std::unique_ptr<Task>;
 
+class Taskbar : public waybar::AModule {
+ public:
+  Taskbar(const std::string &, const waybar::Bar &, const Json::Value &);
+  ~Taskbar();
+  void update();
 
-class Taskbar : public waybar::AModule
-{
-   public:
-    Taskbar(const std::string&, const waybar::Bar&, const Json::Value&);
-    ~Taskbar();
-    void update();
+ private:
+  const waybar::Bar &bar_;
+  Gtk::Box box_;
+  std::vector<TaskPtr> tasks_;
 
-   private:
-    const waybar::Bar &bar_;
-    Gtk::Box box_;
-    std::vector<TaskPtr> tasks_;
+  std::vector<Glib::RefPtr<Gtk::IconTheme>> icon_themes_;
+  std::unordered_set<std::string> ignore_list_;
+  std::map<std::string, std::string> app_ids_replace_map_;
 
-    std::vector<Glib::RefPtr<Gtk::IconTheme>> icon_themes_;
-    std::unordered_set<std::string> ignore_list_;
-    std::map<std::string, std::string> app_ids_replace_map_;
+  struct zwlr_foreign_toplevel_manager_v1 *manager_;
+  struct wl_seat *seat_;
 
-    struct zwlr_foreign_toplevel_manager_v1 *manager_;
-    struct wl_seat *seat_;
+ 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);
 
-   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);
+  /* Callbacks for the wlr protocol */
+  void handle_toplevel_create(struct zwlr_foreign_toplevel_handle_v1 *);
+  void handle_finished();
 
-    /* Callbacks for the wlr protocol */
-    void handle_toplevel_create(struct zwlr_foreign_toplevel_handle_v1 *);
-    void handle_finished();
+ public:
+  void add_button(Gtk::Button &);
+  void move_button(Gtk::Button &, int);
+  void remove_button(Gtk::Button &);
+  void remove_task(uint32_t);
 
-   public:
-    void add_button(Gtk::Button &);
-    void move_button(Gtk::Button &, int);
-    void remove_button(Gtk::Button &);
-    void remove_task(uint32_t);
+  bool show_output(struct wl_output *) const;
+  bool all_outputs() const;
 
-    bool show_output(struct wl_output *) const;
-    bool all_outputs() const;
-
-    const std::vector<Glib::RefPtr<Gtk::IconTheme>>& icon_themes() const;
-    const std::unordered_set<std::string>& ignore_list() const;
-    const std::map<std::string, std::string>& app_ids_replace_map() const;
+  const std::vector<Glib::RefPtr<Gtk::IconTheme>> &icon_themes() const;
+  const std::unordered_set<std::string> &ignore_list() const;
+  const std::map<std::string, std::string> &app_ids_replace_map() const;
 };
 
 } /* namespace waybar::modules::wlr */

include/modules/wlr/workspace_manager.hpp

@@ -53,24 +53,24 @@ class Workspace {
  private:
   auto get_icon() -> std::string;
 
-  const Bar         &bar_;
+  const Bar &bar_;
   const Json::Value &config_;
-  WorkspaceGroup    &workspace_group_;
+  WorkspaceGroup &workspace_group_;
 
   // wlr stuff
   zext_workspace_handle_v1 *workspace_handle_;
-  uint32_t                  state_ = 0;
+  uint32_t state_ = 0;
 
-  uint32_t                                  id_;
-  std::string                               name_;
-  std::vector<uint32_t>                     coordinates_;
+  uint32_t id_;
+  std::string name_;
+  std::vector<uint32_t> coordinates_;
   static std::map<std::string, std::string> icons_map_;
-  std::string                               format_;
-  bool                                      with_icon_ = false;
+  std::string format_;
+  bool with_icon_ = false;
 
   Gtk::Button button_;
-  Gtk::Box    content_;
-  Gtk::Label  label_;
+  Gtk::Box content_;
+  Gtk::Label label_;
 };
 
 class WorkspaceGroup {
@@ -102,19 +102,19 @@ class WorkspaceGroup {
   auto commit() -> void;
 
  private:
-  static uint32_t    workspace_global_id;
+  static uint32_t workspace_global_id;
   const waybar::Bar &bar_;
-  Gtk::Box          &box_;
+  Gtk::Box &box_;
   const Json::Value &config_;
-  WorkspaceManager  &workspace_manager_;
+  WorkspaceManager &workspace_manager_;
 
   // wlr stuff
   zext_workspace_group_handle_v1 *workspace_group_handle_;
-  wl_output                      *output_ = nullptr;
+  wl_output *output_ = nullptr;
 
-  uint32_t                                id_;
+  uint32_t id_;
   std::vector<std::unique_ptr<Workspace>> workspaces_;
-  bool                                    need_to_sort = false;
+  bool need_to_sort = false;
 };
 
 class WorkspaceManager : public AModule {
@@ -141,8 +141,8 @@ class WorkspaceManager : public AModule {
   auto commit() -> void;
 
  private:
-  const waybar::Bar                           &bar_;
-  Gtk::Box                                     box_;
+  const waybar::Bar &bar_;
+  Gtk::Box box_;
   std::vector<std::unique_ptr<WorkspaceGroup>> groups_;
 
   // wlr stuff
@@ -152,6 +152,7 @@ class WorkspaceManager : public AModule {
 
   bool sort_by_name_ = true;
   bool sort_by_coordinates_ = true;
+  bool sort_by_number_ = false;
   bool all_outputs_ = false;
   bool active_only_ = false;
   bool creation_delayed_ = false;

include/modules/wlr/workspace_manager_binding.hpp

@@ -1,8 +1,10 @@
 #include "ext-workspace-unstable-v1-client-protocol.h"
 
 namespace waybar::modules::wlr {
-  void add_registry_listener(void *data);
-  void add_workspace_listener(zext_workspace_handle_v1 *workspace_handle, void *data);
-  void add_workspace_group_listener(zext_workspace_group_handle_v1 *workspace_group_handle, void *data);
-  zext_workspace_manager_v1* workspace_manager_bind(wl_registry *registry, uint32_t name, uint32_t version, void *data);
-}
+void add_registry_listener(void *data);
+void add_workspace_listener(zext_workspace_handle_v1 *workspace_handle, void *data);
+void add_workspace_group_listener(zext_workspace_group_handle_v1 *workspace_group_handle,
+                                  void *data);
+zext_workspace_manager_v1 *workspace_manager_bind(wl_registry *registry, uint32_t name,
+                                                  uint32_t version, void *data);
+}  // namespace waybar::modules::wlr

include/util/SafeSignal.hpp

@@ -64,10 +64,10 @@ struct SafeSignal : sigc::signal<void(std::decay_t<Args>...)> {
     }
   }
 
-  Glib::Dispatcher        dp_;
-  std::mutex              mutex_;
+  Glib::Dispatcher dp_;
+  std::mutex mutex_;
   std::queue<arg_tuple_t> queue_;
-  const std::thread::id   main_tid_ = std::this_thread::get_id();
+  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/command.hpp

@@ -20,13 +20,13 @@ extern std::list<pid_t> reap;
 namespace waybar::util::command {
 
 struct res {
-  int         exit_code;
+  int exit_code;
   std::string out;
 };
 
 inline std::string read(FILE* fp) {
   std::array<char, 128> buffer = {0};
-  std::string           output;
+  std::string output;
   while (feof(fp) == 0) {
     if (fgets(buffer.data(), 128, fp) != nullptr) {
       output += buffer.data();
@@ -68,7 +68,7 @@ inline int close(FILE* fp, pid_t pid) {
 inline FILE* open(const std::string& cmd, int& pid) {
   if (cmd == "") return nullptr;
   int fd[2];
-  if (pipe(fd) != 0){
+  if (pipe(fd) != 0) {
     spdlog::error("Unable to pipe fd");
     return nullptr;
   }
@@ -112,7 +112,7 @@ inline FILE* open(const std::string& cmd, int& pid) {
 }
 
 inline struct res exec(const std::string& cmd) {
-  int  pid;
+  int pid;
   auto fp = command::open(cmd, pid);
   if (!fp) return {-1, ""};
   auto output = command::read(fp);
@@ -121,7 +121,7 @@ inline struct res exec(const std::string& cmd) {
 }
 
 inline struct res execNoRead(const std::string& cmd) {
-  int  pid;
+  int pid;
   auto fp = command::open(cmd, pid);
   if (!fp) return {-1, ""};
   auto stat = command::close(fp, pid);

include/util/format.hpp

@@ -4,96 +4,96 @@
 #include <glibmm/ustring.h>
 
 class pow_format {
-  public:
-    pow_format(long long val, std::string&& unit, bool binary = false):
-      val_(val), unit_(unit), binary_(binary) { };
+ public:
+  pow_format(long long val, std::string&& unit, bool binary = false)
+      : val_(val), unit_(unit), binary_(binary){};
 
-    long long val_;
-    std::string unit_;
-    bool binary_;
+  long long val_;
+  std::string unit_;
+  bool binary_;
 };
 
-
 namespace fmt {
-  template <>
-    struct formatter<pow_format> {
-      char spec = 0;
-      int width = 0;
+template <>
+struct formatter<pow_format> {
+  char spec = 0;
+  int width = 0;
 
-      template <typename ParseContext>
-        constexpr auto parse(ParseContext& ctx) -> decltype (ctx.begin()) {
-          auto it = ctx.begin(), end = ctx.end();
-          if (it != end && *it == ':') ++it;
-          if (it && (*it == '>' || *it == '<' || *it == '=')) {
-            spec = *it;
-            ++it;
-          }
-          if (it == end || *it == '}') return it;
-          if ('0' <= *it && *it <= '9') {
-            // We ignore it for now, but keep it for compatibility with
-            // existing configs where the format for pow_format'ed numbers was
-            // 'string' and specifications such as {:>9} were valid.
-            // The rationale for ignoring it is that the only reason to specify
-            // an alignment and a with is to get a fixed width bar, and ">" is
-            // sufficient in this implementation.
+  template <typename ParseContext>
+  constexpr auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    auto it = ctx.begin(), end = ctx.end();
+    if (it != end && *it == ':') ++it;
+    if (it && (*it == '>' || *it == '<' || *it == '=')) {
+      spec = *it;
+      ++it;
+    }
+    if (it == end || *it == '}') return it;
+    if ('0' <= *it && *it <= '9') {
+      // We ignore it for now, but keep it for compatibility with
+      // existing configs where the format for pow_format'ed numbers was
+      // 'string' and specifications such as {:>9} were valid.
+      // The rationale for ignoring it is that the only reason to specify
+      // an alignment and a with is to get a fixed width bar, and ">" is
+      // sufficient in this implementation.
 #if FMT_VERSION < 80000
-            width = parse_nonnegative_int(it, end, ctx);
+      width = parse_nonnegative_int(it, end, ctx);
 #else
-            width = detail::parse_nonnegative_int(it, end, -1);
+      width = detail::parse_nonnegative_int(it, end, -1);
 #endif
-          }
-          return it;
-        }
+    }
+    return it;
+  }
 
-      template<class FormatContext>
-        auto format(const pow_format& s, FormatContext &ctx) -> decltype (ctx.out()) {
-          const char* units[] = { "", "k",  "M",  "G",  "T",  "P",  nullptr};
+  template <class FormatContext>
+  auto format(const pow_format& s, FormatContext& ctx) -> decltype(ctx.out()) {
+    const char* units[] = {"", "k", "M", "G", "T", "P", nullptr};
 
-          auto base = s.binary_ ? 1024ull : 1000ll;
-          auto fraction = (double) s.val_;
+    auto base = s.binary_ ? 1024ull : 1000ll;
+    auto fraction = (double)s.val_;
 
-          int pow;
-          for (pow = 0; units[pow+1] != nullptr && fraction / base >= 1; ++pow) {
-            fraction /= base;
-          }
+    int pow;
+    for (pow = 0; units[pow + 1] != nullptr && fraction / base >= 1; ++pow) {
+      fraction /= base;
+    }
 
-          auto max_width = 4                  // coeff in {:.3g} format
-                         + 1                  // prefix from units array
-                         + s.binary_          // for the 'i' in GiB.
-                         + s.unit_.length();
+    auto number_width = 5              // coeff in {:.1f} format
+                        + s.binary_;   // potential 4th digit before the decimal point
+    auto max_width = number_width + 1  // prefix from units array
+                     + s.binary_       // for the 'i' in GiB.
+                     + s.unit_.length();
 
-          const char * format;
-          std::string string;
-          switch (spec) {
-            case '>':
-              return format_to(ctx.out(), "{:>{}}", fmt::format("{}", s), max_width);
-            case '<':
-              return format_to(ctx.out(), "{:<{}}", fmt::format("{}", s), max_width);
-            case '=':
-              format = "{coefficient:<4.3g}{padding}{prefix}{unit}";
-              break;
-            case 0:
-            default:
-              format = "{coefficient:.3g}{prefix}{unit}";
-              break;
-          }
-          return format_to(ctx.out(), format
-              , fmt::arg("coefficient", fraction)
-              , fmt::arg("prefix", std::string() + units[pow] + ((s.binary_ && pow) ? "i" : ""))
-              , fmt::arg("unit", s.unit_)
-              , fmt::arg("padding", pow ? "" : s.binary_ ? "  " : " ")
-            );
-        }
-    };
-
-
-    // Glib ustirng support
-    template <>
-    struct formatter<Glib::ustring> : formatter<std::string> {
-      template <typename FormatContext>
-      auto format(const Glib::ustring& value, FormatContext& ctx) {
-        return formatter<std::string>::format(value, ctx);
-      }
-    };
-}
+    const char* format;
+    std::string string;
+    switch (spec) {
+      case '>':
+        return format_to(ctx.out(), "{:>{}}", fmt::format("{}", s), max_width);
+      case '<':
+        return format_to(ctx.out(), "{:<{}}", fmt::format("{}", s), max_width);
+      case '=':
+        format = "{coefficient:<{number_width}.1f}{padding}{prefix}{unit}";
+        break;
+      case 0:
+      default:
+        format = "{coefficient:.1f}{prefix}{unit}";
+        break;
+    }
+    return format_to(
+        ctx.out(), format, fmt::arg("coefficient", fraction),
+        fmt::arg("number_width", number_width),
+        fmt::arg("prefix", std::string() + units[pow] + ((s.binary_ && pow) ? "i" : "")),
+        fmt::arg("unit", s.unit_),
+        fmt::arg("padding", pow         ? ""
+                            : s.binary_ ? "  "
+                                        : " "));
+  }
+};
 
+// Glib ustirng support
+template <>
+struct formatter<Glib::ustring> : formatter<std::string> {
+  template <typename FormatContext>
+  auto format(const Glib::ustring& value, FormatContext& ctx) {
+    return formatter<std::string>::format(value, ctx);
+  }
+};
+}  // namespace fmt

include/util/json.hpp

@@ -1,7 +1,15 @@
 #pragma once
 
+#include <fmt/ostream.h>
 #include <json/json.h>
 
+#if (FMT_VERSION >= 90000)
+
+template <>
+struct fmt::formatter<Json::Value> : ostream_formatter {};
+
+#endif
+
 namespace waybar::util {
 
 struct JsonParser {
@@ -13,7 +21,7 @@ struct JsonParser {
       return root;
     }
     std::unique_ptr<Json::CharReader> const reader(builder_.newCharReader());
-    std::string                             err;
+    std::string err;
     bool res = reader->parse(data.c_str(), data.c_str() + data.size(), &root, &err);
     if (!res) throw std::runtime_error(err);
     return root;

include/util/rewrite_title.hpp

@@ -0,0 +1,8 @@
+#pragma once
+#include <json/json.h>
+
+#include <string>
+
+namespace waybar::util {
+std::string rewriteTitle(const std::string&, const Json::Value&);
+}

include/util/rfkill.hpp

@@ -17,8 +17,8 @@ class Rfkill : public sigc::trackable {
 
  private:
   enum rfkill_type rfkill_type_;
-  bool             state_ = false;
-  int              fd_ = -1;
+  bool state_ = false;
+  int fd_ = -1;
 
   bool on_event(Glib::IOCondition cond);
 };

include/util/sanitize_str.hpp

@@ -0,0 +1,6 @@
+#pragma once
+#include <string>
+
+namespace waybar::util {
+std::string sanitize_string(std::string str);
+}  // namespace waybar::util

include/util/sleeper_thread.hpp

@@ -17,7 +17,8 @@ namespace waybar::util {
  */
 class CancellationGuard {
   int oldstate;
-public:
+
+ public:
   CancellationGuard() { pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate); }
   ~CancellationGuard() { pthread_setcancelstate(oldstate, &oldstate); }
 };
@@ -47,7 +48,7 @@ class SleeperThread {
   bool isRunning() const { return do_run_; }
 
   auto sleep_for(std::chrono::system_clock::duration dur) {
-    std::unique_lock  lk(mutex_);
+    std::unique_lock lk(mutex_);
     CancellationGuard cancel_lock;
     return condvar_.wait_for(lk, dur, [this] { return signal_ || !do_run_; });
   }
@@ -55,7 +56,7 @@ class SleeperThread {
   auto sleep_until(
       std::chrono::time_point<std::chrono::system_clock, std::chrono::system_clock::duration>
           time_point) {
-    std::unique_lock  lk(mutex_);
+    std::unique_lock lk(mutex_);
     CancellationGuard cancel_lock;
     return condvar_.wait_until(lk, time_point, [this] { return signal_ || !do_run_; });
   }
@@ -90,11 +91,11 @@ class SleeperThread {
   }
 
  private:
-  std::thread             thread_;
+  std::thread thread_;
   std::condition_variable condvar_;
-  std::mutex              mutex_;
-  bool                    do_run_ = true;
-  bool                    signal_ = false;
+  std::mutex mutex_;
+  bool do_run_ = true;
+  bool signal_ = false;
 };
 
 }  // namespace waybar::util

include/util/waybar_time.hpp

@@ -6,7 +6,7 @@
 namespace waybar {
 
 struct waybar_time {
-  std::locale         locale;
+  std::locale locale;
   date::zoned_seconds ztime;
 };
 

man/waybar-backlight.5.scd

@@ -37,8 +37,8 @@ The *backlight* module displays the current backlight level.
 	Positive value to rotate the text label.
 
 *states*: ++
-	typeof: array ++
-	A number of backlight states which get activated on certain brightness levels.
+	typeof: object ++
+	A number of backlight states which get activated on certain brightness levels. See *waybar-states(5)*.
 
 *on-click*: ++
 	typeof: string ++

man/waybar-battery.5.scd

@@ -33,13 +33,13 @@ The *battery* module displays the current capacity and state (eg. charging) of y
 	The interval in which the information gets polled.
 
 *states*: ++
-	typeof: array ++
+	typeof: object ++
 	A number of battery states which get activated on certain capacity levels. See *waybar-states(5)*.
 
 *format*: ++
 	typeof: string ++
 	default: {capacity}% ++
-	The format, how the time should be displayed.
+	The format, how information should be displayed.
 
 *format-time*: ++
 	typeof: string ++
@@ -114,9 +114,10 @@ The *battery* module displays the current capacity and state (eg. charging) of y
 
 The *battery* module allows you to define how time should be formatted via *format-time*.
 
-The two arguments are:
+The three arguments are:
 *{H}*: Hours
 *{M}*: Minutes
+*{m}*: Zero-padded minutes
 
 # CUSTOM FORMATS
 

man/waybar-bluetooth.5.scd

@@ -6,21 +6,47 @@ waybar - bluetooth module
 
 # DESCRIPTION
 
-The *bluetooth* module displays information about the status of the device's bluetooth device.
+The *bluetooth* module displays information about a bluetooth controller and its connections.
 
 # CONFIGURATION
 
 Addressed by *bluetooth*
 
+*controller*: ++
+	typeof: string ++
+	Use the controller with the defined alias. Otherwise a random controller is used. Recommended to define when there is more than 1 controller available to the system.
+
+*format-device-preference*: ++
+	typeof: array ++
+	A ranking of bluetooth devices, addressed by their alias. The order is from *first displayed* to *last displayed*. ++
+	If this config option is not defined or none of the devices in the list are connected, it will fall back to showing the last connected device.
+
 *format*: ++
 	typeof: string  ++
-	default: *{icon}* ++
+	default: * {status}* ++
 	The format, how information should be displayed. This format is used when other formats aren't specified.
 
+*format-disabled*: ++
+	typeof: string ++
+	This format is used when the displayed controller is disabled.
+
+*format-off*: ++
+	typeof: string ++
+	This format is used when the displayed controller is turned off.
+
+*format-on*: ++
+	typeof: string ++
+	This format is used when the displayed controller is turned on with no devices connected.
+
+*format-connected*: ++
+	typeof: string ++
+	This format is used when the displayed controller is connected to at least 1 device.
+
 *format-icons*: ++
 	typeof: array/object ++
-	Based on the device status, the corresponding icon gets selected. ++
-	The order is *low* to *high*. Or by the state if it is an object.
+	Based on the current battery percentage (see section *EXPERIMENTAL BATTERY PERCENTAGE FEATURE*), the corresponding icon gets selected. ++
+	The order is *low* to *high*. Will only show the current battery percentage icon in the *\*-connected-battery* config options. ++
+	Or by the state if it is an object. It will fall back to the enabled state if its derivatives are not defined (on, off, connected).
 
 *rotate*: ++
 	typeof: integer ++
@@ -71,26 +97,106 @@ Addressed by *bluetooth*
 	typeof: string ++
 	The format, how information should be displayed in the tooltip. This format is used when other formats aren't specified.
 
+*tooltip-format-disabled*: ++
+	typeof: string ++
+	This format is used when the displayed controller is disabled.
+
+*tooltip-format-off*: ++
+	typeof: string ++
+	This format is used when the displayed controller is turned off.
+
+*tooltip-format-on*: ++
+	typeof: string ++
+	This format is used when the displayed controller is turned on with no devices connected.
+
+*tooltip-format-connected*: ++
+	typeof: string ++
+	This format is used when the displayed controller is connected to at least 1 device.
+
+*tooltip-format-enumerate-connected*: ++
+	typeof: string ++
+	This format is used to define how each connected device should be displayed within the *device_enumerate* format replacement in the tooltip menu.
+
 # FORMAT REPLACEMENTS
 
 *{status}*: Status of the bluetooth device.
 
 *{icon}*: Icon, as defined in *format-icons*.
 
+*{num_connections}*: Number of connections the displayed controller has.
+
+*{controller_address}*: Address of the displayed controller.
+
+*{controller_address_type}*: Address type of the displayed controller.
+
+*{controller_alias}*: Alias of the displayed controller.
+
+*{device_address}*: Address of the displayed device.
+
+*{device_address_type}*: Address type of the displayed device.
+
+*{device_alias}*: Alias of the displayed device.
+
+*{device_enumerate}*: Show a list of all connected devices, each on a separate line. Define the format of each device with the *tooltip-format-enumerate-connected* ++
+and/or *tooltip-format-enumerate-connected-battery* config options. Can only be used in the tooltip related format options.
+
+# EXPERIMENTAL BATTERY PERCENTAGE FEATURE
+
+At the time of writing, the experimental features of BlueZ need to be turned on, for the battery percentage options listed below to work.
+
+## FORMAT REPLACEMENT
+
+*{device_battery_percentage}*: Battery percentage of the displayed device if available. Use only in the config options defined below.
+
+## CONFIGURATION
+
+*format-connected-battery*: ++
+	typeof: string ++
+	This format is used when the displayed device provides its battery percentage.
+
+*tooltip-format-connected-battery*: ++
+	typeof: string ++
+	This format is used when the displayed device provides its battery percentage.
+
+*tooltip-format-enumerate-connected-battery*: ++
+	typeof: string ++
+	This format is used to define how each connected device with a battery should be displayed within the *device_enumerate* format replacement option. ++
+	When this config option is not defined, it will fall back on the *tooltip-format-enumerate-connected* config option.
+
 # EXAMPLES
 
 ```
 "bluetooth": {
-	"format": "{icon}",
-	"format-alt": "bluetooth: {status}",
-	"format-icons": {
-		"enabled": "",
-		"disabled": ""
-	},
-	"tooltip-format": "{}"
+	// "controller": "controller1", // specify the alias of the controller if there are more than 1 on the system
+	"format": " {status}",
+	"format-disabled": "", // an empty format will hide the module
+	"format-connected": " {num_connections} connected",
+	"tooltip-format": "{controller_alias}\\t{controller_address}",
+	"tooltip-format-connected": "{controller_alias}\\t{controller_address}\\n\\n{device_enumerate}",
+	"tooltip-format-enumerate-connected": "{device_alias}\\t{device_address}"
+}
+```
+
+```
+"bluetooth": {
+	"format": " {status}",
+	"format-connected": " {device_alias}",
+	"format-connected-battery": " {device_alias} {device_battery_percentage}%",
+	// "format-device-preference": [ "device1", "device2" ], // preference list deciding the displayed device
+	"tooltip-format": "{controller_alias}\\t{controller_address}\\n\\n{num_connections} connected",
+	"tooltip-format-connected": "{controller_alias}\\t{controller_address}\\n\\n{num_connections} connected\\n\\n{device_enumerate}",
+	"tooltip-format-enumerate-connected": "{device_alias}\\t{device_address}",
+	"tooltip-format-enumerate-connected-battery": "{device_alias}\\t{device_address}\\t{device_battery_percentage}%"
 }
 ```
 
 # STYLE
 
 - *#bluetooth*
+- *#bluetooth.disabled*
+- *#bluetooth.off*
+- *#bluetooth.on*
+- *#bluetooth.connected*
+- *#bluetooth.discoverable*
+- *#bluetooth.discovering*
+- *#bluetooth.pairable*

man/waybar-cpu.5.scd

@@ -42,7 +42,7 @@ The *cpu* module displays the current cpu utilization.
 	Positive value to rotate the text label.
 
 *states*: ++
-	typeof: array ++
+	typeof: object ++
 	A number of cpu usage states which get activated on certain usage levels. See *waybar-states(5)*.
 
 *on-click*: ++

man/waybar-disk.5.scd

@@ -32,7 +32,7 @@ Addressed by *disk*
 	Positive value to rotate the text label.
 
 *states*: ++
-	typeof: array ++
+	typeof: object ++
 	A number of disk utilization states which get activated on certain percentage thresholds (percentage_used). See *waybar-states(5)*.
 
 *max-length*: ++

man/waybar-gamemode.5.scd

@@ -0,0 +1,95 @@
+waybar-gamemode(5)
+
+# NAME
+
+waybar - gamemode module
+
+# DESCRIPTION
+
+The *gamemode* module displays if any game or application is running with ++
+Feral Gamemode optimizations.
+
+# CONFIGURATION
+
+*format*: ++
+	typeof: string ++
+	default: {glyph} ++
+	The text format.
+
+*format-alt*: ++
+	typeof: string ++
+	default: {glyph} {count} ++
+	The text format when toggled.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
+
+*tooltip-format*: ++
+	typeof: string ++
+	default: Games running: {glyph} ++
+	The text format of the tooltip.
+
+*hide-not-running*: ++
+	typeof: bool ++
+	default: true ++
+	Defines if the module should be hidden if no games are running.
+
+*use-icon*: ++
+	typeof: bool ++
+	default: true ++
+	Defines if the module should display a GTK icon instead of the specified *glyph*
+
+*glyph*: ++
+	typeof: string ++
+	default:  ++
+	The string icon to display. Only visible if *use-icon* is set to false.
+
+*icon-name*: ++
+	typeof: string ++
+	default: input-gaming-symbolic ++
+	The GTK icon to display. Only visible if *use-icon* is set to true.
+
+*icon-size*: ++
+	typeof: unsigned integer ++
+	default: 20 ++
+	Defines the size of the icons.
+
+*icon-spacing*: ++
+	typeof: unsigned integer ++
+	default: 4 ++
+	Defines the spacing between the icon and the text.
+
+# FORMAT REPLACEMENTS
+
+*{glyph}*: The string icon glyph to use instead.
+
+*{count}*: The amount of games running with gamemode optimizations.
+
+# TOOLTIP FORMAT REPLACEMENTS
+
+*{count}*: The amount of games running with gamemode optimizations.
+
+# EXAMPLES
+
+```
+"gamemode": {
+	"format": "{glyph}",
+	"format-alt": "{glyph} {count}",
+	"glyph": "",
+	"hide-not-running": true,
+	"use-icon": true,
+	"icon-name": "input-gaming-symbolic",
+	"icon-spacing": 4,
+	"icon-size": 20,
+	"tooltip": true,
+	"tooltip-format": "Games running: {count}"
+}
+
+```
+
+# STYLE
+
+- *#gamemode*
+- *#gamemode.running*

man/waybar-hyprland-language.5.scd

@@ -0,0 +1,43 @@
+waybar-hyprland-language(5)
+
+# NAME
+
+waybar - hyprland language module
+
+# DESCRIPTION
+
+The *language* module displays the currently selected language.
+
+# CONFIGURATION
+
+Addressed by *hyprland/language*
+
+*format*: ++
+	typeof: string ++
+	default: {} ++
+	The format, how information should be displayed. On {} the currently selected language is displayed.
+
+*format-<lang>* ++
+    typeof: string++
+    Provide an alternative name to display per language where <lang> is the language of your choosing. Can be passed multiple times with multiple languages as shown by the example below.
+
+*keyboard-name*: ++
+    typeof: string ++
+    Specifies which keyboard to use from hyprctl devices output. Using the option that begins with "at-translated-set..." is recommended.
+
+
+
+# EXAMPLES
+
+```
+"hyprland/language": {
+    "format": "Lang: {}"
+    "format-en": "AMERICA, HELL YEAH!"
+    "format-tr": "As bayrakları"
+    "keyboard-name": "at-translated-set-2-keyboard"
+}
+```
+
+# STYLE
+
+- *#language*

man/waybar-hyprland-submap.5.scd

@@ -0,0 +1,82 @@
+waybar-hyprland-submap(5)
+
+# NAME
+
+waybar - hyprland submap module
+
+# DESCRIPTION
+
+The *submap* module displays the currently active submap similar to *sway/mode*.
+
+# CONFIGURATION
+
+Addressed by *hyprland/submap*
+
+*format*: ++
+	typeof: string ++
+	default: {} ++
+	The format, how information should be displayed. On {} the currently active submap is displayed.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in character the module should display.
+
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
+*on-click*: ++
+	typeof: string ++
+	Command to execute when clicked on the module.
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when you right clicked on the module.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when scrolling up on the module.
+
+*on-scroll-down*: ++
+	typeof: string ++
+	Command to execute when scrolling down on the module.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
+
+
+# EXAMPLES
+
+```
+"hyprland/submap": {
+    "format": "✌️ {}",
+    "max-length": 8,
+    "tooltip": false
+}
+```
+
+# STYLE
+
+- *#submap*

man/waybar-hyprland-window.5.scd

@@ -0,0 +1,50 @@
+waybar-hyprland-window(5)
+
+# NAME
+
+waybar - hyprland window module
+
+# DESCRIPTION
+
+The *window* module displays the title of the currently focused window in Hyprland.
+
+# CONFIGURATION
+
+Addressed by *hyprland/window*
+
+*format*: ++
+	typeof: string ++
+	default: {} ++
+	The format, how information should be displayed. On {} the current window title is displayed.
+
+*rewrite*: ++
+	typeof: object ++
+	Rules to rewrite window title. See *rewrite rules*.
+
+# REWRITE RULES
+
+*rewrite* is an object where keys are regular expressions and values are
+rewrite rules if the expression matches. Rules may contain references to
+captures of the expression.
+
+Regular expression and replacement follow ECMA-script rules.
+
+If no expression matches, the title is left unchanged.
+
+Invalid expressions (e.g., mismatched parentheses) are skipped.
+
+# EXAMPLES
+
+```
+"hyprland/window": {
+    "format": "{}",
+    "rewrite": {
+      "(.*) - Mozilla Firefox": "🌎 $1",
+      "(.*) - zsh": "> [$1]"
+    }
+}
+```
+
+# STYLE
+
+- *#window*

man/waybar-idle-inhibitor.5.scd

@@ -63,11 +63,28 @@ screensaving, also known as "presentation mode".
 	typeof: double ++
 	Threshold to be used when scrolling.
 
+*start-activated*: ++
+  typeof: bool ++
+  default: *false* ++
+  Whether the inhibit should be activated when starting waybar.
+
+*timeout*: ++
+	typeof: double ++
+	The number of minutes the inhibit should last.
+
 *tooltip*: ++
 	typeof: bool ++
 	default: true ++
 	Option to disable tooltip on hover.
 
+*tooltip-format-activated*: ++
+	typeof: string ++
+	This format is used when the inhibit is activated.
+
+*tooltip-format-deactivated*: ++
+	typeof: string ++
+	This format is used when the inhibit is deactivated.
+
 # FORMAT REPLACEMENTS
 
 *{status}*: status (*activated* or *deactivated*)
@@ -82,6 +99,7 @@ screensaving, also known as "presentation mode".
 	"format-icons": {
 	    "activated": "",
 	    "deactivated": ""
-	}
+	},
+	"timeout": 30.5
 }
 ```

man/waybar-image.5.scd

@@ -0,0 +1,72 @@
+waybar-custom(5)
+
+# NAME
+
+waybar - image module
+
+# DESCRIPTION
+
+The *image* module displays an image from a path.
+
+# CONFIGURATION
+
+Addressed by *custom/<name>*
+
+*path*: ++
+	typeof: string ++
+	The path to the image.
+
+*size*: ++
+	typeof: integer ++
+	The width/height to render the image.
+
+*interval*: ++
+	typeof: integer ++
+	The interval (in seconds) to re-render the image.
+	This is useful if the contents of *path* changes.
+	If no *interval* is defined, the image will only be rendered once.
+
+*signal*: ++
+	typeof: integer ++
+	The signal number used to update the module.
+	This can be used instead of *interval* if the file changes irregularly.
+	The number is valid between 1 and N, where *SIGRTMIN+N* = *SIGRTMAX*.
+
+*on-click*: ++
+	typeof: string ++
+	Command to execute when clicked on the module.
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when scrolling up on the module.
+
+*on-scroll-down*: ++
+	typeof: string ++
+	Command to execute when scrolling down on the module.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
+# EXAMPLES
+
+## Spotify:
+
+## mpd:
+
+```
+"image/album-art": {
+	"path": "/tmp/mpd_art",
+	"size": 32,
+	"interval": 5,
+	"on-click": "mpc toggle"
+}
+```

man/waybar-inhibitor.5.scd

@@ -6,7 +6,7 @@ waybar - inhibitor module
 
 # DESCRIPTION
 
-The *inhibitor* module allows to take an inhibitor lock that logind provides.
+The *inhibitor* module allows one to take an inhibitor lock that logind provides.
 See *systemd-inhibit*(1) for more information.
 
 # CONFIGURATION

man/waybar-jack.5.scd

@@ -0,0 +1,112 @@
+waybar-jack(5)
+
+# NAME
+
+waybar - JACK module
+
+# DESCRIPTION
+
+The *jack* module displays the current state of the JACK server.
+
+# CONFIGURATION
+
+Addressed by *jack*
+
+*format*: ++
+    typeof: string ++
+    default: *{load}%* ++
+    The format, how information should be displayed. This format is used when other formats aren't specified.
+
+*format-connected*: ++
+    typeof: string ++
+    This format is used when the module is connected to the JACK server.
+
+*format-disconnected*: ++
+    typeof: string ++
+    This format is used when the module is not connected to the JACK server.
+
+*format-xrun*: ++
+    typeof: string ++
+    This format is used for one polling interval, when the JACK server reports an xrun.
+
+*realtime*: ++
+    typeof: bool ++
+    default: *true* ++
+    Option to drop real-time privileges for the JACK client opened by Waybar.
+
+*tooltip*: ++
+    typeof: bool ++
+    default: *true* ++
+    Option to disable tooltip on hover.
+
+*tooltip-format*: ++
+    typeof: string ++
+    default: *{bufsize}/{samplerate} {latency}ms* ++
+    The format of information displayed in the tooltip.
+
+*interval*: ++
+    typeof: integer ++
+    default: 1 ++
+    The interval in which the information gets polled.
+
+*rotate*: ++
+    typeof: integer ++
+    Positive value to rotate the text label.
+
+*max-length*: ++
+    typeof: integer ++
+    The maximum length in character the module should display.
+
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
+*on-click*: ++
+    typeof: string ++
+    Command to execute when clicked on the module.
+
+*on-click-middle*: ++
+    typeof: string ++
+    Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+    typeof: string ++
+    Command to execute when you right clicked on the module.
+
+*on-update*: ++
+    typeof: string ++
+    Command to execute when the module is updated.
+
+# FORMAT REPLACEMENTS
+
+*{load}*: The current CPU load estimated by JACK.
+
+*{bufsize}*: The size of the JACK buffer.
+
+*{samplerate}*: The samplerate at which the JACK server is running.
+
+*{latency}*: The duration, in ms, of the current buffer size.
+
+*{xruns}*: The number of xruns reported by the JACK server since starting Waybar.
+
+# EXAMPLES
+
+```
+"jack": {
+    "format": "DSP {}%",
+    "format-xrun": "{xruns} xruns",
+    "format-disconnected": "DSP off",
+    "realtime": true
+}
+```
+
+# STYLE
+
+- *#jack*
+- *#jack.connected*
+- *#jack.disconnected*
+- *#jack.xrun*

man/waybar-keyboard-state.5.scd

@@ -13,6 +13,7 @@ You must be a member of the input group to use this module.
 # CONFIGURATION
 
 *interval*: ++
+	Deprecated, this module use event loop now, the interval has no effect.
 	typeof: integer ++
 	default: 1 ++
 	The interval, in seconds, to poll the keyboard state.
@@ -79,4 +80,9 @@ The following *format-icons* can be set.
 - *#keyboard-state*
 - *#keyboard-state label*
 - *#keyboard-state label.locked*
-
+- *#keyboard-state label.numlock*
+- *#keyboard-state label.numlock.locked*
+- *#keyboard-state label.capslock*
+- *#keyboard-state label.capslock.locked*
+- *#keyboard-state label.scrolllock*
+- *#keyboard-state label.scrolllock.locked*

man/waybar-memory.5.scd

@@ -32,7 +32,7 @@ Addressed by *memory*
 	Positive value to rotate the text label.
 
 *states*: ++
-	typeof: array ++
+	typeof: object ++
 	A number of memory utilization states which get activated on certain percentage thresholds. See *waybar-states(5)*.
 
 *max-length*: ++

man/waybar-mpris.5.scd

@@ -0,0 +1,103 @@
+waybar-mpris(5)
+
+# NAME
+
+waybar - MPRIS module
+
+# DESCRIPTION
+
+The *mpris* module displays currently playing media via libplayerctl.
+
+# CONFIGURATION
+
+*player*: ++
+	typeof: string ++
+	default: playerctld ++
+	Name of the MPRIS player to attach to. Using the default value always
+	follows the currenly active player.
+
+*ignored-players*: ++
+	typeof: []string ++
+	Ignore updates of the listed players, when using playerctld.
+
+*interval*: ++
+	typeof: integer ++
+	Refresh MPRIS information on a timer.
+
+*format*: ++
+	typeof: string ++
+	default: {player} ({status}) {dynamic} ++
+	The text format.
+
+*format-[status]*: ++
+	typeof: string ++
+	The status-specific text format.
+
+*on-click*: ++
+	typeof: string ++
+	default: play-pause ++
+	Overwrite default action toggles.
+
+*on-middle-click*: ++
+	typeof: string ++
+	default: previous track ++
+	Overwrite default action toggles.
+
+*on-right-click*: ++
+	typeof: string ++
+	default: next track ++
+	Overwrite default action toggles.
+
+*player-icons*: ++
+	typeof: map[string]string
+	Allows setting _{player-icon}_ based on player-name property.
+
+*status-icons*: ++
+	typeof: map[string]string
+	Allows setting _{status-icon}_ based on player status (playing, paused,
+	stopped).
+
+
+# FORMAT REPLACEMENTS
+
+*{player}*: The name of the current media player
+
+*{status}*: The current status (playing, paused, stopped)
+
+*{artist}*: The artist of the current track
+
+*{album}*: The album title of the current track
+
+*{title}*: The title of the current track
+
+*{length}*: Length of the track, formatted as HH:MM:SS
+
+*{dynamic}*: Use _{artist}_, _{album}_, _{title}_ and _{length}_, automatically omit++
+           empty values
+
+*{player-icon}*: Chooses an icon from _player-icons_ based on _{player}_
+
+*{status-icon}*: Chooses an icon from _status-icons_ based on _{status}_
+
+# EXAMPLES
+
+```
+"mpris": {
+	"format": "DEFAULT: {player_icon} {dynamic}",
+	"format-paused": "DEFAULT: {status_icon} <i>{dynamic}</i>",
+	"player-icons": {
+		"default": "▶",
+		"mpv": "🎵"
+	},
+	"status-icons": {
+		"paused": "⏸"
+	},
+	// "ignored-players": ["firefox"]
+}
+```
+
+# STYLE
+
+- *#mpris*
+- *#mpris.${status}*
+- *#mpris.${player}*

man/waybar-network.5.scd

@@ -149,10 +149,20 @@ Addressed by *network*
 
 *{bandwidthDownBits}*: Instant down speed in bits/seconds.
 
+*{bandwidthTotalBits}*: Instant total speed in bits/seconds.
+
 *{bandwidthUpOctets}*: Instant up speed in octets/seconds.
 
 *{bandwidthDownOctets}*: Instant down speed in octets/seconds.
 
+*{bandwidthTotalOctets}*: Instant total speed in octets/seconds.
+
+*{bandwidthUpBytes}*: Instant up speed in bytes/seconds.
+
+*{bandwidthDownBytes}*: Instant down speed in bytes/seconds.
+
+*{bandwidthTotalBytes}*: Instant total speed in bytes/seconds.
+
 *{icon}*: Icon, as defined in *format-icons*.
 
 # EXAMPLES

man/waybar-pulseaudio.5.scd

@@ -43,8 +43,8 @@ Additionally you can control the volume by scrolling *up* or *down* while the cu
 	Positive value to rotate the text label.
 
 *states*: ++
-	typeof: array ++
-	A number of volume states which get activated on certain volume levels. See *waybar-states(5)*
+	typeof: object ++
+	A number of volume states which get activated on certain volume levels. See *waybar-states(5)*.
 
 *max-length*: ++
 	typeof: integer ++
@@ -96,6 +96,15 @@ Additionally you can control the volume by scrolling *up* or *down* while the cu
 	default: true ++
 	Option to disable tooltip on hover.
 
+*max-volume*: ++
+	typeof: integer ++
+	default: 100 ++
+	The maximum volume that can be set, in percentage.
+
+*ignored-sinks*: ++
+	typeof: array ++
+	Sinks in this list will not be shown as the active sink by Waybar. Entries should be the sink's description field.
+
 # FORMAT REPLACEMENTS
 
 *{desc}*: Pulseaudio port's description, for bluetooth it'll be the device name.

man/waybar-river-mode.5.scd

@@ -0,0 +1,75 @@
+waybar-river-mode(5)
+
+# NAME
+
+waybar - river mode module
+
+# DESCRIPTION
+
+The *mode* module displays the current mapping mode of river.
+
+# CONFIGURATION
+
+Addressed by *river/mode*
+
+*format*: ++
+    typeof: string  ++
+    default: {} ++
+    The format, how information should be displayed. On {} data gets inserted.
+
+*rotate*: ++
+    typeof: integer ++
+    Positive value to rotate the text label.
+
+*max-length*: ++
+    typeof: integer ++
+    The maximum length in character the module should display.
+
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
+*on-click*: ++
+    typeof: string ++
+    Command to execute when clicked on the module.
+
+*on-click-middle*: ++
+    typeof: string ++
+    Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+    typeof: string ++
+    Command to execute when you right clicked on the module.
+
+*on-update*: ++
+    typeof: string ++
+    Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+    typeof: string ++
+    Command to execute when scrolling up on the module.
+
+*on-scroll-down*: ++
+    typeof: string ++
+    Command to execute when scrolling down on the module.
+
+*smooth-scrolling-threshold*: ++
+    typeof: double ++
+    Threshold to be used when scrolling.
+
+# EXAMPLES
+
+```
+"river/mode": {
+    "format": " {}"
+}
+```
+
+# STYLE
+
+- *#mode*
+- *#mode.<mode>*

man/waybar-river-window.5.scd

@@ -0,0 +1,59 @@
+waybar-river-window(5)
+
+# NAME
+
+waybar - river window module
+
+# DESCRIPTION
+
+The *window* module displays the title of the currently focused window in river
+
+# CONFIGURATION
+
+Addressed by *river/window*
+
+*format*: ++
+	typeof: string ++
+	default: {} ++
+	The format, how information should be displayed. On {} data gets inserted.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in character the module should display.
+
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
+*on-click*: ++
+	typeof: string ++
+	Command to execute when clicked on the module.
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when you right clicked on the module.
+
+# EXAMPLES
+
+```
+"river/window": {
+    "format": "{}"
+}
+```
+
+# STYLE
+
+- *#window*
+- *#window.focused* Applied when the output this module's bar belongs to is focused.