chore: v0.9.16

The first crash occurs when trying to parse the
ID of a workspace as an uint, since named
workspaces has negative IDs. This is fixed by
using ints for workspace IDs instead of uints.

The second crash occurs when converting a
workspace name that isn't a number to an integer.
This is fixed by wrapping std::stoi in a try
block and only sorting by number, when both names
can successfully be converted to integers.

.clang-format

@@ -1,6 +1,5 @@
 ---
 BasedOnStyle: Google
-AlignConsecutiveDeclarations: true
+AlignConsecutiveDeclarations: false
-BinPackArguments: 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:

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

README.md

@@ -7,9 +7,12 @@
 
 #### 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
@@ -70,6 +73,7 @@ libmpdclient [MPD module]
 libsndio [sndio module]
 libevdev [KeyboardState module]
 xkbregistry
+upower [UPower battery module]
 ```
 
 **Build dependencies**
@@ -103,6 +107,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_;
+  Gtk::Label label_;
-  std::string                format_;
+  std::string format_;
   const std::chrono::seconds interval_;
-  bool                       alt_ = false;
+  bool alt_ = false;
-  std::string                default_format_;
+  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_y_;
-  gdouble          distance_scrolled_x_;
+  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 auto update() -> void = 0;
-  virtual          operator Gtk::Widget &() = 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 name;
-  std::string                identifier;
+  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 exclusive;
-  bool      passthrough;
+  bool passthrough;
-  bool      visible;
+  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;
+  Json::Value config;
-  struct wl_surface    *surface;
+  struct wl_surface *surface;
-  bool                  visible = true;
+  bool visible = true;
-  bool                  vertical = false;
+  bool vertical = false;
-  Gtk::Window           window;
+  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_;
+  std::unique_ptr<BarSurface> surface_impl_;
-  Gtk::Box                                      left_;
+  Gtk::Box left_;
-  Gtk::Box                                      center_;
+  Gtk::Box center_;
-  Gtk::Box                                      right_;
+  Gtk::Box right_;
-  Gtk::Box                                      box_;
+  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[]);
+  int main(int argc, char *argv[]);
-  void           reset();
+  void reset();
 
-  Glib::RefPtr<Gtk::Application>      gtk_app;
+  Glib::RefPtr<Gtk::Application> gtk_app;
-  Glib::RefPtr<Gdk::Display>          gdk_display;
+  Glib::RefPtr<Gdk::Display> gdk_display;
-  struct wl_display *                 wl_display = nullptr;
+  struct wl_display *wl_display = nullptr;
-  struct wl_registry *                registry = nullptr;
+  struct wl_registry *registry = nullptr;
-  struct zwlr_layer_shell_v1 *        layer_shell = nullptr;
+  struct zwlr_layer_shell_v1 *layer_shell = nullptr;
-  struct zxdg_output_manager_v1 *     xdg_output_manager = 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;
+  std::vector<std::unique_ptr<Bar>> bars;
-  Config                              config;
+  Config config;
-  std::string                         bar_id;
+  std::string bar_id;
 
  private:
   Client() = default;
-  const std::string        getStyle(const std::string &style);
+  const std::string getStyle(const std::string &style);
-  void                     bindInterfaces();
+  void bindInterfaces();
-  void                     handleOutput(struct waybar_output &output);
+  void handleOutput(struct waybar_output &output);
-  auto                     setupCss(const std::string &css_file) -> void;
+  auto setupCss(const std::string &css_file) -> void;
-  struct waybar_output &   getOutput(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 handleMonitorAdded(Glib::RefPtr<Gdk::Monitor> monitor);
-  void        handleMonitorRemoved(Glib::RefPtr<Gdk::Monitor> monitor);
+  void handleMonitorRemoved(Glib::RefPtr<Gdk::Monitor> monitor);
-  void        handleDeferredMonitorRemoval(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,27 @@
 #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/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)
@@ -42,6 +50,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 +66,19 @@
 #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/temperature.hpp"
-#if defined(__linux__)
+#include "modules/user.hpp"
-#  ifdef WANT_RFKILL
-#    include "modules/bluetooth.hpp"
-#  endif
-#endif
 
 namespace waybar {
 
@@ -71,7 +88,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);
+    BacklightDev(std::string name, int actual, int max, bool powered);
-    std::string_view   name() const;
+    std::string_view name() const;
-    int                get_actual() const;
+    int get_actual() const;
-    void               set_actual(int actual);
+    void set_actual(int actual);
-    int                get_max() const;
+    int get_max() const;
-    void               set_max(int max);
+    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 actual_ = 1;
-    int         max_ = 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 refreshBatteries();
-  void                                                 worker();
+  void worker();
-  const std::string                                    getAdapterStatus(uint8_t capacity) const;
+  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;
+  int global_watch;
-  std::map<fs::path,int> batteries_;
+  std::map<fs::path, int> batteries_;
-  fs::path              adapter_;
+  fs::path adapter_;
-  int                   battery_watch_fd_;
+  int battery_watch_fd_;
-  int                   global_watch_fd_;
+  int global_watch_fd_;
-  std::mutex            battery_list_mutex_;
+  std::mutex battery_list_mutex_;
-  std::string           old_status_;
+  std::string old_status_;
+  bool warnFirstTime_{true};
 
-  util::SleeperThread   thread_;
+  util::SleeperThread thread_;
-  util::SleeperThread   thread_battery_update_;
+  util::SleeperThread thread_battery_update_;
-  util::SleeperThread   thread_timer_;
+  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,8 +25,9 @@ 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;
+  date::year_month_day calendar_cached_ymd_{date::January / 1 / 0};
-  std::string cached_calendar_text_;
+  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_;
 
@@ -36,8 +38,7 @@ class Clock : public ALabel {
   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::tuple<float, float, float> getCpuFrequency();
-  std::vector<std::tuple<size_t, size_t>>        parseCpuinfo();
+  std::vector<std::tuple<size_t, size_t>> parseCpuinfo();
-  std::vector<float>                             parseCpuFrequencies();
+  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_;
+  const std::string name_;
-  std::string              text_;
+  std::string text_;
-  std::string              alt_;
+  std::string id_;
-  std::string              tooltip_;
+  std::string alt_;
+  std::string tooltip_;
   std::vector<std::string> class_;
-  int                      percentage_;
+  int percentage_;
-  FILE*                    fp_;
+  FILE* fp_;
-  int                      pid_;
+  int pid_;
-  util::command::res       output_;
+  util::command::res output_;
-  util::JsonParser         parser_;
+  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/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/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_;
+  auto tryAddDevice(const std::string&) -> void;
-  Gtk::Label  numlock_label_;
+
-  Gtk::Label  capslock_label_;
+  Gtk::Box box_;
-  Gtk::Label  scrolllock_label_;
+  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_;
+  struct libinput* libinput_;
-  libevdev*   dev_;
+  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 char* server_;
-  const unsigned    port_;
+  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_;
+  mpd_state state_;
-  detail::unique_song   song_;
+  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_connected() const;
-  bool                             is_playing() const;
+  bool is_playing() const;
-  bool                             is_paused() const;
+  bool is_paused() const;
-  bool                             is_stopped() const;
+  bool is_stopped() const;
-  constexpr std::size_t            interval() const;
+  constexpr std::size_t interval() const;
-  void                             tryConnect() const;
+  void tryConnect() const;
-  void                             checkErrors(mpd_connection*) const;
+  void checkErrors(mpd_connection*) const;
-  void                             do_update();
+  void do_update();
-  void                             queryMPD() const;
+  void queryMPD() const;
-  void                             fetchState() const;
+  void fetchState() const;
-  constexpr mpd_state              state() const;
+  constexpr mpd_state state() const;
-  void                             emit() 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 void Context::tryConnect() const { mpd_module_->tryConnect(); }
-inline unique_connection&    Context::connection() { return mpd_module_->connection_; }
+inline unique_connection& Context::connection() { return mpd_module_->connection_; }
-constexpr inline mpd_state   Context::state() const { return mpd_module_->state_; }
+constexpr inline mpd_state Context::state() const { return mpd_module_->state_; }
 
-inline void Context::do_update() {
+inline void Context::do_update() { mpd_module_->setLabel(); }
-  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/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 worker();
-  void              createInfoSocket();
+  void createInfoSocket();
-  void              createEventSocket();
+  void createEventSocket();
-  void              parseEssid(struct nlattr**);
+  void parseEssid(struct nlattr**);
-  void              parseSignal(struct nlattr**);
+  void parseSignal(struct nlattr**);
-  void              parseFreq(struct nlattr**);
+  void parseFreq(struct nlattr**);
-  bool              associatedOrJoined(struct nlattr**);
+  bool associatedOrJoined(struct nlattr**);
-  bool              checkInterface(std::string name);
+  bool checkInterface(std::string name);
-  auto              getInfo() -> void;
+  auto getInfo() -> void;
   const std::string getNetworkState() const;
-  void              clearIface();
+  void clearIface();
-  bool              wildcardMatch(const std::string& pattern, const std::string& text) const;
+  bool wildcardMatch(const std::string& pattern, const std::string& text) const;
   std::optional<std::pair<unsigned long long, unsigned long long>> readBandwidthUsage();
 
-  int                ifid_;
+  int ifid_;
-  sa_family_t        family_;
+  sa_family_t family_;
   struct sockaddr_nl nladdr_ = {0};
-  struct nl_sock*    sock_ = nullptr;
+  struct nl_sock* sock_ = nullptr;
-  struct nl_sock*    ev_sock_ = nullptr;
+  struct nl_sock* ev_sock_ = nullptr;
-  int                efd_;
+  int efd_;
-  int                ev_fd_;
+  int ev_fd_;
-  int                nl80211_id_;
+  int nl80211_id_;
-  std::mutex         mutex_;
+  std::mutex mutex_;
 
-  bool               want_route_dump_;
+  bool want_route_dump_;
-  bool               want_link_dump_;
+  bool want_link_dump_;
-  bool               want_addr_dump_;
+  bool want_addr_dump_;
-  bool               dump_in_progress_;
+  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_;
+  int cidr_;
-  int32_t     signal_strength_dbm_;
+  int32_t signal_strength_dbm_;
-  uint8_t     signal_strength_;
+  uint8_t signal_strength_;
   std::string signal_strength_app_;
-  float       frequency_;
+  float frequency_;
-  uint32_t    route_priority;
+  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_mainloop_api* mainloop_api_;
-  pa_context*           context_;
+  pa_context* context_;
   // SINK
-  uint32_t    sink_idx_{0};
+  uint32_t sink_idx_{0};
-  uint16_t    volume_;
+  uint16_t volume_;
-  pa_cvolume  pa_volume_;
+  pa_cvolume pa_volume_;
-  bool        muted_;
+  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};
+  uint32_t source_idx_{0};
-  uint16_t    source_volume_;
+  uint16_t source_volume_;
-  bool        source_muted_;
+  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_;
+  const waybar::Bar &bar_;
-  Gtk::Box                 box_;
+  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 busAcquired(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring);
-  void        nameAppeared(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring,
+  void nameAppeared(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring,
-                           const Glib::ustring&);
+                    const Glib::ustring&);
-  void        nameVanished(const Glib::RefPtr<Gio::DBus::Connection>&, 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_;
+  std::vector<std::unique_ptr<Item>> items_;
-  const std::string                                 bus_name_;
+  const std::string bus_name_;
-  const std::string                                 object_path_;
+  const std::string object_path_;
-  std::size_t                                       bus_name_id_;
+  std::size_t bus_name_id_;
-  std::size_t                                       watcher_id_;
+  std::size_t watcher_id_;
-  GCancellable*                                     cancellable_ = nullptr;
+  GCancellable* cancellable_ = nullptr;
-  SnWatcher*                                        watcher_ = nullptr;
+  SnWatcher* watcher_ = nullptr;
-  const Json::Value&                                config_;
+  const Json::Value& config_;
-  const Bar&                                        bar_;
+  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 icon_size;
-  int           effective_icon_size;
+  int effective_icon_size;
-  Gtk::Image    image;
+  Gtk::Image image;
   Gtk::EventBox event_box;
-  std::string   category;
+  std::string category;
-  std::string   id;
+  std::string id;
 
-  std::string                  title;
+  std::string title;
-  std::string                  icon_name;
+  std::string icon_name;
-  Glib::RefPtr<Gdk::Pixbuf>    icon_pixmap;
+  Glib::RefPtr<Gdk::Pixbuf> icon_pixmap;
   Glib::RefPtr<Gtk::IconTheme> icon_theme;
-  std::string                  overlay_icon_name;
+  std::string overlay_icon_name;
-  std::string                  attention_icon_name;
+  std::string attention_icon_name;
-  std::string                  attention_movie_name;
+  std::string attention_movie_name;
-  std::string                  icon_theme_path;
+  std::string icon_theme_path;
-  std::string                  menu;
+  std::string menu;
-  ToolTip                      tooltip;
+  ToolTip tooltip;
-  DbusmenuGtkMenu*             dbus_menu = nullptr;
+  DbusmenuGtkMenu* dbus_menu = nullptr;
-  Gtk::Menu*                   gtk_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();
+  double getScaledIconSize();
-  static void               onMenuDestroyed(Item* self, GObject* old_menu_pointer);
+  static void onMenuDestroyed(Item* self, GObject* old_menu_pointer);
-  void                      makeMenu();
+  void makeMenu();
-  bool                      handleClick(GdkEventButton* const& /*ev*/);
+  bool handleClick(GdkEventButton* const& /*ev*/);
-  bool                      handleScroll(GdkEventScroll* const&);
+  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_;
+  Gtk::Box box_;
-  SNI::Watcher::singleton   watcher_;
+  SNI::Watcher::singleton watcher_;
-  SNI::Host                 host_;
+  SNI::Host host_;
 };
 
 }  // namespace waybar::modules::SNI

include/modules/sni/watcher.hpp

@@ -30,26 +30,26 @@ class Watcher {
 
   typedef struct {
     GfWatchType type;
-    Watcher *   watcher;
+    Watcher *watcher;
-    gchar *     service;
+    gchar *service;
-    gchar *     bus_name;
+    gchar *bus_name;
-    gchar *     object_path;
+    gchar *object_path;
-    guint       watch_id;
+    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 nameVanished(GDBusConnection *connection, const char *name, gpointer data);
-  static void     gfWatchFree(gpointer data);
+  static void gfWatchFree(gpointer data);
 
   void updateRegisteredItems(SnWatcher *obj);
 
-  uint32_t   bus_name_id_;
+  uint32_t bus_name_id_;
-  GSList *   hosts_ = nullptr;
+  GSList *hosts_ = nullptr;
-  GSList *   items_ = 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 size;
-    uint32_t    type;
+    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;
+  const std::string getSocketPath() const;
-  int                 open(const std::string &) 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_;
-  int                 fd_event_;
+  int fd_event_;
-  std::mutex          mutex_;
+  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_WORKSPACE = ((1U << 31) | 0),
-  IPC_EVENT_OUTPUT = ((1 << 31) | 1),
+  IPC_EVENT_OUTPUT = ((1U << 31) | 1),
-  IPC_EVENT_MODE = ((1 << 31) | 2),
+  IPC_EVENT_MODE = ((1U << 31) | 2),
-  IPC_EVENT_WINDOW = ((1 << 31) | 3),
+  IPC_EVENT_WINDOW = ((1U << 31) | 3),
-  IPC_EVENT_BARCONFIG_UPDATE = ((1 << 31) | 4),
+  IPC_EVENT_BARCONFIG_UPDATE = ((1U << 31) | 4),
-  IPC_EVENT_BINDING = ((1 << 31) | 5),
+  IPC_EVENT_BINDING = ((1U << 31) | 5),
-  IPC_EVENT_SHUTDOWN = ((1 << 31) | 6),
+  IPC_EVENT_SHUTDOWN = ((1U << 31) | 6),
-  IPC_EVENT_TICK = ((1 << 31) | 7),
+  IPC_EVENT_TICK = ((1U << 31) | 7),
 
-	// sway-specific event types
+  // sway-specific event types
-	IPC_EVENT_BAR_STATE_UPDATE = ((1<<31) | 20),
+  IPC_EVENT_BAR_STATE_UPDATE = ((1U << 31) | 20),
-	IPC_EVENT_INPUT = ((1<<31) | 21),
+  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 {
+  enum class DispayedShortFlag { None = 0, ShortName = 1, ShortDescription = 1 << 1 };
-	  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();
-	   ~XKBContext();
+    ~XKBContext();
-	   auto next_layout() -> Layout*;
+    auto next_layout() -> Layout*;
+
    private:
-	rxkb_context* context_ = nullptr;
+    rxkb_context* context_ = nullptr;
-	rxkb_layout* xkb_layout_ = nullptr;
+    rxkb_layout* xkb_layout_ = nullptr;
-	Layout* layout_ = nullptr;
+    Layout* layout_ = nullptr;
-	std::map<std::string, rxkb_layout*> base_layouts_by_name_;
+    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_;
+  util::JsonParser parser_;
-  std::mutex               mutex_;
+  std::mutex mutex_;
-  Ipc                      ipc_;
+  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_;
+  std::mutex mutex_;
-  Ipc              ipc_;
+  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 onEvent(const struct Ipc::ipc_response&);
-  void                                                   onCmd(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::tuple<std::size_t, int, std::string, std::string, std::string, std::string> getFocusedNode(
-                                                                        std::string&       output);
+      const Json::Value& nodes, std::string& output);
-  void                                                   getTree();
+  void getTree();
-  std::string                                            rewriteTitle(const std::string& title);
+  void updateAppIconName();
-  void                                                   updateAppIcon();
+  void updateAppIcon();
 
-  const Bar&       bar_;
+  const Bar& bar_;
-  std::string      window_;
+  std::string window_;
-  int              windowId_;
+  int windowId_;
-  std::string      app_id_;
+  std::string app_id_;
-  std::string      old_app_id_;
+  std::string app_class_;
-  std::size_t      app_nb_;
+  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_;
+  std::mutex mutex_;
-  Ipc              ipc_;
+  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 onCmd(const struct Ipc::ipc_response&);
-  void              onEvent(const struct Ipc::ipc_response&);
+  void onEvent(const struct Ipc::ipc_response&);
-  bool              filterButtons();
+  bool filterButtons();
-  Gtk::Button&      addButton(const Json::Value&);
+  Gtk::Button& addButton(const Json::Value&);
-  void              onButtonReady(const Json::Value&, Gtk::Button&);
+  void onButtonReady(const Json::Value&, Gtk::Button&);
-  std::string       getIcon(const std::string&, const Json::Value&);
+  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;
+  uint16_t getWorkspaceIndex(const std::string& name) const;
-  std::string       trimWorkspaceName(std::string);
+  std::string trimWorkspaceName(std::string);
-  bool              handleScroll(GdkEventScroll*);
+  bool handleScroll(GdkEventScroll*);
 
-  const Bar&                                   bar_;
+  const Bar& bar_;
-  std::vector<Json::Value>                     workspaces_;
+  std::vector<Json::Value> workspaces_;
-  std::vector<std::string>                     workspaces_order_;
+  std::vector<std::string> workspaces_order_;
-  Gtk::Box                                     box_;
+  Gtk::Box box_;
-  util::JsonParser                             parser_;
+  util::JsonParser parser_;
   std::unordered_map<std::string, Gtk::Button> buttons_;
-  std::mutex                                   mutex_;
+  std::mutex mutex_;
-  Ipc                                          ipc_;
+  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();
+  float getTemperature();
-  bool                isCritical(uint16_t);
+  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
+class Task {
-{
+ public:
-   public:
+  Task(const waybar::Bar &, const Json::Value &, Taskbar *,
-    Task(const waybar::Bar&, const Json::Value&, Taskbar*,
+       struct zwlr_foreign_toplevel_handle_v1 *, struct wl_seat *);
-         struct zwlr_foreign_toplevel_handle_v1 *, struct wl_seat*);
+  ~Task();
-    ~Task();
 
-   public:
+ public:
-    enum State {
+  enum State {
-        MAXIMIZED = (1 << 0),
+    MAXIMIZED = (1 << 0),
-        MINIMIZED = (1 << 1),
+    MINIMIZED = (1 << 1),
-        ACTIVE = (1 << 2),
+    ACTIVE = (1 << 2),
-        FULLSCREEN = (1 << 3),
+    FULLSCREEN = (1 << 3),
-        INVALID = (1 << 4)
+    INVALID = (1 << 4)
-    };
+  };
 
-   private:
+ private:
-    static uint32_t global_id;
+  static uint32_t global_id;
 
-   private:
+ private:
-    const waybar::Bar &bar_;
+  const waybar::Bar &bar_;
-    const Json::Value &config_;
+  const Json::Value &config_;
-    Taskbar *tbar_;
+  Taskbar *tbar_;
-    struct zwlr_foreign_toplevel_handle_v1 *handle_;
+  struct zwlr_foreign_toplevel_handle_v1 *handle_;
-    struct wl_seat *seat_;
+  struct wl_seat *seat_;
 
-    uint32_t id_;
+  uint32_t id_;
 
-    Gtk::Button button_;
+  Gtk::Button button_;
-    Gtk::Box content_;
+  Gtk::Box content_;
-    Gtk::Image icon_;
+  Gtk::Image icon_;
-    Gtk::Label text_before_;
+  Gtk::Label text_before_;
-    Gtk::Label text_after_;
+  Gtk::Label text_after_;
-    Glib::RefPtr<Gio::DesktopAppInfo> app_info_;
+  Glib::RefPtr<Gio::DesktopAppInfo> app_info_;
-    bool button_visible_ = false;
+  bool button_visible_ = false;
-    bool ignored_ = false;
+  bool ignored_ = false;
 
-    bool with_icon_ = false;
+  bool with_icon_ = false;
-    bool with_name_ = false;
+  bool with_name_ = false;
-    std::string format_before_;
+  std::string format_before_;
-    std::string format_after_;
+  std::string format_after_;
 
-    std::string format_tooltip_;
+  std::string format_tooltip_;
 
-    std::string name_;
+  std::string name_;
-    std::string title_;
+  std::string title_;
-    std::string app_id_;
+  std::string app_id_;
-    uint32_t state_ = 0;
+  uint32_t state_ = 0;
 
-   private:
+  int32_t drag_start_x;
-    std::string repr() const;
+  int32_t drag_start_y;
-    std::string state_string(bool = false) const;
+  int32_t drag_start_button = -1;
-    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:
+ private:
-    /* Getter functions */
+  std::string repr() const;
-    uint32_t id() const { return id_; }
+  std::string state_string(bool = false) const;
-    std::string title() const { return title_; }
+  void set_app_info_from_app_id_list(const std::string &app_id_list);
-    std::string app_id() const { return app_id_; }
+  bool image_load_icon(Gtk::Image &image, const Glib::RefPtr<Gtk::IconTheme> &icon_theme,
-    uint32_t state() const { return state_; }
+                       Glib::RefPtr<Gio::DesktopAppInfo> app_info, int size);
-    bool maximized() const { return state_ & MAXIMIZED; }
+  void hide_if_ignored();
-    bool minimized() const { return state_ & MINIMIZED; }
-    bool active() const { return state_ & ACTIVE; }
-    bool fullscreen() const { return state_ & FULLSCREEN; }
 
-   public:
+ public:
-    /* Callbacks for the wlr protocol */
+  /* Getter functions */
-    void handle_title(const char *);
+  uint32_t id() const { return id_; }
-    void handle_app_id(const char *);
+  std::string title() const { return title_; }
-    void handle_output_enter(struct wl_output *);
+  std::string app_id() const { return app_id_; }
-    void handle_output_leave(struct wl_output *);
+  uint32_t state() const { return state_; }
-    void handle_state(struct wl_array *);
+  bool maximized() const { return state_ & MAXIMIZED; }
-    void handle_done();
+  bool minimized() const { return state_ & MINIMIZED; }
-    void handle_closed();
+  bool active() const { return state_ & ACTIVE; }
+  bool fullscreen() const { return state_ & FULLSCREEN; }
 
-    /* Callbacks for Gtk events */
+ public:
-    bool handle_clicked(GdkEventButton *);
+  /* 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:
+  /* Callbacks for Gtk events */
-    bool operator==(const Task&) const;
+  bool handle_clicked(GdkEventButton *);
-    bool operator!=(const Task&) const;
+  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:
+ public:
-    void update();
+  bool operator==(const Task &) const;
+  bool operator!=(const Task &) const;
 
-  public:
+ public:
-    /* Interaction with the tasks */
+  void update();
-    void maximize(bool);
+
-    void minimize(bool);
+ public:
-    void activate();
+  /* Interaction with the tasks */
-    void fullscreen(bool);
+  void maximize(bool);
-    void close();
+  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
+ private:
-{
+  const waybar::Bar &bar_;
-   public:
+  Gtk::Box box_;
-    Taskbar(const std::string&, const waybar::Bar&, const Json::Value&);
+  std::vector<TaskPtr> tasks_;
-    ~Taskbar();
-    void update();
 
-   private:
+  std::vector<Glib::RefPtr<Gtk::IconTheme>> icon_themes_;
-    const waybar::Bar &bar_;
+  std::unordered_set<std::string> ignore_list_;
-    Gtk::Box box_;
+  std::map<std::string, std::string> app_ids_replace_map_;
-    std::vector<TaskPtr> tasks_;
 
-    std::vector<Glib::RefPtr<Gtk::IconTheme>> icon_themes_;
+  struct zwlr_foreign_toplevel_manager_v1 *manager_;
-    std::unordered_set<std::string> ignore_list_;
+  struct wl_seat *seat_;
-    std::map<std::string, std::string> app_ids_replace_map_;
 
-    struct zwlr_foreign_toplevel_manager_v1 *manager_;
+ public:
-    struct wl_seat *seat_;
+  /* 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 the wlr protocol */
-    /* Callbacks for global registration */
+  void handle_toplevel_create(struct zwlr_foreign_toplevel_handle_v1 *);
-    void register_manager(struct wl_registry*, uint32_t name, uint32_t version);
+  void handle_finished();
-    void register_seat(struct wl_registry*, uint32_t name, uint32_t version);
 
-    /* Callbacks for the wlr protocol */
+ public:
-    void handle_toplevel_create(struct zwlr_foreign_toplevel_handle_v1 *);
+  void add_button(Gtk::Button &);
-    void handle_finished();
+  void move_button(Gtk::Button &, int);
+  void remove_button(Gtk::Button &);
+  void remove_task(uint32_t);
 
-   public:
+  bool show_output(struct wl_output *) const;
-    void add_button(Gtk::Button &);
+  bool all_outputs() const;
-    void move_button(Gtk::Button &, int);
-    void remove_button(Gtk::Button &);
-    void remove_task(uint32_t);
 
-    bool show_output(struct wl_output *) const;
+  const std::vector<Glib::RefPtr<Gtk::IconTheme>> &icon_themes() const;
-    bool all_outputs() 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_;
+  uint32_t id_;
-  std::string                               name_;
+  std::string name_;
-  std::vector<uint32_t>                     coordinates_;
+  std::vector<uint32_t> coordinates_;
   static std::map<std::string, std::string> icons_map_;
-  std::string                               format_;
+  std::string format_;
-  bool                                      with_icon_ = false;
+  bool with_icon_ = false;
 
   Gtk::Button button_;
-  Gtk::Box    content_;
+  Gtk::Box content_;
-  Gtk::Label  label_;
+  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_;
+  const waybar::Bar &bar_;
-  Gtk::Box                                     box_;
+  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_registry_listener(void *data);
-  void add_workspace_listener(zext_workspace_handle_v1 *workspace_handle, 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);
+void add_workspace_group_listener(zext_workspace_group_handle_v1 *workspace_group_handle,
-  zext_workspace_manager_v1* workspace_manager_bind(wl_registry *registry, uint32_t name, uint32_t version, void *data);
+                                  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_;
+  Glib::Dispatcher dp_;
-  std::mutex              mutex_;
+  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:
+ public:
-    pow_format(long long val, std::string&& unit, bool binary = false):
+  pow_format(long long val, std::string&& unit, bool binary = false)
-      val_(val), unit_(unit), binary_(binary) { };
+      : val_(val), unit_(unit), binary_(binary){};
 
-    long long val_;
+  long long val_;
-    std::string unit_;
+  std::string unit_;
-    bool binary_;
+  bool binary_;
 };
 
-
 namespace fmt {
-  template <>
+template <>
-    struct formatter<pow_format> {
+struct formatter<pow_format> {
-      char spec = 0;
+  char spec = 0;
-      int width = 0;
+  int width = 0;
 
-      template <typename ParseContext>
+  template <typename ParseContext>
-        constexpr auto parse(ParseContext& ctx) -> decltype (ctx.begin()) {
+  constexpr auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-          auto it = ctx.begin(), end = ctx.end();
+    auto it = ctx.begin(), end = ctx.end();
-          if (it != end && *it == ':') ++it;
+    if (it != end && *it == ':') ++it;
-          if (it && (*it == '>' || *it == '<' || *it == '=')) {
+    if (it && (*it == '>' || *it == '<' || *it == '=')) {
-            spec = *it;
+      spec = *it;
-            ++it;
+      ++it;
-          }
+    }
-          if (it == end || *it == '}') return it;
+    if (it == end || *it == '}') return it;
-          if ('0' <= *it && *it <= '9') {
+    if ('0' <= *it && *it <= '9') {
-            // We ignore it for now, but keep it for compatibility with
+      // We ignore it for now, but keep it for compatibility with
-            // existing configs where the format for pow_format'ed numbers was
+      // existing configs where the format for pow_format'ed numbers was
-            // 'string' and specifications such as {:>9} were valid.
+      // 'string' and specifications such as {:>9} were valid.
-            // The rationale for ignoring it is that the only reason to specify
+      // 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
+      // an alignment and a with is to get a fixed width bar, and ">" is
-            // sufficient in this implementation.
+      // 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>
+  template <class FormatContext>
-        auto format(const pow_format& s, FormatContext &ctx) -> decltype (ctx.out()) {
+  auto format(const pow_format& s, FormatContext& ctx) -> decltype(ctx.out()) {
-          const char* units[] = { "", "k",  "M",  "G",  "T",  "P",  nullptr};
+    const char* units[] = {"", "k", "M", "G", "T", "P", nullptr};
 
-          auto base = s.binary_ ? 1024ull : 1000ll;
+    auto base = s.binary_ ? 1024ull : 1000ll;
-          auto fraction = (double) s.val_;
+    auto fraction = (double)s.val_;
 
-          int pow;
+    int pow;
-          for (pow = 0; units[pow+1] != nullptr && fraction / base >= 1; ++pow) {
+    for (pow = 0; units[pow + 1] != nullptr && fraction / base >= 1; ++pow) {
-            fraction /= base;
+      fraction /= base;
-          }
+    }
 
-          auto max_width = 4                  // coeff in {:.3g} format
+    auto number_width = 5              // coeff in {:.1f} format
-                         + 1                  // prefix from units array
+                        + s.binary_;   // potential 4th digit before the decimal point
-                         + s.binary_          // for the 'i' in GiB.
+    auto max_width = number_width + 1  // prefix from units array
-                         + s.unit_.length();
+                     + s.binary_       // for the 'i' in GiB.
+                     + s.unit_.length();
 
-          const char * format;
+    const char* format;
-          std::string string;
+    std::string string;
-          switch (spec) {
+    switch (spec) {
-            case '>':
+      case '>':
-              return format_to(ctx.out(), "{:>{}}", fmt::format("{}", s), max_width);
+        return format_to(ctx.out(), "{:>{}}", fmt::format("{}", s), max_width);
-            case '<':
+      case '<':
-              return format_to(ctx.out(), "{:<{}}", fmt::format("{}", s), max_width);
+        return format_to(ctx.out(), "{:<{}}", fmt::format("{}", s), max_width);
-            case '=':
+      case '=':
-              format = "{coefficient:<4.3g}{padding}{prefix}{unit}";
+        format = "{coefficient:<{number_width}.1f}{padding}{prefix}{unit}";
-              break;
+        break;
-            case 0:
+      case 0:
-            default:
+      default:
-              format = "{coefficient:.3g}{prefix}{unit}";
+        format = "{coefficient:.1f}{prefix}{unit}";
-              break;
+        break;
-          }
+    }
-          return format_to(ctx.out(), format
+    return format_to(
-              , fmt::arg("coefficient", fraction)
+        ctx.out(), format, fmt::arg("coefficient", fraction),
-              , fmt::arg("prefix", std::string() + units[pow] + ((s.binary_ && pow) ? "i" : ""))
+        fmt::arg("number_width", number_width),
-              , fmt::arg("unit", s.unit_)
+        fmt::arg("prefix", std::string() + units[pow] + ((s.binary_ && pow) ? "i" : "")),
-              , fmt::arg("padding", pow ? "" : s.binary_ ? "  " : " ")
+        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);
-      }
-    };
-}
 
+// 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;
+  bool state_ = false;
-  int              fd_ = -1;
+  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_;
+  std::mutex mutex_;
-  bool                    do_run_ = true;
+  bool do_run_ = true;
-  bool                    signal_ = false;
+  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 ++
+	typeof: object ++
-	A number of backlight states which get activated on certain brightness levels.
+	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. ++
+	Based on the current battery percentage (see section *EXPERIMENTAL BATTERY PERCENTAGE FEATURE*), the corresponding icon gets selected. ++
-	The order is *low* to *high*. Or by the state if it is an object.
+	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}",
+	// "controller": "controller1", // specify the alias of the controller if there are more than 1 on the system
-	"format-alt": "bluetooth: {status}",
+	"format": " {status}",
-	"format-icons": {
+	"format-disabled": "", // an empty format will hide the module
-		"enabled": "",
+	"format-connected": " {num_connections} connected",
-		"disabled": ""
+	"tooltip-format": "{controller_alias}\\t{controller_address}",
-	},
+	"tooltip-format-connected": "{controller_alias}\\t{controller_address}\\n\\n{device_enumerate}",
-	"tooltip-format": "{}"
+	"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-us": "AMERICA, HELL YEAH!" // For American English
+    "format-tr": "As bayrakları" // For Turkish
+    "keyboard-name": "AT Translated Set 2 keyboard"
+}
+```
+
+# STYLE
+
+- *#language*

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-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-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 ++
+	typeof: object ++
-	A number of volume states which get activated on certain volume levels. See *waybar-states(5)*
+	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.

