Merge branch 'master' into issue-1681

2023-07-04 22:49:35 +02:00
parent 15132aeec3 31e4c9023e
commit ee0958973b
174 changed files with 6310 additions and 1503 deletions
--- a/include/AButton.hpp
+++ b/include/AButton.hpp
@ -1,35 +0,0 @@
-#pragma once
-
-#include <glibmm/markup.h>
-#include <gtkmm/button.h>
-#include <gtkmm/cssprovider.h>
-#include <gtkmm/label.h>
-#include <json/json.h>
-
-#include "AModule.hpp"
-
-namespace waybar {
-
-class AButton : public AModule {
- public:
-  AButton(const Json::Value &, const std::string &, const std::string &, const std::string &format,
-          uint16_t interval = 0, bool ellipsize = false, bool enable_click = false,
-          bool enable_scroll = false);
-  virtual ~AButton() = default;
-  virtual auto update() -> void;
-  virtual std::string getIcon(uint16_t, const std::string &alt = "", uint16_t max = 0);
-  virtual std::string getIcon(uint16_t, const std::vector<std::string> &alts, uint16_t max = 0);
-
- protected:
-  Gtk::Button button_ = Gtk::Button(name_);
-  Gtk::Label *label_ = (Gtk::Label *)button_.get_child();
-  std::string format_;
-  const std::chrono::seconds interval_;
-  bool alt_ = false;
-  std::string default_format_;
-
-  virtual bool handleToggle(GdkEventButton *const &e);
-  virtual std::string getState(uint8_t value, bool lesser = false);
-};
-
-}  // namespace waybar
--- a/include/AIconLabel.hpp
+++ b/include/AIconLabel.hpp
@ -13,7 +13,7 @@ class AIconLabel : public ALabel {
             const std::string &format, uint16_t interval = 0, bool ellipsize = false,
             bool enable_click = false, bool enable_scroll = false);
  virtual ~AIconLabel() = default;
-  virtual auto update() -> void;
+  auto update() -> void override;

 protected:
  Gtk::Image image_;
--- a/include/ALabel.hpp
+++ b/include/ALabel.hpp
@ -14,7 +14,7 @@ class ALabel : public AModule {
         uint16_t interval = 0, bool ellipsize = false, bool enable_click = false,
         bool enable_scroll = false);
  virtual ~ALabel() = default;
-  virtual auto update() -> void;
+  auto update() -> void override;
  virtual std::string getIcon(uint16_t, const std::string &alt = "", uint16_t max = 0);
  virtual std::string getIcon(uint16_t, const std::vector<std::string> &alts, uint16_t max = 0);

@ -25,7 +25,7 @@ class ALabel : public AModule {
  bool alt_ = false;
  std::string default_format_;

-  virtual bool handleToggle(GdkEventButton *const &e);
+  bool handleToggle(GdkEventButton *const &e) override;
  virtual std::string getState(uint8_t value, bool lesser = false);
 };

