chore: 0.9.15

Revert "Escape text in custom module"

.clang-format

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

.github/workflows/freebsd.yml

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

.github/workflows/lint.yml

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

.github/workflows/linux.yml

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

Dockerfiles/gentoo

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

README.md

@@ -2,14 +2,17 @@
 
 > Highly customizable Wayland bar for Sway and Wlroots based compositors.<br>
 > Available in Arch [community](https://www.archlinux.org/packages/community/x86_64/waybar/) or
-[AUR](https://aur.archlinux.org/packages/waybar-git/), [Gentoo](https://packages.gentoo.org/packages/gui-apps/waybar), [openSUSE](https://build.opensuse.org/package/show/X11:Wayland/waybar), and [Alpine Linux](https://pkgs.alpinelinux.org/packages?name=waybar)<br>
+[AUR](https://aur.archlinux.org/packages/waybar-git/), [Gentoo](https://packages.gentoo.org/packages/gui-apps/waybar), [openSUSE](https://build.opensuse.org/package/show/X11:Wayland/waybar), and [Alpine Linux](https://pkgs.alpinelinux.org/packages?name=waybar).<br>
 > *Waybar [examples](https://github.com/Alexays/Waybar/wiki/Examples)*
 
 #### 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
@@ -20,7 +23,7 @@
 - MPD
 - Custom scripts
 - Multiple output configuration
-- And much more customizations
+- And many more customizations
 
 #### Configuration and Styling
 
@@ -70,6 +73,7 @@ libmpdclient [MPD module]
 libsndio [sndio module]
 libevdev [KeyboardState module]
 xkbregistry
+upower [UPower battery module]
 ```
 
 **Build dependencies**
@@ -81,7 +85,7 @@ scdoc
 wayland-protocols
 ```
 
-On Ubuntu you can install all the relevant dependencies using this command (tested with 19.10 and 20.04):
+On Ubuntu, you can install all the relevant dependencies using this command (tested with 19.10 and 20.04):
 
 ```
 sudo apt install \
@@ -103,12 +107,14 @@ sudo apt install \
   libspdlog-dev \
   libwayland-dev \
   scdoc \
+  upower \
   libxkbregistry-dev
 ```
 
 
-Contributions welcome! - have fun :)<br>
+Contributions welcome!<br>
-The style guidelines is [Google's](https://google.github.io/styleguide/cppguide.html)
+Have fun :)<br>
+The style guidelines are [Google's](https://google.github.io/styleguide/cppguide.html)
 
 ## License
 

include/AButton.hpp

@@ -0,0 +1,35 @@
+#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

include/ALabel.hpp

@@ -3,6 +3,7 @@
 #include <glibmm/markup.h>
 #include <gtkmm/label.h>
 #include <json/json.h>
+
 #include "AModule.hpp"
 
 namespace waybar {
@@ -10,7 +11,8 @@ namespace waybar {
 class ALabel : public AModule {
  public:
   ALabel(const Json::Value &, const std::string &, const std::string &, const std::string &format,
-         uint16_t interval = 0, bool ellipsize = false, bool enable_click = false, bool enable_scroll = false);
+         uint16_t interval = 0, bool ellipsize = false, bool enable_click = false,
+         bool enable_scroll = false);
   virtual ~ALabel() = default;
   virtual auto update() -> void;
   virtual std::string getIcon(uint16_t, const std::string &alt = "", uint16_t max = 0);

include/AModule.hpp

@@ -36,6 +36,22 @@ class AModule : public IModule {
   std::vector<int> pid_;
   gdouble distance_scrolled_y_;
   gdouble distance_scrolled_x_;
+  static const inline std::map<std::pair<uint, GdkEventType>, std::string> eventMap_{
+      {std::make_pair(1, GdkEventType::GDK_BUTTON_PRESS), "on-click"},
+      {std::make_pair(1, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click"},
+      {std::make_pair(1, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click"},
+      {std::make_pair(2, GdkEventType::GDK_BUTTON_PRESS), "on-click-middle"},
+      {std::make_pair(2, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-middle"},
+      {std::make_pair(2, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click-middle"},
+      {std::make_pair(3, GdkEventType::GDK_BUTTON_PRESS), "on-click-right"},
+      {std::make_pair(3, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-right"},
+      {std::make_pair(3, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click-right"},
+      {std::make_pair(8, GdkEventType::GDK_BUTTON_PRESS), "on-click-backward"},
+      {std::make_pair(8, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-backward"},
+      {std::make_pair(8, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click-backward"},
+      {std::make_pair(9, GdkEventType::GDK_BUTTON_PRESS), "on-click-forward"},
+      {std::make_pair(9, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-forward"},
+      {std::make_pair(9, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click-forward"}};
 };
 
 }  // namespace waybar

include/IModule.hpp

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

include/bar.hpp

@@ -98,7 +98,7 @@ class Bar {
  private:
   void onMap(GdkEventAny *);
   auto setupWidgets() -> void;
-  void getModules(const Factory &, const std::string &, Gtk::Box*);
+  void getModules(const Factory &, const std::string &, Gtk::Box *);
   void setupAltFormatKeyForModule(const std::string &module_name);
   void setupAltFormatKeyForModuleList(const char *module_list_name);
   void setMode(const bar_mode &);

include/client.hpp

@@ -22,10 +22,10 @@ class Client {
 
   Glib::RefPtr<Gtk::Application> gtk_app;
   Glib::RefPtr<Gdk::Display> gdk_display;
-  struct wl_display *                 wl_display = nullptr;
+  struct wl_display *wl_display = nullptr;
-  struct wl_registry *                registry = nullptr;
+  struct wl_registry *registry = nullptr;
-  struct zwlr_layer_shell_v1 *        layer_shell = nullptr;
+  struct zwlr_layer_shell_v1 *layer_shell = nullptr;
-  struct zxdg_output_manager_v1 *     xdg_output_manager = nullptr;
+  struct zxdg_output_manager_v1 *xdg_output_manager = nullptr;
   struct zwp_idle_inhibit_manager_v1 *idle_inhibit_manager = nullptr;
   std::vector<std::unique_ptr<Bar>> bars;
   Config config;
@@ -37,7 +37,7 @@ class Client {
   void bindInterfaces();
   void handleOutput(struct waybar_output &output);
   auto setupCss(const std::string &css_file) -> void;
-  struct waybar_output &   getOutput(void *);
+  struct waybar_output &getOutput(void *);
   std::vector<Json::Value> getOutputConfigs(struct waybar_output &output);
 
   static void handleGlobal(void *data, struct wl_registry *registry, uint32_t name,

include/config.hpp

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

include/factory.hpp

@@ -7,19 +7,27 @@
 #include "modules/simpleclock.hpp"
 #endif
 #ifdef HAVE_SWAY
+#include "modules/sway/language.hpp"
 #include "modules/sway/mode.hpp"
+#include "modules/sway/scratchpad.hpp"
 #include "modules/sway/window.hpp"
 #include "modules/sway/workspaces.hpp"
-#include "modules/sway/language.hpp"
 #endif
 #ifdef HAVE_WLR
 #include "modules/wlr/taskbar.hpp"
 #include "modules/wlr/workspace_manager.hpp"
 #endif
 #ifdef HAVE_RIVER
+#include "modules/river/mode.hpp"
 #include "modules/river/tags.hpp"
+#include "modules/river/window.hpp"
 #endif
-#if defined(__linux__) && !defined(NO_FILESYSTEM)
+#ifdef HAVE_HYPRLAND
+#include "modules/hyprland/backend.hpp"
+#include "modules/hyprland/language.hpp"
+#include "modules/hyprland/window.hpp"
+#endif
+#if defined(__FreeBSD__) || (defined(__linux__) && !defined(NO_FILESYSTEM))
 #include "modules/battery.hpp"
 #endif
 #if defined(HAVE_CPU_LINUX) || defined(HAVE_CPU_BSD)
@@ -42,6 +50,12 @@
 #ifdef HAVE_LIBEVDEV
 #include "modules/keyboard_state.hpp"
 #endif
+#ifdef HAVE_GAMEMODE
+#include "modules/gamemode.hpp"
+#endif
+#ifdef HAVE_UPOWER
+#include "modules/upower/upower.hpp"
+#endif
 #ifdef HAVE_LIBPULSE
 #include "modules/pulseaudio.hpp"
 #endif
@@ -52,16 +66,16 @@
 #include "modules/sndio.hpp"
 #endif
 #ifdef HAVE_GIO_UNIX
+#include "modules/bluetooth.hpp"
 #include "modules/inhibitor.hpp"
 #endif
+#ifdef HAVE_LIBJACK
+#include "modules/jack.hpp"
+#endif
 #include "bar.hpp"
 #include "modules/custom.hpp"
 #include "modules/temperature.hpp"
-#if defined(__linux__)
+#include "modules/user.hpp"
-#  ifdef WANT_RFKILL
-#    include "modules/bluetooth.hpp"
-#  endif
-#endif
 
 namespace waybar {
 

include/group.hpp

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

include/modules/backlight.hpp

@@ -5,7 +5,7 @@
 #include <string_view>
 #include <vector>
 
-#include "ALabel.hpp"
+#include "AButton.hpp"
 #include "util/json.hpp"
 #include "util/sleeper_thread.hpp"
 
@@ -14,7 +14,7 @@ struct udev_device;
 
 namespace waybar::modules {
 
-class Backlight : public ALabel {
+class Backlight : public AButton {
   class BacklightDev {
    public:
     BacklightDev() = default;

include/modules/battery.hpp

@@ -6,12 +6,16 @@
 #include <filesystem>
 #endif
 #include <fmt/format.h>
+#if defined(__linux__)
 #include <sys/inotify.h>
+#endif
+
 #include <algorithm>
 #include <fstream>
 #include <string>
 #include <vector>
-#include "ALabel.hpp"
+
+#include "AButton.hpp"
 #include "util/sleeper_thread.hpp"
 
 namespace waybar::modules {
@@ -22,7 +26,7 @@ namespace fs = std::experimental::filesystem;
 namespace fs = std::filesystem;
 #endif
 
-class Battery : public ALabel {
+class Battery : public AButton {
  public:
   Battery(const std::string&, const Json::Value&);
   ~Battery();
@@ -38,12 +42,13 @@ class Battery : public ALabel {
   const std::string formatTimeRemaining(float hoursRemaining);
 
   int global_watch;
-  std::map<fs::path,int> batteries_;
+  std::map<fs::path, int> batteries_;
   fs::path adapter_;
   int battery_watch_fd_;
   int global_watch_fd_;
   std::mutex battery_list_mutex_;
   std::string old_status_;
+  bool warnFirstTime_{true};
 
   util::SleeperThread thread_;
   util::SleeperThread thread_battery_update_;

include/modules/bluetooth.hpp

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

include/modules/clock.hpp

@@ -1,7 +1,8 @@
 #pragma once
 
 #include <date/tz.h>
-#include "ALabel.hpp"
+
+#include "AButton.hpp"
 #include "util/sleeper_thread.hpp"
 
 namespace waybar {
@@ -13,7 +14,7 @@ namespace modules {
 const std::string kCalendarPlaceholder = "calendar";
 const std::string KTimezonedTimeListPlaceholder = "timezoned_time_list";
 
-class Clock : public ALabel {
+class Clock : public AButton {
  public:
   Clock(const std::string&, const Json::Value&);
   ~Clock() = default;
@@ -24,8 +25,9 @@ class Clock : public ALabel {
   std::locale locale_;
   std::vector<const date::time_zone*> time_zones_;
   int current_time_zone_idx_;
-  date::year_month_day cached_calendar_ymd_ = date::January/1/0;
+  date::year_month_day calendar_cached_ymd_{date::January / 1 / 0};
-  std::string cached_calendar_text_;
+  date::months calendar_shift_{0}, calendar_shift_init_{0};
+  std::string calendar_cached_text_;
   bool is_calendar_in_tooltip_;
   bool is_timezoned_list_in_tooltip_;
 
@@ -36,8 +38,7 @@ class Clock : public ALabel {
   auto first_day_of_week() -> date::weekday;
   const date::time_zone* current_timezone();
   bool is_timezone_fixed();
-  auto timezones_text(std::chrono::_V2::system_clock::time_point *now) -> std::string;
+  auto timezones_text(std::chrono::system_clock::time_point* now) -> std::string;
 };
-
 }  // namespace modules
 }  // namespace waybar

include/modules/cpu.hpp

@@ -1,18 +1,20 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include <cstdint>
 #include <fstream>
 #include <numeric>
 #include <string>
 #include <utility>
 #include <vector>
-#include "ALabel.hpp"
+
+#include "AButton.hpp"
 #include "util/sleeper_thread.hpp"
 
 namespace waybar::modules {
 
-class Cpu : public ALabel {
+class Cpu : public AButton {
  public:
   Cpu(const std::string&, const Json::Value&);
   ~Cpu() = default;

include/modules/custom.hpp

@@ -1,16 +1,18 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include <csignal>
 #include <string>
-#include "ALabel.hpp"
+
+#include "AButton.hpp"
 #include "util/command.hpp"
 #include "util/json.hpp"
 #include "util/sleeper_thread.hpp"
 
 namespace waybar::modules {
 
-class Custom : public ALabel {
+class Custom : public AButton {
  public:
   Custom(const std::string&, const std::string&, const Json::Value&);
   ~Custom();
@@ -28,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/disk.hpp

@@ -1,15 +1,17 @@
 #pragma once
 
 #include <fmt/format.h>
-#include <fstream>
 #include <sys/statvfs.h>
-#include "ALabel.hpp"
+
-#include "util/sleeper_thread.hpp"
+#include <fstream>
+
+#include "AButton.hpp"
 #include "util/format.hpp"
+#include "util/sleeper_thread.hpp"
 
 namespace waybar::modules {
 
-class Disk : public ALabel {
+class Disk : public AButton {
  public:
   Disk(const std::string&, const Json::Value&);
   ~Disk() = default;

include/modules/gamemode.hpp

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

include/modules/hyprland/backend.hpp

@@ -0,0 +1,28 @@
+#pragma once
+#include <deque>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <thread>
+
+namespace waybar::modules::hyprland {
+class IPC {
+ public:
+  IPC() { startIPC(); }
+
+  void registerForIPC(const std::string&, std::function<void(const std::string&)>);
+
+  std::string getSocket1Reply(const std::string& rq);
+
+ private:
+  void startIPC();
+  void parseIPC(const std::string&);
+
+  std::mutex callbackMutex;
+  std::deque<std::pair<std::string, std::function<void(const std::string&)>>> 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 "AButton.hpp"
+#include "bar.hpp"
+#include "modules/hyprland/backend.hpp"
+#include "util/json.hpp"
+
+namespace waybar::modules::hyprland {
+
+class Language : public waybar::AButton {
+ public:
+  Language(const std::string&, const waybar::Bar&, const Json::Value&);
+  ~Language() = default;
+
+  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:
+  Window(const std::string&, const waybar::Bar&, const Json::Value&);
+  ~Window() = default;
+
+  auto update() -> void;
+
+ private:
+  uint getActiveWorkspaceID(std::string);
+  std::string getLastWindowTitle(uint);
+  void onEvent(const std::string&);
+
+  bool separate_outputs;
+  std::mutex mutex_;
+  const Bar& bar_;
+  util::JsonParser parser_;
+  std::string lastView;
+};
+
+}  // namespace waybar::modules::hyprland

include/modules/idle_inhibitor.hpp

@@ -1,13 +1,16 @@
 #pragma once
 
 #include <fmt/format.h>
-#include "ALabel.hpp"
+
+#include "AButton.hpp"
 #include "bar.hpp"
 #include "client.hpp"
 
 namespace waybar::modules {
 
-class IdleInhibitor : public ALabel {
+class IdleInhibitor : public AButton {
+  sigc::connection timeout_;
+
  public:
   IdleInhibitor(const std::string&, const waybar::Bar&, const Json::Value&);
   ~IdleInhibitor();
@@ -17,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/inhibitor.hpp

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

include/modules/jack.hpp

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

include/modules/keyboard_state.hpp

@@ -1,18 +1,17 @@
 #pragma once
 
-#include <fmt/format.h>
-#if FMT_VERSION < 60000
-#include <fmt/time.h>
-#else
 #include <fmt/chrono.h>
-#endif
+#include <gtkmm/label.h>
+
+#include <unordered_map>
+
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "util/sleeper_thread.hpp"
-#include <gtkmm/label.h>
 
 extern "C" {
 #include <libevdev/libevdev.h>
+#include <libinput.h>
 }
 
 namespace waybar::modules {
@@ -24,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_;
@@ -35,11 +36,12 @@ class KeyboardState : public AModule {
   const std::chrono::seconds interval_;
   std::string icon_locked_;
   std::string icon_unlocked_;
+  std::string devices_path_;
 
-  int         fd_;
+  struct libinput* libinput_;
-  libevdev*   dev_;
+  std::unordered_map<std::string, struct libinput_device*> libinput_devices_;
 
-  util::SleeperThread thread_;
+  util::SleeperThread libinput_thread_, hotplug_thread_;
 };
 
 }  // namespace waybar::modules

include/modules/memory.hpp

@@ -1,14 +1,16 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include <fstream>
 #include <unordered_map>
-#include "ALabel.hpp"
+
+#include "AButton.hpp"
 #include "util/sleeper_thread.hpp"
 
 namespace waybar::modules {
 
-class Memory : public ALabel {
+class Memory : public AButton {
  public:
   Memory(const std::string&, const Json::Value&);
   ~Memory() = default;

include/modules/mpd/mpd.hpp

@@ -7,12 +7,12 @@
 #include <condition_variable>
 #include <thread>
 
-#include "ALabel.hpp"
+#include "AButton.hpp"
 #include "modules/mpd/state.hpp"
 
 namespace waybar::modules {
 
-class MPD : public ALabel {
+class MPD : public AButton {
   friend class detail::Context;
 
   // State machine
@@ -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/mpd/state.hpp

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <mpd/client.h>
 #include <fmt/format.h>
+#include <mpd/client.h>
 #include <spdlog/spdlog.h>
 
 #include <condition_variable>
 #include <thread>
 
-#include "ALabel.hpp"
+#include "AButton.hpp"
 
 namespace waybar::modules {
 class MPD;

include/modules/mpd/state.inl.hpp

@@ -12,9 +12,7 @@ inline void                  Context::tryConnect() const { mpd_module_->tryConne
 inline unique_connection& Context::connection() { return mpd_module_->connection_; }
 constexpr inline mpd_state Context::state() const { return mpd_module_->state_; }
 
-inline void Context::do_update() {
+inline void Context::do_update() { mpd_module_->setLabel(); }
-  mpd_module_->setLabel();
-}
 
 inline void Context::checkErrors(mpd_connection* conn) const { mpd_module_->checkErrors(conn); }
 inline void Context::queryMPD() const { mpd_module_->queryMPD(); }

include/modules/network.hpp

@@ -7,7 +7,10 @@
 #include <netlink/genl/genl.h>
 #include <netlink/netlink.h>
 #include <sys/epoll.h>
-#include "ALabel.hpp"
+
+#include <optional>
+
+#include "AButton.hpp"
 #include "util/sleeper_thread.hpp"
 #ifdef WANT_RFKILL
 #include "util/rfkill.hpp"
@@ -15,7 +18,7 @@
 
 namespace waybar::modules {
 
-class Network : public ALabel {
+class Network : public AButton {
  public:
   Network(const std::string&, const Json::Value&);
   ~Network();

include/modules/pulseaudio.hpp

@@ -3,13 +3,15 @@
 #include <fmt/format.h>
 #include <pulse/pulseaudio.h>
 #include <pulse/volume.h>
+
 #include <algorithm>
 #include <array>
-#include "ALabel.hpp"
+
+#include "AButton.hpp"
 
 namespace waybar::modules {
 
-class Pulseaudio : public ALabel {
+class Pulseaudio : public AButton {
  public:
   Pulseaudio(const std::string&, const Json::Value&);
   ~Pulseaudio();

include/modules/river/mode.hpp

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

include/modules/river/tags.hpp

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

include/modules/river/window.hpp

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

include/modules/simpleclock.hpp

@@ -1,17 +1,13 @@
 #pragma once
 
-#include <fmt/format.h>
-#if FMT_VERSION < 60000
-#include <fmt/time.h>
-#else
 #include <fmt/chrono.h>
-#endif
+
-#include "ALabel.hpp"
+#include "AButton.hpp"
 #include "util/sleeper_thread.hpp"
 
 namespace waybar::modules {
 
-class Clock : public ALabel {
+class Clock : public AButton {
  public:
   Clock(const std::string&, const Json::Value&);
   ~Clock() = default;

include/modules/sndio.hpp

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

include/modules/sni/host.hpp

@@ -4,7 +4,9 @@
 #include <giomm.h>
 #include <glibmm/refptr.h>
 #include <json/json.h>
+
 #include <tuple>
+
 #include "bar.hpp"
 #include "modules/sni/item.hpp"
 

include/modules/sni/tray.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "modules/sni/host.hpp"

include/modules/sni/watcher.hpp

@@ -30,10 +30,10 @@ class Watcher {
 
   typedef struct {
     GfWatchType type;
-    Watcher *   watcher;
+    Watcher *watcher;
-    gchar *     service;
+    gchar *service;
-    gchar *     bus_name;
+    gchar *bus_name;
-    gchar *     object_path;
+    gchar *object_path;
     guint watch_id;
   } GfWatch;
 
@@ -48,8 +48,8 @@ class Watcher {
   void updateRegisteredItems(SnWatcher *obj);
 
   uint32_t bus_name_id_;
-  GSList *   hosts_ = nullptr;
+  GSList *hosts_ = nullptr;
-  GSList *   items_ = nullptr;
+  GSList *items_ = nullptr;
   SnWatcher *watcher_ = nullptr;
 };
 

include/modules/sway/bar.hpp

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

include/modules/sway/ipc/client.hpp

@@ -4,9 +4,11 @@
 #include <sys/socket.h>
 #include <sys/un.h>
 #include <unistd.h>
+
 #include <cstring>
 #include <memory>
 #include <mutex>
+
 #include "ipc.hpp"
 #include "util/sleeper_thread.hpp"
 

include/modules/sway/ipc/ipc.hpp

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

include/modules/sway/language.hpp

@@ -6,7 +6,7 @@
 #include <map>
 #include <string>
 
-#include "ALabel.hpp"
+#include "AButton.hpp"
 #include "bar.hpp"
 #include "client.hpp"
 #include "modules/sway/ipc/client.hpp"
@@ -14,18 +14,14 @@
 
 namespace waybar::modules::sway {
 
-class Language : public ALabel, public sigc::trackable {
+class Language : public AButton, public sigc::trackable {
  public:
   Language(const std::string& id, const Json::Value& config);
   ~Language() = default;
   auto update() -> void;
 
  private:
-  enum class DispayedShortFlag {
+  enum class DispayedShortFlag { None = 0, ShortName = 1, ShortDescription = 1 << 1 };
-	  None = 0,
-	  ShortName = 1,
-	  ShortDescription = 1 << 1
-  };
 
   struct Layout {
     std::string full_name;
@@ -40,6 +36,7 @@ class Language : public ALabel, public sigc::trackable {
     XKBContext();
     ~XKBContext();
     auto next_layout() -> Layout*;
+
    private:
     rxkb_context* context_ = nullptr;
     rxkb_layout* xkb_layout_ = nullptr;

include/modules/sway/mode.hpp

@@ -1,7 +1,8 @@
 #pragma once
 
 #include <fmt/format.h>
-#include "ALabel.hpp"
+
+#include "AButton.hpp"
 #include "bar.hpp"
 #include "client.hpp"
 #include "modules/sway/ipc/client.hpp"
@@ -9,7 +10,7 @@
 
 namespace waybar::modules::sway {
 
-class Mode : public ALabel, public sigc::trackable {
+class Mode : public AButton, public sigc::trackable {
  public:
   Mode(const std::string&, const Json::Value&);
   ~Mode() = default;

include/modules/sway/scratchpad.hpp

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

include/modules/sway/window.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include <tuple>
 
 #include "AIconLabel.hpp"
@@ -20,18 +21,23 @@ 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> getFocusedNode(const Json::Value& nodes,
+  std::tuple<std::size_t, int, std::string, std::string, std::string, std::string> getFocusedNode(
-                                                                        std::string&       output);
+      const Json::Value& nodes, std::string& output);
   void getTree();
-  std::string                                            rewriteTitle(const std::string& title);
+  void updateAppIconName();
   void updateAppIcon();
 
   const Bar& bar_;
   std::string window_;
   int windowId_;
   std::string app_id_;
+  std::string app_class_;
   std::string old_app_id_;
   std::size_t app_nb_;
+  std::string shell_;
+  unsigned app_icon_size_{24};
+  bool update_app_icon_{true};
+  std::string app_icon_name_;
   util::JsonParser parser_;
   std::mutex mutex_;
   Ipc ipc_;

include/modules/sway/workspaces.hpp

@@ -1,10 +1,11 @@
 #pragma once
 
-#include <unordered_map>
 #include <fmt/format.h>
 #include <gtkmm/button.h>
 #include <gtkmm/label.h>
+
 #include <unordered_map>
+
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "client.hpp"

include/modules/temperature.hpp

@@ -1,13 +1,15 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include <fstream>
-#include "ALabel.hpp"
+
+#include "AButton.hpp"
 #include "util/sleeper_thread.hpp"
 
 namespace waybar::modules {
 
-class Temperature : public ALabel {
+class Temperature : public AButton {
  public:
   Temperature(const std::string&, const Json::Value&);
   ~Temperature() = default;

include/modules/upower/upower.hpp

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

include/modules/upower/upower_tooltip.hpp

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

include/modules/user.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <fmt/chrono.h>
+#include <gdkmm/pixbuf.h>
+#include <glibmm/refptr.h>
+
+#include "AIconLabel.hpp"
+#include "util/sleeper_thread.hpp"
+
+namespace waybar::modules {
+class User : public AIconLabel {
+ public:
+  User(const std::string&, const Json::Value&);
+  ~User() = default;
+  auto update() -> void;
+
+ 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();
+  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/wlr/taskbar.hpp

@@ -1,40 +1,35 @@
 #pragma once
 
+#include <gdk/gdk.h>
+#include <glibmm/refptr.h>
+#include <gtkmm/box.h>
+#include <gtkmm/button.h>
+#include <gtkmm/icontheme.h>
+#include <gtkmm/image.h>
+#include <gtkmm/label.h>
+#include <wayland-client.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "client.hpp"
 #include "giomm/desktopappinfo.h"
 #include "util/json.hpp"
-
-#include <memory>
-#include <string>
-#include <vector>
-#include <map>
-#include <unordered_set>
-
-#include <gdk/gdk.h>
-
-#include <glibmm/refptr.h>
-
-#include <gtkmm/box.h>
-#include <gtkmm/button.h>
-#include <gtkmm/image.h>
-#include <gtkmm/label.h>
-#include <gtkmm/icontheme.h>
-
-#include <wayland-client.h>
 #include "wlr-foreign-toplevel-management-unstable-v1-client-protocol.h"
 
-
 namespace waybar::modules::wlr {
 
 class Taskbar;
 
-class Task
+class Task {
-{
  public:
-    Task(const waybar::Bar&, const Json::Value&, Taskbar*,
+  Task(const waybar::Bar &, const Json::Value &, Taskbar *,
-         struct zwlr_foreign_toplevel_handle_v1 *, struct wl_seat*);
+       struct zwlr_foreign_toplevel_handle_v1 *, struct wl_seat *);
   ~Task();
 
  public:
@@ -79,11 +74,16 @@ 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;
-    void set_app_info_from_app_id_list(const std::string& app_id_list);
+  void set_app_info_from_app_id_list(const std::string &app_id_list);
-    bool image_load_icon(Gtk::Image& image, const Glib::RefPtr<Gtk::IconTheme>& icon_theme, Glib::RefPtr<Gio::DesktopAppInfo> app_info, int size);
+  bool image_load_icon(Gtk::Image &image, const Glib::RefPtr<Gtk::IconTheme> &icon_theme,
+                       Glib::RefPtr<Gio::DesktopAppInfo> app_info, int size);
   void hide_if_ignored();
 
  public:
@@ -109,10 +109,16 @@ 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;
+  bool operator==(const Task &) const;
-    bool operator!=(const Task&) const;
+  bool operator!=(const Task &) const;
 
  public:
   void update();
@@ -128,11 +134,9 @@ class Task
 
 using TaskPtr = std::unique_ptr<Task>;
 
-
+class Taskbar : public waybar::AModule {
-class Taskbar : public waybar::AModule
-{
  public:
-    Taskbar(const std::string&, const waybar::Bar&, const Json::Value&);
+  Taskbar(const std::string &, const waybar::Bar &, const Json::Value &);
   ~Taskbar();
   void update();
 
@@ -150,8 +154,8 @@ class Taskbar : public waybar::AModule
 
  public:
   /* Callbacks for global registration */
-    void register_manager(struct wl_registry*, uint32_t name, uint32_t version);
+  void register_manager(struct wl_registry *, uint32_t name, uint32_t version);
-    void register_seat(struct wl_registry*, uint32_t name, uint32_t version);
+  void register_seat(struct wl_registry *, uint32_t name, uint32_t version);
 
   /* Callbacks for the wlr protocol */
   void handle_toplevel_create(struct zwlr_foreign_toplevel_handle_v1 *);
@@ -166,9 +170,9 @@ class Taskbar : public waybar::AModule
   bool show_output(struct wl_output *) const;
   bool all_outputs() const;
 
-    const std::vector<Glib::RefPtr<Gtk::IconTheme>>& icon_themes() const;
+  const std::vector<Glib::RefPtr<Gtk::IconTheme>> &icon_themes() const;
-    const std::unordered_set<std::string>& ignore_list() const;
+  const std::unordered_set<std::string> &ignore_list() const;
-    const std::map<std::string, std::string>& app_ids_replace_map() const;
+  const std::map<std::string, std::string> &app_ids_replace_map() const;
 };
 
 } /* namespace waybar::modules::wlr */

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/modules/wlr/workspace_manager_binding.hpp

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

include/util/command.hpp

@@ -68,7 +68,7 @@ inline int close(FILE* fp, pid_t pid) {
 inline FILE* open(const std::string& cmd, int& pid) {
   if (cmd == "") return nullptr;
   int fd[2];
-  if (pipe(fd) != 0){
+  if (pipe(fd) != 0) {
     spdlog::error("Unable to pipe fd");
     return nullptr;
   }

include/util/format.hpp

@@ -5,23 +5,22 @@
 
 class pow_format {
  public:
-    pow_format(long long val, std::string&& unit, bool binary = false):
+  pow_format(long long val, std::string&& unit, bool binary = false)
-      val_(val), unit_(unit), binary_(binary) { };
+      : val_(val), unit_(unit), binary_(binary){};
 
   long long val_;
   std::string unit_;
   bool binary_;
 };
 
-
 namespace fmt {
-  template <>
+template <>
-    struct formatter<pow_format> {
+struct formatter<pow_format> {
   char spec = 0;
   int width = 0;
 
   template <typename ParseContext>
-        constexpr auto parse(ParseContext& ctx) -> decltype (ctx.begin()) {
+  constexpr auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
     auto it = ctx.begin(), end = ctx.end();
     if (it != end && *it == ':') ++it;
     if (it && (*it == '>' || *it == '<' || *it == '=')) {
@@ -45,24 +44,25 @@ namespace fmt {
     return it;
   }
 
-      template<class FormatContext>
+  template <class FormatContext>
-        auto format(const pow_format& s, FormatContext &ctx) -> decltype (ctx.out()) {
+  auto format(const pow_format& s, FormatContext& ctx) -> decltype(ctx.out()) {
-          const char* units[] = { "", "k",  "M",  "G",  "T",  "P",  nullptr};
+    const char* units[] = {"", "k", "M", "G", "T", "P", nullptr};
 
     auto base = s.binary_ ? 1024ull : 1000ll;
-          auto fraction = (double) s.val_;
+    auto fraction = (double)s.val_;
 
     int pow;
-          for (pow = 0; units[pow+1] != nullptr && fraction / base >= 1; ++pow) {
+    for (pow = 0; units[pow + 1] != nullptr && fraction / base >= 1; ++pow) {
       fraction /= base;
     }
 
-          auto max_width = 4                  // coeff in {:.3g} format
+    auto number_width = 5              // coeff in {:.1f} format
-                         + 1                  // prefix from units array
+                        + s.binary_;   // potential 4th digit before the decimal point
+    auto max_width = number_width + 1  // prefix from units array
                      + s.binary_       // for the 'i' in GiB.
                      + s.unit_.length();
 
-          const char * format;
+    const char* format;
     std::string string;
     switch (spec) {
       case '>':
@@ -70,30 +70,30 @@ namespace fmt {
       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
+    return format_to(
-              , fmt::arg("coefficient", fraction)
+        ctx.out(), format, fmt::arg("coefficient", fraction),
-              , fmt::arg("prefix", std::string() + units[pow] + ((s.binary_ && pow) ? "i" : ""))
+        fmt::arg("number_width", number_width),
-              , fmt::arg("unit", s.unit_)
+        fmt::arg("prefix", std::string() + units[pow] + ((s.binary_ && pow) ? "i" : "")),
-              , fmt::arg("padding", pow ? "" : s.binary_ ? "  " : " ")
+        fmt::arg("unit", s.unit_),
-            );
+        fmt::arg("padding", pow         ? ""
+                            : s.binary_ ? "  "
+                                        : " "));
   }
-    };
+};
 
-
+// Glib ustirng support
-    // Glib ustirng support
+template <>
-    template <>
+struct formatter<Glib::ustring> : formatter<std::string> {
-    struct formatter<Glib::ustring> : formatter<std::string> {
   template <typename FormatContext>
   auto format(const Glib::ustring& value, FormatContext& ctx) {
     return formatter<std::string>::format(value, ctx);
   }
-    };
+};
-}
+}  // namespace fmt
-

include/util/json.hpp

@@ -1,7 +1,15 @@
 #pragma once
 
+#include <fmt/ostream.h>
 #include <json/json.h>
 
+#if (FMT_VERSION >= 90000)
+
+template <>
+struct fmt::formatter<Json::Value> : ostream_formatter {};
+
+#endif
+
 namespace waybar::util {
 
 struct JsonParser {

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

include/util/sleeper_thread.hpp

@@ -17,7 +17,8 @@ namespace waybar::util {
  */
 class CancellationGuard {
   int oldstate;
-public:
+
+ public:
   CancellationGuard() { pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate); }
   ~CancellationGuard() { pthread_setcancelstate(oldstate, &oldstate); }
 };

man/waybar-battery.5.scd

@@ -39,7 +39,7 @@ The *battery* module displays the current capacity and state (eg. charging) of y
 *format*: ++
 	typeof: string ++
 	default: {capacity}% ++
-	The format, how the time should be displayed.
+	The format, how information should be displayed.
 
 *format-time*: ++
 	typeof: string ++
@@ -114,9 +114,10 @@ The *battery* module displays the current capacity and state (eg. charging) of y
 
 The *battery* module allows you to define how time should be formatted via *format-time*.
 
-The two arguments are:
+The three arguments are:
 *{H}*: Hours
 *{M}*: Minutes
+*{m}*: Zero-padded minutes
 
 # CUSTOM FORMATS
 

man/waybar-bluetooth.5.scd

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

man/waybar-gamemode.5.scd

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

man/waybar-hyprland-language.5.scd

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

man/waybar-hyprland-window.5.scd

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

man/waybar-idle-inhibitor.5.scd

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

man/waybar-jack.5.scd

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

man/waybar-keyboard-state.5.scd

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

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

@@ -96,6 +96,15 @@ Additionally you can control the volume by scrolling *up* or *down* while the cu
 	default: true ++
 	Option to disable tooltip on hover.
 
+*max-volume*: ++
+	typeof: integer ++
+	default: 100 ++
+	The maximum volume that can be set, in percentage.
+
+*ignored-sinks*: ++
+	typeof: array ++
+	Sinks in this list will not be shown as the active sink by Waybar. Entries should be the sink's description field.
+
 # FORMAT REPLACEMENTS
 
 *{desc}*: Pulseaudio port's description, for bluetooth it'll be the device name.

man/waybar-river-mode.5.scd

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

man/waybar-river-window.5.scd

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

man/waybar-sway-scratchpad.5.scd

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

man/waybar-sway-window.5.scd

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

man/waybar-upower.5.scd

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

man/waybar-wlr-workspaces.5.scd

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

man/waybar.5.scd.in

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

meson.build

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

meson_options.txt

@@ -1,8 +1,10 @@
 option('libcxx', type : 'boolean', value : false, description : 'Build with Clang\'s libc++ instead of libstdc++ on Linux.')
+option('libinput', type: 'feature', value: 'auto', description: 'Enable libinput support for libinput related features')
 option('libnl', type: 'feature', value: 'auto', description: 'Enable libnl support for network related features')
 option('libudev', type: 'feature', value: 'auto', description: 'Enable libudev support for udev related features')
 option('libevdev', type: 'feature', value: 'auto', description: 'Enable libevdev support for evdev related features')
 option('pulseaudio', type: 'feature', value: 'auto', description: 'Enable support for pulseaudio')
+option('upower_glib', type: 'feature', value: 'auto', description: 'Enable support for upower')
 option('systemd', type: 'feature', value: 'auto', description: 'Install systemd user service unit')
 option('dbusmenu-gtk', type: 'feature', value: 'auto', description: 'Enable support for tray')
 option('man-pages', type: 'feature', value: 'auto', description: 'Generate and install man pages')
@@ -13,3 +15,4 @@ 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')

protocol/river-status-unstable-v1.xml

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

resources/config

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

resources/style.css

@@ -34,21 +34,28 @@ window#waybar.chromium {
     border: none;
 }
 
-#workspaces button {
+button {
-    padding: 0 5px;
-    background-color: transparent;
-    color: #ffffff;
     /* Use box-shadow instead of border so the text isn't offset */
     box-shadow: inset 0 -3px transparent;
-    /* Avoid rounded borders under each workspace name */
+    /* Avoid rounded borders under each button name */
     border: none;
     border-radius: 0;
 }
 
 /* https://github.com/Alexays/Waybar/wiki/FAQ#the-workspace-buttons-have-a-strange-hover-effect */
+button:hover {
+    background: inherit;
+    box-shadow: inset 0 -3px #ffffff;
+}
+
+#workspaces button {
+    padding: 0 5px;
+    background-color: transparent;
+    color: #ffffff;
+}
+
 #workspaces button:hover {
     background: rgba(0, 0, 0, 0.2);
-    box-shadow: inset 0 -3px #ffffff;
 }
 
 #workspaces button.focused {
@@ -78,6 +85,7 @@ window#waybar.chromium {
 #tray,
 #mode,
 #idle_inhibitor,
+#scratchpad,
 #mpd {
     padding: 0 10px;
     color: #ffffff;
@@ -252,3 +260,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/AButton.cpp

@@ -0,0 +1,160 @@
+#include "AButton.hpp"
+
+#include <fmt/format.h>
+
+#include <util/command.hpp>
+
+namespace waybar {
+
+AButton::AButton(const Json::Value& config, const std::string& name, const std::string& id,
+                 const std::string& format, uint16_t interval, bool ellipsize, bool enable_click,
+                 bool enable_scroll)
+    : AModule(config, name, id, config["format-alt"].isString() || enable_click, enable_scroll),
+      format_(config_["format"].isString() ? config_["format"].asString() : format),
+      interval_(config_["interval"] == "once"
+                    ? std::chrono::seconds(100000000)
+                    : std::chrono::seconds(
+                          config_["interval"].isUInt() ? config_["interval"].asUInt() : interval)),
+      default_format_(format_) {
+  button_.set_name(name);
+  button_.set_relief(Gtk::RELIEF_NONE);
+
+  /* https://github.com/Alexays/Waybar/issues/1731 */
+  auto css = Gtk::CssProvider::create();
+  css->load_from_data("button { min-width: 0; }");
+  button_.get_style_context()->add_provider(css, GTK_STYLE_PROVIDER_PRIORITY_USER);
+
+  if (!id.empty()) {
+    button_.get_style_context()->add_class(id);
+  }
+  event_box_.add(button_);
+  if (config_["max-length"].isUInt()) {
+    label_->set_max_width_chars(config_["max-length"].asInt());
+    label_->set_ellipsize(Pango::EllipsizeMode::ELLIPSIZE_END);
+    label_->set_single_line_mode(true);
+  } else if (ellipsize && label_->get_max_width_chars() == -1) {
+    label_->set_ellipsize(Pango::EllipsizeMode::ELLIPSIZE_END);
+    label_->set_single_line_mode(true);
+  }
+
+  if (config_["min-length"].isUInt()) {
+    label_->set_width_chars(config_["min-length"].asUInt());
+  }
+
+  uint rotate = 0;
+
+  if (config_["rotate"].isUInt()) {
+    rotate = config["rotate"].asUInt();
+    label_->set_angle(rotate);
+  }
+
+  if (config_["align"].isDouble()) {
+    auto align = config_["align"].asFloat();
+    if (rotate == 90 || rotate == 270) {
+      label_->set_yalign(align);
+    } else {
+      label_->set_xalign(align);
+    }
+  }
+
+  if (!(config_["on-click"].isString() || config_["on-click-middle"].isString() ||
+        config_["on-click-backward"].isString() || config_["on-click-forward"].isString() ||
+        config_["on-click-right"].isString() || config_["format-alt"].isString() || enable_click)) {
+    button_.set_sensitive(false);
+  } else {
+    button_.signal_pressed().connect([this] {
+      GdkEventButton* e = (GdkEventButton*)gdk_event_new(GDK_BUTTON_PRESS);
+      e->button = 1;
+      handleToggle(e);
+    });
+  }
+}
+
+auto AButton::update() -> void { AModule::update(); }
+
+std::string AButton::getIcon(uint16_t percentage, const std::string& alt, uint16_t max) {
+  auto format_icons = config_["format-icons"];
+  if (format_icons.isObject()) {
+    if (!alt.empty() && (format_icons[alt].isString() || format_icons[alt].isArray())) {
+      format_icons = format_icons[alt];
+    } else {
+      format_icons = format_icons["default"];
+    }
+  }
+  if (format_icons.isArray()) {
+    auto size = format_icons.size();
+    auto idx = std::clamp(percentage / ((max == 0 ? 100 : max) / size), 0U, size - 1);
+    format_icons = format_icons[idx];
+  }
+  if (format_icons.isString()) {
+    return format_icons.asString();
+  }
+  return "";
+}
+
+std::string AButton::getIcon(uint16_t percentage, const std::vector<std::string>& alts,
+                             uint16_t max) {
+  auto format_icons = config_["format-icons"];
+  if (format_icons.isObject()) {
+    std::string _alt = "default";
+    for (const auto& alt : alts) {
+      if (!alt.empty() && (format_icons[alt].isString() || format_icons[alt].isArray())) {
+        _alt = alt;
+        break;
+      }
+    }
+    format_icons = format_icons[_alt];
+  }
+  if (format_icons.isArray()) {
+    auto size = format_icons.size();
+    auto idx = std::clamp(percentage / ((max == 0 ? 100 : max) / size), 0U, size - 1);
+    format_icons = format_icons[idx];
+  }
+  if (format_icons.isString()) {
+    return format_icons.asString();
+  }
+  return "";
+}
+
+bool waybar::AButton::handleToggle(GdkEventButton* const& e) {
+  if (config_["format-alt-click"].isUInt() && e->button == config_["format-alt-click"].asUInt()) {
+    alt_ = !alt_;
+    if (alt_ && config_["format-alt"].isString()) {
+      format_ = config_["format-alt"].asString();
+    } else {
+      format_ = default_format_;
+    }
+  }
+  return AModule::handleToggle(e);
+}
+
+std::string AButton::getState(uint8_t value, bool lesser) {
+  if (!config_["states"].isObject()) {
+    return "";
+  }
+  // Get current state
+  std::vector<std::pair<std::string, uint8_t>> states;
+  if (config_["states"].isObject()) {
+    for (auto it = config_["states"].begin(); it != config_["states"].end(); ++it) {
+      if (it->isUInt() && it.key().isString()) {
+        states.emplace_back(it.key().asString(), it->asUInt());
+      }
+    }
+  }
+  // Sort states
+  std::sort(states.begin(), states.end(), [&lesser](auto& a, auto& b) {
+    return lesser ? a.second < b.second : a.second > b.second;
+  });
+  std::string valid_state;
+  for (auto const& state : states) {
+    if ((lesser ? value <= state.second : value >= state.second) && valid_state.empty()) {
+      button_.get_style_context()->add_class(state.first);
+      valid_state = state.first;
+    } else {
+      button_.get_style_context()->remove_class(state.first);
+    }
+  }
+  return valid_state;
+}
+
+}  // namespace waybar

src/ALabel.cpp

@@ -1,5 +1,7 @@
 #include "ALabel.hpp"
+
 #include <fmt/format.h>
+
 #include <util/command.hpp>
 
 namespace waybar {
@@ -46,15 +48,10 @@ ALabel::ALabel(const Json::Value& config, const std::string& name, const std::st
     } else {
       label_.set_xalign(align);
     }
-
   }
-
-
 }
 
-auto ALabel::update() -> void {
+auto ALabel::update() -> void { AModule::update(); }
-  AModule::update();
-}
 
 std::string ALabel::getIcon(uint16_t percentage, const std::string& alt, uint16_t max) {
   auto format_icons = config_["format-icons"];
@@ -78,7 +75,8 @@ std::string ALabel::getIcon(uint16_t percentage, const std::string& alt, uint16_
   return "";
 }
 
-std::string ALabel::getIcon(uint16_t percentage, const std::vector<std::string>& alts, uint16_t max) {
+std::string ALabel::getIcon(uint16_t percentage, const std::vector<std::string>& alts,
+                            uint16_t max) {
   auto format_icons = config_["format-icons"];
   if (format_icons.isObject()) {
     std::string _alt = "default";

src/AModule.cpp

@@ -1,20 +1,32 @@
 #include "AModule.hpp"
+
 #include <fmt/format.h>
+
 #include <util/command.hpp>
 
 namespace waybar {
 
 AModule::AModule(const Json::Value& config, const std::string& name, const std::string& id,
                  bool enable_click, bool enable_scroll)
-    : name_(std::move(name)), config_(std::move(config))
+    : name_(std::move(name)),
-    , distance_scrolled_y_(0.0)
+      config_(std::move(config)),
-    , distance_scrolled_x_(0.0) {
+      distance_scrolled_y_(0.0),
+      distance_scrolled_x_(0.0) {
   // configure events' user commands
-  if (config_["on-click"].isString() || config_["on-click-middle"].isString() ||
+  if (enable_click) {
-      config_["on-click-backward"].isString() || config_["on-click-forward"].isString() ||
-      config_["on-click-right"].isString() || enable_click) {
     event_box_.add_events(Gdk::BUTTON_PRESS_MASK);
     event_box_.signal_button_press_event().connect(sigc::mem_fun(*this, &AModule::handleToggle));
+  } else {
+    std::map<std::pair<uint, GdkEventType>, std::string>::const_iterator it{eventMap_.cbegin()};
+    while (it != eventMap_.cend()) {
+      if (config_[it->second].isString()) {
+        event_box_.add_events(Gdk::BUTTON_PRESS_MASK);
+        event_box_.signal_button_press_event().connect(
+            sigc::mem_fun(*this, &AModule::handleToggle));
+        break;
+      }
+      ++it;
+    }
   }
   if (config_["on-scroll-up"].isString() || config_["on-scroll-down"].isString() || enable_scroll) {
     event_box_.add_events(Gdk::SCROLL_MASK | Gdk::SMOOTH_SCROLL_MASK);
@@ -30,7 +42,6 @@ AModule::~AModule() {
   }
 }
 
-
 auto AModule::update() -> void {
   // Run user-provided update handler if configured
   if (config_["on-update"].isString()) {
@@ -39,18 +50,17 @@ auto AModule::update() -> void {
 }
 
 bool AModule::handleToggle(GdkEventButton* const& e) {
-  std::string format;
+  const std::map<std::pair<uint, GdkEventType>, std::string>::const_iterator& rec{
-  if (config_["on-click"].isString() && e->button == 1) {
+      eventMap_.find(std::pair(e->button, e->type))};
-    format = config_["on-click"].asString();
+  std::string format{(rec != eventMap_.cend()) ? rec->second : std::string{""}};
-  } else if (config_["on-click-middle"].isString() && e->button == 2) {
+
-    format = config_["on-click-middle"].asString();
+  if (!format.empty()) {
-  } else if (config_["on-click-right"].isString() && e->button == 3) {
+    if (config_[format].isString())
-    format = config_["on-click-right"].asString();
+      format = config_[format].asString();
-  } else if (config_["on-click-backward"].isString() && e->button == 8) {
+    else
-    format = config_["on-click-backward"].asString();
+      format.clear();
-  } else if (config_["on-click-forward"].isString() && e->button == 9) {
-    format = config_["on-click-forward"].asString();
   }
+
   if (!format.empty()) {
     pid_.push_back(util::command::forkExec(format));
   }
@@ -59,11 +69,15 @@ bool AModule::handleToggle(GdkEventButton* const& e) {
 }
 
 AModule::SCROLL_DIR AModule::getScrollDir(GdkEventScroll* e) {
-  switch (e -> direction) {
+  switch (e->direction) {
-    case GDK_SCROLL_UP: return SCROLL_DIR::UP;
+    case GDK_SCROLL_UP:
-    case GDK_SCROLL_DOWN: return SCROLL_DIR::DOWN;
+      return SCROLL_DIR::UP;
-    case GDK_SCROLL_LEFT: return SCROLL_DIR::LEFT;
+    case GDK_SCROLL_DOWN:
-    case GDK_SCROLL_RIGHT: return SCROLL_DIR::RIGHT;
+      return SCROLL_DIR::DOWN;
+    case GDK_SCROLL_LEFT:
+      return SCROLL_DIR::LEFT;
+    case GDK_SCROLL_RIGHT:
+      return SCROLL_DIR::RIGHT;
     case GDK_SCROLL_SMOOTH: {
       SCROLL_DIR dir{SCROLL_DIR::NONE};
 
@@ -101,7 +115,8 @@ AModule::SCROLL_DIR AModule::getScrollDir(GdkEventScroll* e) {
       return dir;
     }
     // Silence -Wreturn-type:
-    default: return SCROLL_DIR::NONE;
+    default:
+      return SCROLL_DIR::NONE;
   }
 }
 

src/bar.cpp

@@ -170,12 +170,21 @@ struct GLSSurfaceImpl : public BarSurface, public sigc::trackable {
       vertical_ = true;
       unanchored = GTK_LAYER_SHELL_EDGE_LEFT;
     }
-    for (auto edge : {GTK_LAYER_SHELL_EDGE_LEFT,
+    for (auto edge : {GTK_LAYER_SHELL_EDGE_LEFT, GTK_LAYER_SHELL_EDGE_RIGHT,
-                      GTK_LAYER_SHELL_EDGE_RIGHT,
+                      GTK_LAYER_SHELL_EDGE_TOP, GTK_LAYER_SHELL_EDGE_BOTTOM}) {
-                      GTK_LAYER_SHELL_EDGE_TOP,
-                      GTK_LAYER_SHELL_EDGE_BOTTOM}) {
       gtk_layer_set_anchor(window_.gobj(), edge, unanchored != edge);
     }
+
+    // Disable anchoring for other edges too if the width
+    // or the height has been set to a value other than 'auto'
+    // otherwise the bar will use all space
+    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 (!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);
+    }
   }
 
   void setSize(uint32_t width, uint32_t height) override {
@@ -276,8 +285,8 @@ struct RawSurfaceImpl : public BarSurface, public sigc::trackable {
     margins_ = margins;
     // updating already mapped window
     if (layer_surface_) {
-      zwlr_layer_surface_v1_set_margin(
+      zwlr_layer_surface_v1_set_margin(layer_surface_.get(), margins_.top, margins_.right,
-          layer_surface_.get(), margins_.top, margins_.right, margins_.bottom, margins_.left);
+                                       margins_.bottom, margins_.left);
     }
   }
 
@@ -365,14 +374,14 @@ struct RawSurfaceImpl : public BarSurface, public sigc::trackable {
     auto gdk_window = window_.get_window()->gobj();
     surface_ = gdk_wayland_window_get_wl_surface(gdk_window);
 
-    layer_surface_.reset(zwlr_layer_shell_v1_get_layer_surface(
+    layer_surface_.reset(zwlr_layer_shell_v1_get_layer_surface(client->layer_shell, surface_,
-        client->layer_shell, surface_, output_, layer_, "waybar"));
+                                                               output_, layer_, "waybar"));
 
     zwlr_layer_surface_v1_add_listener(layer_surface_.get(), &layer_surface_listener, this);
     zwlr_layer_surface_v1_set_keyboard_interactivity(layer_surface_.get(), false);
     zwlr_layer_surface_v1_set_anchor(layer_surface_.get(), anchor_);
-    zwlr_layer_surface_v1_set_margin(
+    zwlr_layer_surface_v1_set_margin(layer_surface_.get(), margins_.top, margins_.right,
-        layer_surface_.get(), margins_.top, margins_.right, margins_.bottom, margins_.left);
+                                     margins_.bottom, margins_.left);
 
     setSurfaceSize(width_, height_);
     setExclusiveZone(exclusive_zone_);
@@ -453,10 +462,8 @@ struct RawSurfaceImpl : public BarSurface, public sigc::trackable {
       o->window_.set_size_request(o->width_, o->height_);
       o->window_.resize(o->width_, o->height_);
       o->setExclusiveZone(o->exclusive_zone_);
-      spdlog::info(BAR_SIZE_MSG,
+      spdlog::info(BAR_SIZE_MSG, o->width_ == 1 ? "auto" : std::to_string(o->width_),
-                   o->width_ == 1 ? "auto" : std::to_string(o->width_),
+                   o->height_ == 1 ? "auto" : std::to_string(o->height_), o->output_name_);
-                   o->height_ == 1 ? "auto" : std::to_string(o->height_),
-                   o->output_name_);
       o->commit();
     }
     zwlr_layer_surface_v1_ack_configure(surface, serial);
@@ -567,8 +574,10 @@ waybar::Bar::Bar(struct waybar_output* w_output, const Json::Value& w_config)
   }
 
   surface_impl_->setMargins(margins_);
-  surface_impl_->setPosition(position);
   surface_impl_->setSize(width, height);
+  // Position needs to be set after calculating the height due to the
+  // GTK layer shell anchors logic relying on the dimensions of the bar.
+  surface_impl_->setPosition(position);
 
   /* Read custom modes if available */
   if (auto modes = config.get("modes", {}); modes.isObject()) {
@@ -665,7 +674,11 @@ void waybar::Bar::onMap(GdkEventAny*) {
 
 void waybar::Bar::setVisible(bool value) {
   visible = value;
+  if (auto mode = config.get("mode", {}); mode.isString()) {
+    setMode(visible ? config["mode"].asString() : MODE_INVISIBLE);
+  } else {
     setMode(visible ? MODE_DEFAULT : MODE_INVISIBLE);
+  }
 }
 
 void waybar::Bar::toggle() { setVisible(!visible); }
@@ -719,7 +732,8 @@ void waybar::Bar::handleSignal(int signal) {
   }
 }
 
-void waybar::Bar::getModules(const Factory& factory, const std::string& pos, Gtk::Box* group = nullptr) {
+void waybar::Bar::getModules(const Factory& factory, const std::string& pos,
+                             Gtk::Box* group = nullptr) {
   auto module_list = group ? config[pos]["modules"] : config[pos];
   if (module_list.isArray()) {
     for (const auto& name : module_list) {

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() {
@@ -32,7 +32,7 @@ void waybar::Client::handleGlobal(void *data, struct wl_registry *registry, uint
   }
 }
 
-void waybar::Client::handleGlobalRemove(void *   data, struct wl_registry * /*registry*/,
+void waybar::Client::handleGlobalRemove(void *data, struct wl_registry * /*registry*/,
                                         uint32_t name) {
   // Nothing here
 }
@@ -52,8 +52,8 @@ void waybar::Client::handleOutput(struct waybar_output &output) {
 }
 
 struct waybar::waybar_output &waybar::Client::getOutput(void *addr) {
-  auto it = std::find_if(
+  auto it = std::find_if(outputs_.begin(), outputs_.end(),
-      outputs_.begin(), outputs_.end(), [&addr](const auto &output) { return &output == addr; });
+                         [&addr](const auto &output) { return &output == addr; });
   if (it == outputs_.end()) {
     throw std::runtime_error("Unable to find valid output");
   }
@@ -93,7 +93,7 @@ void waybar::Client::handleOutputDone(void *data, struct zxdg_output_v1 * /*xdg_
   }
 }
 
-void waybar::Client::handleOutputName(void *      data, struct zxdg_output_v1 * /*xdg_output*/,
+void waybar::Client::handleOutputName(void *data, struct zxdg_output_v1 * /*xdg_output*/,
                                       const char *name) {
   auto client = waybar::Client::inst();
   try {
@@ -108,7 +108,7 @@ void waybar::Client::handleOutputDescription(void *data, struct zxdg_output_v1 *
                                              const char *description) {
   auto client = waybar::Client::inst();
   try {
-    auto &      output = client->getOutput(data);
+    auto &output = client->getOutput(data);
     const char *open_paren = strrchr(description, '(');
 
     // Description format: "identifier (name)"
@@ -169,8 +169,8 @@ auto waybar::Client::setupCss(const std::string &css_file) -> void {
     throw std::runtime_error("Can't open style file");
   }
   // there's always only one screen
-  style_context_->add_provider_for_screen(
+  style_context_->add_provider_for_screen(Gdk::Screen::get_default(), css_provider_,
-      Gdk::Screen::get_default(), css_provider_, GTK_STYLE_PROVIDER_PRIORITY_USER);
+                                          GTK_STYLE_PROVIDER_PRIORITY_USER);
 }
 
 void waybar::Client::bindInterfaces() {
@@ -224,8 +224,8 @@ int waybar::Client::main(int argc, char *argv[]) {
   if (!log_level.empty()) {
     spdlog::set_level(spdlog::level::from_str(log_level));
   }
-  gtk_app = Gtk::Application::create(
+  gtk_app = Gtk::Application::create(argc, argv, "fr.arouillard.waybar",
-      argc, argv, "fr.arouillard.waybar", Gio::APPLICATION_HANDLES_COMMAND_LINE);
+                                     Gio::APPLICATION_HANDLES_COMMAND_LINE);
   gdk_display = Gdk::Display::get_default();
   if (!gdk_display) {
     throw std::runtime_error("Can't find display");
@@ -244,6 +244,4 @@ int waybar::Client::main(int argc, char *argv[]) {
   return 0;
 }
 
-void waybar::Client::reset() {
+void waybar::Client::reset() { gtk_app->quit(); }
-  gtk_app->quit();
-}

src/config.cpp

@@ -1,32 +1,43 @@
 #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 = {
-    "$XDG_CONFIG_HOME/waybar/",
+    "$XDG_CONFIG_HOME/waybar/", "$HOME/.config/waybar/",   "$HOME/waybar/",
-    "$HOME/.config/waybar/",
+    "/etc/xdg/waybar/",         SYSCONFDIR "/xdg/waybar/", "./resources/",
-    "$HOME/waybar/",
-    "/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);
@@ -36,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;
       }
     }
@@ -73,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,11 +7,21 @@ 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]);
     }
 #endif
+#ifdef HAVE_GAMEMODE
+    if (ref == "gamemode") {
+      return new waybar::modules::Gamemode(id, config_[name]);
+    }
+#endif
+#ifdef HAVE_UPOWER
+    if (ref == "upower") {
+      return new waybar::modules::upower::UPower(id, config_[name]);
+    }
+#endif
 #ifdef HAVE_SWAY
     if (ref == "sway/mode") {
       return new waybar::modules::sway::Mode(id, config_[name]);
@@ -25,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") {
@@ -37,9 +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]);
@@ -57,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]);
     }
@@ -96,20 +126,21 @@ waybar::AModule* waybar::Factory::makeModule(const std::string& name) const {
     }
 #endif
 #ifdef HAVE_GIO_UNIX
+    if (ref == "bluetooth") {
+      return new waybar::modules::Bluetooth(id, config_[name]);
+    }
     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
     if (ref == "temperature") {
       return new waybar::modules::Temperature(id, config_[name]);
     }
-#if defined(__linux__)
-#  ifdef WANT_RFKILL
-    if (ref == "bluetooth") {
-      return new waybar::modules::Bluetooth(id, config_[name]);
-    }
-#  endif
-#endif
     if (ref.compare(0, 7, "custom/") == 0 && ref.size() > 7) {
       return new waybar::modules::Custom(ref.substr(7), id, config_[name]);
     }

src/group.cpp

@@ -1,14 +1,14 @@
 #include "group.hpp"
+
 #include <fmt/format.h>
+
 #include <util/command.hpp>
 
 namespace waybar {
 
 Group::Group(const std::string& name, const Bar& bar, const Json::Value& config)
     : AModule(config, name, "", false, false),
-      box{bar.vertical ? Gtk::ORIENTATION_HORIZONTAL : Gtk::ORIENTATION_VERTICAL, 0}
+      box{bar.vertical ? Gtk::ORIENTATION_HORIZONTAL : Gtk::ORIENTATION_VERTICAL, 0} {}
-    {
-}
 
 auto Group::update() -> void {
   // noop

src/main.cpp

@@ -1,9 +1,11 @@
+#include <spdlog/spdlog.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
 #include <csignal>
 #include <list>
 #include <mutex>
-#include <sys/types.h>
+
-#include <sys/wait.h>
-#include <spdlog/spdlog.h>
 #include "client.hpp"
 
 std::mutex reap_mtx;
@@ -38,8 +40,7 @@ void* signalThread(void* args) {
         }
         break;
       default:
-        spdlog::debug("Received signal with number {}, but not handling",
+        spdlog::debug("Received signal with number {}, but not handling", signum);
-                      signum);
         break;
     }
   }

src/modules/backlight.cpp

@@ -87,14 +87,14 @@ int waybar::modules::Backlight::BacklightDev::get_max() const { return max_; }
 void waybar::modules::Backlight::BacklightDev::set_max(int max) { max_ = max; }
 
 waybar::modules::Backlight::Backlight(const std::string &id, const Json::Value &config)
-    : ALabel(config, "backlight", id, "{percent}%", 2),
+    : AButton(config, "backlight", id, "{percent}%", 2),
       preferred_device_(config["device"].isString() ? config["device"].asString() : "") {
   // Get initial state
   {
     std::unique_ptr<udev, UdevDeleter> udev_check{udev_new()};
     check_nn(udev_check.get(), "Udev check new failed");
-    enumerate_devices(
+    enumerate_devices(devices_.begin(), devices_.end(), std::back_inserter(devices_),
-        devices_.begin(), devices_.end(), std::back_inserter(devices_), udev_check.get());
+                      udev_check.get());
     if (devices_.empty()) {
       throw std::runtime_error("No backlight found");
     }
@@ -108,8 +108,7 @@ waybar::modules::Backlight::Backlight(const std::string &id, const Json::Value &
     std::unique_ptr<udev_monitor, UdevMonitorDeleter> mon{
         udev_monitor_new_from_netlink(udev.get(), "udev")};
     check_nn(mon.get(), "udev monitor new failed");
-    check_gte(udev_monitor_filter_add_match_subsystem_devtype(mon.get(), "backlight", nullptr),
+    check_gte(udev_monitor_filter_add_match_subsystem_devtype(mon.get(), "backlight", nullptr), 0,
-              0,
               "udev failed to add monitor filter: ");
     udev_monitor_enable_receiving(mon.get());
 
@@ -126,8 +125,8 @@ waybar::modules::Backlight::Backlight(const std::string &id, const Json::Value &
     epoll_event events[EPOLL_MAX_EVENTS];
 
     while (udev_thread_.isRunning()) {
-      const int event_count = epoll_wait(
+      const int event_count = epoll_wait(epoll_fd.get(), events, EPOLL_MAX_EVENTS,
-          epoll_fd.get(), events, EPOLL_MAX_EVENTS, std::chrono::milliseconds{interval_}.count());
+                                         std::chrono::milliseconds{interval_}.count());
       if (!udev_thread_.isRunning()) {
         break;
       }
@@ -173,20 +172,21 @@ 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());
+    const uint8_t percent =
-    label_.set_markup(fmt::format(
+        best->get_max() == 0 ? 100 : round(best->get_actual() * 100.0f / best->get_max());
-        format_, fmt::arg("percent", std::to_string(percent)), fmt::arg("icon", getIcon(percent))));
+    label_->set_markup(fmt::format(format_, fmt::arg("percent", std::to_string(percent)),
+                                   fmt::arg("icon", getIcon(percent))));
     getState(percent);
   } else {
     if (!previous_best_.has_value()) {
       return;
     }
-    label_.set_markup("");
+    label_->set_markup("");
   }
   previous_best_ = best == nullptr ? std::nullopt : std::optional{*best};
   previous_format_ = format_;
   // Call parent update
-  ALabel::update();
+  AButton::update();
 }
 
 template <class ForwardIt>
@@ -214,19 +214,20 @@ void waybar::modules::Backlight::upsert_device(ForwardIt first, ForwardIt last,
       strncmp(name, "amdgpu_bl", 9) == 0 ? "brightness" : "actual_brightness";
 
   const char *actual = udev_device_get_sysattr_value(dev, actual_brightness_attr);
-  check_nn(actual);
-  const int actual_int = std::stoi(actual);
-
   const char *max = udev_device_get_sysattr_value(dev, "max_brightness");
-  check_nn(max);
-  const int max_int = std::stoi(max);
 
   auto found =
       std::find_if(first, last, [name](const auto &device) { return device.name() == name; });
   if (found != last) {
-    found->set_actual(actual_int);
+    if (actual != nullptr) {
-    found->set_max(max_int);
+      found->set_actual(std::stoi(actual));
+    }
+    if (max != nullptr) {
+      found->set_max(std::stoi(max));
+    }
   } 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};
     ++inserter;
   }
@@ -241,7 +242,7 @@ void waybar::modules::Backlight::enumerate_devices(ForwardIt first, ForwardIt la
   udev_list_entry *enum_devices = udev_enumerate_get_list_entry(enumerate.get());
   udev_list_entry *dev_list_entry;
   udev_list_entry_foreach(dev_list_entry, enum_devices) {
-    const char *                                    path = udev_list_entry_get_name(dev_list_entry);
+    const char *path = udev_list_entry_get_name(dev_list_entry);
     std::unique_ptr<udev_device, UdevDeviceDeleter> dev{udev_device_new_from_syspath(udev, path)};
     check_nn(dev.get(), "dev new failed");
     upsert_device(first, last, inserter, dev.get());

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) {
+    : AButton(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,12 +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
-  refreshBatteries();
   worker();
 }
 
 waybar::modules::Battery::~Battery() {
+#if defined(__linux__)
   std::lock_guard<std::mutex> guard(battery_list_mutex_);
 
   if (global_watch >= 0) {
@@ -40,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
@@ -69,11 +80,12 @@ 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;
   for (auto const& bat : batteries_) {
@@ -88,12 +100,13 @@ void waybar::modules::Battery::refreshBatteries() {
       auto dir_name = node.path().filename();
       auto bat_defined = config_["bat"].isString();
       if (((bat_defined && dir_name == config_["bat"].asString()) || !bat_defined) &&
-          fs::exists(node.path() / "capacity") && fs::exists(node.path() / "uevent") &&
+          (fs::exists(node.path() / "capacity") || fs::exists(node.path() / "charge_now")) &&
-          fs::exists(node.path() / "status") && fs::exists(node.path() / "type")) {
+          fs::exists(node.path() / "uevent") && fs::exists(node.path() / "status") &&
+          fs::exists(node.path() / "type")) {
         std::string type;
         std::ifstream(node.path() / "type") >> type;
 
-        if (!type.compare("Battery")){
+        if (!type.compare("Battery")) {
           check_map[node.path()] = true;
           auto search = batteries_.find(node.path());
           if (search == batteries_.end()) {
@@ -109,18 +122,21 @@ 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();
       }
     }
   } catch (fs::filesystem_error& e) {
     throw std::runtime_error(e.what());
   }
-  if (batteries_.empty()) {
+  if (warnFirstTime_ && batteries_.empty()) {
     if (config_["bat"].isString()) {
-      throw std::runtime_error("No battery named " + config_["bat"].asString());
+      spdlog::warn("No battery named {0}", config_["bat"].asString());
+    } else {
+      spdlog::warn("No batteries.");
     }
-    throw std::runtime_error("No batteries.");
+
+    warnFirstTime_ = false;
   }
 
   // Remove any batteries that are no longer present and unwatch them
@@ -133,15 +149,21 @@ void waybar::modules::Battery::refreshBatteries() {
       batteries_.erase(check.first);
     }
   }
+#endif
 }
 
 // Unknown > Full > Not charging > Discharging > Charging
 static bool status_gt(const std::string& a, const std::string& b) {
-  if (a == b) return false;
+  if (a == b)
-  else if (a == "Unknown") return true;
+    return false;
-  else if (a == "Full" && b != "Unknown") return true;
+  else if (a == "Unknown")
-  else if (a == "Not charging" && b != "Unknown" && b != "Full") return true;
+    return true;
-  else if (a == "Discharging" && b != "Unknown" && b != "Full" && b != "Not charging") return true;
+  else if (a == "Full" && b != "Unknown")
+    return true;
+  else if (a == "Not charging" && b != "Unknown" && b != "Full")
+    return true;
+  else if (a == "Discharging" && b != "Unknown" && b != "Full" && b != "Not charging")
+    return true;
   return false;
 }
 
@@ -149,83 +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
+#if defined(__FreeBSD__)
-    uint32_t    total_energy = 0;  // μWh
+    /* Allocate state of battery units reported via ACPI. */
-    uint32_t    total_energy_full = 0;
+    int battery_units = 0;
-    uint32_t    total_energy_full_design = 0;
+    size_t battery_units_size = sizeof battery_units;
-    std::string status = "Unknown";
+    if (sysctlbyname("hw.acpi.battery.units", &battery_units, &battery_units_size, NULL, 0) != 0) {
-    for (auto const& item : batteries_) {
+      throw std::runtime_error("sysctl hw.acpi.battery.units failed");
-      auto bat = item.first;
-      uint32_t    power_now;
-      uint32_t    energy_full;
-      uint32_t    energy_now;
-      uint32_t    energy_full_design;
-      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.
-      if (fs::exists(bat / "current_now")) {
-        uint32_t voltage_now;
-        uint32_t current_now;
-        uint32_t charge_now;
-        uint32_t charge_full;
-        uint32_t charge_full_design;
-        std::ifstream(bat / "voltage_now") >> voltage_now;
-        std::ifstream(bat / "current_now") >> 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;
-      } else {
-        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;
     }
 
-      // Show the "smallest" status among all batteries
+    if (battery_units < 0) {
-      if (status_gt(status, _status)) {
+      throw std::runtime_error("No battery units");
-        status = _status;
     }
-      total_power += power_now;
+
-      total_energy += energy_now;
+    int capacity;
-      total_energy_full += energy_full;
+    size_t size_capacity = sizeof capacity;
-      total_energy_full_design += energy_full_design;
+    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") {
+    int time;
-      bool online;
+    size_t size_time = sizeof time;
-      std::ifstream(adapter_ / "online") >> online;
+    if (sysctlbyname("hw.acpi.battery.time", &time, &size_time, NULL, 0) != 0) {
-      if (online) {
+      throw std::runtime_error("sysctl hw.acpi.battery.time failed");
-        status = "Plugged";
     }
+    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");
     }
-    float time_remaining = 0;
+
-    if (status == "Discharging" && total_power != 0) {
+    auto status = getAdapterStatus(capacity);
-      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 = ((float)total_energy * 100.0f / (float) total_energy_full);
-    // Handle design-capacity
-    if (config_["design-capacity"].isBool() ? config_["design-capacity"].asBool() : false) {
-        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();
@@ -239,13 +213,317 @@ 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;
+      }
+    }
+
+    if (!adapter_.empty() && status == "Discharging") {
+      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;
+      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};
@@ -253,13 +531,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";
@@ -279,19 +570,26 @@ 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);
   }
   auto status_pretty = status;
   // Transform to lowercase  and replace space with dash
-  std::transform(status.begin(), status.end(), status.begin(), [](char ch) {
+  std::transform(status.begin(), status.end(), status.begin(),
-    return ch == ' ' ? '-' : std::tolower(ch);
+                 [](char ch) { return ch == ' ' ? '-' : std::tolower(ch); });
-  });
   auto format = format_;
   auto state = getState(capacity, true);
   auto time_remaining_formatted = formatTimeRemaining(time_remaining);
@@ -313,15 +611,14 @@ auto waybar::modules::Battery::update() -> void {
     } else if (config_["tooltip-format"].isString()) {
       tooltip_format = config_["tooltip-format"].asString();
     }
-    label_.set_tooltip_text(fmt::format(tooltip_format,
+    button_.set_tooltip_text(fmt::format(tooltip_format, fmt::arg("timeTo", tooltip_text_default),
-                                        fmt::arg("timeTo", tooltip_text_default),
+                                         fmt::arg("power", power), fmt::arg("capacity", capacity),
-                                        fmt::arg("capacity", capacity),
                                          fmt::arg("time", time_remaining_formatted)));
   }
   if (!old_status_.empty()) {
-    label_.get_style_context()->remove_class(old_status_);
+    button_.get_style_context()->remove_class(old_status_);
   }
-  label_.get_style_context()->add_class(status);
+  button_.get_style_context()->add_class(status);
   old_status_ = status;
   if (!state.empty() && config_["format-" + status + "-" + state].isString()) {
     format = config_["format-" + status + "-" + state].asString();
@@ -335,12 +632,10 @@ auto waybar::modules::Battery::update() -> void {
   } else {
     event_box_.show();
     auto icons = std::vector<std::string>{status + "-" + state, status, state};
-    label_.set_markup(fmt::format(format,
+    label_->set_markup(fmt::format(format, fmt::arg("capacity", capacity), fmt::arg("power", power),
-                                  fmt::arg("capacity", capacity),
-                                  fmt::arg("power", power),
                                    fmt::arg("icon", getIcon(capacity, icons)),
                                    fmt::arg("time", time_remaining_formatted)));
   }
   // Call parent update
-  ALabel::update();
+  AButton::update();
 }

src/modules/bluetooth.cpp

@@ -1,25 +1,411 @@
 #include "modules/bluetooth.hpp"
 
 #include <fmt/format.h>
+#include <spdlog/spdlog.h>
+
+#include <algorithm>
+#include <sstream>
+
+namespace {
+
+using GDBusManager = std::unique_ptr<GDBusObjectManager, void (*)(GDBusObjectManager*)>;
+
+auto generateManager() -> GDBusManager {
+  GError* error = nullptr;
+  GDBusObjectManager* manager = g_dbus_object_manager_client_new_for_bus_sync(
+      G_BUS_TYPE_SYSTEM,
+      GDBusObjectManagerClientFlags::G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START,
+      "org.bluez", "/", NULL, NULL, NULL, NULL, &error);
+
+  if (error) {
+    spdlog::error("g_dbus_object_manager_client_new_for_bus_sync() failed: {}", error->message);
+    g_error_free(error);
+  }
+
+  auto destructor = [](GDBusObjectManager* manager) {
+    if (manager) {
+      g_object_unref(manager);
+    }
+  };
+
+  return GDBusManager{manager, destructor};
+}
+
+auto getBoolProperty(GDBusProxy* proxy, const char* property_name) -> bool {
+  auto gvar = g_dbus_proxy_get_cached_property(proxy, property_name);
+  if (gvar) {
+    bool property_value = g_variant_get_boolean(gvar);
+    g_variant_unref(gvar);
+    return property_value;
+  }
+
+  spdlog::error("getBoolProperty() failed: doesn't have property {}", property_name);
+  return false;
+}
+
+auto getOptionalStringProperty(GDBusProxy* proxy, const char* property_name)
+    -> std::optional<std::string> {
+  auto gvar = g_dbus_proxy_get_cached_property(proxy, property_name);
+  if (gvar) {
+    std::string property_value = g_variant_get_string(gvar, NULL);
+    g_variant_unref(gvar);
+    return property_value;
+  }
+
+  return std::nullopt;
+}
+
+auto getStringProperty(GDBusProxy* proxy, const char* property_name) -> std::string {
+  auto property_value = getOptionalStringProperty(proxy, property_name);
+  if (!property_value.has_value()) {
+    spdlog::error("getStringProperty() failed: doesn't have property {}", property_name);
+  }
+  return property_value.value_or("");
+}
+
+auto getUcharProperty(GDBusProxy* proxy, const char* property_name) -> unsigned char {
+  auto gvar = g_dbus_proxy_get_cached_property(proxy, property_name);
+  if (gvar) {
+    unsigned char property_value;
+    g_variant_get(gvar, "y", &property_value);
+    g_variant_unref(gvar);
+
+    return property_value;
+  }
+
+  spdlog::error("getUcharProperty() failed: doesn't have property {}", property_name);
+  return 0;
+}
+
+}  // namespace
 
 waybar::modules::Bluetooth::Bluetooth(const std::string& id, const Json::Value& config)
-    : ALabel(config, "bluetooth", id, "{icon}", 10), rfkill_{RFKILL_TYPE_BLUETOOTH} {
+    : AButton(config, "bluetooth", id, " {status}", 10),
+#ifdef WANT_RFKILL
+      rfkill_{RFKILL_TYPE_BLUETOOTH},
+#endif
+      manager_(generateManager()) {
+
+  if (config_["format-device-preference"].isArray()) {
+    std::transform(config_["format-device-preference"].begin(),
+                   config_["format-device-preference"].end(),
+                   std::back_inserter(device_preference_), [](auto x) { return x.asString(); });
+  }
+
+  // NOTE: assumption made that the controller that is selcected stays unchanged
+  // for duration of the module
+  if (!findCurController(cur_controller_)) {
+    if (config_["controller-alias"].isString()) {
+      spdlog::error("findCurController() failed: no bluetooth controller found with alias '{}'",
+                    config_["controller-alias"].asString());
+    } else {
+      spdlog::error("findCurController() failed: no bluetooth controller found");
+    }
+    event_box_.hide();
+    return;
+  }
+  findConnectedDevices(cur_controller_.path, connected_devices_);
+
+  g_signal_connect(manager_.get(), "interface-proxy-properties-changed",
+                   G_CALLBACK(onInterfaceProxyPropertiesChanged), this);
+  g_signal_connect(manager_.get(), "interface-added", G_CALLBACK(onInterfaceAddedOrRemoved), this);
+  g_signal_connect(manager_.get(), "interface-removed", G_CALLBACK(onInterfaceAddedOrRemoved),
+                   this);
+#ifdef WANT_RFKILL
   rfkill_.on_update.connect(sigc::hide(sigc::mem_fun(*this, &Bluetooth::update)));
+#endif
+
+  dp.emit();
 }
 
 auto waybar::modules::Bluetooth::update() -> void {
-  std::string status = rfkill_.getState() ? "disabled" : "enabled";
+  // focussed device is either:
+  // - the first device in the device_preference_ list that is connected to the
+  //   current controller (if none fallback to last connected device)
+  // - it is the last device that connected to the current controller
+  if (!connected_devices_.empty()) {
+    bool preferred_device_connected = false;
+    if (!device_preference_.empty()) {
+      for (const std::string& device_alias : device_preference_) {
+        auto it =
+            std::find_if(connected_devices_.begin(), connected_devices_.end(),
+                         [device_alias](auto device) { return device_alias == device.alias; });
+        if (it != connected_devices_.end()) {
+          preferred_device_connected = true;
+          cur_focussed_device_ = *it;
+          break;
+        }
+      }
+    }
+    if (!preferred_device_connected) {
+      cur_focussed_device_ = connected_devices_.back();
+    }
+  }
 
-  label_.set_markup(
+  std::string state;
-      fmt::format(format_, fmt::arg("status", status), fmt::arg("icon", getIcon(0, status))));
+  std::string tooltip_format;
+  if (!cur_controller_.powered)
+    state = "off";
+  else if (!connected_devices_.empty())
+    state = "connected";
+  else
+    state = "on";
+#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 (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()) {
+      format_ = config_["format"].asString();
+    } else {
+      format_ = default_format_;
+    }
+  }
+  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();
+  }
+
+  format_.empty() ? event_box_.hide() : event_box_.show();
+
+  auto update_style_context = [this](const std::string& style_class, bool in_next_state) {
+    if (in_next_state && !button_.get_style_context()->has_class(style_class)) {
+      button_.get_style_context()->add_class(style_class);
+    } else if (!in_next_state && button_.get_style_context()->has_class(style_class)) {
+      button_.get_style_context()->remove_class(style_class);
+    }
+  };
+  update_style_context("discoverable", cur_controller_.discoverable);
+  update_style_context("discovering", cur_controller_.discovering);
+  update_style_context("pairable", cur_controller_.pairable);
+  if (!state_.empty()) {
+    update_style_context(state_, false);
+  }
+  update_style_context(state, true);
+  state_ = state;
+
+  label_->set_markup(fmt::format(
+      format_, fmt::arg("status", state_), fmt::arg("num_connections", connected_devices_.size()),
+      fmt::arg("controller_address", cur_controller_.address),
+      fmt::arg("controller_address_type", cur_controller_.address_type),
+      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("icon", icon_label),
+      fmt::arg("device_battery_percentage", cur_focussed_device_.battery_percentage.value_or(0))));
 
   if (tooltipEnabled()) {
-    if (config_["tooltip-format"].isString()) {
+    bool tooltip_enumerate_connections_ = config_["tooltip-format-enumerate-connected"].isString();
-      auto tooltip_format = config_["tooltip-format"].asString();
+    bool tooltip_enumerate_connections_battery_ =
-      auto tooltip_text = fmt::format(tooltip_format, status, fmt::arg("status", status));
+        config_["tooltip-format-enumerate-connected-battery"].isString();
-      label_.set_tooltip_text(tooltip_text);
+    if (tooltip_enumerate_connections_ || tooltip_enumerate_connections_battery_) {
+      std::stringstream ss;
+      for (DeviceInfo dev : connected_devices_) {
+        if ((tooltip_enumerate_connections_battery_ && dev.battery_percentage.has_value()) ||
+            tooltip_enumerate_connections_) {
+          ss << "\n";
+          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 {
-      label_.set_tooltip_text(status);
+            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("icon", enumerate_icon),
+              fmt::arg("device_battery_percentage", dev.battery_percentage.value_or(0)));
+        }
+      }
+      device_enumerate_ = ss.str();
+      // don't start the connected devices text with a new line
+      if (!device_enumerate_.empty()) {
+        device_enumerate_.erase(0, 1);
+      }
+    }
+    button_.set_tooltip_text(fmt::format(
+        tooltip_format, fmt::arg("status", state_),
+        fmt::arg("num_connections", connected_devices_.size()),
+        fmt::arg("controller_address", cur_controller_.address),
+        fmt::arg("controller_address_type", cur_controller_.address_type),
+        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("icon", icon_tooltip),
+        fmt::arg("device_battery_percentage", cur_focussed_device_.battery_percentage.value_or(0)),
+        fmt::arg("device_enumerate", device_enumerate_)));
+  }
+
+  // Call parent update
+  AButton::update();
+}
+
+// NOTE: only for when the org.bluez.Battery1 interface is added/removed after/before a device is
+// connected/disconnected
+auto waybar::modules::Bluetooth::onInterfaceAddedOrRemoved(GDBusObjectManager* manager,
+                                                           GDBusObject* object,
+                                                           GDBusInterface* interface,
+                                                           gpointer user_data) -> void {
+  std::string interface_name = g_dbus_proxy_get_interface_name(G_DBUS_PROXY(interface));
+  std::string object_path = g_dbus_proxy_get_object_path(G_DBUS_PROXY(interface));
+  if (interface_name == "org.bluez.Battery1") {
+    Bluetooth* bt = static_cast<Bluetooth*>(user_data);
+    auto device = std::find_if(bt->connected_devices_.begin(), bt->connected_devices_.end(),
+                               [object_path](auto d) { return d.path == object_path; });
+    if (device != bt->connected_devices_.end()) {
+      device->battery_percentage = bt->getDeviceBatteryPercentage(object);
+      bt->dp.emit();
     }
   }
 }
+
+auto waybar::modules::Bluetooth::onInterfaceProxyPropertiesChanged(
+    GDBusObjectManagerClient* manager, GDBusObjectProxy* object_proxy, GDBusProxy* interface_proxy,
+    GVariant* changed_properties, const gchar* const* invalidated_properties, gpointer user_data)
+    -> void {
+  std::string interface_name = g_dbus_proxy_get_interface_name(interface_proxy);
+  std::string object_path = g_dbus_object_get_object_path(G_DBUS_OBJECT(object_proxy));
+
+  Bluetooth* bt = static_cast<Bluetooth*>(user_data);
+  if (interface_name == "org.bluez.Adapter1") {
+    if (object_path == bt->cur_controller_.path) {
+      bt->getControllerProperties(G_DBUS_OBJECT(object_proxy), bt->cur_controller_);
+      bt->dp.emit();
+    }
+  } else if (interface_name == "org.bluez.Device1" || interface_name == "org.bluez.Battery1") {
+    DeviceInfo device;
+    bt->getDeviceProperties(G_DBUS_OBJECT(object_proxy), device);
+    auto cur_device = std::find_if(bt->connected_devices_.begin(), bt->connected_devices_.end(),
+                                   [device](auto d) { return d.path == device.path; });
+    if (cur_device == bt->connected_devices_.end()) {
+      if (device.connected) {
+        bt->connected_devices_.push_back(device);
+        bt->dp.emit();
+      }
+    } else {
+      if (!device.connected) {
+        bt->connected_devices_.erase(cur_device);
+      } else {
+        *cur_device = device;
+      }
+      bt->dp.emit();
+    }
+  }
+}
+
+auto waybar::modules::Bluetooth::getDeviceBatteryPercentage(GDBusObject* object)
+    -> std::optional<unsigned char> {
+  GDBusProxy* proxy_device_bat =
+      G_DBUS_PROXY(g_dbus_object_get_interface(object, "org.bluez.Battery1"));
+  if (proxy_device_bat != NULL) {
+    unsigned char battery_percentage = getUcharProperty(proxy_device_bat, "Percentage");
+    g_object_unref(proxy_device_bat);
+
+    return battery_percentage;
+  }
+  return std::nullopt;
+}
+
+auto waybar::modules::Bluetooth::getDeviceProperties(GDBusObject* object, DeviceInfo& device_info)
+    -> bool {
+  GDBusProxy* proxy_device = G_DBUS_PROXY(g_dbus_object_get_interface(object, "org.bluez.Device1"));
+
+  if (proxy_device != NULL) {
+    device_info.path = g_dbus_object_get_object_path(object);
+    device_info.paired_controller = getStringProperty(proxy_device, "Adapter");
+    device_info.address = getStringProperty(proxy_device, "Address");
+    device_info.address_type = getStringProperty(proxy_device, "AddressType");
+    device_info.alias = getStringProperty(proxy_device, "Alias");
+    device_info.icon = getOptionalStringProperty(proxy_device, "Icon");
+    device_info.paired = getBoolProperty(proxy_device, "Paired");
+    device_info.trusted = getBoolProperty(proxy_device, "Trusted");
+    device_info.blocked = getBoolProperty(proxy_device, "Blocked");
+    device_info.connected = getBoolProperty(proxy_device, "Connected");
+    device_info.services_resolved = getBoolProperty(proxy_device, "ServicesResolved");
+
+    g_object_unref(proxy_device);
+
+    device_info.battery_percentage = getDeviceBatteryPercentage(object);
+
+    return true;
+  }
+  return false;
+}
+
+auto waybar::modules::Bluetooth::getControllerProperties(GDBusObject* object,
+                                                         ControllerInfo& controller_info) -> bool {
+  GDBusProxy* proxy_controller =
+      G_DBUS_PROXY(g_dbus_object_get_interface(object, "org.bluez.Adapter1"));
+
+  if (proxy_controller != NULL) {
+    controller_info.path = g_dbus_object_get_object_path(object);
+    controller_info.address = getStringProperty(proxy_controller, "Address");
+    controller_info.address_type = getStringProperty(proxy_controller, "AddressType");
+    controller_info.alias = getStringProperty(proxy_controller, "Alias");
+    controller_info.powered = getBoolProperty(proxy_controller, "Powered");
+    controller_info.discoverable = getBoolProperty(proxy_controller, "Discoverable");
+    controller_info.pairable = getBoolProperty(proxy_controller, "Pairable");
+    controller_info.discovering = getBoolProperty(proxy_controller, "Discovering");
+
+    g_object_unref(proxy_controller);
+
+    return true;
+  }
+  return false;
+}
+
+auto waybar::modules::Bluetooth::findCurController(ControllerInfo& controller_info) -> bool {
+  bool found_controller = false;
+
+  GList* objects = g_dbus_object_manager_get_objects(manager_.get());
+  for (GList* l = objects; l != NULL; l = l->next) {
+    GDBusObject* object = G_DBUS_OBJECT(l->data);
+    if (getControllerProperties(object, controller_info) &&
+        (!config_["controller-alias"].isString() ||
+         config_["controller-alias"].asString() == controller_info.alias)) {
+      found_controller = true;
+      break;
+    }
+  }
+  g_list_free_full(objects, g_object_unref);
+
+  return found_controller;
+}
+
+auto waybar::modules::Bluetooth::findConnectedDevices(const std::string& cur_controller_path,
+                                                      std::vector<DeviceInfo>& connected_devices)
+    -> void {
+  GList* objects = g_dbus_object_manager_get_objects(manager_.get());
+  for (GList* l = objects; l != NULL; l = l->next) {
+    GDBusObject* object = G_DBUS_OBJECT(l->data);
+    DeviceInfo device;
+    if (getDeviceProperties(object, device) && device.connected &&
+        device.paired_controller == cur_controller_.path) {
+      connected_devices.push_back(device);
+    }
+  }
+  g_list_free_full(objects, g_object_unref);
+}