man/waybar-states.5.scd

@@ -7,14 +7,13 @@ apply a class when the value matches the declared state value.
 
 # STATES
 
-- Every entry (*state*) consists of a *<name>* (typeof: *string*) and a *<value>* (typeof: *integer*).
+Every entry (*state*) consists of a *<name>* (typeof: *string*) and a *<value>* (typeof: *integer*).
 
-	- The state can be addressed as a CSS class in the *style.css*. The name of the CSS class is the *<name>* of the state.
+- The state can be addressed as a CSS class in the *style.css*. The name of the CSS class is the *<name>* of the state.
-	  Each class gets activated when the current capacity is equal or below the configured *<value>*.
+  Each class gets activated when the current value is equal to or less than the configured *<value>* for the *battery* module, or equal to or greater than the configured *<value>* for all other modules.
 
-	- Also each state can have its own *format*.
+- Also, each state can have its own *format*.
-	  Those can be configured via *format-<name>*.
+  Those can be configured via *format-<name>*, or if you want to differentiate a bit more, as *format-<status>-<state>*.
-	  Or if you want to differentiate a bit more even as *format-<status>-<state>*.
 
 # EXAMPLE
 

man/waybar-sway-scratchpad.5.scd

@@ -0,0 +1,64 @@
+waybar-sway-scratchpad(5)
+
+# NAME
+
+waybar - sway scratchpad module
+
+# DESCRIPTION
+
+The *scratchpad* module displays the scratchpad status in Sway
+
+# CONFIGURATION
+
+Addressed by *sway/scratchpad*
+
+*format*: ++
+	typeof: string ++
+	default: {icon} {count} ++
+	The format, how information should be displayed.
+
+*show-empty*: ++
+	typeof: bool ++
+	default: false ++
+	Option to show module when scratchpad is empty.
+
+*format-icons*: ++
+	typeof: array/object ++
+	Based on the current scratchpad window counts, the corresponding icon gets selected.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
+
+*tooltip-format*: ++
+	typeof: string ++
+	default: {app}: {title} ++
+	The format, how information in the tooltip should be displayed.
+
+# FORMAT REPLACEMENTS
+
+*{icon}*: Icon, as defined in *format-icons*.
+
+*{count}*: Number of windows in the scratchpad.
+
+*{app}*: Name of the application in the scratchpad.
+
+*{title}*: Title of the application in the scratchpad.
+
+# EXAMPLES
+
+```
+"sway/scratchpad": {
+    "format": "{icon} {count}",
+    "show-empty": false,
+    "format-icons": ["", ""],
+    "tooltip": true,
+    "tooltip-format": "{app}: {title}"
+}
+```
+
+# STYLE
+
+- *#scratchpad*
+- *#scratchpad.empty*