--- a/include/AModule.hpp
+++ b/include/AModule.hpp
@ -11,15 +11,20 @@ namespace waybar {

 class AModule : public IModule {
 public:
-  AModule(const Json::Value &, const std::string &, const std::string &, bool enable_click = false,
-          bool enable_scroll = false);
  virtual ~AModule();
-  virtual auto update() -> void;
-  virtual operator Gtk::Widget &();
+  auto update() -> void override;
+  virtual auto refresh(int) -> void{};
+  operator Gtk::Widget &() override;
+  auto doAction(const std::string &name) -> void override;

  Glib::Dispatcher dp;

 protected:
+  // Don't need to make an object directly
+  // Derived classes are able to use it
+  AModule(const Json::Value &, const std::string &, const std::string &, bool enable_click = false,
+          bool enable_scroll = false);
+
  enum SCROLL_DIR { NONE, UP, DOWN, LEFT, RIGHT };

  SCROLL_DIR getScrollDir(GdkEventScroll *e);
@ -36,6 +41,7 @@ class AModule : public IModule {
 private:
  gdouble distance_scrolled_y_;
  gdouble distance_scrolled_x_;
+  std::map<std::string, std::string> eventActionMap_;
  static const inline std::map<std::pair<uint, GdkEventType>, std::string> eventMap_{
      {std::make_pair(1, GdkEventType::GDK_BUTTON_PRESS), "on-click"},
      {std::make_pair(1, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click"},
--- a/include/IModule.hpp
+++ b/include/IModule.hpp
@ -9,6 +9,7 @@ class IModule {
  virtual ~IModule() = default;
  virtual auto update() -> void = 0;
  virtual operator Gtk::Widget&() = 0;
+  virtual auto doAction(const std::string& name) -> void = 0;
 };

 }  // namespace waybar
--- a/include/factory.hpp
+++ b/include/factory.hpp
@ -1,7 +1,7 @@
 #pragma once

 #include <json/json.h>
-#ifdef HAVE_LIBDATE
+#if defined(HAVE_CHRONO_TIMEZONES) || defined(HAVE_LIBDATE)
 #include "modules/clock.hpp"
 #else
 #include "modules/simpleclock.hpp"
@ -18,14 +18,20 @@
 #include "modules/wlr/workspace_manager.hpp"
 #endif
 #ifdef HAVE_RIVER
+#include "modules/river/layout.hpp"
 #include "modules/river/mode.hpp"
 #include "modules/river/tags.hpp"
 #include "modules/river/window.hpp"
 #endif
+#ifdef HAVE_DWL
+#include "modules/dwl/tags.hpp"
+#endif
 #ifdef HAVE_HYPRLAND
 #include "modules/hyprland/backend.hpp"
 #include "modules/hyprland/language.hpp"
+#include "modules/hyprland/submap.hpp"
 #include "modules/hyprland/window.hpp"
+#include "modules/hyprland/workspaces.hpp"
 #endif
 #if defined(__FreeBSD__) || (defined(__linux__) && !defined(NO_FILESYSTEM))
 #include "modules/battery.hpp"
@ -41,6 +47,9 @@
 #ifdef HAVE_DBUSMENU
 #include "modules/sni/tray.hpp"
 #endif
+#ifdef HAVE_MPRIS
+#include "modules/mpris/mpris.hpp"
+#endif
 #ifdef HAVE_LIBNL
 #include "modules/network.hpp"
 #endif
@ -72,8 +81,15 @@
 #ifdef HAVE_LIBJACK
 #include "modules/jack.hpp"
 #endif
+#ifdef HAVE_LIBWIREPLUMBER
+#include "modules/wireplumber.hpp"
+#endif
+#ifdef HAVE_LIBCAVA
+#include "modules/cava.hpp"
+#endif
 #include "bar.hpp"
 #include "modules/custom.hpp"
+#include "modules/image.hpp"
 #include "modules/temperature.hpp"
 #include "modules/user.hpp"

--- a/include/group.hpp
+++ b/include/group.hpp
@ -12,10 +12,10 @@ namespace waybar {

 class Group : public AModule {
 public:
-  Group(const std::string&, const Bar&, const Json::Value&);
+  Group(const std::string&, const std::string&, const Json::Value&, bool);
  ~Group() = default;
-  auto update() -> void;
-  operator Gtk::Widget&();
+  auto update() -> void override;
+  operator Gtk::Widget&() override;
  Gtk::Box box;
 };

--- a/include/modules/backlight.hpp
+++ b/include/modules/backlight.hpp
@ -5,7 +5,8 @@
 #include <string_view>
 #include <vector>

-#include "AButton.hpp"
+#include "ALabel.hpp"
+#include "giomm/dbusproxy.h"
 #include "util/json.hpp"
 #include "util/sleeper_thread.hpp"

@ -14,7 +15,7 @@ struct udev_device;

 namespace waybar::modules {

-class Backlight : public AButton {
+class Backlight : public ALabel {
  class BacklightDev {
   public:
    BacklightDev() = default;
@ -39,8 +40,8 @@ class Backlight : public AButton {

 public:
  Backlight(const std::string &, const Json::Value &);
-  ~Backlight();
-  auto update() -> void;
+  virtual ~Backlight();
+  auto update() -> void override;

 private:
  template <class ForwardIt>
@ -50,6 +51,8 @@ class Backlight : public AButton {
  template <class ForwardIt, class Inserter>
  static void enumerate_devices(ForwardIt first, ForwardIt last, Inserter inserter, udev *udev);

+  bool handleScroll(GdkEventScroll *e) override;
+
  const std::string preferred_device_;
  static constexpr int EPOLL_MAX_EVENTS = 16;

@ -60,5 +63,7 @@ class Backlight : public AButton {
  std::vector<BacklightDev> devices_;
  // thread must destruct before shared data
  util::SleeperThread udev_thread_;
+
+  Glib::RefPtr<Gio::DBus::Proxy> login_proxy_;
 };
 }  // namespace waybar::modules
--- a/include/modules/battery.hpp
+++ b/include/modules/battery.hpp
@ -15,7 +15,7 @@
 #include <string>
 #include <vector>

-#include "AButton.hpp"
+#include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"

 namespace waybar::modules {
@ -26,11 +26,11 @@ namespace fs = std::experimental::filesystem;
 namespace fs = std::filesystem;
 #endif

-class Battery : public AButton {
+class Battery : public ALabel {
 public:
  Battery(const std::string&, const Json::Value&);
-  ~Battery();
-  auto update() -> void;
+  virtual ~Battery();
+  auto update() -> void override;

 private:
  static inline const fs::path data_dir_ = "/sys/class/power_supply/";
--- a/include/modules/bluetooth.hpp
+++ b/include/modules/bluetooth.hpp
@ -1,6 +1,6 @@
 #pragma once

-#include "AButton.hpp"
+#include "ALabel.hpp"
 #ifdef WANT_RFKILL
 #include "util/rfkill.hpp"
 #endif
@ -12,7 +12,7 @@

 namespace waybar::modules {

-class Bluetooth : public AButton {
+class Bluetooth : public ALabel {
  struct ControllerInfo {
    std::string path;
    std::string address;
@ -45,8 +45,8 @@ class Bluetooth : public AButton {

 public:
  Bluetooth(const std::string&, const Json::Value&);
-  ~Bluetooth() = default;
-  auto update() -> void;
+  virtual ~Bluetooth() = default;
+  auto update() -> void override;

 private:
  static auto onInterfaceAddedOrRemoved(GDBusObjectManager*, GDBusObject*, GDBusInterface*,
--- a/include/modules/cava.hpp
+++ b/include/modules/cava.hpp
@ -0,0 +1,46 @@
+#pragma once
+
+#include "ALabel.hpp"
+#include "util/sleeper_thread.hpp"
+
+extern "C" {
+#include <cava/common.h>
+}
+
+namespace waybar::modules {
+using namespace std::literals::chrono_literals;
+
+class Cava final : public ALabel {
+ public:
+  Cava(const std::string&, const Json::Value&);
+  virtual ~Cava();
+  auto update() -> void override;
+  auto doAction(const std::string& name) -> void override;
+
+ private:
+  util::SleeperThread thread_;
+  util::SleeperThread thread_fetch_input_;
+
+  struct error_s error_ {};          // cava errors
+  struct config_params prm_ {};      // cava parameters
+  struct audio_raw audio_raw_ {};    // cava handled raw audio data(is based on audio_data)
+  struct audio_data audio_data_ {};  // cava audio data
+  struct cava_plan* plan_;           //{new cava_plan{}};
+  // Cava API to read audio source
+  ptr input_source_;
+  // Delay to handle audio source
+  std::chrono::milliseconds frame_time_milsec_{1s};
+  // Text to display
+  std::string text_{""};
+  int rePaint_{1};
+  std::chrono::seconds fetch_input_delay_{4};
+  std::chrono::seconds suspend_silence_delay_{0};
+  bool silence_{false};
+  int sleep_counter_{0};
+  // Cava method
+  void pause_resume();
+  // ModuleActionMap
+  static inline std::map<const std::string, void (waybar::modules::Cava::*const)()> actionMap_{
+      {"mode", &waybar::modules::Cava::pause_resume}};
+};
+}  // namespace waybar::modules
--- a/include/modules/clock.hpp
+++ b/include/modules/clock.hpp
@ -1,44 +1,72 @@
 #pragma once

-#include <date/tz.h>
-
-#include "AButton.hpp"
+#include "ALabel.hpp"
+#include "util/date.hpp"
 #include "util/sleeper_thread.hpp"

-namespace waybar {
-
-struct waybar_time;
-
-namespace modules {
+namespace waybar::modules {

 const std::string kCalendarPlaceholder = "calendar";
 const std::string KTimezonedTimeListPlaceholder = "timezoned_time_list";

-class Clock : public AButton {
+enum class WeeksSide {
+  LEFT,
+  RIGHT,
+  HIDDEN,
+};
+
+enum class CldMode { MONTH, YEAR };
+
+class Clock final : public ALabel {
 public:
  Clock(const std::string&, const Json::Value&);
-  ~Clock() = default;
-  auto update() -> void;
+  virtual ~Clock() = default;
+  auto update() -> void override;
+  auto doAction(const std::string& name) -> void override;

 private:
  util::SleeperThread thread_;
  std::locale locale_;
  std::vector<const date::time_zone*> time_zones_;
  int current_time_zone_idx_;
-  date::year_month_day calendar_cached_ymd_{date::January / 1 / 0};
-  date::months calendar_shift_{0}, calendar_shift_init_{0};
-  std::string calendar_cached_text_;
  bool is_calendar_in_tooltip_;
  bool is_timezoned_list_in_tooltip_;

-  bool handleScroll(GdkEventScroll* e);
-
-  auto calendar_text(const waybar_time& wtime) -> std::string;
-  auto weekdays_header(const date::weekday& first_dow, std::ostream& os) -> void;
  auto first_day_of_week() -> date::weekday;
  const date::time_zone* current_timezone();
  bool is_timezone_fixed();
  auto timezones_text(std::chrono::system_clock::time_point* now) -> std::string;
+
+  /*Calendar properties*/
+  WeeksSide cldWPos_{WeeksSide::HIDDEN};
+  std::map<int, std::string const> fmtMap_;
+  CldMode cldMode_{CldMode::MONTH};
+  uint cldMonCols_{3};    // Count of the month in the row
+  int cldMonColLen_{20};  // Length of the month column
+  int cldWnLen_{3};       // Length of the week number
+  date::year_month_day cldYearShift_;
+  date::year_month cldMonShift_;
+  date::months cldCurrShift_{0};
+  date::months cldShift_{0};
+  std::string cldYearCached_{};
+  std::string cldMonCached_{};
+  date::day cldBaseDay_{0};
+  /*Calendar functions*/
+  auto get_calendar(const date::zoned_seconds& now, const date::zoned_seconds& wtime)
+      -> std::string;
+  /*Clock actions*/
+  void cldModeSwitch();
+  void cldShift_up();
+  void cldShift_down();
+  void tz_up();
+  void tz_down();
+
+  // ModuleActionMap
+  static inline std::map<const std::string, void (waybar::modules::Clock::*const)()> actionMap_{
+      {"mode", &waybar::modules::Clock::cldModeSwitch},
+      {"shift_up", &waybar::modules::Clock::cldShift_up},
+      {"shift_down", &waybar::modules::Clock::cldShift_down},
+      {"tz_up", &waybar::modules::Clock::tz_up},
+      {"tz_down", &waybar::modules::Clock::tz_down}};
 };
-}  // namespace modules
-}  // namespace waybar
+}  // namespace waybar::modules
--- a/include/modules/cpu.hpp
+++ b/include/modules/cpu.hpp
@ -9,16 +9,16 @@
 #include <utility>
 #include <vector>

-#include "AButton.hpp"
+#include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"

 namespace waybar::modules {

-class Cpu : public AButton {
+class Cpu : public ALabel {
 public:
  Cpu(const std::string&, const Json::Value&);
-  ~Cpu() = default;
-  auto update() -> void;
+  virtual ~Cpu() = default;
+  auto update() -> void override;

 private:
  double getCpuLoad();
--- a/include/modules/custom.hpp
+++ b/include/modules/custom.hpp
@ -5,19 +5,19 @@
 #include <csignal>
 #include <string>

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

 namespace waybar::modules {

-class Custom : public AButton {
+class Custom : public ALabel {
 public:
  Custom(const std::string&, const std::string&, const Json::Value&);
-  ~Custom();
-  auto update() -> void;
-  void refresh(int /*signal*/);
+  virtual ~Custom();
+  auto update() -> void override;
+  void refresh(int /*signal*/) override;

 private:
  void delayWorker();
@ -25,8 +25,8 @@ class Custom : public AButton {
  void parseOutputRaw();
  void parseOutputJson();
  void handleEvent();
-  bool handleScroll(GdkEventScroll* e);
-  bool handleToggle(GdkEventButton* const& e);
+  bool handleScroll(GdkEventScroll* e) override;
+  bool handleToggle(GdkEventButton* const& e) override;

  const std::string name_;
  std::string text_;
--- a/include/modules/disk.hpp
+++ b/include/modules/disk.hpp
@ -5,17 +5,17 @@

 #include <fstream>

-#include "AButton.hpp"
+#include "ALabel.hpp"
 #include "util/format.hpp"
 #include "util/sleeper_thread.hpp"

 namespace waybar::modules {

-class Disk : public AButton {
+class Disk : public ALabel {
 public:
  Disk(const std::string&, const Json::Value&);
-  ~Disk() = default;
-  auto update() -> void;
+  virtual ~Disk() = default;
+  auto update() -> void override;

 private:
  util::SleeperThread thread_;
--- a/include/modules/dwl/tags.hpp
+++ b/include/modules/dwl/tags.hpp
@ -0,0 +1,34 @@
+#pragma once
+
+#include <gtkmm/button.h>
+#include <wayland-client.h>
+
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "dwl-ipc-unstable-v2-client-protocol.h"
+#include "xdg-output-unstable-v1-client-protocol.h"
+
+namespace waybar::modules::dwl {
+
+class Tags : public waybar::AModule {
+ public:
+  Tags(const std::string &, const waybar::Bar &, const Json::Value &);
+  virtual ~Tags();
+
+  // Handlers for wayland events
+  void handle_view_tags(uint32_t tag, uint32_t state, uint32_t clients, uint32_t focused);
+
+  void handle_primary_clicked(uint32_t tag);
+  bool handle_button_press(GdkEventButton *event_button, uint32_t tag);
+
+  struct zdwl_ipc_manager_v2 *status_manager_;
+  struct wl_seat *seat_;
+
+ private:
+  const waybar::Bar &bar_;
+  Gtk::Box box_;
+  std::vector<Gtk::Button> buttons_;
+  struct zdwl_ipc_output_v2 *output_status_;
+};
+
+} /* namespace waybar::modules::dwl */
--- a/include/modules/gamemode.hpp
+++ b/include/modules/gamemode.hpp
@ -18,8 +18,8 @@ namespace waybar::modules {
 class Gamemode : public AModule {
 public:
  Gamemode(const std::string &, const Json::Value &);
-  ~Gamemode();
-  auto update() -> void;
+  virtual ~Gamemode();
+  auto update() -> void override;

 private:
  const std::string DEFAULT_ICON_NAME = "input-gaming-symbolic";
@ -39,7 +39,7 @@ class Gamemode : public AModule {
                 const Glib::VariantContainerBase &arguments);

  void getData();
-  bool handleToggle(GdkEventButton *const &);
+  bool handleToggle(GdkEventButton *const &) override;

  // Config
  std::string format = DEFAULT_FORMAT;
--- a/include/modules/hyprland/backend.hpp
+++ b/include/modules/hyprland/backend.hpp
@ -1,15 +1,17 @@
 #pragma once
-#include <list>
 #include <functional>
+#include <list>
 #include <memory>
 #include <mutex>
 #include <string>
 #include <thread>

+#include "util/json.hpp"
+
 namespace waybar::modules::hyprland {

 class EventHandler {
-public:
+ public:
  virtual void onEvent(const std::string& ev) = 0;
  virtual ~EventHandler() = default;
 };
@ -22,12 +24,14 @@ class IPC {
  void unregisterForIPC(EventHandler*);

  std::string getSocket1Reply(const std::string& rq);
+  Json::Value getSocket1JsonReply(const std::string& rq);

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

  std::mutex callbackMutex;
+  util::JsonParser parser_;
  std::list<std::pair<std::string, EventHandler*>> callbacks;
 };

--- a/include/modules/hyprland/language.hpp
+++ b/include/modules/hyprland/language.hpp
@ -1,30 +1,38 @@
 #include <fmt/format.h>

-#include "AButton.hpp"
+#include "ALabel.hpp"
 #include "bar.hpp"
 #include "modules/hyprland/backend.hpp"
 #include "util/json.hpp"

 namespace waybar::modules::hyprland {

-class Language : public waybar::AButton,
-public EventHandler {
+class Language : public waybar::ALabel, public EventHandler {
 public:
  Language(const std::string&, const waybar::Bar&, const Json::Value&);
-  ~Language();
+  virtual ~Language();

-  auto update() -> void;
+  auto update() -> void override;

 private:
-  void onEvent(const std::string&);
+  void onEvent(const std::string&) override;

  void initLanguage();
-  std::string getShortFrom(const std::string&);
+
+  struct Layout {
+    std::string full_name;
+    std::string short_name;
+    std::string variant;
+    std::string short_description;
+  };
+
+  auto getLayout(const std::string&) -> Layout;

  std::mutex mutex_;
  const Bar& bar_;
  util::JsonParser parser_;
-  std::string layoutName_;
+
+  Layout layout_;
 };

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

-#include <tuple>
-
 #include "ALabel.hpp"
 #include "bar.hpp"
 #include "modules/hyprland/backend.hpp"
@ -9,24 +7,40 @@

 namespace waybar::modules::hyprland {

-class Window : public waybar::ALabel,
- public EventHandler {
+class Window : public waybar::ALabel, public EventHandler {
 public:
  Window(const std::string&, const waybar::Bar&, const Json::Value&);
-  ~Window();
+  virtual ~Window();

-  auto update() -> void;
+  auto update() -> void override;

 private:
-  uint getActiveWorkspaceID(std::string);
-  std::string getLastWindowTitle(uint);
-  void onEvent(const std::string&);
+  struct Workspace {
+    int id;
+    int windows;
+    std::string last_window;
+    std::string last_window_title;
+
+    static auto parse(const Json::Value&) -> Workspace;
+  };
+
+  auto getActiveWorkspace(const std::string&) -> Workspace;
+  auto getActiveWorkspace() -> Workspace;
+  void onEvent(const std::string&) override;
+  void queryActiveWorkspace();
+  void setClass(const std::string&, bool enable);

  bool separate_outputs;
  std::mutex mutex_;
  const Bar& bar_;
  util::JsonParser parser_;
-  std::string lastView;
+  std::string last_title_;
+  Workspace workspace_;
+  std::string solo_class_;
+  std::string last_solo_class_;
+  bool solo_;
+  bool all_floating_;
+  bool fullscreen_;
 };

 }  // namespace waybar::modules::hyprland
--- a/include/modules/hyprland/workspaces.hpp
+++ b/include/modules/hyprland/workspaces.hpp
@ -0,0 +1,64 @@
+#include <gtkmm/button.h>
+#include <gtkmm/label.h>
+
+#include <memory>
+
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "modules/hyprland/backend.hpp"
+
+namespace waybar::modules::hyprland {
+
+struct WorkspaceDto {
+  int id;
+
+  static WorkspaceDto parse(const Json::Value& value);
+};
+
+class Workspace {
+ public:
+  Workspace(int id);
+  Workspace(WorkspaceDto dto);
+  int id() const { return id_; };
+  int active() const { return active_; };
+  std::string& select_icon(std::map<std::string, std::string>& icons_map);
+  void set_active(bool value = true) { active_ = value; };
+  Gtk::Button& button() { return button_; };
+
+  void update(const std::string& format, const std::string& icon);
+
+ private:
+  int id_;
+  bool active_;
+
+  Gtk::Button button_;
+  Gtk::Box content_;
+  Gtk::Label label_;
+};
+
+class Workspaces : public AModule, public EventHandler {
+ public:
+  Workspaces(const std::string&, const waybar::Bar&, const Json::Value&);
+  virtual ~Workspaces();
+  void update() override;
+  void init();
+
+ private:
+  void onEvent(const std::string&) override;
+  void sort_workspaces();
+  void create_workspace(int id);
+  void remove_workspace(int id);
+
+  std::string format_;
+  std::map<std::string, std::string> icons_map_;
+  bool with_icon_;
+  int active_workspace_id;
+  std::vector<std::unique_ptr<Workspace>> workspaces_;
+  std::vector<int> workspaces_to_create_;
+  std::vector<int> workspaces_to_remove_;
+  std::mutex mutex_;
+  const Bar& bar_;
+  Gtk::Box box_;
+};
+
+}  // namespace waybar::modules::hyprland
--- a/include/modules/idle_inhibitor.hpp
+++ b/include/modules/idle_inhibitor.hpp
@ -2,24 +2,24 @@

 #include <fmt/format.h>

-#include "AButton.hpp"
+#include "ALabel.hpp"
 #include "bar.hpp"
 #include "client.hpp"

 namespace waybar::modules {

-class IdleInhibitor : public AButton {
+class IdleInhibitor : public ALabel {
  sigc::connection timeout_;

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

 private:
-  bool handleToggle(GdkEventButton* const& e);
+  bool handleToggle(GdkEventButton* const& e) override;
  void toggleStatus();

  const Bar& bar_;
--- a/include/modules/image.hpp
+++ b/include/modules/image.hpp
@ -0,0 +1,40 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <gtkmm/image.h>
+
+#include <csignal>
+#include <string>
+
+#include "ALabel.hpp"
+#include "gtkmm/box.h"
+#include "util/command.hpp"
+#include "util/json.hpp"
+#include "util/sleeper_thread.hpp"
+
+namespace waybar::modules {
+
+class Image : public AModule {
+ public:
+  Image(const std::string&, const Json::Value&);
+  virtual ~Image() = default;
+  auto update() -> void override;
+  void refresh(int /*signal*/) override;
+
+ private:
+  void delayWorker();
+  void handleEvent();
+  void parseOutputRaw();
+
+  Gtk::Box box_;
+  Gtk::Image image_;
+  std::string path_;
+  std::string tooltip_;
+  int size_;
+  int interval_;
+  util::command::res output_;
+
+  util::SleeperThread thread_;
+};
+
+}  // namespace waybar::modules
--- a/include/modules/inhibitor.hpp
+++ b/include/modules/inhibitor.hpp
@ -4,20 +4,20 @@

 #include <memory>

-#include "AButton.hpp"
+#include "ALabel.hpp"
 #include "bar.hpp"

 namespace waybar::modules {

-class Inhibitor : public AButton {
+class Inhibitor : public ALabel {
 public:
  Inhibitor(const std::string&, const waybar::Bar&, const Json::Value&);
-  ~Inhibitor() override;
-  auto update() -> void;
+  virtual ~Inhibitor();
+  auto update() -> void override;
  auto activated() -> bool;

 private:
-  auto handleToggle(::GdkEventButton* const& e) -> bool;
+  auto handleToggle(::GdkEventButton* const& e) -> bool override;

  const std::unique_ptr<::GDBusConnection, void (*)(::GDBusConnection*)> dbus_;
  const std::string inhibitors_;
--- a/include/modules/jack.hpp
+++ b/include/modules/jack.hpp
@ -14,8 +14,8 @@ namespace waybar::modules {
 class JACK : public ALabel {
 public:
  JACK(const std::string &, const Json::Value &);
-  ~JACK() = default;
-  auto update() -> void;
+  virtual ~JACK() = default;
+  auto update() -> void override;

  int bufSize(jack_nframes_t size);
  int sampleRate(jack_nframes_t rate);
--- a/include/modules/keyboard_state.hpp
+++ b/include/modules/keyboard_state.hpp
@ -19,8 +19,8 @@ namespace waybar::modules {
 class KeyboardState : public AModule {
 public:
  KeyboardState(const std::string&, const waybar::Bar&, const Json::Value&);
-  ~KeyboardState();
-  auto update() -> void;
+  virtual ~KeyboardState();
+  auto update() -> void override;

 private:
  auto tryAddDevice(const std::string&) -> void;
--- a/include/modules/memory.hpp
+++ b/include/modules/memory.hpp
@ -5,16 +5,16 @@
 #include <fstream>
 #include <unordered_map>

-#include "AButton.hpp"
+#include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"

 namespace waybar::modules {

-class Memory : public AButton {
+class Memory : public ALabel {
 public:
  Memory(const std::string&, const Json::Value&);
-  ~Memory() = default;
-  auto update() -> void;
+  virtual ~Memory() = default;
+  auto update() -> void override;

 private:
  void parseMeminfo();
--- a/include/modules/mpd/mpd.hpp
+++ b/include/modules/mpd/mpd.hpp
@ -7,12 +7,12 @@
 #include <condition_variable>
 #include <thread>

-#include "AButton.hpp"
+#include "ALabel.hpp"
 #include "modules/mpd/state.hpp"

 namespace waybar::modules {

-class MPD : public AButton {
+class MPD : public ALabel {
  friend class detail::Context;

  // State machine
@ -37,7 +37,7 @@ class MPD : public AButton {
 public:
  MPD(const std::string&, const Json::Value&);
  virtual ~MPD() noexcept = default;
-  auto update() -> void;
+  auto update() -> void override;

 private:
  std::string getTag(mpd_tag_type type, unsigned idx = 0) const;
--- a/include/modules/mpd/state.hpp
+++ b/include/modules/mpd/state.hpp
@ -7,7 +7,7 @@
 #include <condition_variable>
 #include <thread>

-#include "AButton.hpp"
+#include "ALabel.hpp"

 namespace waybar::modules {
 class MPD;
--- a/include/modules/mpris/mpris.hpp
+++ b/include/modules/mpris/mpris.hpp
@ -0,0 +1,88 @@
+#pragma once
+
+#include <iostream>
+#include <optional>
+#include <string>
+
+#include "gtkmm/box.h"
+#include "gtkmm/label.h"
+
+extern "C" {
+#include <playerctl/playerctl.h>
+}
+
+#include "ALabel.hpp"
+#include "util/sleeper_thread.hpp"
+
+namespace waybar::modules::mpris {
+
+class Mpris : public ALabel {
+ public:
+  Mpris(const std::string&, const Json::Value&);
+  virtual ~Mpris();
+  auto update() -> void override;
+  bool handleToggle(GdkEventButton* const&) override;
+
+ private:
+  static auto onPlayerNameAppeared(PlayerctlPlayerManager*, PlayerctlPlayerName*, gpointer) -> void;
+  static auto onPlayerNameVanished(PlayerctlPlayerManager*, PlayerctlPlayerName*, gpointer) -> void;
+  static auto onPlayerPlay(PlayerctlPlayer*, gpointer) -> void;
+  static auto onPlayerPause(PlayerctlPlayer*, gpointer) -> void;
+  static auto onPlayerStop(PlayerctlPlayer*, gpointer) -> void;
+  static auto onPlayerMetadata(PlayerctlPlayer*, GVariant*, gpointer) -> void;
+
+  struct PlayerInfo {
+    std::string name;
+    PlayerctlPlaybackStatus status;
+    std::string status_string;
+
+    std::optional<std::string> artist;
+    std::optional<std::string> album;
+    std::optional<std::string> title;
+    std::optional<std::string> length;    // as HH:MM:SS
+    std::optional<std::string> position;  // same format
+  };
+
+  auto getPlayerInfo() -> std::optional<PlayerInfo>;
+  auto getIconFromJson(const Json::Value&, const std::string&) -> std::string;
+  auto getArtistStr(const PlayerInfo&, bool) -> std::string;
+  auto getAlbumStr(const PlayerInfo&, bool) -> std::string;
+  auto getTitleStr(const PlayerInfo&, bool) -> std::string;
+  auto getLengthStr(const PlayerInfo&, bool) -> std::string;
+  auto getPositionStr(const PlayerInfo&, bool) -> std::string;
+  auto getDynamicStr(const PlayerInfo&, bool, bool) -> std::string;
+
+  // config
+  std::string format_playing_;
+  std::string format_paused_;
+  std::string format_stopped_;
+
+  std::string tooltip_;
+  std::string tooltip_playing_;
+  std::string tooltip_paused_;
+  std::string tooltip_stopped_;
+
+  int artist_len_;
+  int album_len_;
+  int title_len_;
+  int dynamic_len_;
+  std::string dynamic_separator_;
+  std::vector<std::string> dynamic_order_;
+  std::vector<std::string> dynamic_prio_;
+  bool truncate_hours_;
+  bool tooltip_len_limits_;
+  std::string ellipsis_;
+
+  std::string player_;
+  std::vector<std::string> ignored_players_;
+
+  PlayerctlPlayerManager* manager;
+  PlayerctlPlayer* player;
+  std::string lastStatus;
+  std::string lastPlayer;
+
+  util::SleeperThread thread_;
+  std::chrono::time_point<std::chrono::system_clock> last_update_;
+};
+
+}  // namespace waybar::modules::mpris
--- a/include/modules/network.hpp
+++ b/include/modules/network.hpp
@ -10,7 +10,7 @@

 #include <optional>

-#include "AButton.hpp"
+#include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 #ifdef WANT_RFKILL
 #include "util/rfkill.hpp"
@ -18,11 +18,11 @@

 namespace waybar::modules {

-class Network : public AButton {
+class Network : public ALabel {
 public:
  Network(const std::string&, const Json::Value&);
-  ~Network();
-  auto update() -> void;
+  virtual ~Network();
+  auto update() -> void override;

 private:
  static const uint8_t MAX_RETRY = 5;
@ -62,6 +62,7 @@ class Network : public AButton {
  bool want_link_dump_;
  bool want_addr_dump_;
  bool dump_in_progress_;
+  bool is_p2p_;

  unsigned long long bandwidth_down_total_;
  unsigned long long bandwidth_up_total_;
@ -77,7 +78,6 @@ class Network : public AButton {
  int32_t signal_strength_dbm_;
  uint8_t signal_strength_;
  std::string signal_strength_app_;
-  float frequency_;
  uint32_t route_priority;

  util::SleeperThread thread_;
@ -85,6 +85,7 @@ class Network : public AButton {
 #ifdef WANT_RFKILL
  util::Rfkill rfkill_;
 #endif
+  float frequency_;
 };

 }  // namespace waybar::modules
--- a/include/modules/pulseaudio.hpp
+++ b/include/modules/pulseaudio.hpp
@ -7,15 +7,15 @@
 #include <algorithm>
 #include <array>

-#include "AButton.hpp"
+#include "ALabel.hpp"

 namespace waybar::modules {

-class Pulseaudio : public AButton {
+class Pulseaudio : public ALabel {
 public:
  Pulseaudio(const std::string&, const Json::Value&);
-  ~Pulseaudio();
-  auto update() -> void;
+  virtual ~Pulseaudio();
+  auto update() -> void override;

 private:
  static void subscribeCb(pa_context*, pa_subscription_event_type_t, uint32_t, void*);
@ -25,7 +25,7 @@ class Pulseaudio : public AButton {
  static void serverInfoCb(pa_context*, const pa_server_info*, void*);
  static void volumeModifyCb(pa_context*, int, void*);

-  bool handleScroll(GdkEventScroll* e);
+  bool handleScroll(GdkEventScroll* e) override;
  const std::vector<std::string> getPulseIcon() const;

  pa_threaded_mainloop* mainloop_;
--- a/include/modules/river/layout.hpp
+++ b/include/modules/river/layout.hpp
@ -0,0 +1,33 @@
+#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 Layout : public waybar::ALabel {
+ public:
+  Layout(const std::string &, const waybar::Bar &, const Json::Value &);
+  virtual ~Layout();
+
+  // Handlers for wayland events
+  void handle_name(const char *name);
+  void handle_clear();
+  void handle_focused_output(struct wl_output *output);
+  void handle_unfocused_output(struct wl_output *output);
+
+  struct zriver_status_manager_v1 *status_manager_;
+  struct wl_seat *seat_;
+
+ private:
+  const waybar::Bar &bar_;
+  struct wl_output *output_;          // stores the output this module belongs to
+  struct wl_output *focused_output_;  // stores the currently focused output
+  struct zriver_output_status_v1 *output_status_;
+  struct zriver_seat_status_v1 *seat_status_;
+};
+
+} /* namespace waybar::modules::river */
--- a/include/modules/river/mode.hpp
+++ b/include/modules/river/mode.hpp
@ -11,7 +11,7 @@ namespace waybar::modules::river {
 class Mode : public waybar::ALabel {
 public:
  Mode(const std::string &, const waybar::Bar &, const Json::Value &);
-  ~Mode();
+  virtual ~Mode();

  // Handlers for wayland events
  void handle_mode(const char *mode);
--- a/include/modules/river/tags.hpp
+++ b/include/modules/river/tags.hpp
@ -14,7 +14,7 @@ namespace waybar::modules::river {
 class Tags : public waybar::AModule {
 public:
  Tags(const std::string &, const waybar::Bar &, const Json::Value &);
-  ~Tags();
+  virtual ~Tags();

  // Handlers for wayland events
  void handle_focused_tags(uint32_t tags);
--- a/include/modules/river/window.hpp
+++ b/include/modules/river/window.hpp
@ -13,7 +13,7 @@ namespace waybar::modules::river {
 class Window : public waybar::ALabel {
 public:
  Window(const std::string &, const waybar::Bar &, const Json::Value &);
-  ~Window();
+  virtual ~Window();

  // Handlers for wayland events
  void handle_focused_view(const char *title);
--- a/include/modules/simpleclock.hpp
+++ b/include/modules/simpleclock.hpp
@ -2,16 +2,16 @@

 #include <fmt/chrono.h>

-#include "AButton.hpp"
+#include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"

 namespace waybar::modules {

-class Clock : public AButton {
+class Clock : public ALabel {
 public:
  Clock(const std::string&, const Json::Value&);
-  ~Clock() = default;
-  auto update() -> void;
+  virtual ~Clock() = default;
+  auto update() -> void override;

 private:
  util::SleeperThread thread_;
--- a/include/modules/sndio.hpp
+++ b/include/modules/sndio.hpp
@ -4,20 +4,20 @@

 #include <vector>

-#include "AButton.hpp"
+#include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"

 namespace waybar::modules {

-class Sndio : public AButton {
+class Sndio : public ALabel {
 public:
  Sndio(const std::string &, const Json::Value &);
-  ~Sndio();
-  auto update() -> void;
+  virtual ~Sndio();
+  auto update() -> void override;
  auto set_desc(struct sioctl_desc *, unsigned int) -> void;
  auto put_val(unsigned int, unsigned int) -> void;
-  bool handleScroll(GdkEventScroll *);
-  bool handleToggle(GdkEventButton *const &);
+  bool handleScroll(GdkEventScroll *) override;
+  bool handleToggle(GdkEventButton *const &) override;

 private:
  auto connect_to_sndio() -> void;
--- a/include/modules/sni/tray.hpp
+++ b/include/modules/sni/tray.hpp
@ -13,8 +13,8 @@ namespace waybar::modules::SNI {
 class Tray : public AModule {
 public:
  Tray(const std::string&, const Bar&, const Json::Value&);
-  ~Tray() = default;
-  auto update() -> void;
+  virtual ~Tray() = default;
+  auto update() -> void override;

 private:
  void onAdd(std::unique_ptr<Item>& item);
--- a/include/modules/sway/ipc/client.hpp
+++ b/include/modules/sway/ipc/client.hpp
@ -8,6 +8,8 @@
 #include <cstring>
 #include <memory>
 #include <mutex>
+#include <stdexcept>
+#include <string>

 #include "ipc.hpp"
 #include "util/sleeper_thread.hpp"
--- a/include/modules/sway/language.hpp
+++ b/include/modules/sway/language.hpp
@ -6,7 +6,7 @@
 #include <map>
 #include <string>

-#include "AButton.hpp"
+#include "ALabel.hpp"
 #include "bar.hpp"
 #include "client.hpp"
 #include "modules/sway/ipc/client.hpp"
@ -14,11 +14,11 @@

 namespace waybar::modules::sway {

-class Language : public AButton, public sigc::trackable {
+class Language : public ALabel, public sigc::trackable {
 public:
  Language(const std::string& id, const Json::Value& config);
-  ~Language() = default;
-  auto update() -> void;
+  virtual ~Language() = default;
+  auto update() -> void override;

 private:
  enum class DispayedShortFlag { None = 0, ShortName = 1, ShortDescription = 1 << 1 };
--- a/include/modules/sway/mode.hpp
+++ b/include/modules/sway/mode.hpp
@ -2,7 +2,7 @@

 #include <fmt/format.h>

-#include "AButton.hpp"
+#include "ALabel.hpp"
 #include "bar.hpp"
 #include "client.hpp"
 #include "modules/sway/ipc/client.hpp"
@ -10,11 +10,11 @@

 namespace waybar::modules::sway {

-class Mode : public AButton, public sigc::trackable {
+class Mode : public ALabel, public sigc::trackable {
 public:
  Mode(const std::string&, const Json::Value&);
-  ~Mode() = default;
-  auto update() -> void;
+  virtual ~Mode() = default;
+  auto update() -> void override;

 private:
  void onEvent(const struct Ipc::ipc_response&);
--- a/include/modules/sway/scratchpad.hpp
+++ b/include/modules/sway/scratchpad.hpp
@ -15,8 +15,8 @@ namespace waybar::modules::sway {
 class Scratchpad : public ALabel {
 public:
  Scratchpad(const std::string&, const Json::Value&);
-  ~Scratchpad() = default;
-  auto update() -> void;
+  virtual ~Scratchpad() = default;
+  auto update() -> void override;

 private:
  auto getTree() -> void;
@ -32,4 +32,4 @@ class Scratchpad : public ALabel {
  Ipc ipc_;
  util::JsonParser parser_;
 };
-}  // namespace waybar::modules::sway
+}  // namespace waybar::modules::sway
--- a/include/modules/sway/window.hpp
+++ b/include/modules/sway/window.hpp
@ -15,14 +15,15 @@ namespace waybar::modules::sway {
 class Window : public AIconLabel, public sigc::trackable {
 public:
  Window(const std::string&, const waybar::Bar&, const Json::Value&);
-  ~Window() = default;
-  auto update() -> void;
+  virtual ~Window() = default;
+  auto update() -> void override;

 private:
+  void setClass(std::string classname, bool enable);
  void onEvent(const struct Ipc::ipc_response&);
  void onCmd(const struct Ipc::ipc_response&);
-  std::tuple<std::size_t, int, std::string, std::string, std::string, std::string> getFocusedNode(
-      const Json::Value& nodes, std::string& output);
+  std::tuple<std::size_t, int, int, std::string, std::string, std::string, std::string, std::string>
+  getFocusedNode(const Json::Value& nodes, std::string& output);
  void getTree();
  void updateAppIconName();
  void updateAppIcon();
@ -32,12 +33,14 @@ class Window : public AIconLabel, public sigc::trackable {
  int windowId_;
  std::string app_id_;
  std::string app_class_;
+  std::string layout_;
  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_;
+  int floating_count_;
  util::JsonParser parser_;
  std::mutex mutex_;
  Ipc ipc_;
--- a/include/modules/sway/workspaces.hpp
+++ b/include/modules/sway/workspaces.hpp
@ -4,6 +4,7 @@
 #include <gtkmm/button.h>
 #include <gtkmm/label.h>

+#include <string_view>
 #include <unordered_map>

 #include "AModule.hpp"
@ -17,11 +18,13 @@ namespace waybar::modules::sway {
 class Workspaces : public AModule, public sigc::trackable {
 public:
  Workspaces(const std::string&, const waybar::Bar&, const Json::Value&);
-  ~Workspaces() = default;
-  auto update() -> void;
+  virtual ~Workspaces() = default;
+  auto update() -> void override;

 private:
-  static inline const std::string workspace_switch_cmd_ = "workspace {} \"{}\"";
+  static constexpr std::string_view workspace_switch_cmd_ = "workspace {} \"{}\"";
+  static constexpr std::string_view persistent_workspace_switch_cmd_ =
+      R"(workspace {} "{}"; move workspace to output "{}"; workspace {} "{}")";

  static int convertWorkspaceNameToNum(std::string name);

@ -34,7 +37,7 @@ class Workspaces : public AModule, public sigc::trackable {
  const std::string getCycleWorkspace(std::vector<Json::Value>::iterator, bool prev) const;
  uint16_t getWorkspaceIndex(const std::string& name) const;
  std::string trimWorkspaceName(std::string);
-  bool handleScroll(GdkEventScroll*);
+  bool handleScroll(GdkEventScroll*) override;

  const Bar& bar_;
  std::vector<Json::Value> workspaces_;
--- a/include/modules/temperature.hpp
+++ b/include/modules/temperature.hpp
@ -4,16 +4,16 @@

 #include <fstream>

-#include "AButton.hpp"
+#include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"

 namespace waybar::modules {

-class Temperature : public AButton {
+class Temperature : public ALabel {
 public:
  Temperature(const std::string&, const Json::Value&);
-  ~Temperature() = default;
-  auto update() -> void;
+  virtual ~Temperature() = default;
+  auto update() -> void override;

 private:
  float getTemperature();
--- a/include/modules/upower/upower.hpp
+++ b/include/modules/upower/upower.hpp
@ -19,8 +19,8 @@ namespace waybar::modules::upower {
 class UPower : public AModule {
 public:
  UPower(const std::string &, const Json::Value &);
-  ~UPower();
-  auto update() -> void;
+  virtual ~UPower();
+  auto update() -> void override;

 private:
  typedef std::unordered_map<std::string, UpDevice *> Devices;
@ -45,7 +45,7 @@ class UPower : public AModule {
  void resetDevices();
  void removeDevices();
  bool show_tooltip_callback(int, int, bool, const Glib::RefPtr<Gtk::Tooltip> &tooltip);
-  bool handleToggle(GdkEventButton *const &);
+  bool handleToggle(GdkEventButton *const &) override;
  std::string timeToString(gint64 time);

  const std::string getDeviceStatus(UpDeviceState &state);
@ -74,6 +74,7 @@ class UPower : public AModule {
  bool showAltText;
  bool upowerRunning;
  guint upowerWatcher_id;
+  std::string nativePath_;
 };

 }  // namespace waybar::modules::upower
--- a/include/modules/upower/upower_tooltip.hpp
+++ b/include/modules/upower/upower_tooltip.hpp
@ -24,7 +24,7 @@ class UPowerTooltip : public Gtk::Window {

 public:
  UPowerTooltip(uint iconSize, uint tooltipSpacing, uint tooltipPadding);
-  ~UPowerTooltip();
+  virtual ~UPowerTooltip();

  uint updateTooltip(Devices& devices);
 };
--- a/include/modules/user.hpp
+++ b/include/modules/user.hpp
@ -11,21 +11,21 @@ namespace waybar::modules {
 class User : public AIconLabel {
 public:
  User(const std::string&, const Json::Value&);
-  ~User() = default;
-  auto update() -> void;
+  virtual ~User() = default;
+  auto update() -> void override;
+
+  bool handleToggle(GdkEventButton* const& e) override;

 private:
  util::SleeperThread thread_;

-  Glib::RefPtr<Gdk::Pixbuf> pixbuf_;
-
  static constexpr inline int defaultUserImageWidth_ = 20;
  static constexpr inline int defaultUserImageHeight_ = 20;

  long uptime_as_seconds();
-  std::string get_user_login();
-  std::string get_user_home_dir();
-  std::string get_default_user_avatar_path();
+  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);
--- a/include/modules/wireplumber.hpp
+++ b/include/modules/wireplumber.hpp
@ -0,0 +1,46 @@
+#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&);
+  virtual ~Wireplumber();
+  auto update() -> void override;
+
+ private:
+  void loadRequiredApiModules();
+  void prepare();
+  void activatePlugins();
+  static void updateVolume(waybar::modules::Wireplumber* self, uint32_t id);
+  static void updateNodeName(waybar::modules::Wireplumber* self, uint32_t id);
+  static void onPluginActivated(WpObject* p, GAsyncResult* res, waybar::modules::Wireplumber* self);
+  static void onObjectManagerInstalled(waybar::modules::Wireplumber* self);
+  static void onMixerChanged(waybar::modules::Wireplumber* self, uint32_t id);
+  static void onDefaultNodesApiChanged(waybar::modules::Wireplumber* self);
+
+  bool handleScroll(GdkEventScroll* e) override;
+
+  WpCore* wp_core_;
+  GPtrArray* apis_;
+  WpObjectManager* om_;
+  WpPlugin* mixer_api_;
+  WpPlugin* def_nodes_api_;
+  gchar* default_node_name_;
+  uint32_t pending_plugins_;
+  bool muted_;
+  double volume_;
+  double min_step_;
+  uint32_t node_id_{0};
+  std::string node_name_;
+};
+
+}  // namespace waybar::modules
--- a/include/modules/wlr/taskbar.hpp
+++ b/include/modules/wlr/taskbar.hpp
@ -40,6 +40,8 @@ class Task {
    FULLSCREEN = (1 << 3),
    INVALID = (1 << 4)
  };
+  // made public so TaskBar can reorder based on configuration.
+  Gtk::Button button;

 private:
  static uint32_t global_id;
@ -53,7 +55,6 @@ class Task {

  uint32_t id_;

-  Gtk::Button button_;
  Gtk::Box content_;
  Gtk::Image icon_;
  Gtk::Label text_before_;
--- a/include/modules/wlr/workspace_manager.hpp
+++ b/include/modules/wlr/workspace_manager.hpp
@ -22,7 +22,7 @@ class WorkspaceGroup;
 class Workspace {
 public:
  Workspace(const waybar::Bar &bar, const Json::Value &config, WorkspaceGroup &workspace_group,
-            zext_workspace_handle_v1 *workspace, uint32_t id);
+            zext_workspace_handle_v1 *workspace, uint32_t id, std::string name);
  ~Workspace();
  auto update() -> void;

@ -30,11 +30,15 @@ class Workspace {
  auto is_active() const -> bool { return state_ & static_cast<uint32_t>(State::ACTIVE); }
  auto is_urgent() const -> bool { return state_ & static_cast<uint32_t>(State::URGENT); }
  auto is_hidden() const -> bool { return state_ & static_cast<uint32_t>(State::HIDDEN); }
+  auto is_empty() const -> bool { return state_ & static_cast<uint32_t>(State::EMPTY); }
+  auto is_persistent() const -> bool { return persistent_; }
  // wlr stuff
  auto handle_name(const std::string &name) -> void;
  auto handle_coordinates(const std::vector<uint32_t> &coordinates) -> void;
  auto handle_state(const std::vector<uint32_t> &state) -> void;
  auto handle_remove() -> void;
+  auto make_persistent() -> void;
+  auto handle_duplicate() -> void;

  auto handle_done() -> void;
  auto handle_clicked(GdkEventButton *bt) -> bool;
@ -48,6 +52,7 @@ class Workspace {
    ACTIVE = (1 << 0),
    URGENT = (1 << 1),
    HIDDEN = (1 << 2),
+    EMPTY = (1 << 3),
  };

 private:
@ -67,6 +72,7 @@ class Workspace {
  static std::map<std::string, std::string> icons_map_;
  std::string format_;
  bool with_icon_ = false;
+  bool persistent_ = false;

  Gtk::Button button_;
  Gtk::Box content_;
@ -87,11 +93,14 @@ class WorkspaceGroup {
  auto active_only() const -> bool;
  auto creation_delayed() const -> bool;
  auto workspaces() -> std::vector<std::unique_ptr<Workspace>> & { return workspaces_; }
+  auto persistent_workspaces() -> std::vector<std::string> & { return persistent_workspaces_; }

  auto sort_workspaces() -> void;
  auto set_need_to_sort() -> void { need_to_sort = true; }
  auto add_button(Gtk::Button &button) -> void;
  auto remove_button(Gtk::Button &button) -> void;
+  auto fill_persistent_workspaces() -> void;
+  auto create_persistent_workspaces() -> void;

  // wlr stuff
  auto handle_workspace_create(zext_workspace_handle_v1 *workspace_handle) -> void;
@ -115,6 +124,8 @@ class WorkspaceGroup {
  uint32_t id_;
  std::vector<std::unique_ptr<Workspace>> workspaces_;
  bool need_to_sort = false;
+  std::vector<std::string> persistent_workspaces_;
+  bool persistent_created_ = false;
 };

 class WorkspaceManager : public AModule {
--- a/include/util/clara.hpp
+++ b/include/util/clara.hpp
@ -989,7 +989,7 @@ struct Help : Opt {
          showHelpFlag = flag;
          return ParserResult::ok(ParseResultType::ShortCircuitAll);
        }) {
-    static_cast<Opt &> (*this)("display usage information")["-?"]["-h"]["--help"].optional();
+    static_cast<Opt &>(*this)("display usage information")["-?"]["-h"]["--help"].optional();
  }
 };

--- a/include/util/command.hpp
+++ b/include/util/command.hpp
@ -1,5 +1,6 @@
 #pragma once

+#include <fcntl.h>
 #include <giomm.h>
 #include <spdlog/spdlog.h>
 #include <sys/wait.h>
@ -68,7 +69,11 @@ inline int close(FILE* fp, pid_t pid) {
 inline FILE* open(const std::string& cmd, int& pid) {
  if (cmd == "") return nullptr;
  int fd[2];
-  if (pipe(fd) != 0) {
+  // Open the pipe with the close-on-exec flag set, so it will not be inherited
+  // by any other subprocesses launched by other threads (which could result in
+  // the pipe staying open after this child dies, causing us to hang when trying
+  // to read from it)
+  if (pipe2(fd, O_CLOEXEC) != 0) {
    spdlog::error("Unable to pipe fd");
    return nullptr;
  }
@ -77,6 +82,8 @@ inline FILE* open(const std::string& cmd, int& pid) {

  if (child_pid < 0) {
    spdlog::error("Unable to exec cmd {}, error {}", cmd.c_str(), strerror(errno));
+    ::close(fd[0]);
+    ::close(fd[1]);
    return nullptr;
  }

--- a/include/util/date.hpp
+++ b/include/util/date.hpp
@ -0,0 +1,60 @@
+#pragma once
+
+#include <fmt/format.h>
+
+#if HAVE_CHRONO_TIMEZONES
+#include <chrono>
+#include <format>
+
+/* Compatibility layer for <date/tz.h> on top of C++20 <chrono> */
+namespace date {
+
+using namespace std::chrono;
+
+namespace literals {
+using std::chrono::last;
+}
+
+inline auto format(const std::string& spec, const auto& ztime) {
+  return spec.empty() ? "" : std::vformat("{:L" + spec + "}", std::make_format_args(ztime));
+}
+
+inline auto format(const std::locale& loc, const std::string& spec, const auto& ztime) {
+  return spec.empty() ? "" : std::vformat(loc, "{:L" + spec + "}", std::make_format_args(ztime));
+}
+
+}  // namespace date
+
+#else
+#include <date/tz.h>
+#endif
+
+template <typename Duration, typename TimeZonePtr>
+struct fmt::formatter<date::zoned_time<Duration, TimeZonePtr>> {
+  std::string_view specs;
+
+  template <typename ParseContext>
+  constexpr auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    auto it = ctx.begin();
+    if (it != ctx.end() && *it == ':') {
+      ++it;
+    }
+    auto end = it;
+    while (end != ctx.end() && *end != '}') {
+      ++end;
+    }
+    if (end != it) {
+      specs = {it, std::string_view::size_type(end - it)};
+    }
+    return end;
+  }
+
+  template <typename FormatContext>
+  auto format(const date::zoned_time<Duration, TimeZonePtr>& ztime, FormatContext& ctx) {
+    if (ctx.locale()) {
+      const auto loc = ctx.locale().template get<std::locale>();
+      return fmt::format_to(ctx.out(), "{}", date::format(loc, fmt::to_string(specs), ztime));
+    }
+    return fmt::format_to(ctx.out(), "{}", date::format(fmt::to_string(specs), ztime));
+  }
+};
--- a/include/util/format.hpp
+++ b/include/util/format.hpp
@ -66,9 +66,9 @@ struct formatter<pow_format> {
    std::string string;
    switch (spec) {
      case '>':
-        return format_to(ctx.out(), "{:>{}}", fmt::format("{}", s), max_width);
+        return fmt::format_to(ctx.out(), "{:>{}}", fmt::format("{}", s), max_width);
      case '<':
-        return format_to(ctx.out(), "{:<{}}", fmt::format("{}", s), max_width);
+        return fmt::format_to(ctx.out(), "{:<{}}", fmt::format("{}", s), max_width);
      case '=':
        format = "{coefficient:<{number_width}.1f}{padding}{prefix}{unit}";
        break;
@ -77,8 +77,8 @@ struct formatter<pow_format> {
        format = "{coefficient:.1f}{prefix}{unit}";
        break;
    }
-    return format_to(
-        ctx.out(), format, fmt::arg("coefficient", fraction),
+    return fmt::format_to(
+        ctx.out(), fmt::runtime(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_),
--- a/include/util/gtk_icon.hpp
+++ b/include/util/gtk_icon.hpp
@ -0,0 +1,14 @@
+#pragma once
+#include <gtkmm/icontheme.h>
+
+#include <mutex>
+#include <string>
+
+class DefaultGtkIconThemeWrapper {
+ private:
+  static std::mutex default_theme_mutex;
+
+ public:
+  static bool has_icon(const std::string&);
+  static Glib::RefPtr<Gdk::Pixbuf> load_icon(const char*, int, Gtk::IconLookupFlags);
+};
--- a/include/util/prepare_for_sleep.h
+++ b/include/util/prepare_for_sleep.h
@ -0,0 +1,9 @@
+#pragma once
+
+#include "SafeSignal.hpp"
+
+namespace waybar::util {
+
+// Get a signal emited with value true when entering sleep, and false when exiting
+SafeSignal<bool>& prepare_for_sleep();
+}  // namespace waybar::util
--- a/include/util/rewrite_string.hpp
+++ b/include/util/rewrite_string.hpp
@ -4,5 +4,5 @@
 #include <string>

 namespace waybar::util {
-std::string rewriteTitle(const std::string&, const Json::Value&);
+std::string rewriteString(const std::string&, const Json::Value&);
 }
--- a/include/util/sleeper_thread.hpp
+++ b/include/util/sleeper_thread.hpp
@ -6,6 +6,8 @@
 #include <functional>
 #include <thread>

+#include "prepare_for_sleep.h"
+
 namespace waybar::util {

 /**
@ -33,7 +35,11 @@ class SleeperThread {
            signal_ = false;
            func();
          }
-        }} {}
+        }} {
+    connection_ = prepare_for_sleep().connect([this](bool sleep) {
+      if (not sleep) wake_up();
+    });
+  }

  SleeperThread& operator=(std::function<void()> func) {
    thread_ = std::thread([this, func] {
@ -42,6 +48,11 @@ class SleeperThread {
        func();
      }
    });
+    if (connection_.empty()) {
+      connection_ = prepare_for_sleep().connect([this](bool sleep) {
+        if (not sleep) wake_up();
+      });
+    }
    return *this;
  }

@ -61,7 +72,7 @@ class SleeperThread {
    return condvar_.wait_until(lk, time_point, [this] { return signal_ || !do_run_; });
  }

-  auto wake_up() {
+  void wake_up() {
    {
      std::lock_guard<std::mutex> lck(mutex_);
      signal_ = true;
@ -96,6 +107,7 @@ class SleeperThread {
  std::mutex mutex_;
  bool do_run_ = true;
  bool signal_ = false;
+  sigc::connection connection_;
 };

 }  // namespace waybar::util
--- a/include/util/waybar_time.hpp
+++ b/include/util/waybar_time.hpp
@ -1,39 +0,0 @@
-#pragma once
-
-#include <date/tz.h>
-#include <fmt/format.h>
-
-namespace waybar {
-
-struct waybar_time {
-  std::locale locale;
-  date::zoned_seconds ztime;
-};
-
-}  // namespace waybar
-
-template <>
-struct fmt::formatter<waybar::waybar_time> {
-  std::string_view specs;
-
-  template <typename ParseContext>
-  constexpr auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
-    auto it = ctx.begin();
-    if (it != ctx.end() && *it == ':') {
-      ++it;
-    }
-    auto end = it;
-    while (end != ctx.end() && *end != '}') {
-      ++end;
-    }
-    if (end != it) {
-      specs = {it, std::string_view::size_type(end - it)};
-    }
-    return end;
-  }
-
-  template <typename FormatContext>
-  auto format(const waybar::waybar_time& t, FormatContext& ctx) {
-    return format_to(ctx.out(), "{}", date::format(t.locale, fmt::to_string(specs), t.ztime));
-  }
-};