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.

.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/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/AModule.hpp

@@ -48,10 +48,10 @@ class AModule : public IModule {
       {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_2BUTTON_PRESS), "on-triple-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_2BUTTON_PRESS), "on-triple-click-forward"}};
+      {std::make_pair(9, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click-forward"}};
 };
 
 }  // namespace waybar

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

@@ -9,6 +9,7 @@
 #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"
 #endif
@@ -17,10 +18,16 @@
 #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)
@@ -62,9 +69,16 @@
 #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"
+#include "modules/user.hpp"
 
 namespace waybar {
 

include/modules/backlight.hpp

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

include/modules/battery.hpp

@@ -6,7 +6,9 @@
 #include <filesystem>
 #endif
 #include <fmt/format.h>
+#if defined(__linux__)
 #include <sys/inotify.h>
+#endif
 
 #include <algorithm>
 #include <fstream>

include/modules/clock.hpp

@@ -25,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;
-  std::string cached_calendar_text_;
+  date::year_month_day calendar_cached_ymd_{date::January / 1 / 0};
+  date::months calendar_shift_{0}, calendar_shift_init_{0};
+  std::string calendar_cached_text_;
   bool is_calendar_in_tooltip_;
   bool is_timezoned_list_in_tooltip_;
 
@@ -36,10 +37,8 @@ class Clock : public ALabel {
   auto weekdays_header(const date::weekday& first_dow, std::ostream& os) -> void;
   auto first_day_of_week() -> date::weekday;
   const date::time_zone* current_timezone();
-  auto print_iso_weeknum(std::ostream& os, int weeknum) -> void;
   bool is_timezone_fixed();
   auto timezones_text(std::chrono::system_clock::time_point* now) -> std::string;
 };
-
 }  // namespace modules
 }  // namespace waybar

include/modules/custom.hpp