man/waybar-sway-window.5.scd

@@ -14,8 +14,8 @@ Addressed by *sway/window*
 
 *format*: ++
 	typeof: string ++
-	default: {} ++
+	default: {title} ++
-	The format, how information should be displayed. On {} data gets inserted.
+	The format, how information should be displayed.
 
 *rotate*: ++
 	typeof: integer ++
@@ -75,6 +75,20 @@ Addressed by *sway/window*
 	default: false ++
 	Option to hide the application icon.
 
+*icon-size*: ++
+	typeof: integer ++
+	default: 24 ++
+	Option to change the size of the application icon.
+
+# FORMAT REPLACEMENTS
+
+*{title}*: The title of the focused window.
+
+*{app_id}*: The app_id of the focused window.
+
+*{shell}*: The shell of the focused window. It's 'xwayland' when the window is
+running through xwayland, otherwise it's 'xdg-shell'.
+
 # REWRITE RULES
 
 *rewrite* is an object where keys are regular expressions and values are

man/waybar-upower.5.scd

@@ -0,0 +1,76 @@
+waybar-upower(5)
+
+# NAME
+
+waybar - upower module
+
+# DESCRIPTION
+
+The *upower* module displays the main battery capacity with all other upower
+compatible devices in the tooltip.
+
+# CONFIGURATION
+
+*icon-size*: ++
+	typeof: integer ++
+	default: 20 ++
+	Defines the size of the icons.
+
+*format*: ++
+	typeof: string ++
+	default: {percentage} ++
+	The text format.
+
+*format-alt*: ++
+	typeof: string ++
+	default: {percentage} {time} ++
+	The text format when toggled.
+
+*hide-if-empty*: ++
+	typeof: bool ++
+	default: true ++
+	Defines visibility of the module if no devices can be found.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
+
+*tooltip-spacing*: ++
+	typeof: integer ++
+	default: 4 ++
+	Defines the spacing between the tooltip device name and device battery ++
+	status.
+
+*tooltip-padding*: ++
+	typeof: integer ++
+	default: 4 ++
+	Defines the spacing between the tooltip window edge and the tooltip content.
+
+# FORMAT REPLACEMENTS
+
+*{percentage}*: The battery capacity in percentage
+
+*{time}*: An estimated time either until empty or until fully charged ++
+depending on the charging state.
+
+# EXAMPLES
+
+```
+"upower": {
+	"icon-size": 20,
+	"hide-if-empty": true,
+	"tooltip": true,
+	"tooltip-spacing": 20
+}
+
+```
+
+# STYLE
+
+- *#upower*
+- *#upower.charging*
+- *#upower.discharging*
+- *#upower.full*
+- *#upower.empty*
+- *#upower.unknown-status*

man/waybar-wireplumber.5.scd

@@ -0,0 +1,87 @@
+waybar-wireplumber(5)
+
+# NAME
+
+waybar - WirePlumber module
+
+# DESCRIPTION
+
+The *wireplumber* module displays the current volume reported by WirePlumber.
+
+# CONFIGURATION
+
+*format*: ++
+    typeof: string ++
+    default: *{volume}%* ++
+    The format, how information should be displayed. This format is used when other formats aren't specified.
+
+ *format-muted*: ++
+    typeof: string ++
+    This format is used when the sound is muted.
+
+*tooltip*: ++
+    typeof: bool ++
+    default: *true* ++
+    Option to disable tooltip on hover.
+
+*tooltip-format*: ++
+    typeof: string ++
+    default: *{node_name}* ++
+    The format of information displayed in the tooltip.
+
+*rotate*: ++
+    typeof: integer ++
+    Positive value to rotate the text label.
+
+*states*: ++
+    typeof: object ++
+    A number of volume states which get activated on certain volume levels. See *waybar-states(5)*.
+
+*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
+
+*{volume}*: Volume in percentage.
+
+*{node_name}*: The node's nickname as reported by WirePlumber (*node.nick* property)
+
+# EXAMPLES
+
+```
+"wireplumber": {
+    "format": "{volume}%",
+    "format-muted": "",
+    "on-click": "helvum"
+}
+```
+
+# STYLE
+
+- *#wireplumber*
+- *#wireplumber.muted*