@@ -30,6 +30,7 @@ class Custom : public ALabel {
 
   const std::string name_;
   std::string text_;
+  std::string id_;
   std::string alt_;
   std::string tooltip_;
   std::vector<std::string> class_;

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

@@ -20,6 +20,7 @@ class IdleInhibitor : public ALabel {
 
  private:
   bool handleToggle(GdkEventButton* const& e);
+  void toggleStatus();
 
   const Bar& bar_;
   struct zwp_idle_inhibitor_v1* idle_inhibitor_;

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,19 +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"
 
 extern "C" {
 #include <libevdev/libevdev.h>
+#include <libinput.h>
 }
 
 namespace waybar::modules {
@@ -25,6 +23,8 @@ class KeyboardState : public AModule {
   auto update() -> void;
 
  private:
+  auto tryAddDevice(const std::string&) -> void;
+
   Gtk::Box box_;
   Gtk::Label numlock_label_;
   Gtk::Label capslock_label_;
@@ -36,11 +36,12 @@ class KeyboardState : public AModule {
   const std::chrono::seconds interval_;
   std::string icon_locked_;
   std::string icon_unlocked_;
+  std::string devices_path_;
 
-  int fd_;
-  libevdev* dev_;
+  struct libinput* libinput_;
+  std::unordered_map<std::string, struct libinput_device*> libinput_devices_;
 
-  util::SleeperThread thread_;
+  util::SleeperThread libinput_thread_, hotplug_thread_;
 };
 
 }  // namespace waybar::modules

include/modules/mpd/mpd.hpp

@@ -41,6 +41,7 @@ class MPD : public ALabel {
 
  private:
   std::string getTag(mpd_tag_type type, unsigned idx = 0) const;
+  std::string getFilename() const;
   void setLabel();
   std::string getStateIcon() const;
   std::string getOptionIcon(std::string optionName, bool activated) const;

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

@@ -21,10 +21,9 @@ class Window : public AIconLabel, public sigc::trackable {
  private:
   void onEvent(const struct Ipc::ipc_response&);
   void onCmd(const struct Ipc::ipc_response&);
-  std::tuple<std::size_t, int, std::string, std::string, std::string> getFocusedNode(
+  std::tuple<std::size_t, int, std::string, std::string, std::string, std::string> getFocusedNode(
       const Json::Value& nodes, std::string& output);
   void getTree();
-  std::string rewriteTitle(const std::string& title);
   void updateAppIconName();
   void updateAppIcon();
 
@@ -35,6 +34,7 @@ class Window : public AIconLabel, public sigc::trackable {
   std::string app_class_;
   std::string old_app_id_;
   std::size_t app_nb_;
+  std::string shell_;
   unsigned app_icon_size_{24};
   bool update_app_icon_{true};
   std::string app_icon_name_;

include/modules/upower/upower.hpp

@@ -5,6 +5,7 @@
 #include <iostream>
 #include <map>
 #include <string>
+#include <unordered_map>
 
 #include "ALabel.hpp"
 #include "glibconfig.h"

include/modules/upower/upower_tooltip.hpp

@@ -2,6 +2,8 @@
 
 #include <libupower-glib/upower.h>
 
+#include <unordered_map>
+
 #include "gtkmm/box.h"
 #include "gtkmm/label.h"
 #include "gtkmm/window.h"

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

@@ -74,6 +74,10 @@ class Task {
   std::string app_id_;
   uint32_t state_ = 0;
 
+  int32_t drag_start_x;
+  int32_t drag_start_y;
+  int32_t drag_start_button = -1;
+
  private:
   std::string repr() const;
   std::string state_string(bool = false) const;
@@ -105,6 +109,12 @@ class Task {
 
   /* Callbacks for Gtk events */
   bool handle_clicked(GdkEventButton *);
+  bool handle_button_release(GdkEventButton *);
+  bool handle_motion_notify(GdkEventMotion *);
+  void handle_drag_data_get(const Glib::RefPtr<Gdk::DragContext> &context,
+                            Gtk::SelectionData &selection_data, guint info, guint time);
+  void handle_drag_data_received(const Glib::RefPtr<Gdk::DragContext> &context, int x, int y,
+                                 Gtk::SelectionData selection_data, guint info, guint time);
 
  public:
   bool operator==(const Task &) const;

include/modules/wlr/workspace_manager.hpp

@@ -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/util/format.hpp

@@ -56,9 +56,10 @@ struct formatter<pow_format> {
       fraction /= base;
     }
 
-    auto max_width = 4            // coeff in {:.3g} format
-                     + 1          // prefix from units array
-                     + s.binary_  // for the 'i' in GiB.
+    auto number_width = 5              // coeff in {:.1f} format
+                        + s.binary_;   // potential 4th digit before the decimal point
+    auto max_width = number_width + 1  // prefix from units array
+                     + s.binary_       // for the 'i' in GiB.
                      + s.unit_.length();
 
     const char* format;
@@ -69,15 +70,16 @@ struct formatter<pow_format> {
       case '<':
         return format_to(ctx.out(), "{:<{}}", fmt::format("{}", s), max_width);
       case '=':
-        format = "{coefficient:<4.3g}{padding}{prefix}{unit}";
+        format = "{coefficient:<{number_width}.1f}{padding}{prefix}{unit}";
         break;
       case 0:
       default:
-        format = "{coefficient:.3g}{prefix}{unit}";
+        format = "{coefficient:.1f}{prefix}{unit}";
         break;
     }
     return format_to(
         ctx.out(), format, fmt::arg("coefficient", fraction),
+        fmt::arg("number_width", number_width),
         fmt::arg("prefix", std::string() + units[pow] + ((s.binary_ && pow) ? "i" : "")),
         fmt::arg("unit", s.unit_),
         fmt::arg("padding", pow         ? ""

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 {

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/sanitize_str.hpp

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

man/waybar-backlight.5.scd

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

man/waybar-battery.5.scd

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

man/waybar-bluetooth.5.scd

@@ -42,6 +42,12 @@ Addressed by *bluetooth*
 	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 current battery percentage (see section *EXPERIMENTAL BATTERY PERCENTAGE FEATURE*), the corresponding icon gets selected. ++
+	The order is *low* to *high*. Will only show the current battery percentage icon in the *\*-connected-battery* config options. ++
+	Or by the state if it is an object. It will fall back to the enabled state if its derivatives are not defined (on, off, connected).
+
 *rotate*: ++
 	typeof: integer ++
 	Positive value to rotate the text label.
@@ -115,6 +121,8 @@ Addressed by *bluetooth*
 
 *{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.
@@ -129,7 +137,7 @@ Addressed by *bluetooth*
 
 *{device_alias}*: Alias of the displayed device.
 
-*{device_enumerate}*: Show a list of all connected devices, each on a seperate line. Define the format of each device with the *tooltip-format-enumerate-connected* ++
+*{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

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

@@ -23,7 +23,7 @@ Feral Gamemode optimizations.
 
 *tooltip*: ++
 	typeof: bool ++
-	defualt: true ++
+	default: true ++
 	Option to disable tooltip on hover.
 
 *tooltip-format*: ++

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,6 +63,11 @@ 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.
@@ -72,6 +77,14 @@ screensaving, also known as "presentation mode".
 	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*)

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.

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

man/waybar-river-mode.5.scd

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

man/waybar-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.
-	  Each class gets activated when the current capacity is equal or below the configured *<value>*.
+- 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 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*.
-	  Those can be configured via *format-<name>*.
-	  Or if you want to differentiate a bit more even as *format-<status>-<state>*.
+- Also, each state can have its own *format*.
+  Those can be configured via *format-<name>*, or if you want to differentiate a bit more, 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: {} ++
-	The format, how information should be displayed. On {} data gets inserted.
+	default: {title} ++
+	The format, how information should be displayed.
 
 *rotate*: ++
 	typeof: integer ++
@@ -80,6 +80,15 @@ Addressed by *sway/window*
 	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

@@ -33,7 +33,7 @@ compatible devices in the tooltip.
 
 *tooltip*: ++
 	typeof: bool ++
-	defualt: true ++
+	default: true ++
 	Option to disable tooltip on hover.
 
 *tooltip-spacing*: ++

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

@@ -268,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.13',
+    version: '0.9.16',
     license: 'MIT',
     meson_version: '>= 0.49.0',
     default_options : [
@@ -79,17 +79,19 @@ 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'])
-spdlog = dependency('spdlog', version : ['>=1.8.5'], fallback : ['spdlog', 'spdlog_dep'], default_options : ['external_fmt=true'])
+fmt = dependency('fmt', version : ['>=8.1.1'], fallback : ['fmt', 'fmt_dep'])
+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() 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'))
@@ -98,6 +100,8 @@ 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()
@@ -148,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
@@ -175,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')
@@ -184,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
@@ -196,10 +209,18 @@ 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()
     add_project_arguments('-DHAVE_LIBNL', language: 'cpp')
     src_files += 'src/modules/network.cpp'
@@ -221,6 +242,16 @@ if libpulse.found()
     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(
@@ -236,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
 
@@ -297,11 +329,15 @@ executable(
         gtkmm,
         dbusmenu_gtk,
         giounix,
+        libinput,
         libnl,
         libnlgen,
         upower_glib,
         libpulse,
+        libjack,
+        libwireplumber,
         libudev,
+        libinotify,
         libepoll,
         libmpdclient,
         libevdev,
@@ -345,16 +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',
@@ -395,6 +434,7 @@ endif
 
 catch2 = dependency(
     'catch2',
+    version: '>=3.0.0',
     fallback: ['catch2', 'catch2_dep'],
     required: get_option('tests'),
 )

meson_options.txt

@@ -1,4 +1,5 @@
 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')
@@ -14,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 ",

resources/style.css

@@ -34,21 +34,28 @@ window#waybar.chromium {
     border: none;
 }
 
-#workspaces button {
-    padding: 0 5px;
-    background-color: transparent;
-    color: #ffffff;
+button {
     /* 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;
+}

src/bar.cpp

@@ -181,7 +181,7 @@ struct GLSSurfaceImpl : public BarSurface, public sigc::trackable {
     if (vertical_ && height_ > 1) {
       gtk_layer_set_anchor(window_.gobj(), GTK_LAYER_SHELL_EDGE_BOTTOM, false);
       gtk_layer_set_anchor(window_.gobj(), GTK_LAYER_SHELL_EDGE_TOP, false);
-    } else if (width_ > 1) {
+    } else if (!vertical_ && width_ > 1) {
       gtk_layer_set_anchor(window_.gobj(), GTK_LAYER_SHELL_EDGE_LEFT, false);
       gtk_layer_set_anchor(window_.gobj(), GTK_LAYER_SHELL_EDGE_RIGHT, false);
     }

src/client.cpp

@@ -1,12 +1,12 @@
 #include "client.hpp"
 
-#include <fmt/ostream.h>
 #include <spdlog/spdlog.h>
 
 #include <iostream>
 
 #include "idle-inhibit-unstable-v1-client-protocol.h"
 #include "util/clara.hpp"
+#include "util/format.hpp"
 #include "wlr-layer-shell-unstable-v1-client-protocol.h"
 
 waybar::Client *waybar::Client::inst() {

src/config.cpp

@@ -1,15 +1,17 @@
 #include "config.hpp"
 
-#include <fmt/ostream.h>
 #include <spdlog/spdlog.h>
 #include <unistd.h>
 #include <wordexp.h>
 
+#include <filesystem>
 #include <fstream>
 #include <stdexcept>
 
 #include "util/json.hpp"
 
+namespace fs = std::filesystem;
+
 namespace waybar {
 
 const std::vector<std::string> Config::CONFIG_DIRS = {
@@ -17,12 +19,25 @@ const std::vector<std::string> Config::CONFIG_DIRS = {
     "/etc/xdg/waybar/",         SYSCONFDIR "/xdg/waybar/", "./resources/",
 };
 
-std::optional<std::string> tryExpandPath(const std::string &path) {
+const char *Config::CONFIG_PATH_ENV = "WAYBAR_CONFIG_DIR";
+
+std::optional<std::string> tryExpandPath(const std::string base, const std::string filename) {
+  fs::path path;
+
+  if (filename != "") {
+    path = fs::path(base) / fs::path(filename);
+  } else {
+    path = fs::path(base);
+  }
+
+  spdlog::debug("Try expanding: {}", path.string());
+
   wordexp_t p;
   if (wordexp(path.c_str(), &p, 0) == 0) {
     if (access(*p.we_wordv, F_OK) == 0) {
       std::string result = *p.we_wordv;
       wordfree(&p);
+      spdlog::debug("Found config file: {}", path.string());
       return result;
     }
     wordfree(&p);
@@ -32,10 +47,17 @@ std::optional<std::string> tryExpandPath(const std::string &path) {
 
 std::optional<std::string> Config::findConfigPath(const std::vector<std::string> &names,
                                                   const std::vector<std::string> &dirs) {
-  std::vector<std::string> paths;
+  if (const char *dir = std::getenv(Config::CONFIG_PATH_ENV)) {
+    for (const auto &name : names) {
+      if (auto res = tryExpandPath(dir, name); res) {
+        return res;
+      }
+    }
+  }
+
   for (const auto &dir : dirs) {
     for (const auto &name : names) {
-      if (auto res = tryExpandPath(dir + name); res) {
+      if (auto res = tryExpandPath(dir, name); res) {
         return res;
       }
     }
@@ -69,11 +91,11 @@ void Config::resolveConfigIncludes(Json::Value &config, int depth) {
   if (includes.isArray()) {
     for (const auto &include : includes) {
       spdlog::info("Including resource file: {}", include.asString());
-      setupConfig(config, tryExpandPath(include.asString()).value_or(""), ++depth);
+      setupConfig(config, tryExpandPath(include.asString(), "").value_or(""), ++depth);
     }
   } else if (includes.isString()) {
     spdlog::info("Including resource file: {}", includes.asString());
-    setupConfig(config, tryExpandPath(includes.asString()).value_or(""), ++depth);
+    setupConfig(config, tryExpandPath(includes.asString(), "").value_or(""), ++depth);
   }
 }
 

src/factory.cpp

@@ -7,7 +7,7 @@ waybar::AModule* waybar::Factory::makeModule(const std::string& name) const {
     auto hash_pos = name.find('#');
     auto ref = name.substr(0, hash_pos);
     auto id = hash_pos != std::string::npos ? name.substr(hash_pos + 1) : "";
-#if defined(__linux__) && !defined(NO_FILESYSTEM)
+#if defined(__FreeBSD__) || (defined(__linux__) && !defined(NO_FILESYSTEM))
     if (ref == "battery") {
       return new waybar::modules::Battery(id, config_[name]);
     }
@@ -35,6 +35,9 @@ waybar::AModule* waybar::Factory::makeModule(const std::string& name) const {
     if (ref == "sway/language") {
       return new waybar::modules::sway::Language(id, config_[name]);
     }
+    if (ref == "sway/scratchpad") {
+      return new waybar::modules::sway::Scratchpad(id, config_[name]);
+    }
 #endif
 #ifdef HAVE_WLR
     if (ref == "wlr/taskbar") {
@@ -47,12 +50,23 @@ waybar::AModule* waybar::Factory::makeModule(const std::string& name) const {
 #endif
 #endif
 #ifdef HAVE_RIVER
+    if (ref == "river/mode") {
+      return new waybar::modules::river::Mode(id, bar_, config_[name]);
+    }
     if (ref == "river/tags") {
       return new waybar::modules::river::Tags(id, bar_, config_[name]);
     }
     if (ref == "river/window") {
       return new waybar::modules::river::Window(id, bar_, config_[name]);
     }
+#endif
+#ifdef HAVE_HYPRLAND
+    if (ref == "hyprland/window") {
+      return new waybar::modules::hyprland::Window(id, bar_, config_[name]);
+    }
+    if (ref == "hyprland/language") {
+      return new waybar::modules::hyprland::Language(id, bar_, config_[name]);
+    }
 #endif
     if (ref == "idle_inhibitor") {
       return new waybar::modules::IdleInhibitor(id, bar_, config_[name]);
@@ -70,6 +84,9 @@ waybar::AModule* waybar::Factory::makeModule(const std::string& name) const {
     if (ref == "clock") {
       return new waybar::modules::Clock(id, config_[name]);
     }
+    if (ref == "user") {
+      return new waybar::modules::User(id, config_[name]);
+    }
     if (ref == "disk") {
       return new waybar::modules::Disk(id, config_[name]);
     }
@@ -115,6 +132,16 @@ waybar::AModule* waybar::Factory::makeModule(const std::string& name) const {
     if (ref == "inhibitor") {
       return new waybar::modules::Inhibitor(id, bar_, config_[name]);
     }
+#endif
+#ifdef HAVE_LIBJACK
+    if (ref == "jack") {
+      return new waybar::modules::JACK(id, config_[name]);
+    }
+#endif
+#ifdef HAVE_LIBWIREPLUMBER
+    if (ref == "wireplumber") {
+      return new waybar::modules::Wireplumber(id, config_[name]);
+    }
 #endif
     if (ref == "temperature") {
       return new waybar::modules::Temperature(id, config_[name]);

src/modules/backlight.cpp

@@ -73,8 +73,9 @@ void check_nn(const void *ptr, const char *message = "ptr was null") {
 }
 }  // namespace
 
-waybar::modules::Backlight::BacklightDev::BacklightDev(std::string name, int actual, int max)
-    : name_(std::move(name)), actual_(actual), max_(max) {}
+waybar::modules::Backlight::BacklightDev::BacklightDev(std::string name, int actual, int max,
+                                                       bool powered)
+    : name_(std::move(name)), actual_(actual), max_(max), powered_(powered) {}
 
 std::string_view waybar::modules::Backlight::BacklightDev::name() const { return name_; }
 
@@ -86,6 +87,10 @@ int waybar::modules::Backlight::BacklightDev::get_max() const { return max_; }
 
 void waybar::modules::Backlight::BacklightDev::set_max(int max) { max_ = max; }
 
+bool waybar::modules::Backlight::BacklightDev::get_powered() const { return powered_; }
+
+void waybar::modules::Backlight::BacklightDev::set_powered(bool powered) { powered_ = powered; }
+
 waybar::modules::Backlight::Backlight(const std::string &id, const Json::Value &config)
     : ALabel(config, "backlight", id, "{percent}%", 2),
       preferred_device_(config["device"].isString() ? config["device"].asString() : "") {
@@ -172,11 +177,16 @@ auto waybar::modules::Backlight::update() -> void {
       return;
     }
 
-    const uint8_t percent =
-        best->get_max() == 0 ? 100 : round(best->get_actual() * 100.0f / best->get_max());
-    label_.set_markup(fmt::format(format_, fmt::arg("percent", std::to_string(percent)),
-                                  fmt::arg("icon", getIcon(percent))));
-    getState(percent);
+    if (best->get_powered()) {
+      event_box_.show();
+      const uint8_t percent =
+          best->get_max() == 0 ? 100 : round(best->get_actual() * 100.0f / best->get_max());
+      label_.set_markup(fmt::format(format_, fmt::arg("percent", std::to_string(percent)),
+                                    fmt::arg("icon", getIcon(percent))));
+      getState(percent);
+    } else {
+      event_box_.hide();
+    }
   } else {
     if (!previous_best_.has_value()) {
       return;
@@ -215,6 +225,7 @@ void waybar::modules::Backlight::upsert_device(ForwardIt first, ForwardIt last,
 
   const char *actual = udev_device_get_sysattr_value(dev, actual_brightness_attr);
   const char *max = udev_device_get_sysattr_value(dev, "max_brightness");
+  const char *power = udev_device_get_sysattr_value(dev, "bl_power");
 
   auto found =
       std::find_if(first, last, [name](const auto &device) { return device.name() == name; });
@@ -225,10 +236,14 @@ void waybar::modules::Backlight::upsert_device(ForwardIt first, ForwardIt last,
     if (max != nullptr) {
       found->set_max(std::stoi(max));
     }
+    if (power != nullptr) {
+      found->set_powered(std::stoi(power) == 0);
+    }
   } else {
     const int actual_int = actual == nullptr ? 0 : std::stoi(actual);
     const int max_int = max == nullptr ? 0 : std::stoi(max);
-    *inserter = BacklightDev{name, actual_int, max_int};
+    const bool power_bool = power == nullptr ? true : std::stoi(power) == 0;
+    *inserter = BacklightDev{name, actual_int, max_int, power_bool};
     ++inserter;
   }
 }

src/modules/battery.cpp

@@ -1,9 +1,13 @@
 #include "modules/battery.hpp"
-
+#if defined(__FreeBSD__)
+#include <sys/sysctl.h>
+#endif
 #include <spdlog/spdlog.h>
 
+#include <iostream>
 waybar::modules::Battery::Battery(const std::string& id, const Json::Value& config)
     : ALabel(config, "battery", id, "{capacity}%", 60) {
+#if defined(__linux__)
   battery_watch_fd_ = inotify_init1(IN_CLOEXEC);
   if (battery_watch_fd_ == -1) {
     throw std::runtime_error("Unable to listen batteries.");
@@ -19,11 +23,12 @@ waybar::modules::Battery::Battery(const std::string& id, const Json::Value& conf
   if (global_watch < 0) {
     throw std::runtime_error("Could not watch for battery plug/unplug");
   }
-
+#endif
   worker();
 }
 
 waybar::modules::Battery::~Battery() {
+#if defined(__linux__)
   std::lock_guard<std::mutex> guard(battery_list_mutex_);
 
   if (global_watch >= 0) {
@@ -39,9 +44,16 @@ waybar::modules::Battery::~Battery() {
     batteries_.erase(it);
   }
   close(battery_watch_fd_);
+#endif
 }
 
 void waybar::modules::Battery::worker() {
+#if defined(__FreeBSD__)
+  thread_timer_ = [this] {
+    dp.emit();
+    thread_timer_.sleep_for(interval_);
+  };
+#else
   thread_timer_ = [this] {
     // Make sure we eventually update the list of batteries even if we miss an
     // inotify event for some reason
@@ -68,9 +80,11 @@ void waybar::modules::Battery::worker() {
     refreshBatteries();
     dp.emit();
   };
+#endif
 }
 
 void waybar::modules::Battery::refreshBatteries() {
+#if defined(__linux__)
   std::lock_guard<std::mutex> guard(battery_list_mutex_);
   // Mark existing list of batteries as not necessarily found
   std::map<fs::path, bool> check_map;
@@ -108,7 +122,7 @@ void waybar::modules::Battery::refreshBatteries() {
       }
       auto adap_defined = config_["adapter"].isString();
       if (((adap_defined && dir_name == config_["adapter"].asString()) || !adap_defined) &&
-          fs::exists(node.path() / "online")) {
+          (fs::exists(node.path() / "online") || fs::exists(node.path() / "status"))) {
         adapter_ = node.path();
       }
     }
@@ -135,6 +149,7 @@ void waybar::modules::Battery::refreshBatteries() {
       batteries_.erase(check.first);
     }
   }
+#endif
 }
 
 // Unknown > Full > Not charging > Discharging > Charging
@@ -156,105 +171,35 @@ const std::tuple<uint8_t, float, std::string, float> waybar::modules::Battery::g
   std::lock_guard<std::mutex> guard(battery_list_mutex_);
 
   try {
-    uint32_t total_power = 0;   // μW
-    uint32_t total_energy = 0;  // μWh
-    uint32_t total_energy_full = 0;
-    uint32_t total_energy_full_design = 0;
-    uint32_t total_capacity{0};
-    std::string status = "Unknown";
-    for (auto const& item : batteries_) {
-      auto bat = item.first;
-      uint32_t power_now;
-      uint32_t energy_full;
-      uint32_t energy_now;
-      uint32_t energy_full_design;
-      uint32_t capacity{0};
-      std::string _status;
-      std::getline(std::ifstream(bat / "status"), _status);
+#if defined(__FreeBSD__)
+    /* Allocate state of battery units reported via ACPI. */
+    int battery_units = 0;
+    size_t battery_units_size = sizeof battery_units;
+    if (sysctlbyname("hw.acpi.battery.units", &battery_units, &battery_units_size, NULL, 0) != 0) {
+      throw std::runtime_error("sysctl hw.acpi.battery.units failed");
+    }
 
-      // Some battery will report current and charge in μA/μAh.
-      // Scale these by the voltage to get μW/μWh.
-      if (fs::exists(bat / "current_now") || fs::exists(bat / "current_avg")) {
-        uint32_t voltage_now;
-        uint32_t current_now;
-        uint32_t charge_now;
-        uint32_t charge_full;
-        uint32_t charge_full_design;
-        // Some batteries have only *_avg, not *_now
-        if (fs::exists(bat / "voltage_now"))
-          std::ifstream(bat / "voltage_now") >> voltage_now;
-        else
-          std::ifstream(bat / "voltage_avg") >> voltage_now;
-        if (fs::exists(bat / "current_now"))
-          std::ifstream(bat / "current_now") >> current_now;
-        else
-          std::ifstream(bat / "current_avg") >> current_now;
-        std::ifstream(bat / "charge_full") >> charge_full;
-        std::ifstream(bat / "charge_full_design") >> charge_full_design;
-        if (fs::exists(bat / "charge_now"))
-          std::ifstream(bat / "charge_now") >> charge_now;
-        else {
-          // charge_now is missing on some systems, estimate using capacity.
-          uint32_t capacity;
-          std::ifstream(bat / "capacity") >> capacity;
-          charge_now = (capacity * charge_full) / 100;
-        }
-        power_now = ((uint64_t)current_now * (uint64_t)voltage_now) / 1000000;
-        energy_now = ((uint64_t)charge_now * (uint64_t)voltage_now) / 1000000;
-        energy_full = ((uint64_t)charge_full * (uint64_t)voltage_now) / 1000000;
-        energy_full_design = ((uint64_t)charge_full_design * (uint64_t)voltage_now) / 1000000;
-      }  // Gamepads such as PS Dualshock provide the only capacity
-      else if (fs::exists(bat / "energy_now") && fs::exists(bat / "energy_full")) {
-        std::ifstream(bat / "power_now") >> power_now;
-        std::ifstream(bat / "energy_now") >> energy_now;
-        std::ifstream(bat / "energy_full") >> energy_full;
-        std::ifstream(bat / "energy_full_design") >> energy_full_design;
-      } else {
-        std::ifstream(bat / "capacity") >> capacity;
-        power_now = 0;
-        energy_now = 0;
-        energy_full = 0;
-        energy_full_design = 0;
-      }
+    if (battery_units < 0) {
+      throw std::runtime_error("No battery units");
+    }
 
-      // Show the "smallest" status among all batteries
-      if (status_gt(status, _status)) {
-        status = _status;
-      }
-      total_power += power_now;
-      total_energy += energy_now;
-      total_energy_full += energy_full;
-      total_energy_full_design += energy_full_design;
-      total_capacity += capacity;
+    int capacity;
+    size_t size_capacity = sizeof capacity;
+    if (sysctlbyname("hw.acpi.battery.life", &capacity, &size_capacity, NULL, 0) != 0) {
+      throw std::runtime_error("sysctl hw.acpi.battery.life failed");
     }
-    if (!adapter_.empty() && status == "Discharging") {
-      bool online;
-      std::ifstream(adapter_ / "online") >> online;
-      if (online) {
-        status = "Plugged";
-      }
+    int time;
+    size_t size_time = sizeof time;
+    if (sysctlbyname("hw.acpi.battery.time", &time, &size_time, NULL, 0) != 0) {
+      throw std::runtime_error("sysctl hw.acpi.battery.time failed");
     }
-    float time_remaining = 0;
-    if (status == "Discharging" && total_power != 0) {
-      time_remaining = (float)total_energy / total_power;
-    } else if (status == "Charging" && total_power != 0) {
-      time_remaining = -(float)(total_energy_full - total_energy) / total_power;
-      if (time_remaining > 0.0f) {
-        // If we've turned positive it means the battery is past 100% and so
-        // just report that as no time remaining
-        time_remaining = 0.0f;
-      }
-    }
-    float capacity{0.0f};
-    if (total_energy_full > 0.0f) {
-      capacity = ((float)total_energy * 100.0f / (float)total_energy_full);
-    } else {
-      capacity = (float)total_capacity;
-    }
-    // Handle design-capacity
-    if (config_["design-capacity"].isBool() ? config_["design-capacity"].asBool() : false) {
-      capacity = ((float)total_energy * 100.0f / (float)total_energy_full_design);
+    int rate;
+    size_t size_rate = sizeof rate;
+    if (sysctlbyname("hw.acpi.battery.rate", &rate, &size_rate, NULL, 0) != 0) {
+      throw std::runtime_error("sysctl hw.acpi.battery.rate failed");
     }
+
+    auto status = getAdapterStatus(capacity);
     // Handle full-at
     if (config_["full-at"].isUInt()) {
       auto full_at = config_["full-at"].asUInt();
@@ -268,13 +213,319 @@ const std::tuple<uint8_t, float, std::string, float> waybar::modules::Battery::g
       capacity = 100.f;
     }
     uint8_t cap = round(capacity);
-    if (cap == 100 && status == "Charging") {
+    if (cap == 100 && status == "Plugged") {
       // If we've reached 100% just mark as full as some batteries can stay
       // stuck reporting they're still charging but not yet done
       status = "Full";
     }
 
+    // spdlog::info("{} {} {} {}", capacity,time,status,rate);
+    return {capacity, time / 60.0, status, rate};
+
+#elif defined(__linux__)
+    uint32_t total_power = 0;  // μW
+    bool total_power_exists = false;
+    uint32_t total_energy = 0;  // μWh
+    bool total_energy_exists = false;
+    uint32_t total_energy_full = 0;
+    bool total_energy_full_exists = false;
+    uint32_t total_energy_full_design = 0;
+    bool total_energy_full_design_exists = false;
+    uint32_t total_capacity = 0;
+    bool total_capacity_exists = false;
+
+    std::string status = "Unknown";
+    for (auto const& item : batteries_) {
+      auto bat = item.first;
+      std::string _status;
+      std::getline(std::ifstream(bat / "status"), _status);
+
+      // Some battery will report current and charge in μA/μAh.
+      // Scale these by the voltage to get μW/μWh.
+
+      uint32_t capacity = 0;
+      bool capacity_exists = false;
+      if (fs::exists(bat / "capacity")) {
+        capacity_exists = true;
+        std::ifstream(bat / "capacity") >> capacity;
+      }
+
+      uint32_t current_now = 0;
+      bool current_now_exists = false;
+      if (fs::exists(bat / "current_now")) {
+        current_now_exists = true;
+        std::ifstream(bat / "current_now") >> current_now;
+      } else if (fs::exists(bat / "current_avg")) {
+        current_now_exists = true;
+        std::ifstream(bat / "current_avg") >> current_now;
+      }
+
+      uint32_t voltage_now = 0;
+      bool voltage_now_exists = false;
+      if (fs::exists(bat / "voltage_now")) {
+        voltage_now_exists = true;
+        std::ifstream(bat / "voltage_now") >> voltage_now;
+      } else if (fs::exists(bat / "voltage_avg")) {
+        voltage_now_exists = true;
+        std::ifstream(bat / "voltage_avg") >> voltage_now;
+      }
+
+      uint32_t charge_full = 0;
+      bool charge_full_exists = false;
+      if (fs::exists(bat / "charge_full")) {
+        charge_full_exists = true;
+        std::ifstream(bat / "charge_full") >> charge_full;
+      }
+
+      uint32_t charge_full_design = 0;
+      bool charge_full_design_exists = false;
+      if (fs::exists(bat / "charge_full_design")) {
+        charge_full_design_exists = true;
+        std::ifstream(bat / "charge_full_design") >> charge_full_design;
+      }
+
+      uint32_t charge_now = 0;
+      bool charge_now_exists = false;
+      if (fs::exists(bat / "charge_now")) {
+        charge_now_exists = true;
+        std::ifstream(bat / "charge_now") >> charge_now;
+      }
+
+      uint32_t power_now = 0;
+      bool power_now_exists = false;
+      if (fs::exists(bat / "power_now")) {
+        power_now_exists = true;
+        std::ifstream(bat / "power_now") >> power_now;
+      }
+
+      uint32_t energy_now = 0;
+      bool energy_now_exists = false;
+      if (fs::exists(bat / "energy_now")) {
+        energy_now_exists = true;
+        std::ifstream(bat / "energy_now") >> energy_now;
+      }
+
+      uint32_t energy_full = 0;
+      bool energy_full_exists = false;
+      if (fs::exists(bat / "energy_full")) {
+        energy_full_exists = true;
+        std::ifstream(bat / "energy_full") >> energy_full;
+      }
+
+      uint32_t energy_full_design = 0;
+      bool energy_full_design_exists = false;
+      if (fs::exists(bat / "energy_full_design")) {
+        energy_full_design_exists = true;
+        std::ifstream(bat / "energy_full_design") >> energy_full_design;
+      }
+
+      if (!voltage_now_exists) {
+        if (power_now_exists && current_now_exists && current_now != 0) {
+          voltage_now_exists = true;
+          voltage_now = 1000000 * (uint64_t)power_now / (uint64_t)current_now;
+        } else if (energy_full_design_exists && charge_full_design_exists &&
+                   charge_full_design != 0) {
+          voltage_now_exists = true;
+          voltage_now = 1000000 * (uint64_t)energy_full_design / (uint64_t)charge_full_design;
+        } else if (energy_now_exists) {
+          if (charge_now_exists && charge_now != 0) {
+            voltage_now_exists = true;
+            voltage_now = 1000000 * (uint64_t)energy_now / (uint64_t)charge_now;
+          } else if (capacity_exists && charge_full_exists) {
+            charge_now_exists = true;
+            charge_now = (uint64_t)charge_full * (uint64_t)capacity / 100;
+            if (charge_full != 0 && capacity != 0) {
+              voltage_now_exists = true;
+              voltage_now =
+                  1000000 * (uint64_t)energy_now * 100 / (uint64_t)charge_full / (uint64_t)capacity;
+            }
+          }
+        } else if (energy_full_exists) {
+          if (charge_full_exists && charge_full != 0) {
+            voltage_now_exists = true;
+            voltage_now = 1000000 * (uint64_t)energy_full / (uint64_t)charge_full;
+          } else if (charge_now_exists && capacity_exists) {
+            if (capacity != 0) {
+              charge_full_exists = true;
+              charge_full = 100 * (uint64_t)charge_now / (uint64_t)capacity;
+            }
+            if (charge_now != 0) {
+              voltage_now_exists = true;
+              voltage_now =
+                  10000 * (uint64_t)energy_full * (uint64_t)capacity / (uint64_t)charge_now;
+            }
+          }
+        }
+      }
+
+      if (!capacity_exists) {
+        if (charge_now_exists && charge_full_exists && charge_full != 0) {
+          capacity_exists = true;
+          capacity = 100 * (uint64_t)charge_now / (uint64_t)charge_full;
+        } else if (energy_now_exists && energy_full_exists && energy_full != 0) {
+          capacity_exists = true;
+          capacity = 100 * (uint64_t)energy_now / (uint64_t)energy_full;
+        } else if (charge_now_exists && energy_full_exists && voltage_now_exists) {
+          if (!charge_full_exists && voltage_now != 0) {
+            charge_full_exists = true;
+            charge_full = 1000000 * (uint64_t)energy_full / (uint64_t)voltage_now;
+          }
+          if (energy_full != 0) {
+            capacity_exists = true;
+            capacity = (uint64_t)charge_now * (uint64_t)voltage_now / 10000 / (uint64_t)energy_full;
+          }
+        } else if (charge_full_exists && energy_now_exists && voltage_now_exists) {
+          if (!charge_now_exists && voltage_now != 0) {
+            charge_now_exists = true;
+            charge_now = 1000000 * (uint64_t)energy_now / (uint64_t)voltage_now;
+          }
+          if (voltage_now != 0 && charge_full != 0) {
+            capacity_exists = true;
+            capacity = 100 * 1000000 * (uint64_t)energy_now / (uint64_t)voltage_now /
+                       (uint64_t)charge_full;
+          }
+        }
+      }
+
+      if (!energy_now_exists && voltage_now_exists) {
+        if (charge_now_exists) {
+          energy_now_exists = true;
+          energy_now = (uint64_t)charge_now * (uint64_t)voltage_now / 1000000;
+        } else if (capacity_exists && charge_full_exists) {
+          charge_now_exists = true;
+          charge_now = (uint64_t)capacity * (uint64_t)charge_full / 100;
+          energy_now_exists = true;
+          energy_now =
+              (uint64_t)voltage_now * (uint64_t)capacity * (uint64_t)charge_full / 1000000 / 100;
+        } else if (capacity_exists && energy_full) {
+          if (voltage_now != 0) {
+            charge_full_exists = true;
+            charge_full = 1000000 * (uint64_t)energy_full / (uint64_t)voltage_now;
+            charge_now_exists = true;
+            charge_now = (uint64_t)capacity * 10000 * (uint64_t)energy_full / (uint64_t)voltage_now;
+          }
+          energy_now_exists = true;
+          energy_now = (uint64_t)capacity * (uint64_t)energy_full / 100;
+        }
+      }
+
+      if (!energy_full_exists && voltage_now_exists) {
+        if (charge_full_exists) {
+          energy_full_exists = true;
+          energy_full = (uint64_t)charge_full * (uint64_t)voltage_now / 1000000;
+        } else if (charge_now_exists && capacity_exists && capacity != 0) {
+          charge_full_exists = true;
+          charge_full = 100 * (uint64_t)charge_now / (uint64_t)capacity;
+          energy_full_exists = true;
+          energy_full = (uint64_t)charge_now * (uint64_t)voltage_now / (uint64_t)capacity / 10000;
+        } else if (capacity_exists && energy_now) {
+          if (voltage_now != 0) {
+            charge_now_exists = true;
+            charge_now = 1000000 * (uint64_t)energy_now / (uint64_t)voltage_now;
+          }
+          if (capacity != 0) {
+            energy_full_exists = true;
+            energy_full = 100 * (uint64_t)energy_now / (uint64_t)capacity;
+            if (voltage_now != 0) {
+              charge_full_exists = true;
+              charge_full =
+                  100 * 1000000 * (uint64_t)energy_now / (uint64_t)voltage_now / (uint64_t)capacity;
+            }
+          }
+        }
+      }
+
+      if (!power_now_exists && voltage_now_exists && current_now_exists) {
+        power_now_exists = true;
+        power_now = (uint64_t)voltage_now * (uint64_t)current_now / 1000000;
+      }
+
+      if (!energy_full_design_exists && voltage_now_exists && charge_full_design_exists) {
+        energy_full_design_exists = true;
+        energy_full_design = (uint64_t)voltage_now * (uint64_t)charge_full_design / 1000000;
+      }
+
+      // Show the "smallest" status among all batteries
+      if (status_gt(status, _status)) status = _status;
+
+      if (power_now_exists) {
+        total_power_exists = true;
+        total_power += power_now;
+      }
+      if (energy_now_exists) {
+        total_energy_exists = true;
+        total_energy += energy_now;
+      }
+      if (energy_full_exists) {
+        total_energy_full_exists = true;
+        total_energy_full += energy_full;
+      }
+      if (energy_full_design_exists) {
+        total_energy_full_design_exists = true;
+        total_energy_full_design += energy_full_design;
+      }
+      if (capacity_exists) {
+        total_capacity_exists = true;
+        total_capacity += capacity;
+      }
+    }
+
+    // Give `Plugged` higher priority over `Not charging`.
+    // So in a setting where TLP is used, `Plugged` is shown when the threshold is reached
+    if (!adapter_.empty() && (status == "Discharging" || status == "Not charging")) {
+      bool online;
+      std::string current_status;
+      std::ifstream(adapter_ / "online") >> online;
+      std::getline(std::ifstream(adapter_ / "status"), current_status);
+      if (online && current_status != "Discharging") status = "Plugged";
+    }
+
+    float time_remaining{0.0f};
+    if (status == "Discharging" && total_power_exists && total_energy_exists) {
+      if (total_power != 0) time_remaining = (float)total_energy / total_power;
+    } else if (status == "Charging" && total_energy_exists && total_energy_full_exists &&
+               total_power_exists) {
+      if (total_power != 0)
+        time_remaining = -(float)(total_energy_full - total_energy) / total_power;
+      // If we've turned positive it means the battery is past 100% and so just report that as no
+      // time remaining
+      if (time_remaining > 0.0f) time_remaining = 0.0f;
+    }
+
+    float calculated_capacity{0.0f};
+    if (total_capacity_exists) {
+      if (total_capacity > 0.0f)
+        calculated_capacity = (float)total_capacity / batteries_.size();
+      else if (total_energy_full_exists && total_energy_exists) {
+        if (total_energy_full > 0.0f)
+          calculated_capacity = ((float)total_energy * 100.0f / (float)total_energy_full);
+      }
+    }
+
+    // Handle design-capacity
+    if ((config_["design-capacity"].isBool() ? config_["design-capacity"].asBool() : false) &&
+        total_energy_exists && total_energy_full_design_exists) {
+      if (total_energy_full_design > 0.0f)
+        calculated_capacity = ((float)total_energy * 100.0f / (float)total_energy_full_design);
+    }
+
+    // Handle full-at
+    if (config_["full-at"].isUInt()) {
+      auto full_at = config_["full-at"].asUInt();
+      if (full_at < 100) calculated_capacity = 100.f * calculated_capacity / full_at;
+    }
+
+    // Handle it gracefully by clamping at 100%
+    // This can happen when the battery is calibrating and goes above 100%
+    if (calculated_capacity > 100.f) calculated_capacity = 100.f;
+
+    uint8_t cap = round(calculated_capacity);
+    // If we've reached 100% just mark as full as some batteries can stay stuck reporting they're
+    // still charging but not yet done
+    if (cap == 100 && status == "Charging") status = "Full";
+
     return {cap, time_remaining, status, total_power / 1e6};
+#endif
   } catch (const std::exception& e) {
     spdlog::error("Battery: {}", e.what());
     return {0, 0, "Unknown", 0};
@@ -282,13 +533,26 @@ const std::tuple<uint8_t, float, std::string, float> waybar::modules::Battery::g
 }
 
 const std::string waybar::modules::Battery::getAdapterStatus(uint8_t capacity) const {
+#if defined(__FreeBSD__)
+  int state;
+  size_t size_state = sizeof state;
+  if (sysctlbyname("hw.acpi.battery.state", &state, &size_state, NULL, 0) != 0) {
+    throw std::runtime_error("sysctl hw.acpi.battery.state failed");
+  }
+  bool online = state == 2;
+  std::string status{"Unknown"};  // TODO: add status in FreeBSD
+  {
+#else
   if (!adapter_.empty()) {
     bool online;
+    std::string status;
     std::ifstream(adapter_ / "online") >> online;
+    std::getline(std::ifstream(adapter_ / "status"), status);
+#endif
     if (capacity == 100) {
       return "Full";
     }
-    if (online) {
+    if (online && status != "Discharging") {
       return "Plugged";
     }
     return "Discharging";
@@ -308,14 +572,18 @@ const std::string waybar::modules::Battery::formatTimeRemaining(float hoursRemai
   if (config_["format-time"].isString()) {
     format = config_["format-time"].asString();
   }
-  return fmt::format(format, fmt::arg("H", full_hours), fmt::arg("M", minutes));
+  std::string zero_pad_minutes = fmt::format("{:02d}", minutes);
+  return fmt::format(format, fmt::arg("H", full_hours), fmt::arg("M", minutes),
+                     fmt::arg("m", zero_pad_minutes));
 }
 
 auto waybar::modules::Battery::update() -> void {
+#if defined(__linux__)
   if (batteries_.empty()) {
     event_box_.hide();
     return;
   }
+#endif
   auto [capacity, time_remaining, status, power] = getInfos();
   if (status == "Unknown") {
     status = getAdapterStatus(capacity);
@@ -346,7 +614,7 @@ auto waybar::modules::Battery::update() -> void {
       tooltip_format = config_["tooltip-format"].asString();
     }
     label_.set_tooltip_text(fmt::format(tooltip_format, fmt::arg("timeTo", tooltip_text_default),
-                                        fmt::arg("capacity", capacity),
+                                        fmt::arg("power", power), fmt::arg("capacity", capacity),
                                         fmt::arg("time", time_remaining_formatted)));
   }
   if (!old_status_.empty()) {

src/modules/bluetooth.cpp

@@ -101,6 +101,7 @@ waybar::modules::Bluetooth::Bluetooth(const std::string& id, const Json::Value&
     } else {
       spdlog::error("findCurController() failed: no bluetooth controller found");
     }
+    event_box_.hide();
     return;
   }
   findConnectedDevices(cur_controller_.path, connected_devices_);
@@ -152,11 +153,23 @@ auto waybar::modules::Bluetooth::update() -> void {
 #ifdef WANT_RFKILL
   if (rfkill_.getState()) state = "disabled";
 #endif
+  bool battery_available =
+      state == "connected" && cur_focussed_device_.battery_percentage.has_value();
+
+#ifdef WANT_RFKILL
+  // also adds enabled icon if icon for state is not defined
+  std::vector<std::string> states = {state, rfkill_.getState() ? "disabled" : "enabled"};
+  std::string icon = getIcon(0, states);
+#else
+  std::string icon = getIcon(0, state);
+#endif
+  std::string icon_label = icon;
+  std::string icon_tooltip = icon;
 
   if (!alt_) {
-    if (state == "connected" && cur_focussed_device_.battery_percentage.has_value() &&
-        config_["format-connected-battery"].isString()) {
+    if (battery_available && config_["format-connected-battery"].isString()) {
       format_ = config_["format-connected-battery"].asString();
+      icon_label = getIcon(cur_focussed_device_.battery_percentage.value_or(0));
     } else if (config_["format-" + state].isString()) {
       format_ = config_["format-" + state].asString();
     } else if (config_["format"].isString()) {
@@ -165,7 +178,10 @@ auto waybar::modules::Bluetooth::update() -> void {
       format_ = default_format_;
     }
   }
-  if (config_["tooltip-format-" + state].isString()) {
+  if (battery_available && config_["tooltip-format-connected-battery"].isString()) {
+    tooltip_format = config_["tooltip-format-connected-battery"].asString();
+    icon_tooltip = getIcon(cur_focussed_device_.battery_percentage.value_or(0));
+  } else if (config_["tooltip-format-" + state].isString()) {
     tooltip_format = config_["tooltip-format-" + state].asString();
   } else if (config_["tooltip-format"].isString()) {
     tooltip_format = config_["tooltip-format"].asString();
@@ -196,7 +212,7 @@ auto waybar::modules::Bluetooth::update() -> void {
       fmt::arg("controller_alias", cur_controller_.alias),
       fmt::arg("device_address", cur_focussed_device_.address),
       fmt::arg("device_address_type", cur_focussed_device_.address_type),
-      fmt::arg("device_alias", cur_focussed_device_.alias),
+      fmt::arg("device_alias", cur_focussed_device_.alias), fmt::arg("icon", icon_label),
       fmt::arg("device_battery_percentage", cur_focussed_device_.battery_percentage.value_or(0))));
 
   if (tooltipEnabled()) {
@@ -209,14 +225,18 @@ auto waybar::modules::Bluetooth::update() -> void {
         if ((tooltip_enumerate_connections_battery_ && dev.battery_percentage.has_value()) ||
             tooltip_enumerate_connections_) {
           ss << "\n";
-          std::string enumerate_format =
-              (tooltip_enumerate_connections_battery_ && dev.battery_percentage.has_value())
-                  ? config_["tooltip-format-enumerate-connected-battery"].asString()
-                  : config_["tooltip-format-enumerate-connected"].asString();
+          std::string enumerate_format;
+          std::string enumerate_icon;
+          if (tooltip_enumerate_connections_battery_ && dev.battery_percentage.has_value()) {
+            enumerate_format = config_["tooltip-format-enumerate-connected-battery"].asString();
+            enumerate_icon = getIcon(dev.battery_percentage.value_or(0));
+          } else {
+            enumerate_format = config_["tooltip-format-enumerate-connected"].asString();
+          }
           ss << fmt::format(
               enumerate_format, fmt::arg("device_address", dev.address),
               fmt::arg("device_address_type", dev.address_type),
-              fmt::arg("device_alias", dev.alias),
+              fmt::arg("device_alias", dev.alias), fmt::arg("icon", enumerate_icon),
               fmt::arg("device_battery_percentage", dev.battery_percentage.value_or(0)));
         }
       }
@@ -234,7 +254,7 @@ auto waybar::modules::Bluetooth::update() -> void {
         fmt::arg("controller_alias", cur_controller_.alias),
         fmt::arg("device_address", cur_focussed_device_.address),
         fmt::arg("device_address_type", cur_focussed_device_.address_type),
-        fmt::arg("device_alias", cur_focussed_device_.alias),
+        fmt::arg("device_alias", cur_focussed_device_.alias), fmt::arg("icon", icon_tooltip),
         fmt::arg("device_battery_percentage", cur_focussed_device_.battery_percentage.value_or(0)),
         fmt::arg("device_enumerate", device_enumerate_)));
   }

src/modules/clock.cpp

@@ -1,15 +1,10 @@
 #include "modules/clock.hpp"
 
+#include <fmt/chrono.h>
 #include <spdlog/spdlog.h>
 
-#include <iomanip>
-#if FMT_VERSION < 60000
-#include <fmt/time.h>
-#else
-#include <fmt/chrono.h>
-#endif
-
 #include <ctime>
+#include <iomanip>
 #include <sstream>
 #include <type_traits>
 
@@ -66,6 +61,13 @@ waybar::modules::Clock::Clock(const std::string& id, const Json::Value& config)
     }
   }
 
+  if (is_calendar_in_tooltip_) {
+    if (config_["on-scroll"][kCalendarPlaceholder].isInt()) {
+      calendar_shift_init_ =
+          date::months{config_["on-scroll"].get(kCalendarPlaceholder, 0).asInt()};
+    }
+  }
+
   if (config_["locale"].isString()) {
     locale_ = std::locale(config_["locale"].asString());
   } else {
@@ -94,8 +96,8 @@ bool waybar::modules::Clock::is_timezone_fixed() {
 auto waybar::modules::Clock::update() -> void {
   auto time_zone = current_timezone();
   auto now = std::chrono::system_clock::now();
-  waybar_time wtime = {locale_,
-                       date::make_zoned(time_zone, date::floor<std::chrono::seconds>(now))};
+  waybar_time wtime = {locale_, date::make_zoned(time_zone, date::floor<std::chrono::seconds>(now) +
+                                                                calendar_shift_)};
   std::string text = "";
   if (!is_timezone_fixed()) {
     // As date dep is not fully compatible, prefer fmt
@@ -109,14 +111,10 @@ auto waybar::modules::Clock::update() -> void {
 
   if (tooltipEnabled()) {
     if (config_["tooltip-format"].isString()) {
-      std::string calendar_lines = "";
-      std::string timezoned_time_lines = "";
-      if (is_calendar_in_tooltip_) {
-        calendar_lines = calendar_text(wtime);
-      }
-      if (is_timezoned_list_in_tooltip_) {
-        timezoned_time_lines = timezones_text(&now);
-      }
+      std::string calendar_lines{""};
+      std::string timezoned_time_lines{""};
+      if (is_calendar_in_tooltip_) calendar_lines = calendar_text(wtime);
+      if (is_timezoned_list_in_tooltip_) timezoned_time_lines = timezones_text(&now);
       auto tooltip_format = config_["tooltip-format"].asString();
       text =
           fmt::format(tooltip_format, wtime, fmt::arg(kCalendarPlaceholder.c_str(), calendar_lines),
@@ -136,20 +134,30 @@ bool waybar::modules::Clock::handleScroll(GdkEventScroll* e) {
   }
 
   auto dir = AModule::getScrollDir(e);
-  if (dir != SCROLL_DIR::UP && dir != SCROLL_DIR::DOWN) {
-    return true;
-  }
-  if (time_zones_.size() == 1) {
-    return true;
-  }
 
-  auto nr_zones = time_zones_.size();
-  if (dir == SCROLL_DIR::UP) {
-    size_t new_idx = current_time_zone_idx_ + 1;
-    current_time_zone_idx_ = new_idx == nr_zones ? 0 : new_idx;
+  // Shift calendar date
+  if (calendar_shift_init_.count() > 0) {
+    if (dir == SCROLL_DIR::UP)
+      calendar_shift_ += calendar_shift_init_;
+    else
+      calendar_shift_ -= calendar_shift_init_;
   } else {
-    current_time_zone_idx_ =
-        current_time_zone_idx_ == 0 ? nr_zones - 1 : current_time_zone_idx_ - 1;
+    // Change time zone
+    if (dir != SCROLL_DIR::UP && dir != SCROLL_DIR::DOWN) {
+      return true;
+    }
+    if (time_zones_.size() == 1) {
+      return true;
+    }
+
+    auto nr_zones = time_zones_.size();
+    if (dir == SCROLL_DIR::UP) {
+      size_t new_idx = current_time_zone_idx_ + 1;
+      current_time_zone_idx_ = new_idx == nr_zones ? 0 : new_idx;
+    } else {
+      current_time_zone_idx_ =
+          current_time_zone_idx_ == 0 ? nr_zones - 1 : current_time_zone_idx_ - 1;
+    }
   }
 
   update();
@@ -158,25 +166,27 @@ bool waybar::modules::Clock::handleScroll(GdkEventScroll* e) {
 
 auto waybar::modules::Clock::calendar_text(const waybar_time& wtime) -> std::string {
   const auto daypoint = date::floor<date::days>(wtime.ztime.get_local_time());
-  const auto ymd = date::year_month_day(daypoint);
-  if (cached_calendar_ymd_ == ymd) {
-    return cached_calendar_text_;
-  }
+  const auto ymd{date::year_month_day{daypoint}};
 
-  const date::year_month ym(ymd.year(), ymd.month());
-  const auto curr_day = ymd.day();
+  if (calendar_cached_ymd_ == ymd) return calendar_cached_text_;
+
+  const auto curr_day{(calendar_shift_init_.count() > 0 && calendar_shift_.count() != 0)
+                          ? date::day{0}
+                          : ymd.day()};
+  const date::year_month ym{ymd.year(), ymd.month()};
+  const auto week_format{config_["format-calendar-weekdays"].isString()
+                             ? config_["format-calendar-weekdays"].asString()
+                             : ""};
+  const auto wn_format{config_["format-calendar-weeks"].isString()
+                           ? config_["format-calendar-weeks"].asString()
+                           : ""};
 
   std::stringstream os;
 
   const auto first_dow = first_day_of_week();
   int ws{0};  // weeks-pos: side(1 - left, 2 - right)
-  int wn{0};  // weeknumber
+
   if (config_["calendar-weeks-pos"].isString()) {
-    wn = (date::sys_days{date::year_month_day{ym / 1}} -
-          date::sys_days{date::year_month_day{ymd.year() / 1 / 1}})
-                 .count() /
-             7 +
-         1;
     if (config_["calendar-weeks-pos"].asString() == "left") {
       ws = 1;
       // Add paddings before the header
@@ -187,15 +197,22 @@ auto waybar::modules::Clock::calendar_text(const waybar_time& wtime) -> std::str
   }
 
   weekdays_header(first_dow, os);
-  /* Print weeknumber on the left for the first row*/
-  if (ws == 1) {
-    print_iso_weeknum(os, wn);
-    os << ' ';
-    ++wn;
-  }
+
   // First week prefixed with spaces if needed.
   auto wd = date::weekday(ym / 1);
   auto empty_days = (wd - first_dow).count();
+  date::sys_days lwd{static_cast<date::sys_days>(ym / 1) + date::days{7 - empty_days}};
+
+  if (first_dow == date::Monday) {
+    lwd -= date::days{1};
+  }
+  /* Print weeknumber on the left for the first row*/
+  if (ws == 1) {
+    os << fmt::format(wn_format, lwd);
+    os << ' ';
+    lwd += date::weeks{1};
+  }
+
   if (empty_days > 0) {
     os << std::string(empty_days * 3 - 1, ' ');
   }
@@ -206,16 +223,16 @@ auto waybar::modules::Clock::calendar_text(const waybar_time& wtime) -> std::str
     } else if (unsigned(d) != 1) {
       if (ws == 2) {
         os << ' ';
-        print_iso_weeknum(os, wn);
-        ++wn;
+        os << fmt::format(wn_format, lwd);
+        lwd += date::weeks{1};
       }
 
       os << '\n';
 
       if (ws == 1) {
-        print_iso_weeknum(os, wn);
+        os << fmt::format(wn_format, lwd);
         os << ' ';
-        ++wn;
+        lwd += date::weeks{1};
       }
     }
     if (d == curr_day) {
@@ -234,14 +251,14 @@ auto waybar::modules::Clock::calendar_text(const waybar_time& wtime) -> std::str
       empty_days = 6 - (wd.c_encoding() - first_dow.c_encoding());
       if (empty_days > 0) {
         os << std::string(empty_days * 3 + 1, ' ');
-        print_iso_weeknum(os, wn);
+        os << fmt::format(wn_format, lwd);
       }
     }
   }
 
   auto result = os.str();
-  cached_calendar_ymd_ = ymd;
-  cached_calendar_text_ = result;
+  calendar_cached_ymd_ = ymd;
+  calendar_cached_text_ = result;
   return result;
 }
 
@@ -291,16 +308,6 @@ auto waybar::modules::Clock::timezones_text(std::chrono::system_clock::time_poin
   return os.str();
 }
 
-auto waybar::modules::Clock::print_iso_weeknum(std::ostream& os, int weeknum) -> void {
-  std::stringstream res;
-  res << std::setfill('0') << std::setw(2) << weeknum;
-
-  if (config_["format-calendar-weeks"].isString()) {
-    os << fmt::format(config_["format-calendar-weeks"].asString(), res.str());
-  } else
-    os << res.str();
-}
-
 #ifdef HAVE_LANGINFO_1STDAY
 template <auto fn>
 using deleter_from_fn = std::integral_constant<decltype(fn), fn>;

src/modules/custom.cpp

@@ -4,7 +4,12 @@
 
 waybar::modules::Custom::Custom(const std::string& name, const std::string& id,
                                 const Json::Value& config)
-    : ALabel(config, "custom-" + name, id, "{}"), name_(name), fp_(nullptr), pid_(-1) {
+    : ALabel(config, "custom-" + name, id, "{}"),
+      name_(name),
+      id_(id),
+      percentage_(0),
+      fp_(nullptr),
+      pid_(-1) {
   dp.emit();
   if (interval_.count() > 0) {
     delayWorker();
@@ -16,6 +21,7 @@ waybar::modules::Custom::Custom(const std::string& name, const std::string& id,
 waybar::modules::Custom::~Custom() {
   if (pid_ != -1) {
     killpg(pid_, SIGTERM);
+    waitpid(pid_, NULL, 0);
     pid_ = -1;
   }
 }
@@ -140,11 +146,14 @@ auto waybar::modules::Custom::update() -> void {
       }
       auto classes = label_.get_style_context()->list_classes();
       for (auto const& c : classes) {
+        if (c == id_) continue;
         label_.get_style_context()->remove_class(c);
       }
       for (auto const& c : class_) {
         label_.get_style_context()->add_class(c);
       }
+      label_.get_style_context()->add_class("flat");
+      label_.get_style_context()->add_class("text-button");
       event_box_.show();
     }
   }

src/modules/gamemode.cpp

@@ -109,7 +109,7 @@ Gamemode::Gamemode(const std::string& id, const Json::Value& config)
 }
 
 Gamemode::~Gamemode() {
-  if (gamemode_proxy) gamemode_proxy->unreference();
+  if (gamemode_proxy) gamemode_proxy.reset();
   if (gamemodeWatcher_id > 0) {
     Gio::DBus::unwatch_name(gamemodeWatcher_id);
     gamemodeWatcher_id = 0;

src/modules/hyprland/backend.cpp

@@ -0,0 +1,193 @@
+#include "modules/hyprland/backend.hpp"
+
+#include <ctype.h>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <spdlog/spdlog.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/un.h>
+#include <unistd.h>
+
+#include <fstream>
+#include <iostream>
+#include <string>
+
+namespace waybar::modules::hyprland {
+
+void IPC::startIPC() {
+  // will start IPC and relay events to parseIPC
+
+  std::thread([&]() {
+    // check for hyprland
+    const char* HIS = getenv("HYPRLAND_INSTANCE_SIGNATURE");
+
+    if (!HIS) {
+      spdlog::warn("Hyprland is not running, Hyprland IPC will not be available.");
+      return;
+    }
+
+    if (!modulesReady) return;
+
+    spdlog::info("Hyprland IPC starting");
+
+    struct sockaddr_un addr;
+    int socketfd = socket(AF_UNIX, SOCK_STREAM, 0);
+
+    if (socketfd == -1) {
+      spdlog::error("Hyprland IPC: socketfd failed");
+      return;
+    }
+
+    addr.sun_family = AF_UNIX;
+
+    // socket path
+    std::string socketPath = "/tmp/hypr/" + std::string(HIS) + "/.socket2.sock";
+
+    strncpy(addr.sun_path, socketPath.c_str(), sizeof(addr.sun_path) - 1);
+
+    addr.sun_path[sizeof(addr.sun_path) - 1] = 0;
+
+    int l = sizeof(struct sockaddr_un);
+
+    if (connect(socketfd, (struct sockaddr*)&addr, l) == -1) {
+      spdlog::error("Hyprland IPC: Unable to connect?");
+      return;
+    }
+
+    auto file = fdopen(socketfd, "r");
+
+    while (1) {
+      // read
+
+      char buffer[1024];  // Hyprland socket2 events are max 1024 bytes
+      auto recievedCharPtr = fgets(buffer, 1024, file);
+
+      if (!recievedCharPtr) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+        continue;
+      }
+
+      callbackMutex.lock();
+
+      std::string messageRecieved(buffer);
+
+      messageRecieved = messageRecieved.substr(0, messageRecieved.find_first_of('\n'));
+
+      spdlog::debug("hyprland IPC received {}", messageRecieved);
+
+      parseIPC(messageRecieved);
+
+      callbackMutex.unlock();
+
+      std::this_thread::sleep_for(std::chrono::milliseconds(1));
+    }
+  }).detach();
+}
+
+void IPC::parseIPC(const std::string& ev) {
+  // todo
+  std::string request = ev.substr(0, ev.find_first_of('>'));
+
+  for (auto& [eventname, handler] : callbacks) {
+    if (eventname == request) {
+      handler->onEvent(ev);
+    }
+  }
+}
+
+void IPC::registerForIPC(const std::string& ev, EventHandler* ev_handler) {
+  if (!ev_handler) {
+    return;
+  }
+  callbackMutex.lock();
+
+  callbacks.emplace_back(std::make_pair(ev, ev_handler));
+
+  callbackMutex.unlock();
+}
+
+void IPC::unregisterForIPC(EventHandler* ev_handler) {
+  if (!ev_handler) {
+    return;
+  }
+
+  callbackMutex.lock();
+
+  for (auto it = callbacks.begin(); it != callbacks.end();) {
+    auto it_current = it;
+    it++;
+    auto& [eventname, handler] = *it_current;
+    if (handler == ev_handler) {
+      callbacks.erase(it_current);
+    }
+  }
+
+  callbackMutex.unlock();
+}
+
+std::string IPC::getSocket1Reply(const std::string& rq) {
+  // basically hyprctl
+
+  const auto SERVERSOCKET = socket(AF_UNIX, SOCK_STREAM, 0);
+
+  if (SERVERSOCKET < 0) {
+    spdlog::error("Hyprland IPC: Couldn't open a socket (1)");
+    return "";
+  }
+
+  const auto SERVER = gethostbyname("localhost");
+
+  if (!SERVER) {
+    spdlog::error("Hyprland IPC: Couldn't get host (2)");
+    return "";
+  }
+
+  // get the instance signature
+  auto instanceSig = getenv("HYPRLAND_INSTANCE_SIGNATURE");
+
+  if (!instanceSig) {
+    spdlog::error("Hyprland IPC: HYPRLAND_INSTANCE_SIGNATURE was not set! (Is Hyprland running?)");
+    return "";
+  }
+
+  std::string instanceSigStr = std::string(instanceSig);
+
+  sockaddr_un serverAddress = {0};
+  serverAddress.sun_family = AF_UNIX;
+
+  std::string socketPath = "/tmp/hypr/" + instanceSigStr + "/.socket.sock";
+
+  strcpy(serverAddress.sun_path, socketPath.c_str());
+
+  if (connect(SERVERSOCKET, (sockaddr*)&serverAddress, SUN_LEN(&serverAddress)) < 0) {
+    spdlog::error("Hyprland IPC: Couldn't connect to " + socketPath + ". (3)");
+    return "";
+  }
+
+  auto sizeWritten = write(SERVERSOCKET, rq.c_str(), rq.length());
+
+  if (sizeWritten < 0) {
+    spdlog::error("Hyprland IPC: Couldn't write (4)");
+    return "";
+  }
+
+  char buffer[8192] = {0};
+
+  sizeWritten = read(SERVERSOCKET, buffer, 8192);
+
+  if (sizeWritten < 0) {
+    spdlog::error("Hyprland IPC: Couldn't read (5)");
+    return "";
+  }
+
+  close(SERVERSOCKET);
+
+  return std::string(buffer);
+}
+
+}  // namespace waybar::modules::hyprland

src/modules/hyprland/language.cpp

@@ -0,0 +1,129 @@
+#include "modules/hyprland/language.hpp"
+
+#include <spdlog/spdlog.h>
+#include <xkbcommon/xkbcommon.h>
+#include <xkbcommon/xkbregistry.h>
+
+#include <util/sanitize_str.hpp>
+
+#include "modules/hyprland/backend.hpp"
+
+namespace waybar::modules::hyprland {
+
+Language::Language(const std::string& id, const Bar& bar, const Json::Value& config)
+    : ALabel(config, "language", id, "{}", 0, true), bar_(bar) {
+  modulesReady = true;
+
+  if (!gIPC.get()) {
+    gIPC = std::make_unique<IPC>();
+  }
+
+  // get the active layout when open
+  initLanguage();
+
+  label_.hide();
+  ALabel::update();
+
+  // register for hyprland ipc
+  gIPC->registerForIPC("activelayout", this);
+}
+
+Language::~Language() {
+  gIPC->unregisterForIPC(this);
+  // wait for possible event handler to finish
+  std::lock_guard<std::mutex> lg(mutex_);
+}
+
+auto Language::update() -> void {
+  std::lock_guard<std::mutex> lg(mutex_);
+
+  if (!format_.empty()) {
+    label_.show();
+    label_.set_markup(layoutName_);
+  } else {
+    label_.hide();
+  }
+
+  ALabel::update();
+}
+
+void Language::onEvent(const std::string& ev) {
+  std::lock_guard<std::mutex> lg(mutex_);
+  auto layoutName = ev.substr(ev.find_last_of(',') + 1);
+  auto keebName = ev.substr(0, ev.find_last_of(','));
+  keebName = keebName.substr(keebName.find_first_of('>') + 2);
+
+  if (config_.isMember("keyboard-name") && keebName != config_["keyboard-name"].asString())
+    return;  // ignore
+
+  const auto BRIEFNAME = getShortFrom(layoutName);
+
+  if (config_.isMember("format-" + BRIEFNAME)) {
+    const auto PROPNAME = "format-" + BRIEFNAME;
+    layoutName = fmt::format(format_, config_[PROPNAME].asString());
+  } else {
+    layoutName = fmt::format(format_, layoutName);
+  }
+
+  layoutName = waybar::util::sanitize_string(layoutName);
+
+  if (layoutName == layoutName_) return;
+
+  layoutName_ = layoutName;
+
+  spdlog::debug("hyprland language onevent with {}", layoutName);
+
+  dp.emit();
+}
+
+void Language::initLanguage() {
+  const auto INPUTDEVICES = gIPC->getSocket1Reply("devices");
+
+  if (!config_.isMember("keyboard-name")) return;
+
+  const auto KEEBNAME = config_["keyboard-name"].asString();
+
+  try {
+    auto searcher = INPUTDEVICES.substr(INPUTDEVICES.find(KEEBNAME) + KEEBNAME.length());
+    searcher = searcher.substr(searcher.find("Keyboard at"));
+    searcher = searcher.substr(searcher.find("keymap:") + 7);
+    searcher = searcher.substr(0, searcher.find_first_of("\n\t"));
+
+    layoutName_ = searcher;
+
+    spdlog::debug("hyprland language initLanguage found {}", layoutName_);
+
+    dp.emit();
+
+  } catch (std::exception& e) {
+    spdlog::error("hyprland language initLanguage failed with {}", e.what());
+  }
+}
+
+std::string Language::getShortFrom(const std::string& fullName) {
+  const auto CONTEXT = rxkb_context_new(RXKB_CONTEXT_LOAD_EXOTIC_RULES);
+  rxkb_context_parse_default_ruleset(CONTEXT);
+
+  std::string foundName = "";
+  rxkb_layout* layout = rxkb_layout_first(CONTEXT);
+  while (layout) {
+    std::string nameOfLayout = rxkb_layout_get_description(layout);
+
+    if (nameOfLayout != fullName) {
+      layout = rxkb_layout_next(layout);
+      continue;
+    }
+
+    std::string briefName = rxkb_layout_get_brief(layout);
+
+    rxkb_context_unref(CONTEXT);
+
+    return briefName;
+  }
+
+  rxkb_context_unref(CONTEXT);
+
+  return "";
+}
+
+}  // namespace waybar::modules::hyprland

src/modules/hyprland/window.cpp

@@ -0,0 +1,100 @@
+#include "modules/hyprland/window.hpp"
+
+#include <spdlog/spdlog.h>
+
+#include <regex>
+#include <util/sanitize_str.hpp>
+
+#include "modules/hyprland/backend.hpp"
+#include "util/command.hpp"
+#include "util/json.hpp"
+#include "util/rewrite_title.hpp"
+
+namespace waybar::modules::hyprland {
+
+Window::Window(const std::string& id, const Bar& bar, const Json::Value& config)
+    : ALabel(config, "window", id, "{}", 0, true), bar_(bar) {
+  modulesReady = true;
+  separate_outputs = config["separate-outputs"].as<bool>();
+
+  if (!gIPC.get()) {
+    gIPC = std::make_unique<IPC>();
+  }
+
+  label_.hide();
+  ALabel::update();
+
+  // register for hyprland ipc
+  gIPC->registerForIPC("activewindow", this);
+}
+
+Window::~Window() {
+  gIPC->unregisterForIPC(this);
+  // wait for possible event handler to finish
+  std::lock_guard<std::mutex> lg(mutex_);
+}
+
+auto Window::update() -> void {
+  // fix ampersands
+  std::lock_guard<std::mutex> lg(mutex_);
+
+  if (!format_.empty()) {
+    label_.show();
+    label_.set_markup(
+        fmt::format(format_, waybar::util::rewriteTitle(lastView, config_["rewrite"])));
+  } else {
+    label_.hide();
+  }
+
+  ALabel::update();
+}
+
+int Window::getActiveWorkspaceID(std::string monitorName) {
+  auto cmd = waybar::util::command::exec("hyprctl monitors -j");
+  assert(cmd.exit_code == 0);
+  Json::Value json = parser_.parse(cmd.out);
+  assert(json.isArray());
+  auto monitor = std::find_if(json.begin(), json.end(),
+                              [&](Json::Value monitor) { return monitor["name"] == monitorName; });
+  if (monitor == std::end(json)) {
+    return 0;
+  }
+  return (*monitor)["activeWorkspace"]["id"].as<int>();
+}
+
+std::string Window::getLastWindowTitle(int workspaceID) {
+  auto cmd = waybar::util::command::exec("hyprctl workspaces -j");
+  assert(cmd.exit_code == 0);
+  Json::Value json = parser_.parse(cmd.out);
+  assert(json.isArray());
+  auto workspace = std::find_if(json.begin(), json.end(), [&](Json::Value workspace) {
+    return workspace["id"].as<int>() == workspaceID;
+  });
+
+  if (workspace == std::end(json)) {
+    return "";
+  }
+  return (*workspace)["lastwindowtitle"].as<std::string>();
+}
+
+void Window::onEvent(const std::string& ev) {
+  std::lock_guard<std::mutex> lg(mutex_);
+
+  std::string windowName;
+  if (separate_outputs) {
+    windowName = getLastWindowTitle(getActiveWorkspaceID(this->bar_.output->name));
+  } else {
+    windowName = ev.substr(ev.find_first_of(',') + 1).substr(0, 256);
+  }
+
+  windowName = waybar::util::sanitize_string(windowName);
+
+  if (windowName == lastView) return;
+
+  lastView = windowName;
+
+  spdlog::debug("hyprland window onevent with {}", windowName);
+
+  dp.emit();
+}
+}  // namespace waybar::modules::hyprland

src/modules/idle_inhibitor.cpp

@@ -8,7 +8,7 @@ bool waybar::modules::IdleInhibitor::status = false;
 
 waybar::modules::IdleInhibitor::IdleInhibitor(const std::string& id, const Bar& bar,
                                               const Json::Value& config)
-    : ALabel(config, "idle_inhibitor", id, "{status}"),
+    : ALabel(config, "idle_inhibitor", id, "{status}", 0, false, true),
       bar_(bar),
       idle_inhibitor_(nullptr),
       pid_(-1) {
@@ -16,6 +16,11 @@ waybar::modules::IdleInhibitor::IdleInhibitor(const std::string& id, const Bar&
     throw std::runtime_error("idle-inhibit not available");
   }
 
+  if (waybar::modules::IdleInhibitor::modules.empty() && config_["start-activated"].isBool() &&
+      config_["start-activated"].asBool() != status) {
+    toggleStatus();
+  }
+
   event_box_.add_events(Gdk::BUTTON_PRESS_MASK);
   event_box_.signal_button_press_event().connect(
       sigc::mem_fun(*this, &IdleInhibitor::handleToggle));
@@ -62,40 +67,54 @@ auto waybar::modules::IdleInhibitor::update() -> void {
                                 fmt::arg("icon", getIcon(0, status_text))));
   label_.get_style_context()->add_class(status_text);
   if (tooltipEnabled()) {
-    label_.set_tooltip_text(status_text);
+    label_.set_tooltip_markup(
+        status ? fmt::format(config_["tooltip-format-activated"].isString()
+                                 ? config_["tooltip-format-activated"].asString()
+                                 : "{status}",
+                             fmt::arg("status", status_text),
+                             fmt::arg("icon", getIcon(0, status_text)))
+               : fmt::format(config_["tooltip-format-deactivated"].isString()
+                                 ? config_["tooltip-format-deactivated"].asString()
+                                 : "{status}",
+                             fmt::arg("status", status_text),
+                             fmt::arg("icon", getIcon(0, status_text))));
   }
   // Call parent update
   ALabel::update();
 }
 
+void waybar::modules::IdleInhibitor::toggleStatus() {
+  status = !status;
+
+  if (timeout_.connected()) {
+    /* cancel any already active timeout handler */
+    timeout_.disconnect();
+  }
+
+  if (status && config_["timeout"].isNumeric()) {
+    auto timeoutMins = config_["timeout"].asDouble();
+    int timeoutSecs = timeoutMins * 60;
+
+    timeout_ = Glib::signal_timeout().connect_seconds(
+        []() {
+          /* intentionally not tied to a module instance lifetime
+           * as the output with `this` can be disconnected
+           */
+          spdlog::info("deactivating idle_inhibitor by timeout");
+          status = false;
+          for (auto const& module : waybar::modules::IdleInhibitor::modules) {
+            module->update();
+          }
+          /* disconnect */
+          return false;
+        },
+        timeoutSecs);
+  }
+}
+
 bool waybar::modules::IdleInhibitor::handleToggle(GdkEventButton* const& e) {
   if (e->button == 1) {
-    status = !status;
-
-    if (timeout_.connected()) {
-      /* cancel any already active timeout handler */
-      timeout_.disconnect();
-    }
-
-    if (status && config_["timeout"].isNumeric()) {
-      auto timeoutMins = config_["timeout"].asDouble();
-      int timeoutSecs = timeoutMins * 60;
-
-      timeout_ = Glib::signal_timeout().connect_seconds(
-          []() {
-            /* intentionally not tied to a module instance lifetime
-             * as the output with `this` can be disconnected
-             */
-            spdlog::info("deactivating idle_inhibitor by timeout");
-            status = false;
-            for (auto const& module : waybar::modules::IdleInhibitor::modules) {
-              module->update();
-            }
-            /* disconnect */
-            return false;
-          },
-          timeoutSecs);
-    }
+    toggleStatus();
 
     // Make all other idle inhibitor modules update
     for (auto const& module : waybar::modules::IdleInhibitor::modules) {

src/modules/jack.cpp

@@ -0,0 +1,126 @@
+#include "modules/jack.hpp"
+
+namespace waybar::modules {
+
+JACK::JACK(const std::string &id, const Json::Value &config)
+    : ALabel(config, "jack", id, "{load}%", 1) {
+  running_ = false;
+  client_ = NULL;
+
+  thread_ = [this] {
+    dp.emit();
+    thread_.sleep_for(interval_);
+  };
+}
+
+std::string JACK::JACKState() {
+  std::lock_guard<std::mutex> lock(mutex_);
+  if (running_) {
+    load_ = jack_cpu_load(client_);
+    return state_;
+  }
+
+  xruns_ = 0;
+  load_ = 0;
+  bufsize_ = 0;
+  samplerate_ = 0;
+
+  if (client_) {
+    jack_client_close(client_);
+    client_ = NULL;
+  }
+
+  client_ = jack_client_open("waybar", JackNoStartServer, NULL);
+  if (!client_) return "disconnected";
+
+  if (config_["realtime"].isBool() && !config_["realtime"].asBool()) {
+    pthread_t jack_thread = jack_client_thread_id(client_);
+    jack_drop_real_time_scheduling(jack_thread);
+  }
+
+  bufsize_ = jack_get_buffer_size(client_);
+  samplerate_ = jack_get_sample_rate(client_);
+  jack_set_sample_rate_callback(client_, sampleRateCallback, this);
+  jack_set_buffer_size_callback(client_, bufSizeCallback, this);
+  jack_set_xrun_callback(client_, xrunCallback, this);
+  jack_on_shutdown(client_, shutdownCallback, this);
+  if (jack_activate(client_)) return "disconnected";
+
+  running_ = true;
+  return "connected";
+}
+
+auto JACK::update() -> void {
+  std::string format;
+  std::string state = JACKState();
+  float latency = 1000 * (float)bufsize_ / (float)samplerate_;
+
+  if (label_.get_style_context()->has_class("xrun")) {
+    label_.get_style_context()->remove_class("xrun");
+    state = "connected";
+  }
+
+  if (label_.get_style_context()->has_class(state_))
+    label_.get_style_context()->remove_class(state_);
+  label_.get_style_context()->add_class(state);
+  state_ = state;
+
+  if (config_["format-" + state].isString()) {
+    format = config_["format-" + state].asString();
+  } else if (config_["format"].isString()) {
+    format = config_["format"].asString();
+  } else
+    format = "{load}%";
+
+  label_.set_markup(fmt::format(format, fmt::arg("load", std::round(load_)),
+                                fmt::arg("bufsize", bufsize_), fmt::arg("samplerate", samplerate_),
+                                fmt::arg("latency", fmt::format("{:.2f}", latency)),
+                                fmt::arg("xruns", xruns_)));
+
+  if (tooltipEnabled()) {
+    std::string tooltip_format = "{bufsize}/{samplerate} {latency}ms";
+    if (config_["tooltip-format"].isString()) tooltip_format = config_["tooltip-format"].asString();
+    label_.set_tooltip_text(fmt::format(
+        tooltip_format, fmt::arg("load", std::round(load_)), fmt::arg("bufsize", bufsize_),
+        fmt::arg("samplerate", samplerate_), fmt::arg("latency", fmt::format("{:.2f}", latency)),
+        fmt::arg("xruns", xruns_)));
+  }
+
+  // Call parent update
+  ALabel::update();
+}
+
+int JACK::bufSize(jack_nframes_t size) {
+  bufsize_ = size;
+  return 0;
+}
+
+int JACK::sampleRate(jack_nframes_t rate) {
+  samplerate_ = rate;
+  return 0;
+}
+
+int JACK::xrun() {
+  xruns_ += 1;
+  state_ = "xrun";
+  return 0;
+}
+
+void JACK::shutdown() {
+  std::lock_guard<std::mutex> lock(mutex_);
+  running_ = false;
+}
+
+}  // namespace waybar::modules
+
+int bufSizeCallback(jack_nframes_t size, void *obj) {
+  return static_cast<waybar::modules::JACK *>(obj)->bufSize(size);
+}
+
+int sampleRateCallback(jack_nframes_t rate, void *obj) {
+  return static_cast<waybar::modules::JACK *>(obj)->sampleRate(rate);
+}
+
+int xrunCallback(void *obj) { return static_cast<waybar::modules::JACK *>(obj)->xrun(); }
+
+void shutdownCallback(void *obj) { return static_cast<waybar::modules::JACK *>(obj)->shutdown(); }

src/modules/keyboard_state.cpp

@@ -8,8 +8,13 @@
 
 extern "C" {
 #include <fcntl.h>
+#include <libinput.h>
+#include <linux/input-event-codes.h>
+#include <poll.h>
+#include <sys/inotify.h>
 #include <sys/stat.h>
 #include <sys/types.h>
+#include <unistd.h>
 }
 
 class errno_error : public std::runtime_error {
@@ -99,8 +104,18 @@ waybar::modules::KeyboardState::KeyboardState(const std::string& id, const Bar&
       icon_unlocked_(config_["format-icons"]["unlocked"].isString()
                          ? config_["format-icons"]["unlocked"].asString()
                          : "unlocked"),
-      fd_(0),
-      dev_(nullptr) {
+      devices_path_("/dev/input/"),
+      libinput_(nullptr),
+      libinput_devices_({}) {
+  static struct libinput_interface interface = {
+      [](const char* path, int flags, void* user_data) { return open(path, flags); },
+      [](int fd, void* user_data) { close(fd); }};
+  if (config_["interval"].isUInt()) {
+    spdlog::warn("keyboard-state: interval is deprecated");
+  }
+
+  libinput_ = libinput_path_create_context(&interface, NULL);
+
   box_.set_name("keyboard-state");
   if (config_["numlock"].asBool()) {
     numlock_label_.get_style_context()->add_class("numlock");
@@ -121,70 +136,135 @@ waybar::modules::KeyboardState::KeyboardState(const std::string& id, const Bar&
 
   if (config_["device-path"].isString()) {
     std::string dev_path = config_["device-path"].asString();
-    fd_ = openFile(dev_path, O_NONBLOCK | O_CLOEXEC | O_RDONLY);
-    dev_ = openDevice(fd_);
-  } else {
-    DIR* dev_dir = opendir("/dev/input");
-    if (dev_dir == nullptr) {
-      throw errno_error(errno, "Failed to open /dev/input");
-    }
-    dirent* ep;
-    while ((ep = readdir(dev_dir))) {
-      if (ep->d_type != DT_CHR) continue;
-      std::string dev_path = std::string("/dev/input/") + ep->d_name;
-      int fd = openFile(dev_path.c_str(), O_NONBLOCK | O_CLOEXEC | O_RDONLY);
-      try {
-        auto dev = openDevice(fd);
-        if (supportsLockStates(dev)) {
-          spdlog::info("Found device {} at '{}'", libevdev_get_name(dev), dev_path);
-          fd_ = fd;
-          dev_ = dev;
-          break;
-        }
-      } catch (const errno_error& e) {
-        // ENOTTY just means the device isn't an evdev device, skip it
-        if (e.code != ENOTTY) {
-          spdlog::warn(e.what());
-        }
-      }
-      closeFile(fd);
-    }
-    if (dev_ == nullptr) {
-      throw errno_error(errno, "Failed to find keyboard device");
+    tryAddDevice(dev_path);
+    if (libinput_devices_.empty()) {
+      spdlog::error("keyboard-state: Cannot find device {}", dev_path);
     }
   }
 
-  thread_ = [this] {
+  DIR* dev_dir = opendir(devices_path_.c_str());
+  if (dev_dir == nullptr) {
+    throw errno_error(errno, "Failed to open " + devices_path_);
+  }
+  dirent* ep;
+  while ((ep = readdir(dev_dir))) {
+    if (ep->d_type == DT_DIR) continue;
+    std::string dev_path = devices_path_ + ep->d_name;
+    tryAddDevice(dev_path);
+  }
+
+  if (libinput_devices_.empty()) {
+    throw errno_error(errno, "Failed to find keyboard device");
+  }
+
+  libinput_thread_ = [this] {
     dp.emit();
-    thread_.sleep_for(interval_);
+    while (1) {
+      struct pollfd fd = {libinput_get_fd(libinput_), POLLIN, 0};
+      poll(&fd, 1, -1);
+      libinput_dispatch(libinput_);
+      struct libinput_event* event;
+      while ((event = libinput_get_event(libinput_))) {
+        auto type = libinput_event_get_type(event);
+        if (type == LIBINPUT_EVENT_KEYBOARD_KEY) {
+          auto keyboard_event = libinput_event_get_keyboard_event(event);
+          auto state = libinput_event_keyboard_get_key_state(keyboard_event);
+          if (state == LIBINPUT_KEY_STATE_RELEASED) {
+            uint32_t key = libinput_event_keyboard_get_key(keyboard_event);
+            switch (key) {
+              case KEY_CAPSLOCK:
+              case KEY_NUMLOCK:
+              case KEY_SCROLLLOCK:
+                dp.emit();
+                break;
+              default:
+                break;
+            }
+          }
+        }
+        libinput_event_destroy(event);
+      }
+    }
+  };
+
+  hotplug_thread_ = [this] {
+    int fd;
+    fd = inotify_init();
+    if (fd < 0) {
+      spdlog::error("Failed to initialize inotify: {}", strerror(errno));
+      return;
+    }
+    inotify_add_watch(fd, devices_path_.c_str(), IN_CREATE | IN_DELETE);
+    while (1) {
+      int BUF_LEN = 1024 * (sizeof(struct inotify_event) + 16);
+      char buf[BUF_LEN];
+      int length = read(fd, buf, 1024);
+      if (length < 0) {
+        spdlog::error("Failed to read inotify: {}", strerror(errno));
+        return;
+      }
+      for (int i = 0; i < length;) {
+        struct inotify_event* event = (struct inotify_event*)&buf[i];
+        std::string dev_path = devices_path_ + event->name;
+        if (event->mask & IN_CREATE) {
+          // Wait for device setup
+          int timeout = 10;
+          while (timeout--) {
+            try {
+              int fd = openFile(dev_path, O_NONBLOCK | O_CLOEXEC | O_RDONLY);
+              closeFile(fd);
+              break;
+            } catch (const errno_error& e) {
+              if (e.code == EACCES) {
+                sleep(1);
+              }
+            }
+          }
+          tryAddDevice(dev_path);
+        } else if (event->mask & IN_DELETE) {
+          auto it = libinput_devices_.find(dev_path);
+          if (it != libinput_devices_.end()) {
+            spdlog::info("Keyboard {} has been removed.", dev_path);
+            libinput_devices_.erase(it);
+          }
+        }
+        i += sizeof(struct inotify_event) + event->len;
+      }
+    }
   };
 }
 
 waybar::modules::KeyboardState::~KeyboardState() {
-  libevdev_free(dev_);
-  try {
-    closeFile(fd_);
-  } catch (const std::runtime_error& e) {
-    spdlog::warn(e.what());
+  for (const auto& [_, dev_ptr] : libinput_devices_) {
+    libinput_path_remove_device(dev_ptr);
   }
 }
 
 auto waybar::modules::KeyboardState::update() -> void {
-  int err = LIBEVDEV_READ_STATUS_SUCCESS;
-  while (err == LIBEVDEV_READ_STATUS_SUCCESS) {
-    input_event ev;
-    err = libevdev_next_event(dev_, LIBEVDEV_READ_FLAG_NORMAL, &ev);
-    while (err == LIBEVDEV_READ_STATUS_SYNC) {
-      err = libevdev_next_event(dev_, LIBEVDEV_READ_FLAG_SYNC, &ev);
+  sleep(0);  // Wait for keyboard status change
+  int numl = 0, capsl = 0, scrolll = 0;
+
+  try {
+    std::string dev_path;
+    if (config_["device-path"].isString() &&
+        libinput_devices_.find(config_["device-path"].asString()) != libinput_devices_.end()) {
+      dev_path = config_["device-path"].asString();
+    } else {
+      dev_path = libinput_devices_.begin()->first;
+    }
+    int fd = openFile(dev_path, O_NONBLOCK | O_CLOEXEC | O_RDONLY);
+    auto dev = openDevice(fd);
+    numl = libevdev_get_event_value(dev, EV_LED, LED_NUML);
+    capsl = libevdev_get_event_value(dev, EV_LED, LED_CAPSL);
+    scrolll = libevdev_get_event_value(dev, EV_LED, LED_SCROLLL);
+    libevdev_free(dev);
+    closeFile(fd);
+  } catch (const errno_error& e) {
+    // ENOTTY just means the device isn't an evdev device, skip it
+    if (e.code != ENOTTY) {
+      spdlog::warn(e.what());
     }
   }
-  if (-err != EAGAIN) {
-    throw errno_error(-err, "Failed to sync evdev device");
-  }
-
-  int numl = libevdev_get_event_value(dev_, EV_LED, LED_NUML);
-  int capsl = libevdev_get_event_value(dev_, EV_LED, LED_CAPSL);
-  int scrolll = libevdev_get_event_value(dev_, EV_LED, LED_SCROLLL);
 
   struct {
     bool state;
@@ -211,3 +291,25 @@ auto waybar::modules::KeyboardState::update() -> void {
 
   AModule::update();
 }
+
+auto waybar::modules ::KeyboardState::tryAddDevice(const std::string& dev_path) -> void {
+  try {
+    int fd = openFile(dev_path, O_NONBLOCK | O_CLOEXEC | O_RDONLY);
+    auto dev = openDevice(fd);
+    if (supportsLockStates(dev)) {
+      spdlog::info("Found device {} at '{}'", libevdev_get_name(dev), dev_path);
+      if (libinput_devices_.find(dev_path) == libinput_devices_.end()) {
+        auto device = libinput_path_add_device(libinput_, dev_path.c_str());
+        libinput_device_ref(device);
+        libinput_devices_[dev_path] = device;
+      }
+    }
+    libevdev_free(dev);
+    closeFile(fd);
+  } catch (const errno_error& e) {
+    // ENOTTY just means the device isn't an evdev device, skip it
+    if (e.code != ENOTTY) {
+      spdlog::warn(e.what());
+    }
+  }
+}

src/modules/memory/common.cpp

@@ -31,17 +31,18 @@ auto waybar::modules::Memory::update() -> void {
   }
 
   if (memtotal > 0 && memfree >= 0) {
-    auto total_ram_gigabytes = memtotal / std::pow(1024, 2);
-    auto total_swap_gigabytes = swaptotal / std::pow(1024, 2);
+    float total_ram_gigabytes =
+        0.01 * round(memtotal / 10485.76);  // 100*10485.76 = 2^20 = 1024^2 = GiB/KiB
+    float total_swap_gigabytes = 0.01 * round(swaptotal / 10485.76);
     int used_ram_percentage = 100 * (memtotal - memfree) / memtotal;
     int used_swap_percentage = 0;
     if (swaptotal && swapfree) {
       used_swap_percentage = 100 * (swaptotal - swapfree) / swaptotal;
     }
-    auto used_ram_gigabytes = (memtotal - memfree) / std::pow(1024, 2);
-    auto used_swap_gigabytes = (swaptotal - swapfree) / std::pow(1024, 2);
-    auto available_ram_gigabytes = memfree / std::pow(1024, 2);
-    auto available_swap_gigabytes = swapfree / std::pow(1024, 2);
+    float used_ram_gigabytes = 0.01 * round((memtotal - memfree) / 10485.76);
+    float used_swap_gigabytes = 0.01 * round((swaptotal - swapfree) / 10485.76);
+    float available_ram_gigabytes = 0.01 * round(memfree / 10485.76);
+    float available_swap_gigabytes = 0.01 * round(swapfree / 10485.76);
 
     auto format = format_;
     auto state = getState(used_ram_percentage);

src/modules/mpd/mpd.cpp

@@ -4,6 +4,9 @@
 #include <glibmm/ustring.h>
 #include <spdlog/spdlog.h>
 
+#include <util/sanitize_str.hpp>
+using namespace waybar::util;
+
 #include "modules/mpd/state.hpp"
 #if defined(MPD_NOINLINE)
 namespace waybar::modules {
@@ -12,7 +15,7 @@ namespace waybar::modules {
 #endif
 
 waybar::modules::MPD::MPD(const std::string& id, const Json::Value& config)
-    : ALabel(config, "mpd", id, "{album} - {artist} - {title}", 5),
+    : ALabel(config, "mpd", id, "{album} - {artist} - {title}", 5, false, true),
       module_name_(id.empty() ? "mpd" : "mpd#" + id),
       server_(nullptr),
       port_(config_["port"].isUInt() ? config["port"].asUInt() : 0),
@@ -73,6 +76,16 @@ std::string waybar::modules::MPD::getTag(mpd_tag_type type, unsigned idx) const
   return result;
 }
 
+std::string waybar::modules::MPD::getFilename() const {
+  std::string path = mpd_song_get_uri(song_.get());
+  size_t position = path.find_last_of("/");
+  if (position == std::string::npos) {
+    return path;
+  } else {
+    return path.substr(position + 1);
+  }
+}
+
 void waybar::modules::MPD::setLabel() {
   if (connection_ == nullptr) {
     label_.get_style_context()->add_class("disconnected");
@@ -100,7 +113,7 @@ void waybar::modules::MPD::setLabel() {
 
   auto format = format_;
   Glib::ustring artist, album_artist, album, title;
-  std::string date;
+  std::string date, filename;
   int song_pos = 0, queue_length = 0, volume = 0;
   std::chrono::seconds elapsedTime, totalTime;
 
@@ -125,11 +138,12 @@ void waybar::modules::MPD::setLabel() {
 
     stateIcon = getStateIcon();
 
-    artist = getTag(MPD_TAG_ARTIST);
-    album_artist = getTag(MPD_TAG_ALBUM_ARTIST);
-    album = getTag(MPD_TAG_ALBUM);
-    title = getTag(MPD_TAG_TITLE);
-    date = getTag(MPD_TAG_DATE);
+    artist = sanitize_string(getTag(MPD_TAG_ARTIST));
+    album_artist = sanitize_string(getTag(MPD_TAG_ALBUM_ARTIST));
+    album = sanitize_string(getTag(MPD_TAG_ALBUM));
+    title = sanitize_string(getTag(MPD_TAG_TITLE));
+    date = sanitize_string(getTag(MPD_TAG_DATE));
+    filename = sanitize_string(getFilename());
     song_pos = mpd_status_get_song_pos(status_.get()) + 1;
     volume = mpd_status_get_volume(status_.get());
     if (volume < 0) {
@@ -155,17 +169,15 @@ void waybar::modules::MPD::setLabel() {
   if (config_["title-len"].isInt()) title = title.substr(0, config_["title-len"].asInt());
 
   try {
-    label_.set_markup(
-        fmt::format(format, fmt::arg("artist", Glib::Markup::escape_text(artist).raw()),
-                    fmt::arg("albumArtist", Glib::Markup::escape_text(album_artist).raw()),
-                    fmt::arg("album", Glib::Markup::escape_text(album).raw()),
-                    fmt::arg("title", Glib::Markup::escape_text(title).raw()),
-                    fmt::arg("date", Glib::Markup::escape_text(date).raw()),
-                    fmt::arg("volume", volume), fmt::arg("elapsedTime", elapsedTime),
-                    fmt::arg("totalTime", totalTime), fmt::arg("songPosition", song_pos),
-                    fmt::arg("queueLength", queue_length), fmt::arg("stateIcon", stateIcon),
-                    fmt::arg("consumeIcon", consumeIcon), fmt::arg("randomIcon", randomIcon),
-                    fmt::arg("repeatIcon", repeatIcon), fmt::arg("singleIcon", singleIcon)));
+    label_.set_markup(fmt::format(
+        format, fmt::arg("artist", artist.raw()), fmt::arg("albumArtist", album_artist.raw()),
+        fmt::arg("album", album.raw()), fmt::arg("title", title.raw()), fmt::arg("date", date),
+        fmt::arg("volume", volume), fmt::arg("elapsedTime", elapsedTime),
+        fmt::arg("totalTime", totalTime), fmt::arg("songPosition", song_pos),
+        fmt::arg("queueLength", queue_length), fmt::arg("stateIcon", stateIcon),
+        fmt::arg("consumeIcon", consumeIcon), fmt::arg("randomIcon", randomIcon),
+        fmt::arg("repeatIcon", repeatIcon), fmt::arg("singleIcon", singleIcon),
+        fmt::arg("filename", filename)));
   } catch (fmt::format_error const& e) {
     spdlog::warn("mpd: format error: {}", e.what());
   }

src/modules/mpd/state.cpp

@@ -10,6 +10,13 @@ namespace waybar::modules {
 }  // namespace waybar::modules
 #endif
 
+#if FMT_VERSION >= 90000
+/* Satisfy fmt 9.x deprecation of implicit conversion of enums to int */
+auto format_as(enum mpd_idle val) {
+  return static_cast<std::underlying_type_t<enum mpd_idle>>(val);
+}
+#endif
+
 namespace waybar::modules::detail {
 
 #define IDLE_RUN_NOIDLE_AND_CMD(...)                                      \

src/modules/network.cpp

@@ -95,7 +95,7 @@ waybar::modules::Network::Network(const std::string &id, const Json::Value &conf
 #endif
       frequency_(0.0) {
 
-  // Start with some "text" in the module's label_, update() will then
+  // Start with some "text" in the module's label_. update() will then
   // update it. Since the text should be different, update() will be able
   // to show or hide the event_box_. This is to work around the case where
   // the module start with no text, but the the event_box_ is shown.
@@ -339,10 +339,16 @@ auto waybar::modules::Network::update() -> void {
       fmt::arg("icon", getIcon(signal_strength_, state_)),
       fmt::arg("bandwidthDownBits", pow_format(bandwidth_down * 8ull / interval_.count(), "b/s")),
       fmt::arg("bandwidthUpBits", pow_format(bandwidth_up * 8ull / interval_.count(), "b/s")),
+      fmt::arg("bandwidthTotalBits",
+               pow_format((bandwidth_up + bandwidth_down) * 8ull / interval_.count(), "b/s")),
       fmt::arg("bandwidthDownOctets", pow_format(bandwidth_down / interval_.count(), "o/s")),
       fmt::arg("bandwidthUpOctets", pow_format(bandwidth_up / interval_.count(), "o/s")),
+      fmt::arg("bandwidthTotalOctets",
+               pow_format((bandwidth_up + bandwidth_down) / interval_.count(), "o/s")),
       fmt::arg("bandwidthDownBytes", pow_format(bandwidth_down / interval_.count(), "B/s")),
-      fmt::arg("bandwidthUpBytes", pow_format(bandwidth_up / interval_.count(), "B/s")));
+      fmt::arg("bandwidthUpBytes", pow_format(bandwidth_up / interval_.count(), "B/s")),
+      fmt::arg("bandwidthTotalBytes",
+               pow_format((bandwidth_up + bandwidth_down) / interval_.count(), "B/s")));
   if (text.compare(label_.get_label()) != 0) {
     label_.set_markup(text);
     if (text.empty()) {
@@ -366,15 +372,21 @@ auto waybar::modules::Network::update() -> void {
           fmt::arg("bandwidthDownBits",
                    pow_format(bandwidth_down * 8ull / interval_.count(), "b/s")),
           fmt::arg("bandwidthUpBits", pow_format(bandwidth_up * 8ull / interval_.count(), "b/s")),
+          fmt::arg("bandwidthTotalBits",
+                   pow_format((bandwidth_up + bandwidth_down) * 8ull / interval_.count(), "b/s")),
           fmt::arg("bandwidthDownOctets", pow_format(bandwidth_down / interval_.count(), "o/s")),
           fmt::arg("bandwidthUpOctets", pow_format(bandwidth_up / interval_.count(), "o/s")),
+          fmt::arg("bandwidthTotalOctets",
+                   pow_format((bandwidth_up + bandwidth_down) / interval_.count(), "o/s")),
           fmt::arg("bandwidthDownBytes", pow_format(bandwidth_down / interval_.count(), "B/s")),
-          fmt::arg("bandwidthUpBytes", pow_format(bandwidth_up / interval_.count(), "B/s")));
+          fmt::arg("bandwidthUpBytes", pow_format(bandwidth_up / interval_.count(), "B/s")),
+          fmt::arg("bandwidthTotalBytes",
+                   pow_format((bandwidth_up + bandwidth_down) / interval_.count(), "B/s")));
       if (label_.get_tooltip_text() != tooltip_text) {
-        label_.set_tooltip_text(tooltip_text);
+        label_.set_tooltip_markup(tooltip_text);
       }
     } else if (label_.get_tooltip_text() != text) {
-      label_.set_tooltip_text(text);
+      label_.set_tooltip_markup(text);
     }
   }
 
@@ -634,7 +646,12 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
       if (has_gateway && !has_destination && temp_idx != -1) {
         // Check if this is the first default route we see, or if this new
         // route have a higher priority.
-        if (!is_del_event && ((net->ifid_ == -1) || (priority < net->route_priority))) {
+        /** Module doesn`t update state, because RTA_GATEWAY call before enable new router and set
+        higher priority. Disable router -> RTA_GATEWAY -> up new router -> set higher priority added
+        checking route id
+        **/
+        if (!is_del_event &&
+            ((net->ifid_ == -1) || (priority < net->route_priority) || (net->ifid_ != temp_idx))) {
           // Clear if's state for the case were there is a higher priority
           // route on a different interface.
           net->clearIface();

src/modules/pulseaudio.cpp

@@ -36,6 +36,7 @@ waybar::modules::Pulseaudio::Pulseaudio(const std::string &id, const Json::Value
 }
 
 waybar::modules::Pulseaudio::~Pulseaudio() {
+  pa_context_disconnect(context_);
   mainloop_api_->quit(mainloop_api_, 0);
   pa_threaded_mainloop_stop(mainloop_);
   pa_threaded_mainloop_free(mainloop_);
@@ -90,16 +91,32 @@ bool waybar::modules::Pulseaudio::handleScroll(GdkEventScroll *e) {
   double volume_tick = static_cast<double>(PA_VOLUME_NORM) / 100;
   pa_volume_t change = volume_tick;
   pa_cvolume pa_volume = pa_volume_;
+  int max_volume = 100;
+  double step = 1;
   // isDouble returns true for integers as well, just in case
   if (config_["scroll-step"].isDouble()) {
-    change = round(config_["scroll-step"].asDouble() * volume_tick);
+    step = config_["scroll-step"].asDouble();
   }
+  if (config_["max-volume"].isInt()) {
+    max_volume = std::min(config_["max-volume"].asInt(), static_cast<int>(PA_VOLUME_UI_MAX));
+  }
+
   if (dir == SCROLL_DIR::UP) {
-    if (volume_ + 1 <= 100) {
+    if (volume_ < max_volume) {
+      if (volume_ + step > max_volume) {
+        change = round((max_volume - volume_) * volume_tick);
+      } else {
+        change = round(step * volume_tick);
+      }
       pa_cvolume_inc(&pa_volume, change);
     }
   } else if (dir == SCROLL_DIR::DOWN) {
-    if (volume_ - 1 >= 0) {
+    if (volume_ > 0) {
+      if (volume_ - step < 0) {
+        change = round(volume_ * volume_tick);
+      } else {
+        change = round(step * volume_tick);
+      }
       pa_cvolume_dec(&pa_volume, change);
     }
   }
@@ -166,6 +183,15 @@ void waybar::modules::Pulseaudio::sinkInfoCb(pa_context * /*context*/, const pa_
   if (i == nullptr) return;
 
   auto pa = static_cast<waybar::modules::Pulseaudio *>(data);
+
+  if (pa->config_["ignored-sinks"].isArray()) {
+    for (const auto &ignored_sink : pa->config_["ignored-sinks"]) {
+      if (ignored_sink.asString() == i->description) {
+        return;
+      }
+    }
+  }
+
   if (pa->current_sink_name_ == i->name) {
     if (i->state != PA_SINK_RUNNING) {
       pa->current_sink_running_ = false;
@@ -190,6 +216,8 @@ void waybar::modules::Pulseaudio::sinkInfoCb(pa_context * /*context*/, const pa_
     pa->port_name_ = i->active_port != nullptr ? i->active_port->name : "Unknown";
     if (auto ff = pa_proplist_gets(i->proplist, PA_PROP_DEVICE_FORM_FACTOR)) {
       pa->form_factor_ = ff;
+    } else {
+      pa->form_factor_ = "";
     }
     pa->dp.emit();
   }
@@ -232,7 +260,8 @@ auto waybar::modules::Pulseaudio::update() -> void {
   if (!alt_) {
     std::string format_name = "format";
     if (monitor_.find("a2dp_sink") != std::string::npos ||  // PulseAudio
-        monitor_.find("a2dp-sink") != std::string::npos) {  // PipeWire
+        monitor_.find("a2dp-sink") != std::string::npos ||  // PipeWire
+        monitor_.find("bluez") != std::string::npos) {
       format_name = format_name + "-bluetooth";
       label_.get_style_context()->add_class("bluetooth");
     } else {

src/modules/river/mode.cpp

@@ -0,0 +1,114 @@
+#include "modules/river/mode.hpp"
+
+#include <spdlog/spdlog.h>
+#include <wayland-client.h>
+
+#include "client.hpp"
+
+namespace waybar::modules::river {
+
+static void listen_focused_output(void *data, struct zriver_seat_status_v1 *seat_status,
+                                  struct wl_output *output) {
+  // Intentionally empty
+}
+
+static void listen_unfocused_output(void *data, struct zriver_seat_status_v1 *seat_status,
+                                    struct wl_output *output) {
+  // Intentionally empty
+}
+
+static void listen_focused_view(void *data, struct zriver_seat_status_v1 *seat_status,
+                                const char *title) {
+  // Intentionally empty
+}
+
+static void listen_mode(void *data, struct zriver_seat_status_v1 *seat_status, const char *mode) {
+  static_cast<Mode *>(data)->handle_mode(mode);
+}
+
+static const zriver_seat_status_v1_listener seat_status_listener_impl = {
+    .focused_output = listen_focused_output,
+    .unfocused_output = listen_unfocused_output,
+    .focused_view = listen_focused_view,
+    .mode = listen_mode,
+};
+
+static void handle_global(void *data, struct wl_registry *registry, uint32_t name,
+                          const char *interface, uint32_t version) {
+  if (std::strcmp(interface, zriver_status_manager_v1_interface.name) == 0) {
+    version = std::min<uint32_t>(version, 3);
+    if (version < ZRIVER_SEAT_STATUS_V1_MODE_SINCE_VERSION) {
+      spdlog::error(
+          "river server does not support the \"mode\" event; the module will be disabled");
+      return;
+    }
+    static_cast<Mode *>(data)->status_manager_ = static_cast<struct zriver_status_manager_v1 *>(
+        wl_registry_bind(registry, name, &zriver_status_manager_v1_interface, version));
+  } else if (std::strcmp(interface, wl_seat_interface.name) == 0) {
+    version = std::min<uint32_t>(version, 1);
+    static_cast<Mode *>(data)->seat_ = static_cast<struct wl_seat *>(
+        wl_registry_bind(registry, name, &wl_seat_interface, version));
+  }
+}
+
+static void handle_global_remove(void *data, struct wl_registry *registry, uint32_t name) {
+  // Nobody cares
+}
+
+static const wl_registry_listener registry_listener_impl = {.global = handle_global,
+                                                            .global_remove = handle_global_remove};
+
+Mode::Mode(const std::string &id, const waybar::Bar &bar, const Json::Value &config)
+    : waybar::ALabel(config, "mode", id, "{}"),
+      status_manager_{nullptr},
+      seat_{nullptr},
+      bar_(bar),
+      mode_{""},
+      seat_status_{nullptr} {
+  struct wl_display *display = Client::inst()->wl_display;
+  struct wl_registry *registry = wl_display_get_registry(display);
+  wl_registry_add_listener(registry, &registry_listener_impl, this);
+  wl_display_roundtrip(display);
+
+  if (!status_manager_) {
+    spdlog::error("river_status_manager_v1 not advertised");
+    return;
+  }
+
+  if (!seat_) {
+    spdlog::error("wl_seat not advertised");
+  }
+
+  label_.hide();
+  ALabel::update();
+
+  seat_status_ = zriver_status_manager_v1_get_river_seat_status(status_manager_, seat_);
+  zriver_seat_status_v1_add_listener(seat_status_, &seat_status_listener_impl, this);
+
+  zriver_status_manager_v1_destroy(status_manager_);
+}
+
+Mode::~Mode() {
+  if (seat_status_) {
+    zriver_seat_status_v1_destroy(seat_status_);
+  }
+}
+
+void Mode::handle_mode(const char *mode) {
+  if (format_.empty()) {
+    label_.hide();
+  } else {
+    if (!mode_.empty()) {
+      label_.get_style_context()->remove_class(mode_);
+    }
+
+    label_.get_style_context()->add_class(mode);
+    label_.set_markup(fmt::format(format_, Glib::Markup::escape_text(mode).raw()));
+    label_.show();
+  }
+
+  mode_ = mode;
+  ALabel::update();
+}
+
+} /* namespace waybar::modules::river */

src/modules/river/window.cpp

@@ -24,10 +24,16 @@ static void listen_unfocused_output(void *data, struct zriver_seat_status_v1 *zr
   static_cast<Window *>(data)->handle_unfocused_output(output);
 }
 
+static void listen_mode(void *data, struct zriver_seat_status_v1 *zriver_seat_status_v1,
+                        const char *mode) {
+  // This module doesn't care
+}
+
 static const zriver_seat_status_v1_listener seat_status_listener_impl{
     .focused_output = listen_focused_output,
     .unfocused_output = listen_unfocused_output,
     .focused_view = listen_focused_view,
+    .mode = listen_mode,
 };
 
 static void handle_global(void *data, struct wl_registry *registry, uint32_t name,
@@ -100,7 +106,7 @@ void Window::handle_focused_view(const char *title) {
     label_.hide();  // hide empty labels or labels with empty format
   } else {
     label_.show();
-    label_.set_markup(fmt::format(format_, title));
+    label_.set_markup(fmt::format(format_, Glib::Markup::escape_text(title).raw()));
   }
 
   ALabel::update();

src/modules/sndio.cpp

@@ -41,7 +41,7 @@ auto Sndio::connect_to_sndio() -> void {
 }
 
 Sndio::Sndio(const std::string &id, const Json::Value &config)
-    : ALabel(config, "sndio", id, "{volume}%", 1),
+    : ALabel(config, "sndio", id, "{volume}%", 1, false, true),
       hdl_(nullptr),
       pfds_(0),
       addr_(0),

src/modules/sni/host.cpp

@@ -1,6 +1,5 @@
 #include "modules/sni/host.hpp"
 
-#include <fmt/ostream.h>
 #include <spdlog/spdlog.h>
 
 namespace waybar::modules::SNI {

src/modules/sni/item.cpp

@@ -300,10 +300,6 @@ void Item::updateImage() {
   auto pixbuf = getIconPixbuf();
   auto scaled_icon_size = getScaledIconSize();
 
-  if (!pixbuf) {
-    pixbuf = getIconByName("image-missing", getScaledIconSize());
-  }
-
   // If the loaded icon is not square, assume that the icon height should match the
   // requested icon size, but the width is allowed to be different. As such, if the
   // height of the image does not match the requested icon size, resize the icon such that
@@ -313,24 +309,47 @@ void Item::updateImage() {
     pixbuf = pixbuf->scale_simple(width, scaled_icon_size, Gdk::InterpType::INTERP_BILINEAR);
   }
 
-  auto surface = Gdk::Cairo::create_surface_from_pixbuf(pixbuf, 0, image.get_window());
+  auto surface =
+      Gdk::Cairo::create_surface_from_pixbuf(pixbuf, image.get_scale_factor(), image.get_window());
   image.set(surface);
 }
 
 Glib::RefPtr<Gdk::Pixbuf> Item::getIconPixbuf() {
-  try {
-    if (!icon_name.empty()) {
+  if (!icon_name.empty()) {
+    try {
       std::ifstream temp(icon_name);
       if (temp.is_open()) {
         return Gdk::Pixbuf::create_from_file(icon_name);
       }
-      return getIconByName(icon_name, getScaledIconSize());
-    } else if (icon_pixmap) {
-      return icon_pixmap;
+    } catch (Glib::Error& e) {
+      // Ignore because we want to also try different methods of getting an icon.
+      //
+      // But a warning is logged, as the file apparently exists, but there was
+      // a failure in creating a pixbuf out of it.
+
+      spdlog::warn("Item '{}': {}", id, static_cast<std::string>(e.what()));
+    }
+
+    try {
+      // Will throw if it can not find an icon.
+      return getIconByName(icon_name, getScaledIconSize());
+    } catch (Glib::Error& e) {
+      spdlog::trace("Item '{}': {}", id, static_cast<std::string>(e.what()));
     }
-  } catch (Glib::Error& e) {
-    spdlog::error("Item '{}': {}", id, static_cast<std::string>(e.what()));
   }
+
+  // Return the pixmap only if an icon for the given name could not be found.
+  if (icon_pixmap) {
+    return icon_pixmap;
+  }
+
+  if (icon_name.empty()) {
+    spdlog::error("Item '{}': No icon name or pixmap given.", id);
+  } else {
+    spdlog::error("Item '{}': Could not find an icon named '{}' and no pixmap given.", id,
+                  icon_name);
+  }
+
   return getIconByName("image-missing", getScaledIconSize());
 }
 

src/modules/sway/bar.cpp

@@ -1,6 +1,5 @@
 #include "modules/sway/bar.hpp"
 
-#include <fmt/ostream.h>
 #include <spdlog/spdlog.h>
 
 #include <sstream>

src/modules/sway/language.cpp

@@ -120,7 +120,9 @@ auto Language::update() -> void {
 }
 
 auto Language::set_current_layout(std::string current_layout) -> void {
+  label_.get_style_context()->remove_class(layout_.short_name);
   layout_ = layouts_map_[current_layout];
+  label_.get_style_context()->add_class(layout_.short_name);
 }
 
 auto Language::init_layouts_map(const std::vector<std::string>& used_layouts) -> void {

src/modules/sway/scratchpad.cpp

@@ -0,0 +1,82 @@
+#include "modules/sway/scratchpad.hpp"
+
+#include <spdlog/spdlog.h>
+
+#include <string>
+
+namespace waybar::modules::sway {
+Scratchpad::Scratchpad(const std::string& id, const Json::Value& config)
+    : ALabel(config, "scratchpad", id,
+             config["format"].isString() ? config["format"].asString() : "{icon} {count}"),
+      tooltip_format_(config_["tooltip-format"].isString() ? config_["tooltip-format"].asString()
+                                                           : "{app}: {title}"),
+      show_empty_(config_["show-empty"].isBool() ? config_["show-empty"].asBool() : false),
+      tooltip_enabled_(config_["tooltip"].isBool() ? config_["tooltip"].asBool() : true),
+      tooltip_text_(""),
+      count_(0) {
+  ipc_.subscribe(R"(["window"])");
+  ipc_.signal_event.connect(sigc::mem_fun(*this, &Scratchpad::onEvent));
+  ipc_.signal_cmd.connect(sigc::mem_fun(*this, &Scratchpad::onCmd));
+
+  getTree();
+
+  ipc_.setWorker([this] {
+    try {
+      ipc_.handleEvent();
+    } catch (const std::exception& e) {
+      spdlog::error("Scratchpad: {}", e.what());
+    }
+  });
+}
+auto Scratchpad::update() -> void {
+  if (count_ || show_empty_) {
+    event_box_.show();
+    label_.set_markup(
+        fmt::format(format_, fmt::arg("icon", getIcon(count_, "", config_["format-icons"].size())),
+                    fmt::arg("count", count_)));
+    if (tooltip_enabled_) {
+      label_.set_tooltip_markup(tooltip_text_);
+    }
+  } else {
+    event_box_.hide();
+  }
+  if (count_) {
+    label_.get_style_context()->remove_class("empty");
+  } else {
+    label_.get_style_context()->add_class("empty");
+  }
+  ALabel::update();
+}
+
+auto Scratchpad::getTree() -> void {
+  try {
+    ipc_.sendCmd(IPC_GET_TREE);
+  } catch (const std::exception& e) {
+    spdlog::error("Scratchpad: {}", e.what());
+  }
+}
+
+auto Scratchpad::onCmd(const struct Ipc::ipc_response& res) -> void {
+  try {
+    std::lock_guard<std::mutex> lock(mutex_);
+    auto tree = parser_.parse(res.payload);
+    count_ = tree["nodes"][0]["nodes"][0]["floating_nodes"].size();
+    if (tooltip_enabled_) {
+      tooltip_text_.clear();
+      for (const auto& window : tree["nodes"][0]["nodes"][0]["floating_nodes"]) {
+        tooltip_text_.append(fmt::format(tooltip_format_ + '\n',
+                                         fmt::arg("app", window["app_id"].asString()),
+                                         fmt::arg("title", window["name"].asString())));
+      }
+      if (!tooltip_text_.empty()) {
+        tooltip_text_.pop_back();
+      }
+    }
+    dp.emit();
+  } catch (const std::exception& e) {
+    spdlog::error("Scratchpad: {}", e.what());
+  }
+}
+
+auto Scratchpad::onEvent(const struct Ipc::ipc_response& res) -> void { getTree(); }
+}  // namespace waybar::modules::sway

src/modules/sway/window.cpp

@@ -12,10 +12,12 @@
 #include <regex>
 #include <string>
 
+#include "util/rewrite_title.hpp"
+
 namespace waybar::modules::sway {
 
 Window::Window(const std::string& id, const Bar& bar, const Json::Value& config)
-    : AIconLabel(config, "window", id, "{}", 0, true), bar_(bar), windowId_(-1) {
+    : AIconLabel(config, "window", id, "{title}", 0, true), bar_(bar), windowId_(-1) {
   // Icon size
   if (config_["icon-size"].isUInt()) {
     app_icon_size_ = config["icon-size"].asUInt();
@@ -44,7 +46,7 @@ void Window::onCmd(const struct Ipc::ipc_response& res) {
     std::lock_guard<std::mutex> lock(mutex_);
     auto payload = parser_.parse(res.payload);
     auto output = payload["output"].isString() ? payload["output"].asString() : "";
-    std::tie(app_nb_, windowId_, window_, app_id_, app_class_) =
+    std::tie(app_nb_, windowId_, window_, app_id_, app_class_, shell_) =
         getFocusedNode(payload["nodes"], output);
     updateAppIconName();
     dp.emit();
@@ -175,8 +177,9 @@ auto Window::update() -> void {
     bar_.window.get_style_context()->remove_class("solo");
     bar_.window.get_style_context()->remove_class("empty");
   }
-  label_.set_markup(
-      fmt::format(format_, fmt::arg("title", rewriteTitle(window_)), fmt::arg("app_id", app_id_)));
+  label_.set_markup(fmt::format(
+      format_, fmt::arg("title", waybar::util::rewriteTitle(window_, config_["rewrite"])),
+      fmt::arg("app_id", app_id_), fmt::arg("shell", shell_)));
   if (tooltipEnabled()) {
     label_.set_tooltip_text(window_);
   }
@@ -206,7 +209,7 @@ int leafNodesInWorkspace(const Json::Value& node) {
   return sum;
 }
 
-std::tuple<std::size_t, int, std::string, std::string, std::string> gfnWithWorkspace(
+std::tuple<std::size_t, int, std::string, std::string, std::string, std::string> gfnWithWorkspace(
     const Json::Value& nodes, std::string& output, const Json::Value& config_, const Bar& bar_,
     Json::Value& parentWorkspace) {
   for (auto const& node : nodes) {
@@ -222,31 +225,34 @@ std::tuple<std::size_t, int, std::string, std::string, std::string> gfnWithWorks
         const auto app_class = node["window_properties"]["class"].isString()
                                    ? node["window_properties"]["class"].asString()
                                    : "";
+
+        const auto shell = node["shell"].isString() ? node["shell"].asString() : "";
+
         int nb = node.size();
         if (parentWorkspace != 0) nb = leafNodesInWorkspace(parentWorkspace);
-        return {nb, node["id"].asInt(), Glib::Markup::escape_text(node["name"].asString()), app_id,
-                app_class};
+        return {nb,     node["id"].asInt(), Glib::Markup::escape_text(node["name"].asString()),
+                app_id, app_class,          shell};
       }
     }
     // iterate
     if (node["type"] == "workspace") parentWorkspace = node;
-    auto [nb, id, name, app_id, app_class] =
+    auto [nb, id, name, app_id, app_class, shell] =
         gfnWithWorkspace(node["nodes"], output, config_, bar_, parentWorkspace);
     if (id > -1 && !name.empty()) {
-      return {nb, id, name, app_id, app_class};
+      return {nb, id, name, app_id, app_class, shell};
     }
     // Search for floating node
-    std::tie(nb, id, name, app_id, app_class) =
+    std::tie(nb, id, name, app_id, app_class, shell) =
         gfnWithWorkspace(node["floating_nodes"], output, config_, bar_, parentWorkspace);
     if (id > -1 && !name.empty()) {
-      return {nb, id, name, app_id, app_class};
+      return {nb, id, name, app_id, app_class, shell};
     }
   }
-  return {0, -1, "", "", ""};
+  return {0, -1, "", "", "", ""};
 }
 
-std::tuple<std::size_t, int, std::string, std::string, std::string> Window::getFocusedNode(
-    const Json::Value& nodes, std::string& output) {
+std::tuple<std::size_t, int, std::string, std::string, std::string, std::string>
+Window::getFocusedNode(const Json::Value& nodes, std::string& output) {
   Json::Value placeholder = 0;
   return gfnWithWorkspace(nodes, output, config_, bar_, placeholder);
 }
@@ -259,30 +265,4 @@ void Window::getTree() {
   }
 }
 
-std::string Window::rewriteTitle(const std::string& title) {
-  const auto& rules = config_["rewrite"];
-  if (!rules.isObject()) {
-    return title;
-  }
-
-  std::string res = title;
-
-  for (auto it = rules.begin(); it != rules.end(); ++it) {
-    if (it.key().isString() && it->isString()) {
-      try {
-        // malformated regexes will cause an exception.
-        // in this case, log error and try the next rule.
-        const std::regex rule{it.key().asString()};
-        if (std::regex_match(title, rule)) {
-          res = std::regex_replace(res, rule, it->asString());
-        }
-      } catch (const std::regex_error& e) {
-        spdlog::error("Invalid rule {}: {}", it.key().asString(), e.what());
-      }
-    }
-  }
-
-  return res;
-}
-
 }  // namespace waybar::modules::sway

src/modules/sway/workspaces.cpp

@@ -8,7 +8,7 @@
 
 namespace waybar::modules::sway {
 
-// Helper function to to assign a number to a workspace, just like sway. In fact
+// Helper function to assign a number to a workspace, just like sway. In fact
 // this is taken quite verbatim from `sway/ipc-json.c`.
 int Workspaces::convertWorkspaceNameToNum(std::string name) {
   if (isdigit(name[0])) {

src/modules/temperature.cpp

@@ -2,8 +2,15 @@
 
 #include <filesystem>
 
+#if defined(__FreeBSD__)
+#include <sys/sysctl.h>
+#endif
+
 waybar::modules::Temperature::Temperature(const std::string& id, const Json::Value& config)
     : ALabel(config, "temperature", id, "{temperatureC}°C", 10) {
+#if defined(__FreeBSD__)
+// try to read sysctl?
+#else
   if (config_["hwmon-path"].isString()) {
     file_path_ = config_["hwmon-path"].asString();
   } else if (config_["hwmon-path-abs"].isString() && config_["input-filename"].isString()) {
@@ -19,6 +26,7 @@ waybar::modules::Temperature::Temperature(const std::string& id, const Json::Val
   if (!temp.is_open()) {
     throw std::runtime_error("Can't open " + file_path_);
   }
+#endif
   thread_ = [this] {
     dp.emit();
     thread_.sleep_for(interval_);
@@ -65,6 +73,21 @@ auto waybar::modules::Temperature::update() -> void {
 }
 
 float waybar::modules::Temperature::getTemperature() {
+#if defined(__FreeBSD__)
+  int temp;
+  size_t size = sizeof temp;
+
+  auto zone = config_["thermal-zone"].isInt() ? config_["thermal-zone"].asInt() : 0;
+  auto sysctl_thermal = fmt::format("hw.acpi.thermal.tz{}.temperature", zone);
+
+  if (sysctlbyname("hw.acpi.thermal.tz0.temperature", &temp, &size, NULL, 0) != 0) {
+    throw std::runtime_error(
+        "sysctl hw.acpi.thermal.tz0.temperature or dev.cpu.0.temperature failed");
+  }
+  auto temperature_c = ((float)temp - 2732) / 10;
+  return temperature_c;
+
+#else  // Linux
   std::ifstream temp(file_path_);
   if (!temp.is_open()) {
     throw std::runtime_error("Can't open " + file_path_);
@@ -76,6 +99,7 @@ float waybar::modules::Temperature::getTemperature() {
   temp.close();
   auto temperature_c = std::strtol(line.c_str(), nullptr, 10) / 1000.0;
   return temperature_c;
+#endif
 }
 
 bool waybar::modules::Temperature::isCritical(uint16_t temperature_c) {

src/modules/user.cpp

@@ -0,0 +1,137 @@
+#include "modules/user.hpp"
+
+#include <fmt/chrono.h>
+#include <glibmm/miscutils.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <chrono>
+
+#include "gdkmm/cursor.h"
+#include "gdkmm/event.h"
+#include "gdkmm/types.h"
+#include "sigc++/functors/mem_fun.h"
+#include "sigc++/functors/ptr_fun.h"
+
+#if HAVE_CPU_LINUX
+#include <sys/sysinfo.h>
+#endif
+
+#if HAVE_CPU_BSD
+#include <time.h>
+#endif
+
+const static int LEFT_MOUSE_BUTTON_CODE = 1;
+
+namespace waybar::modules {
+User::User(const std::string& id, const Json::Value& config)
+    : AIconLabel(config, "user", id, "{user} {work_H}:{work_M}", 60, false, true, true) {
+  if (AIconLabel::iconEnabled()) {
+    this->init_avatar(AIconLabel::config_);
+  }
+  this->init_update_worker();
+}
+
+bool User::handleToggle(GdkEventButton* const& e) {
+  if (AIconLabel::config_["open-on-click"].isBool() &&
+      AIconLabel::config_["open-on-click"].asBool() && e->button == LEFT_MOUSE_BUTTON_CODE) {
+    std::string openPath = this->get_user_home_dir();
+    if (AIconLabel::config_["open-path"].isString()) {
+      std::string customPath = AIconLabel::config_["open-path"].asString();
+      if (!customPath.empty()) {
+        openPath = std::move(customPath);
+      }
+    }
+
+    Gio::AppInfo::launch_default_for_uri("file:///" + openPath);
+  }
+  return true;
+}
+
+long User::uptime_as_seconds() {
+  long uptime = 0;
+
+#if HAVE_CPU_LINUX
+  struct sysinfo s_info;
+  if (0 == sysinfo(&s_info)) {
+    uptime = s_info.uptime;
+  }
+#endif
+
+#if HAVE_CPU_BSD
+  struct timespec s_info;
+  if (0 == clock_gettime(CLOCK_UPTIME_PRECISE, &s_info)) {
+    uptime = s_info.tv_sec;
+  }
+#endif
+
+  return uptime;
+}
+
+std::string User::get_user_login() const { return Glib::get_user_name(); }
+
+std::string User::get_user_home_dir() const { return Glib::get_home_dir(); }
+
+void User::init_update_worker() {
+  this->thread_ = [this] {
+    ALabel::dp.emit();
+    auto now = std::chrono::system_clock::now();
+    auto diff = now.time_since_epoch() % ALabel::interval_;
+    this->thread_.sleep_for(ALabel::interval_ - diff);
+  };
+}
+
+void User::init_avatar(const Json::Value& config) {
+  int height =
+      config["height"].isUInt() ? config["height"].asUInt() : this->defaultUserImageHeight_;
+  int width = config["width"].isUInt() ? config["width"].asUInt() : this->defaultUserImageWidth_;
+
+  if (config["avatar"].isString()) {
+    std::string userAvatar = config["avatar"].asString();
+    if (!userAvatar.empty()) {
+      this->init_user_avatar(userAvatar, width, height);
+      return;
+    }
+  }
+
+  this->init_default_user_avatar(width, width);
+}
+
+std::string User::get_default_user_avatar_path() const {
+  return this->get_user_home_dir() + "/" + ".face";
+}
+
+void User::init_default_user_avatar(int width, int height) {
+  this->init_user_avatar(this->get_default_user_avatar_path(), width, height);
+}
+
+void User::init_user_avatar(const std::string& path, int width, int height) {
+  Glib::RefPtr<Gdk::Pixbuf> pixbuf_ = Gdk::Pixbuf::create_from_file(path, width, height);
+  AIconLabel::image_.set(pixbuf_);
+}
+
+auto User::update() -> void {
+  std::string systemUser = this->get_user_login();
+  std::transform(systemUser.cbegin(), systemUser.cend(), systemUser.begin(),
+                 [](unsigned char c) { return std::toupper(c); });
+
+  long uptimeSeconds = this->uptime_as_seconds();
+  auto workSystemTimeSeconds = std::chrono::seconds(uptimeSeconds);
+  auto currentSystemTime = std::chrono::system_clock::now();
+  auto startSystemTime = currentSystemTime - workSystemTimeSeconds;
+  long workSystemDays = uptimeSeconds / 86400;
+
+  auto label = fmt::format(ALabel::format_, fmt::arg("up_H", fmt::format("{:%H}", startSystemTime)),
+                           fmt::arg("up_M", fmt::format("{:%M}", startSystemTime)),
+                           fmt::arg("up_d", fmt::format("{:%d}", startSystemTime)),
+                           fmt::arg("up_m", fmt::format("{:%m}", startSystemTime)),
+                           fmt::arg("up_Y", fmt::format("{:%Y}", startSystemTime)),
+                           fmt::arg("work_d", workSystemDays),
+                           fmt::arg("work_H", fmt::format("{:%H}", workSystemTimeSeconds)),
+                           fmt::arg("work_M", fmt::format("{:%M}", workSystemTimeSeconds)),
+                           fmt::arg("work_S", fmt::format("{:%S}", workSystemTimeSeconds)),
+                           fmt::arg("user", systemUser));
+  ALabel::label_.set_markup(label);
+  ALabel::update();
+}
+};  // namespace waybar::modules

src/modules/wireplumber.cpp

@@ -0,0 +1,180 @@
+#include "modules/wireplumber.hpp"
+
+waybar::modules::Wireplumber::Wireplumber(const std::string& id, const Json::Value& config)
+    : ALabel(config, "wireplumber", id, "{volume}%"),
+      wp_core_(nullptr),
+      apis_(nullptr),
+      om_(nullptr),
+      pending_plugins_(0),
+      muted_(false),
+      volume_(0.0),
+      node_id_(0) {
+  wp_init(WP_INIT_ALL);
+  wp_core_ = wp_core_new(NULL, NULL);
+  apis_ = g_ptr_array_new_with_free_func(g_object_unref);
+  om_ = wp_object_manager_new();
+
+  prepare();
+
+  loadRequiredApiModules();
+
+  if (!wp_core_connect(wp_core_)) {
+    throw std::runtime_error("Could not connect to PipeWire\n");
+  }
+
+  g_signal_connect_swapped(om_, "installed", (GCallback)onObjectManagerInstalled, this);
+
+  activatePlugins();
+
+  dp.emit();
+}
+
+waybar::modules::Wireplumber::~Wireplumber() {
+  g_clear_pointer(&apis_, g_ptr_array_unref);
+  g_clear_object(&om_);
+  g_clear_object(&wp_core_);
+}
+
+uint32_t waybar::modules::Wireplumber::getDefaultNodeId(waybar::modules::Wireplumber* self) {
+  uint32_t id;
+  g_autoptr(WpPlugin) def_nodes_api = wp_plugin_find(self->wp_core_, "default-nodes-api");
+
+  if (!def_nodes_api) {
+    throw std::runtime_error("Default nodes API is not loaded\n");
+  }
+
+  g_signal_emit_by_name(def_nodes_api, "get-default-node", "Audio/Sink", &id);
+
+  if (id <= 0 || id >= G_MAXUINT32) {
+    auto err = fmt::format("'{}' is not a valid ID (returned by default-nodes-api)\n", id);
+    throw std::runtime_error(err);
+  }
+
+  return id;
+}
+
+void waybar::modules::Wireplumber::updateNodeName(waybar::modules::Wireplumber* self) {
+  auto proxy = static_cast<WpPipewireObject*>(wp_object_manager_lookup(
+      self->om_, WP_TYPE_GLOBAL_PROXY, WP_CONSTRAINT_TYPE_PW_GLOBAL_PROPERTY, "object.id", "=u",
+      self->node_id_, NULL));
+
+  if (!proxy) {
+    throw std::runtime_error(fmt::format("Object '{}' not found\n", self->node_id_));
+  }
+
+  g_autoptr(WpProperties) properties = wp_pipewire_object_get_properties(proxy);
+  properties = wp_properties_ensure_unique_owner(properties);
+  self->node_name_ = wp_properties_get(properties, "node.nick");
+}
+
+void waybar::modules::Wireplumber::updateVolume(waybar::modules::Wireplumber* self) {
+  double vol;
+  GVariant* variant = NULL;
+  g_autoptr(WpPlugin) mixer_api = wp_plugin_find(self->wp_core_, "mixer-api");
+  g_signal_emit_by_name(mixer_api, "get-volume", self->node_id_, &variant);
+  if (!variant) {
+    auto err = fmt::format("Node {} does not support volume\n", self->node_id_);
+    throw std::runtime_error(err);
+  }
+
+  g_variant_lookup(variant, "volume", "d", &vol);
+  g_variant_lookup(variant, "mute", "b", &self->muted_);
+  g_clear_pointer(&variant, g_variant_unref);
+
+  self->volume_ = std::round(vol * 100.0F);
+  self->dp.emit();
+}
+
+void waybar::modules::Wireplumber::onObjectManagerInstalled(waybar::modules::Wireplumber* self) {
+  self->node_id_ =
+      self->config_["node-id"].isInt() ? self->config_["node-id"].asInt() : getDefaultNodeId(self);
+
+  g_autoptr(WpPlugin) mixer_api = wp_plugin_find(self->wp_core_, "mixer-api");
+
+  updateVolume(self);
+  updateNodeName(self);
+  g_signal_connect_swapped(mixer_api, "changed", (GCallback)updateVolume, self);
+}
+
+void waybar::modules::Wireplumber::onPluginActivated(WpObject* p, GAsyncResult* res,
+                                                     waybar::modules::Wireplumber* self) {
+  g_autoptr(GError) error = NULL;
+
+  if (!wp_object_activate_finish(p, res, &error)) {
+    throw std::runtime_error(error->message);
+  }
+
+  if (--self->pending_plugins_ == 0) {
+    wp_core_install_object_manager(self->wp_core_, self->om_);
+  }
+}
+
+void waybar::modules::Wireplumber::activatePlugins() {
+  for (uint16_t i = 0; i < apis_->len; i++) {
+    WpPlugin* plugin = static_cast<WpPlugin*>(g_ptr_array_index(apis_, i));
+    pending_plugins_++;
+    wp_object_activate(WP_OBJECT(plugin), WP_PLUGIN_FEATURE_ENABLED, NULL,
+                       (GAsyncReadyCallback)onPluginActivated, this);
+  }
+}
+
+void waybar::modules::Wireplumber::prepare() {
+  wp_object_manager_add_interest(om_, WP_TYPE_NODE, NULL);
+  wp_object_manager_request_object_features(om_, WP_TYPE_GLOBAL_PROXY,
+                                            WP_PIPEWIRE_OBJECT_FEATURES_MINIMAL);
+}
+
+void waybar::modules::Wireplumber::loadRequiredApiModules() {
+  g_autoptr(GError) error = NULL;
+
+  if (!wp_core_load_component(wp_core_, "libwireplumber-module-default-nodes-api", "module", NULL,
+                              &error)) {
+    throw std::runtime_error(error->message);
+  }
+
+  if (!wp_core_load_component(wp_core_, "libwireplumber-module-mixer-api", "module", NULL,
+                              &error)) {
+    throw std::runtime_error(error->message);
+  }
+
+  g_ptr_array_add(apis_, wp_plugin_find(wp_core_, "default-nodes-api"));
+  g_ptr_array_add(apis_, ({
+                    WpPlugin* p = wp_plugin_find(wp_core_, "mixer-api");
+                    g_object_set(G_OBJECT(p), "scale", 1 /* cubic */, NULL);
+                    p;
+                  }));
+}
+
+auto waybar::modules::Wireplumber::update() -> void {
+  auto format = format_;
+  std::string tooltip_format;
+
+  if (muted_) {
+    format = config_["format-muted"].isString() ? config_["format-muted"].asString() : format;
+    label_.get_style_context()->add_class("muted");
+  } else {
+    label_.get_style_context()->remove_class("muted");
+  }
+
+  std::string markup =
+      fmt::format(format, fmt::arg("node_name", node_name_), fmt::arg("volume", volume_));
+  label_.set_markup(markup);
+
+  getState(volume_);
+
+  if (tooltipEnabled()) {
+    if (tooltip_format.empty() && config_["tooltip-format"].isString()) {
+      tooltip_format = config_["tooltip-format"].asString();
+    }
+
+    if (!tooltip_format.empty()) {
+      label_.set_tooltip_text(fmt::format(tooltip_format, fmt::arg("node_name", node_name_),
+                                          fmt::arg("volume", volume_)));
+    } else {
+      label_.set_tooltip_text(node_name_);
+    }
+  }
+
+  // Call parent update
+  ALabel::update();
+}

src/modules/wlr/taskbar.cpp

@@ -15,6 +15,7 @@
 #include <sstream>
 #include <utility>
 
+#include "gdkmm/general.h"
 #include "glibmm/error.h"
 #include "glibmm/fileutils.h"
 #include "glibmm/refptr.h"
@@ -173,18 +174,25 @@ bool Task::image_load_icon(Gtk::Image &image, const Glib::RefPtr<Gtk::IconTheme>
   }
 
   Glib::RefPtr<Gdk::Pixbuf> pixbuf;
+  auto scaled_icon_size = size * image.get_scale_factor();
 
   try {
-    pixbuf = icon_theme->load_icon(ret_icon_name, size, Gtk::ICON_LOOKUP_FORCE_SIZE);
+    pixbuf = icon_theme->load_icon(ret_icon_name, scaled_icon_size, Gtk::ICON_LOOKUP_FORCE_SIZE);
   } catch (...) {
     if (Glib::file_test(ret_icon_name, Glib::FILE_TEST_EXISTS))
-      pixbuf = load_icon_from_file(ret_icon_name, size);
+      pixbuf = load_icon_from_file(ret_icon_name, scaled_icon_size);
     else
       pixbuf = {};
   }
 
   if (pixbuf) {
-    image.set(pixbuf);
+    if (pixbuf->get_width() != scaled_icon_size) {
+      int width = scaled_icon_size * pixbuf->get_width() / pixbuf->get_height();
+      pixbuf = pixbuf->scale_simple(width, scaled_icon_size, Gdk::InterpType::INTERP_BILINEAR);
+    }
+    auto surface = Gdk::Cairo::create_surface_from_pixbuf(pixbuf, image.get_scale_factor(),
+                                                          image.get_window());
+    image.set(surface);
     return true;
   }
 
@@ -243,6 +251,9 @@ static const struct zwlr_foreign_toplevel_handle_v1_listener toplevel_handle_imp
     .parent = tl_handle_parent,
 };
 
+static const std::vector<Gtk::TargetEntry> target_entries = {
+    Gtk::TargetEntry("WAYBAR_TOPLEVEL", Gtk::TARGET_SAME_APP, 0)};
+
 Task::Task(const waybar::Bar &bar, const Json::Value &config, Taskbar *tbar,
            struct zwlr_foreign_toplevel_handle_v1 *tl_handle, struct wl_seat *seat)
     : bar_{bar},
@@ -301,9 +312,22 @@ Task::Task(const waybar::Bar &bar, const Json::Value &config, Taskbar *tbar,
   /* Handle click events if configured */
   if (config_["on-click"].isString() || config_["on-click-middle"].isString() ||
       config_["on-click-right"].isString()) {
-    button_.add_events(Gdk::BUTTON_PRESS_MASK);
-    button_.signal_button_press_event().connect(sigc::mem_fun(*this, &Task::handle_clicked), false);
   }
+
+  button_.add_events(Gdk::BUTTON_PRESS_MASK);
+  button_.signal_button_press_event().connect(sigc::mem_fun(*this, &Task::handle_clicked), false);
+  button_.signal_button_release_event().connect(sigc::mem_fun(*this, &Task::handle_button_release),
+                                                false);
+
+  button_.signal_motion_notify_event().connect(sigc::mem_fun(*this, &Task::handle_motion_notify),
+                                               false);
+
+  button_.drag_source_set(target_entries, Gdk::BUTTON1_MASK, Gdk::ACTION_MOVE);
+  button_.drag_dest_set(target_entries, Gtk::DEST_DEFAULT_ALL, Gdk::ACTION_MOVE);
+
+  button_.signal_drag_data_get().connect(sigc::mem_fun(*this, &Task::handle_drag_data_get), false);
+  button_.signal_drag_data_received().connect(
+      sigc::mem_fun(*this, &Task::handle_drag_data_received), false);
 }
 
 Task::~Task() {
@@ -487,6 +511,14 @@ void Task::handle_closed() {
 }
 
 bool Task::handle_clicked(GdkEventButton *bt) {
+  /* filter out additional events for double/triple clicks */
+  if (bt->type == GDK_BUTTON_PRESS) {
+    /* save where the button press ocurred in case it becomes a drag */
+    drag_start_button = bt->button;
+    drag_start_x = bt->x;
+    drag_start_y = bt->y;
+  }
+
   std::string action;
   if (config_["on-click"].isString() && bt->button == 1)
     action = config_["on-click"].asString();
@@ -520,6 +552,54 @@ bool Task::handle_clicked(GdkEventButton *bt) {
   return true;
 }
 
+bool Task::handle_button_release(GdkEventButton *bt) {
+  drag_start_button = -1;
+  return false;
+}
+
+bool Task::handle_motion_notify(GdkEventMotion *mn) {
+  if (drag_start_button == -1) return false;
+
+  if (button_.drag_check_threshold(drag_start_x, drag_start_y, mn->x, mn->y)) {
+    /* start drag in addition to other assigned action */
+    auto target_list = Gtk::TargetList::create(target_entries);
+    auto refptr = Glib::RefPtr<Gtk::TargetList>(target_list);
+    auto drag_context =
+        button_.drag_begin(refptr, Gdk::DragAction::ACTION_MOVE, drag_start_button, (GdkEvent *)mn);
+  }
+
+  return false;
+}
+
+void Task::handle_drag_data_get(const Glib::RefPtr<Gdk::DragContext> &context,
+                                Gtk::SelectionData &selection_data, guint info, guint time) {
+  spdlog::debug("drag_data_get");
+  void *button_addr = (void *)&this->button_;
+
+  selection_data.set("WAYBAR_TOPLEVEL", 32, (const guchar *)&button_addr, sizeof(gpointer));
+}
+
+void Task::handle_drag_data_received(const Glib::RefPtr<Gdk::DragContext> &context, int x, int y,
+                                     Gtk::SelectionData selection_data, guint info, guint time) {
+  spdlog::debug("drag_data_received");
+  gpointer handle = *(gpointer *)selection_data.get_data();
+  auto dragged_button = (Gtk::Button *)handle;
+
+  if (dragged_button == &this->button_) return;
+
+  auto parent_of_dragged = dragged_button->get_parent();
+  auto parent_of_dest = this->button_.get_parent();
+
+  if (parent_of_dragged != parent_of_dest) return;
+
+  auto box = (Gtk::Box *)parent_of_dragged;
+
+  auto position_prop = box->child_property_position(this->button_);
+  auto position = position_prop.get_value();
+
+  box->reorder_child(*dragged_button, position);
+}
+
 bool Task::operator==(const Task &o) const { return o.id_ == id_; }
 
 bool Task::operator!=(const Task &o) const { return o.id_ != id_; }

src/modules/wlr/workspace_manager.cpp

@@ -6,6 +6,7 @@
 
 #include <algorithm>
 #include <iterator>
+#include <stdexcept>
 #include <vector>
 
 #include "gtkmm/widget.h"
@@ -32,6 +33,11 @@ WorkspaceManager::WorkspaceManager(const std::string &id, const waybar::Bar &bar
     sort_by_coordinates_ = config_sort_by_coordinates.asBool();
   }
 
+  auto config_sort_by_number = config_["sort-by-number"];
+  if (config_sort_by_number.isBool()) {
+    sort_by_number_ = config_sort_by_number.asBool();
+  }
+
   auto config_all_outputs = config_["all-outputs"];
   if (config_all_outputs.isBool()) {
     all_outputs_ = config_all_outputs.asBool();
@@ -61,6 +67,15 @@ auto WorkspaceManager::workspace_comparator() const
     auto is_name_less = lhs->get_name() < rhs->get_name();
     auto is_name_eq = lhs->get_name() == rhs->get_name();
     auto is_coords_less = lhs->get_coords() < rhs->get_coords();
+
+    if (sort_by_number_) {
+      try {
+        auto is_number_less = std::stoi(lhs->get_name()) < std::stoi(rhs->get_name());
+        return is_number_less;
+      } catch (std::invalid_argument) {
+      }
+    }
+
     if (sort_by_name_) {
       if (sort_by_coordinates_) {
         return is_name_eq ? is_coords_less : is_name_less;

src/util/rewrite_title.cpp

@@ -0,0 +1,32 @@
+#include "util/rewrite_title.hpp"
+
+#include <spdlog/spdlog.h>
+
+#include <regex>
+
+namespace waybar::util {
+std::string rewriteTitle(const std::string& title, const Json::Value& rules) {
+  if (!rules.isObject()) {
+    return title;
+  }
+
+  std::string res = title;
+
+  for (auto it = rules.begin(); it != rules.end(); ++it) {
+    if (it.key().isString() && it->isString()) {
+      try {
+        // malformated regexes will cause an exception.
+        // in this case, log error and try the next rule.
+        const std::regex rule{it.key().asString()};
+        if (std::regex_match(title, rule)) {
+          res = std::regex_replace(res, rule, it->asString());
+        }
+      } catch (const std::regex_error& e) {
+        spdlog::error("Invalid rule {}: {}", it.key().asString(), e.what());
+      }
+    }
+  }
+
+  return res;
+}
+}  // namespace waybar::util

src/util/sanitize_str.cpp

@@ -0,0 +1,24 @@
+#include <array>
+#include <string>
+#include <util/sanitize_str.hpp>
+#include <utility>
+
+namespace waybar::util {
+// replaces ``<>&"'`` with their encoded counterparts
+std::string sanitize_string(std::string str) {
+  // note: it's important that '&' is replaced first; therefor we *can't* use std::map
+  const std::pair<char, std::string> replacement_table[] = {
+      {'&', "&amp;"}, {'<', "&lt;"}, {'>', "&gt;"}, {'"', "&quot;"}, {'\'', "&apos;"}};
+  size_t startpoint;
+  for (size_t i = 0; i < (sizeof(replacement_table) / sizeof(replacement_table[0])); ++i) {
+    startpoint = 0;
+    std::pair pair = replacement_table[i];
+    while ((startpoint = str.find(pair.first, startpoint)) != std::string::npos) {
+      str.replace(startpoint, 1, pair.second);
+      startpoint += pair.second.length();
+    }
+  }
+
+  return str;
+}
+}  // namespace waybar::util

subprojects/catch2.wrap

@@ -1,12 +1,13 @@
 [wrap-file]
-directory = Catch2-2.13.7
-source_url = https://github.com/catchorg/Catch2/archive/v2.13.7.zip
-source_filename = Catch2-2.13.7.zip
-source_hash = 3f3ccd90ad3a8fbb1beeb15e6db440ccdcbebe378dfd125d07a1f9a587a927e9
-patch_filename = catch2_2.13.7-1_patch.zip
-patch_url = https://wrapdb.mesonbuild.com/v2/catch2_2.13.7-1/get_patch
-patch_hash = 2f7369645d747e5bd866317ac1dd4c3d04dc97d3aad4fc6b864bdf75d3b57158
+directory = Catch2-3.1.0
+source_url = https://github.com/catchorg/Catch2/archive/v3.1.0.tar.gz
+source_filename = Catch2-3.1.0.tar.gz
+source_hash = c252b2d9537e18046d8b82535069d2567f77043f8e644acf9a9fffc22ea6e6f7
+patch_filename = catch2_3.1.0-1_patch.zip
+patch_url = https://wrapdb.mesonbuild.com/v2/catch2_3.1.0-1/get_patch
+patch_hash = 4ebf4277aed574a9912a79f4817a310d837798e099bbafa6097be23a7f5e3ae4
+wrapdb_version = 3.1.0-1
 
 [provide]
 catch2 = catch2_dep
-
+catch2-with-main = catch2_with_main_dep

subprojects/date.wrap

@@ -1,9 +1,14 @@
 [wrap-file]
-source_url=https://github.com/HowardHinnant/date/archive/v3.0.0.tar.gz
-source_filename=date-3.0.0.tar.gz
-source_hash=87bba2eaf0ebc7ec539e5e62fc317cb80671a337c1fb1b84cb9e4d42c6dbebe3
-directory=date-3.0.0
+source_url = https://github.com/HowardHinnant/date/archive/v3.0.1.tar.gz
+source_filename = date-3.0.1.tar.gz
+source_hash = 7a390f200f0ccd207e8cff6757e04817c1a0aec3e327b006b7eb451c57ee3538
+directory = date-3.0.1
+patch_filename = hinnant-date_3.0.1-2_patch.zip
+patch_url = https://wrapdb.mesonbuild.com/v2/hinnant-date_3.0.1-2/get_patch
+patch_hash = 11b715b792609117a63310eeefc2939cc2ca26ecd4e996108335e504db58a41d
+wrapdb_version = 3.0.1-2
+
+[provide]
+tz = tz_dep
+date = date_dep
 
-patch_url = https://github.com/mesonbuild/hinnant-date/releases/download/3.0.0-1/hinnant-date.zip
-patch_filename = hinnant-date-3.0.0-1-wrap.zip
-patch_hash = 6ccaf70732d8bdbd1b6d5fdf3e1b935c23bf269bda12fdfd0e561276f63432fe