man/waybar-wlr-workspaces.5.scd

@@ -33,6 +33,11 @@ Addressed by *wlr/workspaces*
 	Note that if both  *sort-by-name* and *sort-by-coordinates* are true sort by name will be first.
 	If both are false - sort by id will be performed.
 
+*sort-by-number*: ++
+	typeof: bool ++
+	default: false ++
+	If set to true, workspace names will be sorted numerically. Takes presedence over any other sort-by option.
+
 *all-outputs*: ++
 	typeof: bool ++
 	default: false ++
@@ -75,7 +80,8 @@ Additional to workspace name matching, the following *format-icons* can be set.
 		"5": "",
 		"focused": "",
 		"default": ""
-	}
+	},
+	"sort-by-number": true
 }
 ```
 

man/waybar.5.scd.in

@@ -77,6 +77,13 @@ Also a minimal example configuration can be found on the at the bottom of this m
 	Selects one of the preconfigured display modes. This is an equivalent of the sway-bar(5) *mode* command and supports the same values: *dock*, *hide*, *invisible*, *overlay*. ++
 	Note: *hide* and *invisible* modes may be not as useful without Sway IPC.
 
+modifier-reset ++
+	typeof: string ++
+	default: *press*
+	Defines the timing of modifier key to reset the bar visibility.
+	To reset the visibility of the bar with the press of the modifier key use *press*.
+	Use *release* to reset the visibility upon the release of the modifier key and only if no other action happened while the key was pressed. This prevents hiding the bar when the modifier is used to switch a workspace, change binding mode or start a keybinding.
+
 *exclusive* ++
 	typeof: bool ++
 	default: *true* ++
@@ -261,9 +268,12 @@ A module group is defined by specifying a module named "group/some-group-name".
 - *waybar-mpd(5)*
 - *waybar-network(5)*
 - *waybar-pulseaudio(5)*
+- *waybar-river-mode(5)*
 - *waybar-river-tags(5)*
+- *waybar-river-window(5)*
 - *waybar-states(5)*
 - *waybar-sway-mode(5)*
+- *waybar-sway-scratchpad(5)*
 - *waybar-sway-window(5)*
 - *waybar-sway-workspaces(5)*
 - *waybar-wlr-taskbar(5)*

meson.build

@@ -1,6 +1,6 @@
 project(
     'waybar', 'cpp', 'c',
-    version: '0.9.12',
+    version: '0.9.16',
     license: 'MIT',
     meson_version: '>= 0.49.0',
     default_options : [
@@ -79,24 +79,29 @@ is_netbsd = host_machine.system() == 'netbsd'
 is_openbsd = host_machine.system() == 'openbsd'
 
 thread_dep = dependency('threads')
-fmt = dependency('fmt', version : ['>=7.0.0'], fallback : ['fmt', 'fmt_dep'])
+fmt = dependency('fmt', version : ['>=8.1.1'], fallback : ['fmt', 'fmt_dep'])
-spdlog = dependency('spdlog', version : ['>=1.8.5'], fallback : ['spdlog', 'spdlog_dep'], default_options : ['external_fmt=true'])
+spdlog = dependency('spdlog', version : ['>=1.10.0'], fallback : ['spdlog', 'spdlog_dep'], default_options : ['external_fmt=enabled'])
 wayland_client = dependency('wayland-client')
 wayland_cursor = dependency('wayland-cursor')
 wayland_protos = dependency('wayland-protocols')
 gtkmm = dependency('gtkmm-3.0', version : ['>=3.22.0'])
 dbusmenu_gtk = dependency('dbusmenu-gtk3-0.4', required: get_option('dbusmenu-gtk'))
-giounix = dependency('gio-unix-2.0', required: (get_option('dbusmenu-gtk').enabled() or get_option('logind').enabled()))
+giounix = dependency('gio-unix-2.0', required: (get_option('dbusmenu-gtk').enabled() or get_option('logind').enabled() or get_option('upower_glib').enabled()))
-jsoncpp = dependency('jsoncpp')
+jsoncpp = dependency('jsoncpp', version : ['>=1.9.2'], fallback : ['jsoncpp', 'jsoncpp_dep'])
 sigcpp = dependency('sigc++-2.0')
+libinotify = dependency('libinotify', required: false)
 libepoll = dependency('epoll-shim', required: false)
+libinput = dependency('libinput', required: get_option('libinput'))
 libnl = dependency('libnl-3.0', required: get_option('libnl'))
 libnlgen = dependency('libnl-genl-3.0', required: get_option('libnl'))
+upower_glib = dependency('upower-glib', required: get_option('upower_glib'))
 libpulse = dependency('libpulse', required: get_option('pulseaudio'))
 libudev = dependency('libudev', required: get_option('libudev'))
 libevdev = dependency('libevdev', required: get_option('libevdev'))
 libmpdclient = dependency('libmpdclient', required: get_option('mpd'))
 xkbregistry = dependency('xkbregistry')
+libjack = dependency('jack', required: get_option('jack'))
+libwireplumber = dependency('wireplumber-0.4', required: get_option('wireplumber'))
 
 libsndio = compiler.find_library('sndio', required: get_option('sndio'))
 if libsndio.found()
@@ -147,12 +152,15 @@ src_files = files(
     'src/modules/disk.cpp',
     'src/modules/idle_inhibitor.cpp',
     'src/modules/temperature.cpp',
+    'src/modules/user.cpp',
     'src/main.cpp',
     'src/bar.cpp',
     'src/client.cpp',
     'src/config.cpp',
     'src/group.cpp',
-    'src/util/ustring_clen.cpp'
+    'src/util/ustring_clen.cpp',
+    'src/util/sanitize_str.cpp',
+    'src/util/rewrite_title.cpp'
 )
 
 if is_linux
@@ -174,6 +182,11 @@ elif is_dragonfly or is_freebsd or is_netbsd or is_openbsd
         'src/modules/memory/bsd.cpp',
         'src/modules/memory/common.cpp',
     )
+    if is_freebsd
+    src_files += files(
+        'src/modules/battery.cpp',
+        )
+    endif
 endif
 
 add_project_arguments('-DHAVE_SWAY', language: 'cpp')
@@ -183,7 +196,8 @@ src_files += [
     'src/modules/sway/mode.cpp',
     'src/modules/sway/language.cpp',
     'src/modules/sway/window.cpp',
-    'src/modules/sway/workspaces.cpp'
+    'src/modules/sway/workspaces.cpp',
+    'src/modules/sway/scratchpad.cpp'
 ]
 
 if true
@@ -195,7 +209,16 @@ endif
 
 if true
     add_project_arguments('-DHAVE_RIVER', language: 'cpp')
+    src_files += 'src/modules/river/mode.cpp'
     src_files += 'src/modules/river/tags.cpp'
+    src_files += 'src/modules/river/window.cpp'
+endif
+
+if true
+    add_project_arguments('-DHAVE_HYPRLAND', language: 'cpp')
+    src_files += 'src/modules/hyprland/backend.cpp'
+    src_files += 'src/modules/hyprland/window.cpp'
+    src_files += 'src/modules/hyprland/language.cpp'
 endif
 
 if libnl.found() and libnlgen.found()
@@ -203,11 +226,32 @@ if libnl.found() and libnlgen.found()
     src_files += 'src/modules/network.cpp'
 endif
 
+if (giounix.found() and not get_option('logind').disabled())
+    add_project_arguments('-DHAVE_GAMEMODE', language: 'cpp')
+    src_files += 'src/modules/gamemode.cpp'
+endif
+
+if (upower_glib.found() and giounix.found() and not get_option('logind').disabled())
+    add_project_arguments('-DHAVE_UPOWER', language: 'cpp')
+    src_files += 'src/modules/upower/upower.cpp'
+    src_files += 'src/modules/upower/upower_tooltip.cpp'
+endif
+
 if libpulse.found()
     add_project_arguments('-DHAVE_LIBPULSE', language: 'cpp')
     src_files += 'src/modules/pulseaudio.cpp'
 endif
 
+if libjack.found()
+    add_project_arguments('-DHAVE_LIBJACK', language: 'cpp')
+    src_files += 'src/modules/jack.cpp'
+endif
+
+if libwireplumber.found()
+    add_project_arguments('-DHAVE_LIBWIREPLUMBER', language: 'cpp')
+    src_files += 'src/modules/wireplumber.cpp'
+endif
+
 if dbusmenu_gtk.found()
     add_project_arguments('-DHAVE_DBUSMENU', language: 'cpp')
     src_files += files(
@@ -223,8 +267,9 @@ if libudev.found() and (is_linux or libepoll.found())
     src_files += 'src/modules/backlight.cpp'
 endif
 
-if libevdev.found() and (is_linux or libepoll.found())
+if libevdev.found() and (is_linux or libepoll.found()) and libinput.found() and (is_linux or libinotify.found())
     add_project_arguments('-DHAVE_LIBEVDEV', language: 'cpp')
+    add_project_arguments('-DHAVE_LIBINPUT', language: 'cpp')
     src_files += 'src/modules/keyboard_state.cpp'
 endif
 
@@ -246,16 +291,14 @@ endif
 if (giounix.found() and not get_option('logind').disabled())
     add_project_arguments('-DHAVE_GIO_UNIX', language: 'cpp')
     src_files += 'src/modules/inhibitor.cpp'
+    src_files += 'src/modules/bluetooth.cpp'
 endif
 
-if get_option('rfkill').enabled()
+if get_option('rfkill').enabled() and is_linux
-    if is_linux
+    add_project_arguments('-DWANT_RFKILL', language: 'cpp')
-        add_project_arguments('-DWANT_RFKILL', language: 'cpp')
+    src_files += files(
-        src_files += files(
+        'src/util/rfkill.cpp'
-            'src/modules/bluetooth.cpp',
+    )
-            'src/util/rfkill.cpp'
-        )
-    endif
 endif
 
 if tz_dep.found()
@@ -286,17 +329,22 @@ executable(
         gtkmm,
         dbusmenu_gtk,
         giounix,
+        libinput,
         libnl,
         libnlgen,
+        upower_glib,
         libpulse,
+        libjack,
+        libwireplumber,
         libudev,
+        libinotify,
         libepoll,
         libmpdclient,
         libevdev,
         gtk_layer_shell,
         libsndio,
         tz_dep,
-		xkbregistry 
+		xkbregistry
     ],
     include_directories: [include_directories('include')],
     install: true,
@@ -333,15 +381,19 @@ if scdoc.found()
         'waybar-cpu.5.scd',
         'waybar-custom.5.scd',
         'waybar-disk.5.scd',
+        'waybar-gamemode.5.scd',
         'waybar-idle-inhibitor.5.scd',
         'waybar-keyboard-state.5.scd',
         'waybar-memory.5.scd',
         'waybar-mpd.5.scd',
         'waybar-network.5.scd',
         'waybar-pulseaudio.5.scd',
+        'waybar-river-mode.5.scd',
         'waybar-river-tags.5.scd',
+        'waybar-river-window.5.scd',
         'waybar-sway-language.5.scd',
         'waybar-sway-mode.5.scd',
+        'waybar-sway-scratchpad.5.scd',
         'waybar-sway-window.5.scd',
         'waybar-sway-workspaces.5.scd',
         'waybar-temperature.5.scd',
@@ -351,6 +403,7 @@ if scdoc.found()
         'waybar-wlr-workspaces.5.scd',
         'waybar-bluetooth.5.scd',
         'waybar-sndio.5.scd',
+        'waybar-upower.5.scd',
     ]
 
     if (giounix.found() and not get_option('logind').disabled())
@@ -381,6 +434,7 @@ endif
 
 catch2 = dependency(
     'catch2',
+    version: '>=3.0.0',
     fallback: ['catch2', 'catch2_dep'],
     required: get_option('tests'),
 )

meson_options.txt

@@ -1,8 +1,10 @@
 option('libcxx', type : 'boolean', value : false, description : 'Build with Clang\'s libc++ instead of libstdc++ on Linux.')
+option('libinput', type: 'feature', value: 'auto', description: 'Enable libinput support for libinput related features')
 option('libnl', type: 'feature', value: 'auto', description: 'Enable libnl support for network related features')
 option('libudev', type: 'feature', value: 'auto', description: 'Enable libudev support for udev related features')
 option('libevdev', type: 'feature', value: 'auto', description: 'Enable libevdev support for evdev related features')
 option('pulseaudio', type: 'feature', value: 'auto', description: 'Enable support for pulseaudio')
+option('upower_glib', type: 'feature', value: 'auto', description: 'Enable support for upower')
 option('systemd', type: 'feature', value: 'auto', description: 'Install systemd user service unit')
 option('dbusmenu-gtk', type: 'feature', value: 'auto', description: 'Enable support for tray')
 option('man-pages', type: 'feature', value: 'auto', description: 'Generate and install man pages')
@@ -13,3 +15,5 @@ option('sndio', type: 'feature', value: 'auto', description: 'Enable support for
 option('logind', type: 'feature', value: 'auto', description: 'Enable support for logind')
 option('tests', type: 'feature', value: 'auto', description: 'Enable tests')
 option('experimental', type : 'boolean', value : false, description: 'Enable experimental features')
+option('jack', type: 'feature', value: 'auto', description: 'Enable support for JACK')
+option('wireplumber', type: 'feature', value: 'auto', description: 'Enable support for WirePlumber')

protocol/river-status-unstable-v1.xml

@@ -16,7 +16,7 @@
     OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   </copyright>
 
-  <interface name="zriver_status_manager_v1" version="2">
+  <interface name="zriver_status_manager_v1" version="3">
     <description summary="manage river status objects">
       A global factory for objects that receive status information specific
       to river. It could be used to implement, for example, a status bar.
@@ -85,7 +85,7 @@
     </event>
   </interface>
 
-  <interface name="zriver_seat_status_v1" version="1">
+  <interface name="zriver_seat_status_v1" version="3">
     <description summary="track seat focus">
       This interface allows clients to receive information about the current
       focus of a seat. Note that (un)focused_output events will only be sent
@@ -121,5 +121,13 @@
       </description>
       <arg name="title" type="string" summary="title of the focused view"/>
     </event>
+
+    <event name="mode" since="3">
+      <description summary="the active mode changed">
+        Sent once on binding the interface and again whenever a new mode
+        is entered (e.g. with riverctl enter-mode foobar).
+      </description>
+      <arg name="name" type="string" summary="name of the mode"/>
+    </event>
   </interface>
 </protocol>

resources/config

@@ -5,7 +5,7 @@
     // "width": 1280, // Waybar width
     "spacing": 4, // Gaps between modules (4px)
     // Choose the order of the modules
-    "modules-left": ["sway/workspaces", "sway/mode", "custom/media"],
+    "modules-left": ["sway/workspaces", "sway/mode", "sway/scratchpad", "custom/media"],
     "modules-center": ["sway/window"],
     "modules-right": ["mpd", "idle_inhibitor", "pulseaudio", "network", "cpu", "memory", "temperature", "backlight", "keyboard-state", "sway/language", "battery", "battery#bat2", "clock", "tray"],
     // Modules configuration
@@ -36,6 +36,13 @@
     "sway/mode": {
         "format": "<span style=\"italic\">{}</span>"
     },
+    "sway/scratchpad": {
+        "format": "{icon} {count}",
+        "show-empty": false,
+        "format-icons": ["", ""],
+        "tooltip": true,
+        "tooltip-format": "{app}: {title}"
+    },
     "mpd": {
         "format": "{stateIcon} {consumeIcon}{randomIcon}{repeatIcon}{singleIcon}{artist} - {album} - {title} ({elapsedTime:%M:%S}/{totalTime:%M:%S}) ⸨{songPosition}|{queueLength}⸩ {volume}% ",
         "format-disconnected": "Disconnected ",
@@ -96,7 +103,7 @@
     "backlight": {
         // "device": "acpi_video1",
         "format": "{percent}% {icon}",
-        "format-icons": ["", ""]
+        "format-icons": ["", "", "", "", "", "", "", "", ""]
     },
     "battery": {
         "states": {

resources/style.css

@@ -34,21 +34,28 @@ window#waybar.chromium {
     border: none;
 }
 
-#workspaces button {
+button {
-    padding: 0 5px;
-    background-color: transparent;
-    color: #ffffff;
     /* Use box-shadow instead of border so the text isn't offset */
     box-shadow: inset 0 -3px transparent;
-    /* Avoid rounded borders under each workspace name */
+    /* Avoid rounded borders under each button name */
     border: none;
     border-radius: 0;
 }
 
 /* https://github.com/Alexays/Waybar/wiki/FAQ#the-workspace-buttons-have-a-strange-hover-effect */
+button:hover {
+    background: inherit;
+    box-shadow: inset 0 -3px #ffffff;
+}
+
+#workspaces button {
+    padding: 0 5px;
+    background-color: transparent;
+    color: #ffffff;
+}
+
 #workspaces button:hover {
     background: rgba(0, 0, 0, 0.2);
-    box-shadow: inset 0 -3px #ffffff;
 }
 
 #workspaces button.focused {
@@ -74,10 +81,12 @@ window#waybar.chromium {
 #backlight,
 #network,
 #pulseaudio,
+#wireplumber,
 #custom-media,
 #tray,
 #mode,
 #idle_inhibitor,
+#scratchpad,
 #mpd {
     padding: 0 10px;
     color: #ffffff;
@@ -168,6 +177,15 @@ label:focus {
     color: #2a5c45;
 }
 
+#wireplumber {
+    background-color: #fff0f5;
+    color: #000000;
+}
+
+#wireplumber.muted {
+    background-color: #f53c3c;
+}
+
 #custom-media {
     background-color: #66cc99;
     color: #2a5c45;
@@ -252,3 +270,11 @@ label:focus {
 #keyboard-state > label.locked {
     background: rgba(0, 0, 0, 0.2);
 }
+
+#scratchpad {
+    background: rgba(0, 0, 0, 0.2);
+}
+
+#scratchpad.empty {
+	background-color: transparent;
+}