Merge branch 'master' into master

.clang-format

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

.github/workflows/lint.yml

@@ -0,0 +1,14 @@
+name: Linter
+
+on: [push]
+
+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

include/AIconLabel.hpp

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

include/ALabel.hpp

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

include/AModule.hpp

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

include/IModule.hpp

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

include/bar.hpp

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

include/client.hpp

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

include/factory.hpp

@@ -7,10 +7,10 @@
 #include "modules/simpleclock.hpp"
 #endif
 #ifdef HAVE_SWAY
+#include "modules/sway/language.hpp"
 #include "modules/sway/mode.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"
@@ -61,9 +61,9 @@
 #include "modules/custom.hpp"
 #include "modules/temperature.hpp"
 #if defined(__linux__)
-#  ifdef WANT_RFKILL
+#ifdef WANT_RFKILL
-#    include "modules/bluetooth.hpp"
+#include "modules/bluetooth.hpp"
-#  endif
+#endif
 #endif
 
 namespace waybar {
@@ -74,7 +74,7 @@ class Factory {
   AModule* makeModule(const std::string& name) const;
 
  private:
-  const Bar&         bar_;
+  const Bar& bar_;
   const Json::Value& config_;
 };
 

include/group.hpp

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

include/modules/backlight.hpp

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

include/modules/battery.hpp

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

include/modules/clock.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <date/tz.h>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 
@@ -24,7 +25,7 @@ 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 cached_calendar_ymd_ = date::January / 1 / 0;
   std::string cached_calendar_text_;
   bool is_calendar_in_tooltip_;
   bool is_timezoned_list_in_tooltip_;
@@ -38,7 +39,7 @@ class Clock : public ALabel {
   auto print_iso_weeknum(std::ostream& os,
                          int weeknum) -> void;
   bool is_timezone_fixed();
-  auto timezones_text(std::chrono::system_clock::time_point *now) -> std::string;
+  auto timezones_text(std::chrono::system_clock::time_point* now) -> std::string;
 };
 
 }  // namespace modules

include/modules/cpu.hpp

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

include/modules/custom.hpp

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

include/modules/disk.hpp

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

include/modules/idle_inhibitor.hpp

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

include/modules/inhibitor.hpp

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

include/modules/keyboard_state.hpp

@@ -6,10 +6,11 @@
 #else
 #include <fmt/chrono.h>
 #endif
+#include <gtkmm/label.h>
+
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "util/sleeper_thread.hpp"
-#include <gtkmm/label.h>
 
 extern "C" {
 #include <libevdev/libevdev.h>
@@ -24,10 +25,10 @@ class KeyboardState : public AModule {
   auto update() -> void;
 
  private:
-  Gtk::Box    box_;
+  Gtk::Box box_;
-  Gtk::Label  numlock_label_;
+  Gtk::Label numlock_label_;
-  Gtk::Label  capslock_label_;
+  Gtk::Label capslock_label_;
-  Gtk::Label  scrolllock_label_;
+  Gtk::Label scrolllock_label_;
 
   std::string numlock_format_;
   std::string capslock_format_;
@@ -36,8 +37,8 @@ class KeyboardState : public AModule {
   std::string icon_locked_;
   std::string icon_unlocked_;
 
-  int         fd_;
+  int fd_;
-  libevdev*   dev_;
+  libevdev* dev_;
 
   util::SleeperThread thread_;
 };

include/modules/memory.hpp

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

include/modules/mpd/mpd.hpp

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

include/modules/mpd/state.hpp

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

include/modules/mpd/state.inl.hpp

@@ -8,13 +8,11 @@ inline bool Context::is_paused() const { return mpd_module_->paused(); }
 inline bool Context::is_stopped() const { return mpd_module_->stopped(); }
 
 constexpr inline std::size_t Context::interval() const { return mpd_module_->interval_.count(); }
-inline void                  Context::tryConnect() const { mpd_module_->tryConnect(); }
+inline void Context::tryConnect() const { mpd_module_->tryConnect(); }
-inline unique_connection&    Context::connection() { return mpd_module_->connection_; }
+inline unique_connection& Context::connection() { return mpd_module_->connection_; }
-constexpr inline mpd_state   Context::state() const { return mpd_module_->state_; }
+constexpr inline mpd_state Context::state() const { return mpd_module_->state_; }
 
-inline void Context::do_update() {
+inline void Context::do_update() { mpd_module_->setLabel(); }
-  mpd_module_->setLabel();
-}
 
 inline void Context::checkErrors(mpd_connection* conn) const { mpd_module_->checkErrors(conn); }
 inline void Context::queryMPD() const { mpd_module_->queryMPD(); }

include/modules/network.hpp

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

include/modules/pulseaudio.hpp

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

include/modules/river/tags.hpp

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

include/modules/sndio.hpp

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

include/modules/sni/host.hpp

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

include/modules/sni/item.hpp

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

include/modules/sni/tray.hpp

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

include/modules/sni/watcher.hpp

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

include/modules/sway/bar.hpp

@@ -34,14 +34,14 @@ class BarIpcClient {
   void onVisibilityUpdate(bool visible_by_modifier);
   void update();
 
-  Bar&             bar_;
+  Bar& bar_;
   util::JsonParser parser_;
-  Ipc              ipc_;
+  Ipc ipc_;
 
   swaybar_config bar_config_;
-  bool           visible_by_modifier_ = false;
+  bool visible_by_modifier_ = false;
 
-  SafeSignal<bool>           signal_visible_;
+  SafeSignal<bool> signal_visible_;
   SafeSignal<swaybar_config> signal_config_;
 };
 

include/modules/sway/ipc/client.hpp

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

include/modules/sway/ipc/ipc.hpp

@@ -30,7 +30,7 @@ enum ipc_command_type {
   IPC_EVENT_SHUTDOWN = ((1 << 31) | 6),
   IPC_EVENT_TICK = ((1 << 31) | 7),
 
-	// sway-specific event types
+  // sway-specific event types
-	IPC_EVENT_BAR_STATE_UPDATE = ((1<<31) | 20),
+  IPC_EVENT_BAR_STATE_UPDATE = ((1 << 31) | 20),
-	IPC_EVENT_INPUT = ((1<<31) | 21),
+  IPC_EVENT_INPUT = ((1 << 31) | 21),
 };

include/modules/sway/language.hpp

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

include/modules/sway/mode.hpp

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

include/modules/sway/window.hpp

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

include/modules/sway/workspaces.hpp

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

include/modules/temperature.hpp

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

include/modules/upower/upower.hpp

@@ -38,41 +38,41 @@ class UPower : public AModule {
                            gpointer data);
   static void upowerDisappear(GDBusConnection *connection, const gchar *name, gpointer user_data);
 
-  void        removeDevice(const gchar *objectPath);
+  void removeDevice(const gchar *objectPath);
-  void        addDevice(UpDevice *device);
+  void addDevice(UpDevice *device);
-  void        setDisplayDevice();
+  void setDisplayDevice();
-  void        resetDevices();
+  void resetDevices();
-  void        removeDevices();
+  void removeDevices();
-  bool        show_tooltip_callback(int, int, bool, const Glib::RefPtr<Gtk::Tooltip> &tooltip);
+  bool show_tooltip_callback(int, int, bool, const Glib::RefPtr<Gtk::Tooltip> &tooltip);
-  bool        handleToggle(GdkEventButton *const &);
+  bool handleToggle(GdkEventButton *const &);
   std::string timeToString(gint64 time);
 
   const std::string getDeviceStatus(UpDeviceState &state);
 
-  Gtk::Box   box_;
+  Gtk::Box box_;
   Gtk::Image icon_;
   Gtk::Label label_;
 
   // Config
-  bool        hideIfEmpty = true;
+  bool hideIfEmpty = true;
-  bool        tooltip_enabled = true;
+  bool tooltip_enabled = true;
-  uint        tooltip_spacing = 4;
+  uint tooltip_spacing = 4;
-  uint        tooltip_padding = 4;
+  uint tooltip_padding = 4;
-  uint        iconSize = 20;
+  uint iconSize = 20;
   std::string format = DEFAULT_FORMAT;
   std::string format_alt = DEFAULT_FORMAT_ALT;
 
-  Devices          devices;
+  Devices devices;
-  std::mutex       m_Mutex;
+  std::mutex m_Mutex;
-  UpClient        *client;
+  UpClient *client;
-  UpDevice        *displayDevice;
+  UpDevice *displayDevice;
-  guint            login1_id;
+  guint login1_id;
   GDBusConnection *login1_connection;
-  UPowerTooltip   *upower_tooltip;
+  UPowerTooltip *upower_tooltip;
-  std::string      lastStatus;
+  std::string lastStatus;
-  bool             showAltText;
+  bool showAltText;
-  bool             upowerRunning;
+  bool upowerRunning;
-  guint            upowerWatcher_id;
+  guint upowerWatcher_id;
 };
 
 }  // namespace waybar::modules::upower

include/modules/wlr/taskbar.hpp

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

include/modules/wlr/workspace_manager.hpp

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

include/modules/wlr/workspace_manager_binding.hpp

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

include/util/SafeSignal.hpp

@@ -64,10 +64,10 @@ struct SafeSignal : sigc::signal<void(std::decay_t<Args>...)> {
     }
   }
 
-  Glib::Dispatcher        dp_;
+  Glib::Dispatcher dp_;
-  std::mutex              mutex_;
+  std::mutex mutex_;
   std::queue<arg_tuple_t> queue_;
-  const std::thread::id   main_tid_ = std::this_thread::get_id();
+  const std::thread::id main_tid_ = std::this_thread::get_id();
   // cache functor for signal emission to avoid recreating it on each event
   const slot_t cached_fn_ = make_slot();
 };

include/util/command.hpp

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

include/util/format.hpp

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

include/util/json.hpp

@@ -13,7 +13,7 @@ struct JsonParser {
       return root;
     }
     std::unique_ptr<Json::CharReader> const reader(builder_.newCharReader());
-    std::string                             err;
+    std::string err;
     bool res = reader->parse(data.c_str(), data.c_str() + data.size(), &root, &err);
     if (!res) throw std::runtime_error(err);
     return root;

include/util/rfkill.hpp

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

include/util/sleeper_thread.hpp

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

include/util/waybar_time.hpp

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

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,24 +1,28 @@
 #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 (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()) {
+    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));
+        event_box_.signal_button_press_event().connect(
+            sigc::mem_fun(*this, &AModule::handleToggle));
         break;
       }
       ++it;
@@ -27,7 +31,7 @@ AModule::AModule(const Json::Value& config, const std::string& name, const std::
   if (config_["on-scroll-up"].isString() || config_["on-scroll-down"].isString() || enable_scroll) {
     event_box_.add_events(Gdk::SCROLL_MASK | Gdk::SMOOTH_SCROLL_MASK);
     event_box_.signal_scroll_event().connect(sigc::mem_fun(*this, &AModule::handleScroll));
-    }
+  }
 }
 
 AModule::~AModule() {
@@ -46,12 +50,15 @@ auto AModule::update() -> void {
 }
 
 bool AModule::handleToggle(GdkEventButton* const& e) {
-  const std::map<std::pair<uint, GdkEventType>, std::string>::const_iterator& rec{eventMap_.find(std::pair(e->button, e->type))};
+  const std::map<std::pair<uint, GdkEventType>, std::string>::const_iterator& rec{
-  std::string format{ (rec != eventMap_.cend()) ? rec->second : std::string{""}};
+      eventMap_.find(std::pair(e->button, e->type))};
+  std::string format{(rec != eventMap_.cend()) ? rec->second : std::string{""}};
 
   if (!format.empty()) {
-    if (config_[format].isString()) format = config_[format].asString();
+    if (config_[format].isString())
-    else format.clear();
+      format = config_[format].asString();
+    else
+      format.clear();
   }
 
   if (!format.empty()) {
@@ -62,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};
 
@@ -104,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,10 +170,8 @@ 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);
     }
   }
@@ -186,11 +184,11 @@ struct GLSSurfaceImpl : public BarSurface, public sigc::trackable {
 
  private:
   Gtk::Window& window_;
-  std::string  output_name_;
+  std::string output_name_;
-  uint32_t     width_;
+  uint32_t width_;
-  uint32_t     height_;
+  uint32_t height_;
-  bool         passthrough_ = false;
+  bool passthrough_ = false;
-  bool         vertical_ = false;
+  bool vertical_ = false;
 
   void onMap(GdkEventAny* ev) { setPassThrough(passthrough_); }
 
@@ -276,8 +274,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);
     }
   }
 
@@ -335,21 +333,21 @@ struct RawSurfaceImpl : public BarSurface, public sigc::trackable {
   using layer_surface_ptr =
       std::unique_ptr<zwlr_layer_surface_v1, deleter_fn<zwlr_layer_surface_v1_destroy>>;
 
-  Gtk::Window&       window_;
+  Gtk::Window& window_;
-  std::string        output_name_;
+  std::string output_name_;
-  uint32_t           configured_width_ = 0;
+  uint32_t configured_width_ = 0;
-  uint32_t           configured_height_ = 0;
+  uint32_t configured_height_ = 0;
-  uint32_t           width_ = 0;
+  uint32_t width_ = 0;
-  uint32_t           height_ = 0;
+  uint32_t height_ = 0;
-  uint8_t            anchor_ = HORIZONTAL_ANCHOR | ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP;
+  uint8_t anchor_ = HORIZONTAL_ANCHOR | ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP;
-  bool               exclusive_zone_ = true;
+  bool exclusive_zone_ = true;
-  bool               passthrough_ = false;
+  bool passthrough_ = false;
   struct bar_margins margins_;
 
   zwlr_layer_shell_v1_layer layer_ = ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM;
-  struct wl_output*         output_ = nullptr;   // owned by GTK
+  struct wl_output* output_ = nullptr;    // owned by GTK
-  struct wl_surface*        surface_ = nullptr;  // owned by GTK
+  struct wl_surface* surface_ = nullptr;  // owned by GTK
-  layer_surface_ptr         layer_surface_;
+  layer_surface_ptr layer_surface_;
 
   void onRealize() {
     auto gdk_window = window_.get_window()->gobj();
@@ -365,14 +363,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 +451,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);
@@ -520,7 +516,7 @@ waybar::Bar::Bar(struct waybar_output* w_output, const Json::Value& w_config)
         config["margin-left"].isInt() ? config["margin-left"].asInt() : 0,
     };
   } else if (config["margin"].isString()) {
-    std::istringstream       iss(config["margin"].asString());
+    std::istringstream iss(config["margin"].asString());
     std::vector<std::string> margins{std::istream_iterator<std::string>(iss), {}};
     try {
       if (margins.size() == 1) {
@@ -723,7 +719,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

@@ -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() {
@@ -195,12 +195,12 @@ void waybar::Client::bindInterfaces() {
 }
 
 int waybar::Client::main(int argc, char *argv[]) {
-  bool        show_help = false;
+  bool show_help = false;
-  bool        show_version = false;
+  bool show_version = false;
   std::string config_opt;
   std::string style_opt;
   std::string log_level;
-  auto        cli = clara::detail::Help(show_help) |
+  auto cli = clara::detail::Help(show_help) |
              clara::detail::Opt(show_version)["-v"]["--version"]("Show version") |
              clara::detail::Opt(config_opt, "config")["-c"]["--config"]("Config path") |
              clara::detail::Opt(style_opt, "style")["-s"]["--style"]("Style path") |
@@ -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

@@ -13,12 +13,8 @@
 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) {
@@ -55,9 +51,9 @@ void Config::setupConfig(Json::Value &dst, const std::string &config_file, int d
   if (!file.is_open()) {
     throw std::runtime_error("Can't open config file");
   }
-  std::string      str((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
+  std::string str((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
   util::JsonParser parser;
-  Json::Value      tmp_config = parser.parse(str);
+  Json::Value tmp_config = parser.parse(str);
   if (tmp_config.isArray()) {
     for (auto &config_part : tmp_config) {
       resolveConfigIncludes(config_part, depth);

src/factory.cpp

@@ -28,7 +28,7 @@ waybar::AModule* waybar::Factory::makeModule(const std::string& name) const {
       return new waybar::modules::sway::Window(id, bar_, config_[name]);
     }
     if (ref == "sway/language") {
-        return new waybar::modules::sway::Language(id, config_[name]);
+      return new waybar::modules::sway::Language(id, config_[name]);
     }
 #endif
 #ifdef HAVE_WLR
@@ -109,11 +109,11 @@ waybar::AModule* waybar::Factory::makeModule(const std::string& name) const {
       return new waybar::modules::Temperature(id, config_[name]);
     }
 #if defined(__linux__)
-#  ifdef WANT_RFKILL
+#ifdef WANT_RFKILL
     if (ref == "bluetooth") {
       return new waybar::modules::Bluetooth(id, config_[name]);
     }
-#  endif
+#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;
     }
   }
@@ -79,9 +80,9 @@ int main(int argc, char* argv[]) {
     });
 
     std::signal(SIGUSR2, [](int /*signal*/) {
-        spdlog::info("Reloading...");
+      spdlog::info("Reloading...");
-        reload = true;
+      reload = true;
-        waybar::Client::inst()->reset();
+      waybar::Client::inst()->reset();
     });
 
     for (int sig = SIGRTMIN + 1; sig <= SIGRTMAX; ++sig) {

src/modules/backlight.cpp

@@ -93,8 +93,8 @@ waybar::modules::Backlight::Backlight(const std::string &id, const Json::Value &
   {
     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,9 +172,10 @@ 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()) {
@@ -241,7 +241,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

@@ -52,7 +52,7 @@ void waybar::modules::Battery::worker() {
   };
   thread_ = [this] {
     struct inotify_event event = {0};
-    int                  nbytes = read(battery_watch_fd_, &event, sizeof(event));
+    int nbytes = read(battery_watch_fd_, &event, sizeof(event));
     if (nbytes != sizeof(event) || event.mask & IN_IGNORED) {
       thread_.stop();
       return;
@@ -61,7 +61,7 @@ void waybar::modules::Battery::worker() {
   };
   thread_battery_update_ = [this] {
     struct inotify_event event = {0};
-    int                  nbytes = read(global_watch_fd_, &event, sizeof(event));
+    int nbytes = read(global_watch_fd_, &event, sizeof(event));
     if (nbytes != sizeof(event) || event.mask & IN_IGNORED) {
       thread_.stop();
       return;
@@ -94,7 +94,7 @@ void waybar::modules::Battery::refreshBatteries() {
         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()) {
@@ -139,11 +139,16 @@ void waybar::modules::Battery::refreshBatteries() {
 
 // 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;
 }
 
@@ -151,19 +156,19 @@ const std::tuple<uint8_t, float, std::string, float> waybar::modules::Battery::g
   std::lock_guard<std::mutex> guard(battery_list_mutex_);
 
   try {
-    uint32_t    total_power = 0;   // μW
+    uint32_t total_power = 0;   // μW
-    uint32_t    total_energy = 0;  // μWh
+    uint32_t total_energy = 0;  // μWh
-    uint32_t    total_energy_full = 0;
+    uint32_t total_energy_full = 0;
-    uint32_t    total_energy_full_design = 0;
+    uint32_t total_energy_full_design = 0;
-    uint32_t    total_capacity{0};
+    uint32_t total_capacity{0};
     std::string status = "Unknown";
     for (auto const& item : batteries_) {
       auto bat = item.first;
-      uint32_t    power_now;
+      uint32_t power_now;
-      uint32_t    energy_full;
+      uint32_t energy_full;
-      uint32_t    energy_now;
+      uint32_t energy_now;
-      uint32_t    energy_full_design;
+      uint32_t energy_full_design;
-      uint32_t    capacity{0};
+      uint32_t capacity{0};
       std::string _status;
       std::getline(std::ifstream(bat / "status"), _status);
 
@@ -198,17 +203,17 @@ const std::tuple<uint8_t, float, std::string, float> waybar::modules::Battery::g
         energy_now = ((uint64_t)charge_now * (uint64_t)voltage_now) / 1000000;
         energy_full = ((uint64_t)charge_full * (uint64_t)voltage_now) / 1000000;
         energy_full_design = ((uint64_t)charge_full_design * (uint64_t)voltage_now) / 1000000;
-      } // Gamepads such as PS Dualshock provide the only capacity
+      }  // Gamepads such as PS Dualshock provide the only capacity
-        else if (fs::exists(bat / "energy_now") && fs::exists(bat / "energy_full")) {
+      else if (fs::exists(bat / "energy_now") && fs::exists(bat / "energy_full")) {
-          std::ifstream(bat / "power_now") >> power_now;
+        std::ifstream(bat / "power_now") >> power_now;
-          std::ifstream(bat / "energy_now") >> energy_now;
+        std::ifstream(bat / "energy_now") >> energy_now;
-          std::ifstream(bat / "energy_full") >> energy_full;
+        std::ifstream(bat / "energy_full") >> energy_full;
-          std::ifstream(bat / "energy_full_design") >> energy_full_design;
+        std::ifstream(bat / "energy_full_design") >> energy_full_design;
       } else {
         std::ifstream(bat / "capacity") >> capacity;
-        power_now          = 0;
+        power_now = 0;
-        energy_now         = 0;
+        energy_now = 0;
-        energy_full        = 0;
+        energy_full = 0;
         energy_full_design = 0;
       }
 
@@ -241,14 +246,14 @@ const std::tuple<uint8_t, float, std::string, float> waybar::modules::Battery::g
       }
     }
     float capacity{0.0f};
-    if(total_energy_full > 0.0f) {
+    if (total_energy_full > 0.0f) {
-      capacity = ((float)total_energy * 100.0f / (float) total_energy_full);
+      capacity = ((float)total_energy * 100.0f / (float)total_energy_full);
     } else {
       capacity = (float)total_capacity;
     }
     // Handle design-capacity
     if (config_["design-capacity"].isBool() ? config_["design-capacity"].asBool() : false) {
-        capacity = ((float)total_energy * 100.0f / (float) total_energy_full_design);
+      capacity = ((float)total_energy * 100.0f / (float)total_energy_full_design);
     }
     // Handle full-at
     if (config_["full-at"].isUInt()) {
@@ -295,7 +300,7 @@ const std::string waybar::modules::Battery::formatTimeRemaining(float hoursRemai
   hoursRemaining = std::fabs(hoursRemaining);
   uint16_t full_hours = static_cast<uint16_t>(hoursRemaining);
   uint16_t minutes = static_cast<uint16_t>(60 * (hoursRemaining - full_hours));
-  auto     format = std::string("{H} h {M} min");
+  auto format = std::string("{H} h {M} min");
   if (full_hours == 0 && minutes == 0) {
     // Migh as well not show "0h 0min"
     return "";
@@ -317,9 +322,8 @@ auto waybar::modules::Battery::update() -> void {
   }
   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);
@@ -341,8 +345,7 @@ 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,
+    label_.set_tooltip_text(fmt::format(tooltip_format, fmt::arg("timeTo", tooltip_text_default),
-                                        fmt::arg("timeTo", tooltip_text_default),
                                         fmt::arg("capacity", capacity),
                                         fmt::arg("time", time_remaining_formatted)));
   }
@@ -363,9 +366,7 @@ 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)));
   }

src/modules/clock.cpp

@@ -25,44 +25,38 @@ waybar::modules::Clock::Clock(const std::string& id, const Json::Value& config)
     : ALabel(config, "clock", id, "{:%H:%M}", 60, false, false, true),
       current_time_zone_idx_(0),
       is_calendar_in_tooltip_(false),
-      is_timezoned_list_in_tooltip_(false)
+      is_timezoned_list_in_tooltip_(false) {
-{
   if (config_["timezones"].isArray() && !config_["timezones"].empty()) {
-    for (const auto& zone_name: config_["timezones"]) {
+    for (const auto& zone_name : config_["timezones"]) {
       if (!zone_name.isString() || zone_name.asString().empty()) {
         time_zones_.push_back(nullptr);
         continue;
       }
-      time_zones_.push_back(
+      time_zones_.push_back(date::locate_zone(zone_name.asString()));
-        date::locate_zone(
-          zone_name.asString()
-        )
-      );
     }
   } else if (config_["timezone"].isString() && !config_["timezone"].asString().empty()) {
-    time_zones_.push_back(
+    time_zones_.push_back(date::locate_zone(config_["timezone"].asString()));
-        date::locate_zone(
-          config_["timezone"].asString()
-        )
-      );
   }
 
-  // If all timezones are parsed and no one is good, add nullptr to the timezones vector, to mark that local time should be shown.
+  // If all timezones are parsed and no one is good, add nullptr to the timezones vector, to mark
+  // that local time should be shown.
   if (!time_zones_.size()) {
     time_zones_.push_back(nullptr);
   }
 
   if (!is_timezone_fixed()) {
-    spdlog::warn("As using a timezone, some format args may be missing as the date library haven't got a release since 2018.");
+    spdlog::warn(
+        "As using a timezone, some format args may be missing as the date library haven't got a "
+        "release since 2018.");
   }
 
-  // Check if a particular placeholder is present in the tooltip format, to know what to calculate on update.
+  // Check if a particular placeholder is present in the tooltip format, to know what to calculate
+  // on update.
   if (config_["tooltip-format"].isString()) {
     std::string trimmed_format = config_["tooltip-format"].asString();
-    trimmed_format.erase(std::remove_if(trimmed_format.begin(),
+    trimmed_format.erase(std::remove_if(trimmed_format.begin(), trimmed_format.end(),
-                              trimmed_format.end(),
+                                        [](unsigned char x) { return std::isspace(x); }),
-                              [](unsigned char x){return std::isspace(x);}),
+                         trimmed_format.end());
-               trimmed_format.end());
     if (trimmed_format.find("{" + kCalendarPlaceholder + "}") != std::string::npos) {
       is_calendar_in_tooltip_ = true;
     }
@@ -87,7 +81,8 @@ waybar::modules::Clock::Clock(const std::string& id, const Json::Value& config)
 }
 
 const date::time_zone* waybar::modules::Clock::current_timezone() {
-  return time_zones_[current_time_zone_idx_] ? time_zones_[current_time_zone_idx_] : date::current_zone();
+  return time_zones_[current_time_zone_idx_] ? time_zones_[current_time_zone_idx_]
+                                             : date::current_zone();
 }
 
 bool waybar::modules::Clock::is_timezone_fixed() {
@@ -121,7 +116,9 @@ auto waybar::modules::Clock::update() -> void {
         timezoned_time_lines = timezones_text(&now);
       }
       auto tooltip_format = config_["tooltip-format"].asString();
-      text = fmt::format(tooltip_format, wtime, fmt::arg(kCalendarPlaceholder.c_str(), calendar_lines), fmt::arg(KTimezonedTimeListPlaceholder.c_str(), timezoned_time_lines));
+      text =
+          fmt::format(tooltip_format, wtime, fmt::arg(kCalendarPlaceholder.c_str(), calendar_lines),
+                      fmt::arg(KTimezonedTimeListPlaceholder.c_str(), timezoned_time_lines));
       label_.set_tooltip_markup(text);
     }
   }
@@ -130,7 +127,7 @@ auto waybar::modules::Clock::update() -> void {
   ALabel::update();
 }
 
-bool waybar::modules::Clock::handleScroll(GdkEventScroll *e) {
+bool waybar::modules::Clock::handleScroll(GdkEventScroll* e) {
   // defer to user commands if set
   if (config_["on-scroll-up"].isString() || config_["on-scroll-down"].isString()) {
     return AModule::handleScroll(e);
@@ -149,7 +146,8 @@ bool waybar::modules::Clock::handleScroll(GdkEventScroll *e) {
     size_t new_idx = current_time_zone_idx_ + 1;
     current_time_zone_idx_ = new_idx == nr_zones ? 0 : new_idx;
   } else {
-    current_time_zone_idx_ = current_time_zone_idx_ == 0 ? nr_zones - 1 : current_time_zone_idx_ - 1;
+    current_time_zone_idx_ =
+        current_time_zone_idx_ == 0 ? nr_zones - 1 : current_time_zone_idx_ - 1;
   }
 
   update();
@@ -164,14 +162,15 @@ auto waybar::modules::Clock::calendar_text(const waybar_time& wtime) -> std::str
   }
 
   const date::year_month ym(ymd.year(), ymd.month());
-  const auto             curr_day = ymd.day();
+  const auto curr_day = ymd.day();
 
   std::stringstream os;
-  const auto        first_dow = first_day_of_week();
+
+  const auto first_dow = first_day_of_week();
   int ws{0};    // weeks-pos: side(1 - left, 2 - right)
   int wn{0};    // weeknumber
   if (config_["calendar-weeks-pos"].isString()) {
-    wn = (date::sys_days{date::year_month_day{ym / 1}} - date::sys_days{date::year_month_day{ymd.year() / 1 / 1}}).count() / 7 + 1;
+    wn = (date::sys_days{date::year_month_day{ym/1}} - date::sys_days{date::year_month_day{ymd.year()/1/1}}).count()/7+1;
     if (config_["calendar-weeks-pos"].asString() == "left") {
       ws = 1;
       // Add paddings before the header
@@ -180,6 +179,7 @@ auto waybar::modules::Clock::calendar_text(const waybar_time& wtime) -> std::str
       ws = 2;
     }
   }
+  
   weekdays_header(first_dow, os);
   /* Print weeknumber on the left for the first row*/
   if (ws == 1) {
@@ -246,7 +246,7 @@ auto waybar::modules::Clock::weekdays_header(const date::weekday& first_dow, std
     auto clen = ustring_clen(wd_ustring);
     auto wd_len = wd_ustring.length();
     while (clen > 2) {
-      wd_ustring = wd_ustring.substr(0, wd_len-1);
+      wd_ustring = wd_ustring.substr(0, wd_len - 1);
       wd_len--;
       clen = ustring_clen(wd_ustring);
     }
@@ -260,7 +260,8 @@ auto waybar::modules::Clock::weekdays_header(const date::weekday& first_dow, std
   } else os << res.str();
 }
 
-auto waybar::modules::Clock::timezones_text(std::chrono::system_clock::time_point *now) -> std::string {
+auto waybar::modules::Clock::timezones_text(std::chrono::system_clock::time_point* now)
+    -> std::string {
   if (time_zones_.size() == 1) {
     return "";
   }
@@ -305,9 +306,9 @@ auto waybar::modules::Clock::first_day_of_week() -> date::weekday {
       newlocale(LC_ALL, locale_.name().c_str(), nullptr)};
   if (posix_locale) {
     const int i = (std::intptr_t)nl_langinfo_l(_NL_TIME_WEEK_1STDAY, posix_locale.get());
-    auto      ymd = date::year(i / 10000) / (i / 100 % 100) / (i % 100);
+    auto ymd = date::year(i / 10000) / (i / 100 % 100) / (i % 100);
-    auto      wd = date::weekday(ymd);
+    auto wd = date::weekday(ymd);
-    uint8_t   j = *nl_langinfo_l(_NL_TIME_FIRST_WEEKDAY, posix_locale.get());
+    uint8_t j = *nl_langinfo_l(_NL_TIME_FIRST_WEEKDAY, posix_locale.get());
     return wd + date::days(j - 1);
   }
 #endif

src/modules/cpu/bsd.cpp

@@ -1,16 +1,19 @@
-#include "modules/cpu.hpp"
+#include <spdlog/spdlog.h>
-
+// clang-format off
 #include <sys/types.h>
 #include <sys/sysctl.h>
-#include <spdlog/spdlog.h>
+// clang-format on
-#include <cstdlib>            // malloc
+#include <unistd.h>  // sysconf
-#include <unistd.h>           // sysconf
+
-#include <cmath>              // NAN
+#include <cmath>    // NAN
+#include <cstdlib>  // malloc
+
+#include "modules/cpu.hpp"
 
 #if defined(__NetBSD__) || defined(__OpenBSD__)
-#  include <sys/sched.h>
+#include <sys/sched.h>
 #else
-#  include <sys/resource.h>
+#include <sys/resource.h>
 #endif
 
 #if defined(__NetBSD__)
@@ -32,26 +35,26 @@ std::vector<std::tuple<size_t, size_t>> waybar::modules::Cpu::parseCpuinfo() {
   pcp_time_t *cp_time = static_cast<pcp_time_t *>(malloc(sz)), *pcp_time = cp_time;
 #if defined(__NetBSD__)
   int mib[] = {
-    CTL_KERN,
+      CTL_KERN,
-    KERN_CP_TIME,
+      KERN_CP_TIME,
   };
-  if (sysctl(mib, sizeof(mib)/sizeof(mib[0]), sum_cp_time, &sum_sz, NULL, 0)) {
+  if (sysctl(mib, sizeof(mib) / sizeof(mib[0]), sum_cp_time, &sum_sz, NULL, 0)) {
     throw std::runtime_error("sysctl kern.cp_time failed");
   }
   for (int state = 0; state < CPUSTATES; state++) {
     cp_time[state] = sum_cp_time[state];
   }
   pcp_time += CPUSTATES;
-  if (sysctl(mib, sizeof(mib)/sizeof(mib[0]), pcp_time, &sz, NULL, 0)) {
+  if (sysctl(mib, sizeof(mib) / sizeof(mib[0]), pcp_time, &sz, NULL, 0)) {
     throw std::runtime_error("sysctl kern.cp_time failed");
   }
 #elif defined(__OpenBSD__)
   {
     int mib[] = {
-      CTL_KERN,
+        CTL_KERN,
-      KERN_CPTIME,
+        KERN_CPTIME,
     };
-    if (sysctl(mib, sizeof(mib)/sizeof(mib[0]), sum_cp_time, &sum_sz, NULL, 0)) {
+    if (sysctl(mib, sizeof(mib) / sizeof(mib[0]), sum_cp_time, &sum_sz, NULL, 0)) {
       throw std::runtime_error("sysctl kern.cp_time failed");
     }
   }
@@ -62,14 +65,14 @@ std::vector<std::tuple<size_t, size_t>> waybar::modules::Cpu::parseCpuinfo() {
   sz /= ncpu + 1;
   {
     int mib[] = {
-      CTL_KERN,
+        CTL_KERN,
-      KERN_CPTIME2,
+        KERN_CPTIME2,
-      0,
+        0,
     };
     for (int cpu = 0; cpu < ncpu; cpu++) {
       mib[2] = cpu;
       pcp_time += CPUSTATES;
-      if (sysctl(mib, sizeof(mib)/sizeof(mib[0]), pcp_time, &sz, NULL, 0)) {
+      if (sysctl(mib, sizeof(mib) / sizeof(mib[0]), pcp_time, &sz, NULL, 0)) {
         throw std::runtime_error("sysctl kern.cp_time2 failed");
       }
     }
@@ -101,7 +104,8 @@ std::vector<std::tuple<size_t, size_t>> waybar::modules::Cpu::parseCpuinfo() {
 std::vector<float> waybar::modules::Cpu::parseCpuFrequencies() {
   static std::vector<float> frequencies;
   if (frequencies.empty()) {
-    spdlog::warn("cpu/bsd: parseCpuFrequencies is not implemented, expect garbage in {*_frequency}");
+    spdlog::warn(
+        "cpu/bsd: parseCpuFrequencies is not implemented, expect garbage in {*_frequency}");
     frequencies.push_back(NAN);
   }
   return frequencies;

src/modules/cpu/common.cpp

@@ -46,11 +46,11 @@ auto waybar::modules::Cpu::update() -> void {
     store.push_back(fmt::arg("min_frequency", min_frequency));
     store.push_back(fmt::arg("avg_frequency", avg_frequency));
     for (size_t i = 1; i < cpu_usage.size(); ++i) {
-	    auto core_i = i - 1;
+      auto core_i = i - 1;
-	    auto core_format = fmt::format("usage{}", core_i);
+      auto core_format = fmt::format("usage{}", core_i);
-	    store.push_back(fmt::arg(core_format.c_str(), cpu_usage[i]));
+      store.push_back(fmt::arg(core_format.c_str(), cpu_usage[i]));
-	    auto icon_format = fmt::format("icon{}", core_i);
+      auto icon_format = fmt::format("icon{}", core_i);
-	    store.push_back(fmt::arg(icon_format.c_str(), getIcon(cpu_usage[i], icons)));
+      store.push_back(fmt::arg(icon_format.c_str(), getIcon(cpu_usage[i], icons)));
     }
     label_.set_markup(fmt::vformat(format, store));
   }
@@ -73,14 +73,14 @@ std::tuple<std::vector<uint16_t>, std::string> waybar::modules::Cpu::getCpuUsage
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
   }
   std::vector<std::tuple<size_t, size_t>> curr_times = parseCpuinfo();
-  std::string                             tooltip;
+  std::string tooltip;
-  std::vector<uint16_t>                   usage;
+  std::vector<uint16_t> usage;
   for (size_t i = 0; i < curr_times.size(); ++i) {
     auto [curr_idle, curr_total] = curr_times[i];
     auto [prev_idle, prev_total] = prev_times_[i];
     const float delta_idle = curr_idle - prev_idle;
     const float delta_total = curr_total - prev_total;
-    uint16_t    tmp = 100 * (1 - delta_idle / delta_total);
+    uint16_t tmp = 100 * (1 - delta_idle / delta_total);
     if (i == 0) {
       tooltip = fmt::format("Total: {}%", tmp);
     } else {
@@ -95,12 +95,13 @@ std::tuple<std::vector<uint16_t>, std::string> waybar::modules::Cpu::getCpuUsage
 std::tuple<float, float, float> waybar::modules::Cpu::getCpuFrequency() {
   std::vector<float> frequencies = parseCpuFrequencies();
   auto [min, max] = std::minmax_element(std::begin(frequencies), std::end(frequencies));
-  float avg_frequency = std::accumulate(std::begin(frequencies), std::end(frequencies), 0.0) / frequencies.size();
+  float avg_frequency =
+      std::accumulate(std::begin(frequencies), std::end(frequencies), 0.0) / frequencies.size();
 
   // Round frequencies with double decimal precision to get GHz
   float max_frequency = std::ceil(*max / 10.0) / 100.0;
   float min_frequency = std::ceil(*min / 10.0) / 100.0;
   avg_frequency = std::ceil(avg_frequency / 10.0) / 100.0;
 
-  return { max_frequency, min_frequency, avg_frequency };
+  return {max_frequency, min_frequency, avg_frequency};
 }

src/modules/cpu/linux.cpp

@@ -1,4 +1,5 @@
 #include <filesystem>
+
 #include "modules/cpu.hpp"
 
 std::vector<std::tuple<size_t, size_t>> waybar::modules::Cpu::parseCpuinfo() {
@@ -8,12 +9,12 @@ std::vector<std::tuple<size_t, size_t>> waybar::modules::Cpu::parseCpuinfo() {
     throw std::runtime_error("Can't open " + data_dir_);
   }
   std::vector<std::tuple<size_t, size_t>> cpuinfo;
-  std::string                             line;
+  std::string line;
   while (getline(info, line)) {
     if (line.substr(0, 3).compare("cpu") != 0) {
       break;
     }
-    std::stringstream   sline(line.substr(5));
+    std::stringstream sline(line.substr(5));
     std::vector<size_t> times;
     for (size_t time = 0; sline >> time; times.push_back(time))
       ;
@@ -51,12 +52,9 @@ std::vector<float> waybar::modules::Cpu::parseCpuFrequencies() {
   if (frequencies.size() <= 0) {
     std::string cpufreq_dir = "/sys/devices/system/cpu/cpufreq";
     if (std::filesystem::exists(cpufreq_dir)) {
-      std::vector<std::string> frequency_files = {
+      std::vector<std::string> frequency_files = {"/cpuinfo_min_freq", "/cpuinfo_max_freq"};
-        "/cpuinfo_min_freq",
+      for (auto& p : std::filesystem::directory_iterator(cpufreq_dir)) {
-        "/cpuinfo_max_freq"
+        for (auto freq_file : frequency_files) {
-      };
-      for (auto& p: std::filesystem::directory_iterator(cpufreq_dir)) {
-        for (auto freq_file: frequency_files) {
           std::string freq_file_path = p.path().string() + freq_file;
           if (std::filesystem::exists(freq_file_path)) {
             std::string freq_value;

src/modules/custom.cpp

@@ -48,7 +48,7 @@ void waybar::modules::Custom::continuousWorker() {
     throw std::runtime_error("Unable to open " + cmd);
   }
   thread_ = [this, cmd] {
-    char*  buff = nullptr;
+    char* buff = nullptr;
     size_t len = 0;
     if (getline(&buff, &len, fp_) == -1) {
       int exit_code = 1;
@@ -120,9 +120,7 @@ auto waybar::modules::Custom::update() -> void {
     } else {
       parseOutputRaw();
     }
-    auto str = fmt::format(format_,
+    auto str = fmt::format(format_, text_, fmt::arg("alt", alt_),
-                           text_,
-                           fmt::arg("alt", alt_),
                            fmt::arg("icon", getIcon(percentage_, alt_)),
                            fmt::arg("percentage", percentage_));
     if (str.empty()) {
@@ -156,8 +154,8 @@ auto waybar::modules::Custom::update() -> void {
 
 void waybar::modules::Custom::parseOutputRaw() {
   std::istringstream output(output_.out);
-  std::string        line;
+  std::string line;
-  int                i = 0;
+  int i = 0;
   while (getline(output, line)) {
     if (i == 0) {
       if (config_["escape"].isBool() && config_["escape"].asBool()) {
@@ -180,7 +178,7 @@ void waybar::modules::Custom::parseOutputRaw() {
 
 void waybar::modules::Custom::parseOutputJson() {
   std::istringstream output(output_.out);
-  std::string        line;
+  std::string line;
   class_.clear();
   while (getline(output, line)) {
     auto parsed = parser_.parse(line);

src/modules/disk.cpp

@@ -3,9 +3,7 @@
 using namespace waybar::util;
 
 waybar::modules::Disk::Disk(const std::string& id, const Json::Value& config)
-    : ALabel(config, "disk", id, "{}%", 30)
+    : ALabel(config, "disk", id, "{}%", 30), path_("/") {
-    , path_("/")
-{
   thread_ = [this] {
     dp.emit();
     thread_.sleep_for(interval_);
@@ -28,7 +26,8 @@ auto waybar::modules::Disk::update() -> void {
       unsigned long  f_fsid;     // filesystem ID
       unsigned long  f_flag;     // mount flags
       unsigned long  f_namemax;  // maximum filename length
-  }; */ stats;
+  }; */
+      stats;
   int err = statvfs(path_.c_str(), &stats);
 
   /* Conky options
@@ -59,15 +58,11 @@ auto waybar::modules::Disk::update() -> void {
     event_box_.hide();
   } else {
     event_box_.show();
-    label_.set_markup(fmt::format(format
+    label_.set_markup(
-        , stats.f_bavail * 100 / stats.f_blocks
+        fmt::format(format, stats.f_bavail * 100 / stats.f_blocks, fmt::arg("free", free),
-        , fmt::arg("free", free)
+                    fmt::arg("percentage_free", stats.f_bavail * 100 / stats.f_blocks),
-        , fmt::arg("percentage_free", stats.f_bavail * 100 / stats.f_blocks)
+                    fmt::arg("used", used), fmt::arg("percentage_used", percentage_used),
-        , fmt::arg("used", used)
+                    fmt::arg("total", total), fmt::arg("path", path_)));
-        , fmt::arg("percentage_used", percentage_used)
-        , fmt::arg("total", total)
-        , fmt::arg("path", path_)
-        ));
   }
 
   if (tooltipEnabled()) {
@@ -75,15 +70,11 @@ auto waybar::modules::Disk::update() -> void {
     if (config_["tooltip-format"].isString()) {
       tooltip_format = config_["tooltip-format"].asString();
     }
-    label_.set_tooltip_text(fmt::format(tooltip_format
+    label_.set_tooltip_text(
-      , stats.f_bavail * 100 / stats.f_blocks
+        fmt::format(tooltip_format, stats.f_bavail * 100 / stats.f_blocks, fmt::arg("free", free),
-      , fmt::arg("free", free)
+                    fmt::arg("percentage_free", stats.f_bavail * 100 / stats.f_blocks),
-      , fmt::arg("percentage_free", stats.f_bavail * 100 / stats.f_blocks)
+                    fmt::arg("used", used), fmt::arg("percentage_used", percentage_used),
-      , fmt::arg("used", used)
+                    fmt::arg("total", total), fmt::arg("path", path_)));
-      , fmt::arg("percentage_used", percentage_used)
-      , fmt::arg("total", total)
-      , fmt::arg("path", path_)
-      ));
   }
   // Call parent update
   ALabel::update();

src/modules/idle_inhibitor.cpp

@@ -4,7 +4,7 @@
 #include "util/command.hpp"
 
 std::list<waybar::AModule*> waybar::modules::IdleInhibitor::modules;
-bool                        waybar::modules::IdleInhibitor::status = false;
+bool waybar::modules::IdleInhibitor::status = false;
 
 waybar::modules::IdleInhibitor::IdleInhibitor(const std::string& id, const Bar& bar,
                                               const Json::Value& config)
@@ -47,7 +47,7 @@ auto waybar::modules::IdleInhibitor::update() -> void {
     label_.get_style_context()->remove_class("deactivated");
     if (idle_inhibitor_ == nullptr) {
       idle_inhibitor_ = zwp_idle_inhibit_manager_v1_create_inhibitor(
-        waybar::Client::inst()->idle_inhibit_manager, bar_.surface);
+          waybar::Client::inst()->idle_inhibit_manager, bar_.surface);
     }
   } else {
     label_.get_style_context()->remove_class("activated");
@@ -58,8 +58,8 @@ auto waybar::modules::IdleInhibitor::update() -> void {
   }
 
   std::string status_text = status ? "activated" : "deactivated";
-  label_.set_markup(
+  label_.set_markup(fmt::format(format_, fmt::arg("status", status_text),
-      fmt::format(format_, fmt::arg("status", status_text), fmt::arg("icon", getIcon(0, status_text))));
+                                fmt::arg("icon", getIcon(0, status_text))));
   label_.get_style_context()->add_class(status_text);
   if (tooltipEnabled()) {
     label_.set_tooltip_text(status_text);

src/modules/inhibitor.cpp

@@ -6,12 +6,11 @@
 
 namespace {
 
-using DBus = std::unique_ptr<GDBusConnection, void(*)(GDBusConnection*)>;
+using DBus = std::unique_ptr<GDBusConnection, void (*)(GDBusConnection*)>;
 
 auto dbus() -> DBus {
-  GError *error = nullptr;
+  GError* error = nullptr;
-  GDBusConnection* connection =
+  GDBusConnection* connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
-      g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
 
   if (error) {
     spdlog::error("g_bus_get_sync() failed: {}", error->message);
@@ -20,46 +19,29 @@ auto dbus() -> DBus {
   }
 
   auto destructor = [](GDBusConnection* connection) {
-      GError *error = nullptr;
+    GError* error = nullptr;
-      g_dbus_connection_close_sync(connection, nullptr, &error);
+    g_dbus_connection_close_sync(connection, nullptr, &error);
-      if (error) {
+    if (error) {
-        spdlog::error(
+      spdlog::error("g_bus_connection_close_sync failed(): {}", error->message);
-            "g_bus_connection_close_sync failed(): {}",
+      g_error_free(error);
-            error->message);
+    }
-        g_error_free(error);
-      }
   };
 
   return DBus{connection, destructor};
 }
 
 auto getLocks(const DBus& bus, const std::string& inhibitors) -> int {
-  GError *error = nullptr;
+  GError* error = nullptr;
   GUnixFDList* fd_list;
   int handle;
 
-  auto reply = g_dbus_connection_call_with_unix_fd_list_sync(bus.get(),
+  auto reply = g_dbus_connection_call_with_unix_fd_list_sync(
-      "org.freedesktop.login1",
+      bus.get(), "org.freedesktop.login1", "/org/freedesktop/login1",
-      "/org/freedesktop/login1",
+      "org.freedesktop.login1.Manager", "Inhibit",
-      "org.freedesktop.login1.Manager",
+      g_variant_new("(ssss)", inhibitors.c_str(), "waybar", "Asked by user", "block"),
-      "Inhibit",
+      G_VARIANT_TYPE("(h)"), G_DBUS_CALL_FLAGS_NONE, -1, nullptr, &fd_list, nullptr, &error);
-      g_variant_new(
-          "(ssss)",
-          inhibitors.c_str(),
-          "waybar",
-          "Asked by user",
-          "block"),
-      G_VARIANT_TYPE("(h)"),
-      G_DBUS_CALL_FLAGS_NONE,
-      -1,
-      nullptr,
-      &fd_list,
-      nullptr,
-      &error);
   if (error) {
-    spdlog::error(
+    spdlog::error("g_dbus_connection_call_with_unix_fd_list_sync() failed: {}", error->message);
-        "g_dbus_connection_call_with_unix_fd_list_sync() failed: {}",
-        error->message);
     g_error_free(error);
     handle = -1;
   } else {
@@ -74,18 +56,15 @@ auto getLocks(const DBus& bus, const std::string& inhibitors) -> int {
 }
 
 auto checkInhibitor(const std::string& inhibitor) -> const std::string& {
-  static const auto inhibitors = std::array{
+  static const auto inhibitors = std::array{"idle",
-      "idle",
+                                            "shutdown",
-      "shutdown",
+                                            "sleep",
-      "sleep",
+                                            "handle-power-key",
-      "handle-power-key",
+                                            "handle-suspend-key",
-      "handle-suspend-key",
+                                            "handle-hibernate-key",
-      "handle-hibernate-key",
+                                            "handle-lid-switch"};
-      "handle-lid-switch"
-  };
 
-  if (std::find(inhibitors.begin(), inhibitors.end(), inhibitor)
+  if (std::find(inhibitors.begin(), inhibitors.end(), inhibitor) == inhibitors.end()) {
-          == inhibitors.end()) {
     throw std::runtime_error("invalid logind inhibitor " + inhibitor);
   }
 
@@ -114,18 +93,16 @@ auto getInhibitors(const Json::Value& config) -> std::string {
   return inhibitors;
 }
 
-}
+}  // namespace
 
 namespace waybar::modules {
 
-Inhibitor::Inhibitor(const std::string& id, const Bar& bar,
+Inhibitor::Inhibitor(const std::string& id, const Bar& bar, const Json::Value& config)
-                     const Json::Value& config)
     : ALabel(config, "inhibitor", id, "{status}", true),
       dbus_(::dbus()),
       inhibitors_(::getInhibitors(config)) {
   event_box_.add_events(Gdk::BUTTON_PRESS_MASK);
-  event_box_.signal_button_press_event().connect(
+  event_box_.signal_button_press_event().connect(sigc::mem_fun(*this, &Inhibitor::handleToggle));
-      sigc::mem_fun(*this, &Inhibitor::handleToggle));
   dp.emit();
 }
 
@@ -135,18 +112,14 @@ Inhibitor::~Inhibitor() {
   }
 }
 
-auto Inhibitor::activated() -> bool {
+auto Inhibitor::activated() -> bool { return handle_ != -1; }
-  return handle_ != -1;
-}
 
 auto Inhibitor::update() -> void {
   std::string status_text = activated() ? "activated" : "deactivated";
 
-  label_.get_style_context()->remove_class(
+  label_.get_style_context()->remove_class(activated() ? "deactivated" : "activated");
-      activated() ? "deactivated" : "activated");
+  label_.set_markup(fmt::format(format_, fmt::arg("status", status_text),
-  label_.set_markup(
+                                fmt::arg("icon", getIcon(0, status_text))));
-      fmt::format(format_, fmt::arg("status", status_text),
-      fmt::arg("icon", getIcon(0, status_text))));
   label_.get_style_context()->add_class(status_text);
 
   if (tooltipEnabled()) {
@@ -172,4 +145,4 @@ auto Inhibitor::handleToggle(GdkEventButton* const& e) -> bool {
   return ALabel::handleToggle(e);
 }
 
-} // waybar::modules
+}  // namespace waybar::modules

src/modules/keyboard_state.cpp

@@ -1,31 +1,32 @@
 #include "modules/keyboard_state.hpp"
+
 #include <errno.h>
-#include <filesystem>
 #include <spdlog/spdlog.h>
 #include <string.h>
 
+#include <filesystem>
+
 extern "C" {
-#include <sys/types.h>
-#include <sys/stat.h>
 #include <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
 }
 
 class errno_error : public std::runtime_error {
  public:
   int code;
   errno_error(int code, const std::string& msg)
-    : std::runtime_error(getErrorMsg(code, msg.c_str())),
+      : std::runtime_error(getErrorMsg(code, msg.c_str())), code(code) {}
-      code(code) {}
+  errno_error(int code, const char* msg) : std::runtime_error(getErrorMsg(code, msg)), code(code) {}
-  errno_error(int code, const char* msg)
+
-    : std::runtime_error(getErrorMsg(code, msg)),
-      code(code) {}
  private:
   static auto getErrorMsg(int err, const char* msg) -> std::string {
     std::string error_msg{msg};
     error_msg += ": ";
 
 #if (__GLIBC__ >= 2) && (__GLIBC_MINOR__ >= 32)
-    // strerrorname_np gets the error code's name; it's nice to have, but it's a recent GNU extension
+    // strerrorname_np gets the error code's name; it's nice to have, but it's a recent GNU
+    // extension
     const auto errno_name = strerrorname_np(err);
     error_msg += errno_name;
     error_msg += " ";
@@ -67,33 +68,37 @@ auto openDevice(int fd) -> libevdev* {
 }
 
 auto supportsLockStates(const libevdev* dev) -> bool {
-  return libevdev_has_event_type(dev, EV_LED)
+  return libevdev_has_event_type(dev, EV_LED) && libevdev_has_event_code(dev, EV_LED, LED_NUML) &&
-    && libevdev_has_event_code(dev, EV_LED, LED_NUML)
+         libevdev_has_event_code(dev, EV_LED, LED_CAPSL) &&
-    && libevdev_has_event_code(dev, EV_LED, LED_CAPSL)
+         libevdev_has_event_code(dev, EV_LED, LED_SCROLLL);
-    && libevdev_has_event_code(dev, EV_LED, LED_SCROLLL);
 }
 
-waybar::modules::KeyboardState::KeyboardState(const std::string& id, const Bar& bar, const Json::Value& config)
+waybar::modules::KeyboardState::KeyboardState(const std::string& id, const Bar& bar,
+                                              const Json::Value& config)
     : AModule(config, "keyboard-state", id, false, !config["disable-scroll"].asBool()),
       box_(bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0),
       numlock_label_(""),
       capslock_label_(""),
       numlock_format_(config_["format"].isString() ? config_["format"].asString()
-                      : config_["format"]["numlock"].isString() ? config_["format"]["numlock"].asString()
+                      : config_["format"]["numlock"].isString()
-                      : "{name} {icon}"),
+                          ? config_["format"]["numlock"].asString()
+                          : "{name} {icon}"),
       capslock_format_(config_["format"].isString() ? config_["format"].asString()
-                       : config_["format"]["capslock"].isString() ? config_["format"]["capslock"].asString()
+                       : config_["format"]["capslock"].isString()
-                       : "{name} {icon}"),
+                           ? config_["format"]["capslock"].asString()
+                           : "{name} {icon}"),
       scrolllock_format_(config_["format"].isString() ? config_["format"].asString()
-                         : config_["format"]["scrolllock"].isString() ? config_["format"]["scrolllock"].asString()
+                         : config_["format"]["scrolllock"].isString()
-                         : "{name} {icon}"),
+                             ? config_["format"]["scrolllock"].asString()
-      interval_(std::chrono::seconds(config_["interval"].isUInt() ? config_["interval"].asUInt() : 1)),
+                             : "{name} {icon}"),
+      interval_(
+          std::chrono::seconds(config_["interval"].isUInt() ? config_["interval"].asUInt() : 1)),
       icon_locked_(config_["format-icons"]["locked"].isString()
-                   ? config_["format-icons"]["locked"].asString()
+                       ? config_["format-icons"]["locked"].asString()
-                   : "locked"),
+                       : "locked"),
       icon_unlocked_(config_["format-icons"]["unlocked"].isString()
-                     ? config_["format-icons"]["unlocked"].asString()
+                         ? config_["format-icons"]["unlocked"].asString()
-                     : "unlocked"),
+                         : "unlocked"),
       fd_(0),
       dev_(nullptr) {
   box_.set_name("keyboard-state");
@@ -120,7 +125,7 @@ waybar::modules::KeyboardState::KeyboardState(const std::string& id, const Bar&
     if (dev_dir == nullptr) {
       throw errno_error(errno, "Failed to open /dev/input");
     }
-    dirent *ep;
+    dirent* ep;
     while ((ep = readdir(dev_dir))) {
       if (ep->d_type != DT_CHR) continue;
       std::string dev_path = std::string("/dev/input/") + ep->d_name;
@@ -128,7 +133,7 @@ waybar::modules::KeyboardState::KeyboardState(const std::string& id, const Bar&
       try {
         auto dev = openDevice(fd);
         if (supportsLockStates(dev)) {
-          spdlog::info("Found device {} at '{}'", libevdev_get_name(dev),  dev_path);
+          spdlog::info("Found device {} at '{}'", libevdev_get_name(dev), dev_path);
           fd_ = fd;
           dev_ = dev;
           break;
@@ -184,9 +189,9 @@ auto waybar::modules::KeyboardState::update() -> void {
     const std::string& format;
     const char* name;
   } label_states[] = {
-    {(bool) numl, numlock_label_, numlock_format_, "Num"},
+      {(bool)numl, numlock_label_, numlock_format_, "Num"},
-    {(bool) capsl, capslock_label_, capslock_format_, "Caps"},
+      {(bool)capsl, capslock_label_, capslock_format_, "Caps"},
-    {(bool) scrolll, scrolllock_label_, scrolllock_format_, "Scroll"},
+      {(bool)scrolll, scrolllock_label_, scrolllock_format_, "Scroll"},
   };
   for (auto& label_state : label_states) {
     std::string text;

src/modules/memory/bsd.cpp

@@ -1,15 +1,17 @@
-#include "modules/memory.hpp"
+// clang-format off
-
 #include <sys/types.h>
 #include <sys/sysctl.h>
-#include <unistd.h>           // getpagesize
+// clang-format on
+#include <unistd.h>  // getpagesize
+
+#include "modules/memory.hpp"
 
 #if defined(__DragonFly__)
-#  include <sys/vmmeter.h>    // struct vmstats
+#include <sys/vmmeter.h>  // struct vmstats
 #elif defined(__NetBSD__)
-#  include <uvm/uvm_extern.h> // struct uvmexp_sysctl
+#include <uvm/uvm_extern.h>  // struct uvmexp_sysctl
 #elif defined(__OpenBSD__)
-#  include <uvm/uvmexp.h>     // struct uvmexp
+#include <uvm/uvmexp.h>  // struct uvmexp
 #endif
 
 static uint64_t get_total_memory() {
@@ -43,33 +45,27 @@ static uint64_t get_free_memory() {
   if (sysctlbyname("vm.vmstats", &vms, &sz, NULL, 0)) {
     throw std::runtime_error("sysctl vm.vmstats failed");
   }
-  return static_cast<uint64_t>
+  return static_cast<uint64_t>(vms.v_free_count + vms.v_inactive_count + vms.v_cache_count) *
-    (vms.v_free_count + vms.v_inactive_count + vms.v_cache_count)
+         getpagesize();
-    * getpagesize();
 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
   u_int v_free_count = 0, v_inactive_count = 0, v_cache_count = 0;
   size_t sz = sizeof(u_int);
-  sysctlbyname("vm.stats.vm.v_free_count",
+  sysctlbyname("vm.stats.vm.v_free_count", &v_free_count, &sz, NULL, 0);
-               &v_free_count, &sz, NULL, 0);
+  sysctlbyname("vm.stats.vm.v_inactive_count", &v_inactive_count, &sz, NULL, 0);
-  sysctlbyname("vm.stats.vm.v_inactive_count",
+  sysctlbyname("vm.stats.vm.v_cache_count", &v_cache_count, &sz, NULL, 0);
-               &v_inactive_count, &sz, NULL, 0);
+  return static_cast<uint64_t>(v_free_count + v_inactive_count + v_cache_count) * getpagesize();
-  sysctlbyname("vm.stats.vm.v_cache_count",
-               &v_cache_count, &sz, NULL, 0);
-  return static_cast<uint64_t>
-    (v_free_count + v_inactive_count + v_cache_count)
-    * getpagesize();
 #elif defined(__NetBSD__) || defined(__OpenBSD__)
 #ifdef VM_UVMEXP2
-#  undef VM_UVMEXP
+#undef VM_UVMEXP
-#  define VM_UVMEXP VM_UVMEXP2
+#define VM_UVMEXP VM_UVMEXP2
-#  define uvmexp uvmexp_sysctl
+#define uvmexp uvmexp_sysctl
 #else
-#  define filepages vnodepages
+#define filepages vnodepages
-#  define execpages vtextpages
+#define execpages vtextpages
 #endif
   int mib[] = {
-    CTL_VM,
+      CTL_VM,
-    VM_UVMEXP,
+      VM_UVMEXP,
   };
   u_int miblen = sizeof(mib) / sizeof(mib[0]);
   struct uvmexp uvmexp;
@@ -77,9 +73,9 @@ static uint64_t get_free_memory() {
   if (sysctl(mib, miblen, &uvmexp, &sz, NULL, 0)) {
     throw std::runtime_error("sysctl vm.uvmexp failed");
   }
-  return static_cast<uint64_t>
+  return static_cast<uint64_t>(uvmexp.free + uvmexp.inactive + uvmexp.filepages +
-    (uvmexp.free + uvmexp.inactive + uvmexp.filepages + uvmexp.execpages)
+                               uvmexp.execpages) *
-    * uvmexp.pagesize;
+         uvmexp.pagesize;
 #endif
 }
 

src/modules/memory/common.cpp

@@ -33,8 +33,8 @@ auto waybar::modules::Memory::update() -> void {
   if (memtotal > 0 && memfree >= 0) {
     auto total_ram_gigabytes = memtotal / std::pow(1024, 2);
     auto total_swap_gigabytes = swaptotal / std::pow(1024, 2);
-    int  used_ram_percentage = 100 * (memtotal - memfree) / memtotal;
+    int used_ram_percentage = 100 * (memtotal - memfree) / memtotal;
-    int  used_swap_percentage = 0;
+    int used_swap_percentage = 0;
     if (swaptotal && swapfree) {
       used_swap_percentage = 100 * (swaptotal - swapfree) / swaptotal;
     }
@@ -54,32 +54,25 @@ auto waybar::modules::Memory::update() -> void {
     } else {
       event_box_.show();
       auto icons = std::vector<std::string>{state};
-      label_.set_markup(fmt::format(format,
+      label_.set_markup(fmt::format(
-                                    used_ram_percentage,
+          format, used_ram_percentage, fmt::arg("icon", getIcon(used_ram_percentage, icons)),
-                                    fmt::arg("icon", getIcon(used_ram_percentage, icons)),
+          fmt::arg("total", total_ram_gigabytes), fmt::arg("swapTotal", total_swap_gigabytes),
-                                    fmt::arg("total", total_ram_gigabytes),
+          fmt::arg("percentage", used_ram_percentage),
-                                    fmt::arg("swapTotal", total_swap_gigabytes),
+          fmt::arg("swapPercentage", used_swap_percentage), fmt::arg("used", used_ram_gigabytes),
-                                    fmt::arg("percentage", used_ram_percentage),
+          fmt::arg("swapUsed", used_swap_gigabytes), fmt::arg("avail", available_ram_gigabytes),
-                                    fmt::arg("swapPercentage", used_swap_percentage),
+          fmt::arg("swapAvail", available_swap_gigabytes)));
-                                    fmt::arg("used", used_ram_gigabytes),
-                                    fmt::arg("swapUsed", used_swap_gigabytes),
-                                    fmt::arg("avail", available_ram_gigabytes),
-                                    fmt::arg("swapAvail", available_swap_gigabytes)));
     }
 
     if (tooltipEnabled()) {
       if (config_["tooltip-format"].isString()) {
         auto tooltip_format = config_["tooltip-format"].asString();
-        label_.set_tooltip_text(fmt::format(tooltip_format,
+        label_.set_tooltip_text(fmt::format(
-                                            used_ram_percentage,
+            tooltip_format, used_ram_percentage, fmt::arg("total", total_ram_gigabytes),
-                                            fmt::arg("total", total_ram_gigabytes),
+            fmt::arg("swapTotal", total_swap_gigabytes),
-                                            fmt::arg("swapTotal", total_swap_gigabytes),
+            fmt::arg("percentage", used_ram_percentage),
-                                            fmt::arg("percentage", used_ram_percentage),
+            fmt::arg("swapPercentage", used_swap_percentage), fmt::arg("used", used_ram_gigabytes),
-                                            fmt::arg("swapPercentage", used_swap_percentage),
+            fmt::arg("swapUsed", used_swap_gigabytes), fmt::arg("avail", available_ram_gigabytes),
-                                            fmt::arg("used", used_ram_gigabytes),
+            fmt::arg("swapAvail", available_swap_gigabytes)));
-                                            fmt::arg("swapUsed", used_swap_gigabytes),
-                                            fmt::arg("avail", available_ram_gigabytes),
-                                            fmt::arg("swapAvail", available_swap_gigabytes)));
       } else {
         label_.set_tooltip_text(fmt::format("{:.{}f}GiB used", used_ram_gigabytes, 1));
       }

src/modules/memory/linux.cpp

@@ -4,8 +4,8 @@ static unsigned zfsArcSize() {
   std::ifstream zfs_arc_stats{"/proc/spl/kstat/zfs/arcstats"};
 
   if (zfs_arc_stats.is_open()) {
-    std::string   name;
+    std::string name;
-    std::string   type;
+    std::string type;
     unsigned long data{0};
 
     std::string line;
@@ -23,7 +23,7 @@ static unsigned zfsArcSize() {
 
 void waybar::modules::Memory::parseMeminfo() {
   const std::string data_dir_ = "/proc/meminfo";
-  std::ifstream     info(data_dir_);
+  std::ifstream info(data_dir_);
   if (!info.is_open()) {
     throw std::runtime_error("Can't open " + data_dir_);
   }
@@ -35,7 +35,7 @@ void waybar::modules::Memory::parseMeminfo() {
     }
 
     std::string name = line.substr(0, posDelim);
-    int64_t     value = std::stol(line.substr(posDelim + 1));
+    int64_t value = std::stol(line.substr(posDelim + 1));
     meminfo_[name] = value;
   }
 

src/modules/mpd/mpd.cpp

@@ -1,8 +1,9 @@
 #include "modules/mpd/mpd.hpp"
 
 #include <fmt/chrono.h>
-#include <spdlog/spdlog.h>
 #include <glibmm/ustring.h>
+#include <spdlog/spdlog.h>
+
 #include "modules/mpd/state.hpp"
 #if defined(MPD_NOINLINE)
 namespace waybar::modules {
@@ -98,9 +99,9 @@ void waybar::modules::MPD::setLabel() {
   }
 
   auto format = format_;
-  Glib::ustring        artist, album_artist, album, title;
+  Glib::ustring artist, album_artist, album, title;
-  std::string          date;
+  std::string date;
-  int                  song_pos = 0, queue_length = 0, volume = 0;
+  int song_pos = 0, queue_length = 0, volume = 0;
   std::chrono::seconds elapsedTime, totalTime;
 
   std::string stateIcon = "";
@@ -139,37 +140,32 @@ void waybar::modules::MPD::setLabel() {
     totalTime = std::chrono::seconds(mpd_status_get_total_time(status_.get()));
   }
 
-  bool        consumeActivated = mpd_status_get_consume(status_.get());
+  bool consumeActivated = mpd_status_get_consume(status_.get());
   std::string consumeIcon = getOptionIcon("consume", consumeActivated);
-  bool        randomActivated = mpd_status_get_random(status_.get());
+  bool randomActivated = mpd_status_get_random(status_.get());
   std::string randomIcon = getOptionIcon("random", randomActivated);
-  bool        repeatActivated = mpd_status_get_repeat(status_.get());
+  bool repeatActivated = mpd_status_get_repeat(status_.get());
   std::string repeatIcon = getOptionIcon("repeat", repeatActivated);
-  bool        singleActivated = mpd_status_get_single(status_.get());
+  bool singleActivated = mpd_status_get_single(status_.get());
   std::string singleIcon = getOptionIcon("single", singleActivated);
   if (config_["artist-len"].isInt()) artist = artist.substr(0, config_["artist-len"].asInt());
-  if (config_["album-artist-len"].isInt()) album_artist = album_artist.substr(0, config_["album-artist-len"].asInt());
+  if (config_["album-artist-len"].isInt())
+    album_artist = album_artist.substr(0, config_["album-artist-len"].asInt());
   if (config_["album-len"].isInt()) album = album.substr(0, config_["album-len"].asInt());
-  if (config_["title-len"].isInt()) title = title.substr(0,config_["title-len"].asInt());
+  if (config_["title-len"].isInt()) title = title.substr(0, config_["title-len"].asInt());
 
   try {
     label_.set_markup(
-        fmt::format(format,
+        fmt::format(format, fmt::arg("artist", Glib::Markup::escape_text(artist).raw()),
-                    fmt::arg("artist", Glib::Markup::escape_text(artist).raw()),
                     fmt::arg("albumArtist", Glib::Markup::escape_text(album_artist).raw()),
                     fmt::arg("album", Glib::Markup::escape_text(album).raw()),
                     fmt::arg("title", Glib::Markup::escape_text(title).raw()),
                     fmt::arg("date", Glib::Markup::escape_text(date).raw()),
-                    fmt::arg("volume", volume),
+                    fmt::arg("volume", volume), fmt::arg("elapsedTime", elapsedTime),
-                    fmt::arg("elapsedTime", elapsedTime),
+                    fmt::arg("totalTime", totalTime), fmt::arg("songPosition", song_pos),
-                    fmt::arg("totalTime", totalTime),
+                    fmt::arg("queueLength", queue_length), fmt::arg("stateIcon", stateIcon),
-                    fmt::arg("songPosition", song_pos),
+                    fmt::arg("consumeIcon", consumeIcon), fmt::arg("randomIcon", randomIcon),
-                    fmt::arg("queueLength", queue_length),
+                    fmt::arg("repeatIcon", repeatIcon), fmt::arg("singleIcon", singleIcon)));
-                    fmt::arg("stateIcon", stateIcon),
-                    fmt::arg("consumeIcon", consumeIcon),
-                    fmt::arg("randomIcon", randomIcon),
-                    fmt::arg("repeatIcon", repeatIcon),
-                    fmt::arg("singleIcon", singleIcon)));
   } catch (fmt::format_error const& e) {
     spdlog::warn("mpd: format error: {}", e.what());
   }
@@ -179,22 +175,15 @@ void waybar::modules::MPD::setLabel() {
     tooltip_format = config_["tooltip-format"].isString() ? config_["tooltip-format"].asString()
                                                           : "MPD (connected)";
     try {
-      auto tooltip_text = fmt::format(tooltip_format,
+      auto tooltip_text =
-                                      fmt::arg("artist", artist.raw()),
+          fmt::format(tooltip_format, fmt::arg("artist", artist.raw()),
-                                      fmt::arg("albumArtist", album_artist.raw()),
+                      fmt::arg("albumArtist", album_artist.raw()), fmt::arg("album", album.raw()),
-                                      fmt::arg("album", album.raw()),
+                      fmt::arg("title", title.raw()), fmt::arg("date", date),
-                                      fmt::arg("title", title.raw()),
+                      fmt::arg("volume", volume), fmt::arg("elapsedTime", elapsedTime),
-                                      fmt::arg("date", date),
+                      fmt::arg("totalTime", totalTime), fmt::arg("songPosition", song_pos),
-                                      fmt::arg("volume", volume),
+                      fmt::arg("queueLength", queue_length), fmt::arg("stateIcon", stateIcon),
-                                      fmt::arg("elapsedTime", elapsedTime),
+                      fmt::arg("consumeIcon", consumeIcon), fmt::arg("randomIcon", randomIcon),
-                                      fmt::arg("totalTime", totalTime),
+                      fmt::arg("repeatIcon", repeatIcon), fmt::arg("singleIcon", singleIcon));
-                                      fmt::arg("songPosition", song_pos),
-                                      fmt::arg("queueLength", queue_length),
-                                      fmt::arg("stateIcon", stateIcon),
-                                      fmt::arg("consumeIcon", consumeIcon),
-                                      fmt::arg("randomIcon", randomIcon),
-                                      fmt::arg("repeatIcon", repeatIcon),
-                                      fmt::arg("singleIcon", singleIcon));
       label_.set_tooltip_text(tooltip_text);
     } catch (fmt::format_error const& e) {
       spdlog::warn("mpd: format error (tooltip): {}", e.what());

src/modules/mpd/state.cpp

@@ -50,7 +50,7 @@ void Idle::update() noexcept {
 }
 
 void Idle::entry() noexcept {
-  auto            conn = ctx_->connection().get();
+  auto conn = ctx_->connection().get();
   assert(conn != nullptr);
 
   if (!mpd_send_idle_mask(
@@ -61,8 +61,7 @@ void Idle::entry() noexcept {
     spdlog::debug("mpd: Idle: watching FD");
     sigc::slot<bool, Glib::IOCondition const&> idle_slot = sigc::mem_fun(*this, &Idle::on_io);
     idle_connection_ =
-        Glib::signal_io().connect(idle_slot,
+        Glib::signal_io().connect(idle_slot, mpd_connection_get_fd(conn),
-                                  mpd_connection_get_fd(conn),
                                   Glib::IO_IN | Glib::IO_PRI | Glib::IO_ERR | Glib::IO_HUP);
   }
 }
@@ -75,7 +74,7 @@ void Idle::exit() noexcept {
 }
 
 bool Idle::on_io(Glib::IOCondition const&) {
-  auto                         conn = ctx_->connection().get();
+  auto conn = ctx_->connection().get();
 
   // callback should do this:
   enum mpd_idle events = mpd_recv_idle(conn, /* ignore_timeout?= */ false);
@@ -193,7 +192,7 @@ void Paused::exit() noexcept {
 }
 
 bool Paused::on_timer() {
-  bool                         rc = true;
+  bool rc = true;
 
   // Attempt to connect with MPD.
   try {
@@ -264,7 +263,7 @@ void Stopped::exit() noexcept {
 }
 
 bool Stopped::on_timer() {
-  bool                         rc = true;
+  bool rc = true;
 
   // Attempt to connect with MPD.
   try {
@@ -327,8 +326,7 @@ void Disconnected::arm_timer(int interval) noexcept {
 
   // register timer
   sigc::slot<bool> timer_slot = sigc::mem_fun(*this, &Disconnected::on_timer);
-  timer_connection_ =
+  timer_connection_ = Glib::signal_timeout().connect(timer_slot, interval);
-      Glib::signal_timeout().connect(timer_slot, interval);
   spdlog::debug("mpd: Disconnected: enabled interval timer.");
 }
 
@@ -345,9 +343,7 @@ void Disconnected::entry() noexcept {
   arm_timer(1'000);
 }
 
-void Disconnected::exit() noexcept {
+void Disconnected::exit() noexcept { disarm_timer(); }
-  disarm_timer();
-}
 
 bool Disconnected::on_timer() {
   // Attempt to connect with MPD.

src/modules/network.cpp

@@ -1,13 +1,14 @@
+#include "modules/network.hpp"
+
 #include <linux/if.h>
 #include <spdlog/spdlog.h>
 #include <sys/eventfd.h>
 
 #include <cassert>
 #include <fstream>
-#include <sstream>
 #include <optional>
+#include <sstream>
 
-#include "modules/network.hpp"
 #include "util/format.hpp"
 #ifdef WANT_RFKILL
 #include "util/rfkill.hpp"
@@ -39,7 +40,7 @@ waybar::modules::Network::readBandwidthUsage() {
     std::istringstream iss(line);
 
     std::string ifacename;
-    iss >> ifacename;  // ifacename contains "eth0:"
+    iss >> ifacename;      // ifacename contains "eth0:"
     ifacename.pop_back();  // remove trailing ':'
     if (!checkInterface(ifacename)) {
       continue;
@@ -58,9 +59,13 @@ waybar::modules::Network::readBandwidthUsage() {
     // Skip all the other columns in the received group
     for (int colsToSkip = 7; colsToSkip > 0; colsToSkip--) {
       // skip whitespace between columns
-      while (iss.peek() == ' ') { iss.ignore(); }
+      while (iss.peek() == ' ') {
+        iss.ignore();
+      }
       // skip the irrelevant column
-      while (iss.peek() != ' ') { iss.ignore(); }
+      while (iss.peek() != ' ') {
+        iss.ignore();
+      }
     }
     // Read transmit bytes
     iss >> t;
@@ -192,7 +197,7 @@ void waybar::modules::Network::createEventSocket() {
     }
   }
   {
-    auto               fd = nl_socket_get_fd(ev_sock_);
+    auto fd = nl_socket_get_fd(ev_sock_);
     struct epoll_event event;
     memset(&event, 0, sizeof(event));
     event.events = EPOLLIN | EPOLLET | EPOLLRDHUP;
@@ -274,8 +279,7 @@ void waybar::modules::Network::worker() {
 const std::string waybar::modules::Network::getNetworkState() const {
   if (ifid_ == -1) {
 #ifdef WANT_RFKILL
-    if (rfkill_.getState())
+    if (rfkill_.getState()) return "disabled";
-      return "disabled";
 #endif
     return "disconnected";
   }
@@ -287,7 +291,7 @@ const std::string waybar::modules::Network::getNetworkState() const {
 
 auto waybar::modules::Network::update() -> void {
   std::lock_guard<std::mutex> lock(mutex_);
-  std::string                 tooltip_format;
+  std::string tooltip_format;
 
   auto bandwidth = readBandwidthUsage();
   auto bandwidth_down = 0ull;
@@ -327,17 +331,11 @@ auto waybar::modules::Network::update() -> void {
   getState(signal_strength_);
 
   auto text = fmt::format(
-      format_,
+      format_, fmt::arg("essid", essid_), fmt::arg("signaldBm", signal_strength_dbm_),
-      fmt::arg("essid", essid_),
-      fmt::arg("signaldBm", signal_strength_dbm_),
       fmt::arg("signalStrength", signal_strength_),
-      fmt::arg("signalStrengthApp", signal_strength_app_),
+      fmt::arg("signalStrengthApp", signal_strength_app_), fmt::arg("ifname", ifname_),
-      fmt::arg("ifname", ifname_),
+      fmt::arg("netmask", netmask_), fmt::arg("ipaddr", ipaddr_), fmt::arg("gwaddr", gwaddr_),
-      fmt::arg("netmask", netmask_),
+      fmt::arg("cidr", cidr_), fmt::arg("frequency", fmt::format("{:.1f}", frequency_)),
-      fmt::arg("ipaddr", ipaddr_),
-      fmt::arg("gwaddr", gwaddr_),
-      fmt::arg("cidr", cidr_),
-      fmt::arg("frequency", fmt::format("{:.1f}", frequency_)),
       fmt::arg("icon", getIcon(signal_strength_, state_)),
       fmt::arg("bandwidthDownBits", pow_format(bandwidth_down * 8ull / interval_.count(), "b/s")),
       fmt::arg("bandwidthUpBits", pow_format(bandwidth_up * 8ull / interval_.count(), "b/s")),
@@ -359,17 +357,11 @@ auto waybar::modules::Network::update() -> void {
     }
     if (!tooltip_format.empty()) {
       auto tooltip_text = fmt::format(
-          tooltip_format,
+          tooltip_format, fmt::arg("essid", essid_), fmt::arg("signaldBm", signal_strength_dbm_),
-          fmt::arg("essid", essid_),
-          fmt::arg("signaldBm", signal_strength_dbm_),
           fmt::arg("signalStrength", signal_strength_),
-          fmt::arg("signalStrengthApp", signal_strength_app_),
+          fmt::arg("signalStrengthApp", signal_strength_app_), fmt::arg("ifname", ifname_),
-          fmt::arg("ifname", ifname_),
+          fmt::arg("netmask", netmask_), fmt::arg("ipaddr", ipaddr_), fmt::arg("gwaddr", gwaddr_),
-          fmt::arg("netmask", netmask_),
+          fmt::arg("cidr", cidr_), fmt::arg("frequency", fmt::format("{:.1f}", frequency_)),
-          fmt::arg("ipaddr", ipaddr_),
-          fmt::arg("gwaddr", gwaddr_),
-          fmt::arg("cidr", cidr_),
-          fmt::arg("frequency", fmt::format("{:.1f}", frequency_)),
           fmt::arg("icon", getIcon(signal_strength_, state_)),
           fmt::arg("bandwidthDownBits",
                    pow_format(bandwidth_down * 8ull / interval_.count(), "b/s")),
@@ -414,286 +406,279 @@ void waybar::modules::Network::clearIface() {
 }
 
 int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
-  auto                        net = static_cast<waybar::modules::Network *>(data);
+  auto net = static_cast<waybar::modules::Network *>(data);
   std::lock_guard<std::mutex> lock(net->mutex_);
-  auto                        nh = nlmsg_hdr(msg);
+  auto nh = nlmsg_hdr(msg);
-  bool                        is_del_event = false;
+  bool is_del_event = false;
 
   switch (nh->nlmsg_type) {
-  case RTM_DELLINK:
+    case RTM_DELLINK:
-    is_del_event = true;
+      is_del_event = true;
-  case RTM_NEWLINK: {
+    case RTM_NEWLINK: {
-    struct ifinfomsg *ifi = static_cast<struct ifinfomsg *>(NLMSG_DATA(nh));
+      struct ifinfomsg *ifi = static_cast<struct ifinfomsg *>(NLMSG_DATA(nh));
-    ssize_t attrlen = IFLA_PAYLOAD(nh);
+      ssize_t attrlen = IFLA_PAYLOAD(nh);
-    struct rtattr *ifla = IFLA_RTA(ifi);
+      struct rtattr *ifla = IFLA_RTA(ifi);
-    const char *ifname = NULL;
+      const char *ifname = NULL;
-    size_t ifname_len = 0;
+      size_t ifname_len = 0;
-    std::optional<bool> carrier;
+      std::optional<bool> carrier;
 
-    if (net->ifid_ != -1 && ifi->ifi_index != net->ifid_) {
+      if (net->ifid_ != -1 && ifi->ifi_index != net->ifid_) {
-      return NL_OK;
+        return NL_OK;
-    }
-
-    // Check if the interface goes "down" and if we want to detect the
-    // external interface.
-    if (net->ifid_ != -1 && !(ifi->ifi_flags & IFF_UP)
-        && !net->config_["interface"].isString()) {
-      // The current interface is now down, all the routes associated with
-      // it have been deleted, so start looking for a new default route.
-      spdlog::debug("network: if{} down", net->ifid_);
-      net->clearIface();
-      net->dp.emit();
-      net->want_route_dump_ = true;
-      net->askForStateDump();
-      return NL_OK;
-    }
-
-    for (; RTA_OK(ifla, attrlen); ifla = RTA_NEXT(ifla, attrlen)) {
-      switch (ifla->rta_type) {
-      case IFLA_IFNAME:
-        ifname = static_cast<const char *>(RTA_DATA(ifla));
-        ifname_len = RTA_PAYLOAD(ifla) - 1; // minus \0
-        break;
-      case IFLA_CARRIER: {
-        carrier = *(char*)RTA_DATA(ifla) == 1;
-        break;
       }
-      }
-    }
-
-    if (!is_del_event && ifi->ifi_index == net->ifid_) {
-      // Update interface information
-      if (net->ifname_.empty() && ifname != NULL) {
-        std::string new_ifname (ifname, ifname_len);
-        net->ifname_ = new_ifname;
-      }
-      if (carrier.has_value()) {
-        if (net->carrier_ != *carrier) {
-          if (*carrier) {
-            // Ask for WiFi information
-            net->thread_timer_.wake_up();
-          } else {
-            // clear state related to WiFi connection
-            net->essid_.clear();
-            net->signal_strength_dbm_ = 0;
-            net->signal_strength_ = 0;
-            net->signal_strength_app_.clear();
-            net->frequency_ = 0.0;
-          }
-        }
-        net->carrier_ = carrier.value();
-      }
-    } else if (!is_del_event && net->ifid_ == -1) {
-      // Checking if it's an interface we care about.
-      std::string new_ifname (ifname, ifname_len);
-      if (net->checkInterface(new_ifname)) {
-        spdlog::debug("network: selecting new interface {}/{}", new_ifname, ifi->ifi_index);
-
-        net->ifname_ = new_ifname;
-        net->ifid_ = ifi->ifi_index;
-        if (carrier.has_value()) {
-          net->carrier_ = carrier.value();
-        }
-        net->thread_timer_.wake_up();
-        /* An address for this new interface should be received via an
-         * RTM_NEWADDR event either because we ask for a dump of both links
-         * and addrs, or because this interface has just been created and
-         * the addr will be sent after the RTM_NEWLINK event.
-         * So we don't need to do anything. */
-      }
-    } else if (is_del_event && net->ifid_ >= 0) {
-      // Our interface has been deleted, start looking/waiting for one we care.
-      spdlog::debug("network: interface {}/{} deleted", net->ifname_, net->ifid_);
-
-      net->clearIface();
-      net->dp.emit();
-    }
-    break;
-  }
-
-  case RTM_DELADDR:
-    is_del_event = true;
-  case RTM_NEWADDR: {
-    struct ifaddrmsg *ifa = static_cast<struct ifaddrmsg *>(NLMSG_DATA(nh));
-    ssize_t attrlen = IFA_PAYLOAD(nh);
-    struct rtattr *ifa_rta = IFA_RTA(ifa);
-
-    if ((int)ifa->ifa_index != net->ifid_) {
-      return NL_OK;
-    }
-
-    if (ifa->ifa_family != net->family_) {
-      return NL_OK;
-    }
-
-    // We ignore address mark as scope for the link or host,
-    // which should leave scope global addresses.
-    if (ifa->ifa_scope >= RT_SCOPE_LINK) {
-      return NL_OK;
-    }
-
-    for (; RTA_OK(ifa_rta, attrlen); ifa_rta = RTA_NEXT(ifa_rta, attrlen)) {
-      switch (ifa_rta->rta_type) {
-      case IFA_ADDRESS: {
-        char ipaddr[INET6_ADDRSTRLEN];
-        if (!is_del_event) {
-          net->ipaddr_ = inet_ntop(ifa->ifa_family, RTA_DATA(ifa_rta),
-                                   ipaddr, sizeof (ipaddr));
-          net->cidr_ = ifa->ifa_prefixlen;
-          switch (ifa->ifa_family) {
-          case AF_INET: {
-            struct in_addr netmask;
-            netmask.s_addr = htonl(~0 << (32 - ifa->ifa_prefixlen));
-            net->netmask_ = inet_ntop(ifa->ifa_family, &netmask,
-                                      ipaddr, sizeof (ipaddr));
-          }
-          case AF_INET6: {
-            struct in6_addr netmask;
-            for (int i = 0; i < 16; i++) {
-              int v = (i + 1) * 8 - ifa->ifa_prefixlen;
-              if (v < 0) v = 0;
-              if (v > 8) v = 8;
-              netmask.s6_addr[i] = ~0 << v;
-            }
-            net->netmask_ = inet_ntop(ifa->ifa_family, &netmask,
-                                      ipaddr, sizeof (ipaddr));
-          }
-          }
-          spdlog::debug("network: {}, new addr {}/{}", net->ifname_, net->ipaddr_, net->cidr_);
-        } else {
-          net->ipaddr_.clear();
-          net->cidr_ = 0;
-          net->netmask_.clear();
-          spdlog::debug("network: {} addr deleted {}/{}",
-                        net->ifname_,
-                        inet_ntop(ifa->ifa_family, RTA_DATA(ifa_rta),
-                                  ipaddr, sizeof (ipaddr)),
-                        ifa->ifa_prefixlen);
-        }
-        net->dp.emit();
-        break;
-      }
-      }
-    }
-    break;
-  }
-
-    char	temp_gw_addr[INET6_ADDRSTRLEN];
-  case RTM_DELROUTE:
-    is_del_event = true;
-  case RTM_NEWROUTE: {
-    // Based on https://gist.github.com/Yawning/c70d804d4b8ae78cc698
-    // to find the interface used to reach the outside world
-
-    struct rtmsg  *rtm = static_cast<struct rtmsg *>(NLMSG_DATA(nh));
-    ssize_t attrlen = RTM_PAYLOAD(nh);
-    struct rtattr *attr = RTM_RTA(rtm);
-    bool           has_gateway = false;
-    bool           has_destination = false;
-    int            temp_idx = -1;
-    uint32_t       priority = 0;
-
-
-    /* Find the message(s) concerting the main routing table, each message
-     * corresponds to a single routing table entry.
-     */
-    if (rtm->rtm_table != RT_TABLE_MAIN) {
-      return NL_OK;
-    }
-
-    /* Parse all the attributes for a single routing table entry. */
-    for (; RTA_OK(attr, attrlen); attr = RTA_NEXT(attr, attrlen)) {
-      /* Determine if this routing table entry corresponds to the default
-       * route by seeing if it has a gateway, and if a destination addr is
-       * set, that it is all 0s.
-       */
-      switch(attr->rta_type) {
-      case RTA_GATEWAY:
-        /* The gateway of the route.
-         *
-         * If someone ever needs to figure out the gateway address as well,
-         * it's here as the attribute payload.
-         */
-	inet_ntop(net->family_, RTA_DATA(attr), temp_gw_addr, sizeof(temp_gw_addr));
-        has_gateway = true;
-        break;
-      case RTA_DST: {
-        /* The destination address.
-         * Should be either missing, or maybe all 0s.  Accept both.
-         */
-        const uint32_t nr_zeroes = (net->family_ == AF_INET) ? 4 : 16;
-        unsigned char  c = 0;
-        size_t         dstlen = RTA_PAYLOAD(attr);
-        if (dstlen != nr_zeroes) {
-          break;
-        }
-        for (uint32_t i = 0; i < dstlen; i += 1) {
-          c |= *((unsigned char *)RTA_DATA(attr) + i);
-        }
-        has_destination = (c == 0);
-        break;
-      }
-      case RTA_OIF:
-        /* The output interface index. */
-        temp_idx = *static_cast<int *>(RTA_DATA(attr));
-        break;
-      case RTA_PRIORITY:
-        priority = *(uint32_t*)RTA_DATA(attr);
-        break;
-      default:
-        break;
-      }
-    }
-
-    // Check if we have a default route.
-    if (has_gateway && !has_destination && temp_idx != -1) {
-      // Check if this is the first default route we see, or if this new
-      // route have a higher priority.
-      if (!is_del_event && ((net->ifid_ == -1) || (priority < net->route_priority))) {
-        // Clear if's state for the case were there is a higher priority
-        // route on a different interface.
-        net->clearIface();
-        net->ifid_ = temp_idx;
-        net->route_priority = priority;
-        net->gwaddr_ = temp_gw_addr;
-        spdlog::debug("network: new default route via {} on if{} metric {}", temp_gw_addr, temp_idx, priority);
-
-        /* Ask ifname associated with temp_idx as well as carrier status */
-        struct ifinfomsg ifinfo_hdr = {
-          .ifi_family = AF_UNSPEC,
-          .ifi_index = temp_idx,
-        };
-        int err;
-        err = nl_send_simple(net->ev_sock_, RTM_GETLINK, NLM_F_REQUEST,
-                             &ifinfo_hdr, sizeof (ifinfo_hdr));
-        if (err < 0) {
-          spdlog::error("network: failed to ask link info: {}", err);
-          /* Ask for a dump of all links instead */
-          net->want_link_dump_ = true;
-        }
-
-        /* Also ask for the address. Asking for a addresses of a specific
-         * interface doesn't seems to work so ask for a dump of all
-         * addresses. */
-        net->want_addr_dump_ = true;
-        net->askForStateDump();
-        net->thread_timer_.wake_up();
-      } else if (is_del_event && temp_idx == net->ifid_
-                 && net->route_priority == priority) {
-        spdlog::debug("network: default route deleted {}/if{} metric {}",
-                      net->ifname_, temp_idx, priority);
 
+      // Check if the interface goes "down" and if we want to detect the
+      // external interface.
+      if (net->ifid_ != -1 && !(ifi->ifi_flags & IFF_UP) && !net->config_["interface"].isString()) {
+        // The current interface is now down, all the routes associated with
+        // it have been deleted, so start looking for a new default route.
+        spdlog::debug("network: if{} down", net->ifid_);
         net->clearIface();
         net->dp.emit();
-        /* Ask for a dump of all routes in case another one is already
-         * setup. If there's none, there'll be an event with new one
-         * later. */
         net->want_route_dump_ = true;
         net->askForStateDump();
+        return NL_OK;
       }
+
+      for (; RTA_OK(ifla, attrlen); ifla = RTA_NEXT(ifla, attrlen)) {
+        switch (ifla->rta_type) {
+          case IFLA_IFNAME:
+            ifname = static_cast<const char *>(RTA_DATA(ifla));
+            ifname_len = RTA_PAYLOAD(ifla) - 1;  // minus \0
+            break;
+          case IFLA_CARRIER: {
+            carrier = *(char *)RTA_DATA(ifla) == 1;
+            break;
+          }
+        }
+      }
+
+      if (!is_del_event && ifi->ifi_index == net->ifid_) {
+        // Update interface information
+        if (net->ifname_.empty() && ifname != NULL) {
+          std::string new_ifname(ifname, ifname_len);
+          net->ifname_ = new_ifname;
+        }
+        if (carrier.has_value()) {
+          if (net->carrier_ != *carrier) {
+            if (*carrier) {
+              // Ask for WiFi information
+              net->thread_timer_.wake_up();
+            } else {
+              // clear state related to WiFi connection
+              net->essid_.clear();
+              net->signal_strength_dbm_ = 0;
+              net->signal_strength_ = 0;
+              net->signal_strength_app_.clear();
+              net->frequency_ = 0.0;
+            }
+          }
+          net->carrier_ = carrier.value();
+        }
+      } else if (!is_del_event && net->ifid_ == -1) {
+        // Checking if it's an interface we care about.
+        std::string new_ifname(ifname, ifname_len);
+        if (net->checkInterface(new_ifname)) {
+          spdlog::debug("network: selecting new interface {}/{}", new_ifname, ifi->ifi_index);
+
+          net->ifname_ = new_ifname;
+          net->ifid_ = ifi->ifi_index;
+          if (carrier.has_value()) {
+            net->carrier_ = carrier.value();
+          }
+          net->thread_timer_.wake_up();
+          /* An address for this new interface should be received via an
+           * RTM_NEWADDR event either because we ask for a dump of both links
+           * and addrs, or because this interface has just been created and
+           * the addr will be sent after the RTM_NEWLINK event.
+           * So we don't need to do anything. */
+        }
+      } else if (is_del_event && net->ifid_ >= 0) {
+        // Our interface has been deleted, start looking/waiting for one we care.
+        spdlog::debug("network: interface {}/{} deleted", net->ifname_, net->ifid_);
+
+        net->clearIface();
+        net->dp.emit();
+      }
+      break;
+    }
+
+    case RTM_DELADDR:
+      is_del_event = true;
+    case RTM_NEWADDR: {
+      struct ifaddrmsg *ifa = static_cast<struct ifaddrmsg *>(NLMSG_DATA(nh));
+      ssize_t attrlen = IFA_PAYLOAD(nh);
+      struct rtattr *ifa_rta = IFA_RTA(ifa);
+
+      if ((int)ifa->ifa_index != net->ifid_) {
+        return NL_OK;
+      }
+
+      if (ifa->ifa_family != net->family_) {
+        return NL_OK;
+      }
+
+      // We ignore address mark as scope for the link or host,
+      // which should leave scope global addresses.
+      if (ifa->ifa_scope >= RT_SCOPE_LINK) {
+        return NL_OK;
+      }
+
+      for (; RTA_OK(ifa_rta, attrlen); ifa_rta = RTA_NEXT(ifa_rta, attrlen)) {
+        switch (ifa_rta->rta_type) {
+          case IFA_ADDRESS: {
+            char ipaddr[INET6_ADDRSTRLEN];
+            if (!is_del_event) {
+              net->ipaddr_ = inet_ntop(ifa->ifa_family, RTA_DATA(ifa_rta), ipaddr, sizeof(ipaddr));
+              net->cidr_ = ifa->ifa_prefixlen;
+              switch (ifa->ifa_family) {
+                case AF_INET: {
+                  struct in_addr netmask;
+                  netmask.s_addr = htonl(~0 << (32 - ifa->ifa_prefixlen));
+                  net->netmask_ = inet_ntop(ifa->ifa_family, &netmask, ipaddr, sizeof(ipaddr));
+                }
+                case AF_INET6: {
+                  struct in6_addr netmask;
+                  for (int i = 0; i < 16; i++) {
+                    int v = (i + 1) * 8 - ifa->ifa_prefixlen;
+                    if (v < 0) v = 0;
+                    if (v > 8) v = 8;
+                    netmask.s6_addr[i] = ~0 << v;
+                  }
+                  net->netmask_ = inet_ntop(ifa->ifa_family, &netmask, ipaddr, sizeof(ipaddr));
+                }
+              }
+              spdlog::debug("network: {}, new addr {}/{}", net->ifname_, net->ipaddr_, net->cidr_);
+            } else {
+              net->ipaddr_.clear();
+              net->cidr_ = 0;
+              net->netmask_.clear();
+              spdlog::debug("network: {} addr deleted {}/{}", net->ifname_,
+                            inet_ntop(ifa->ifa_family, RTA_DATA(ifa_rta), ipaddr, sizeof(ipaddr)),
+                            ifa->ifa_prefixlen);
+            }
+            net->dp.emit();
+            break;
+          }
+        }
+      }
+      break;
+    }
+
+      char temp_gw_addr[INET6_ADDRSTRLEN];
+    case RTM_DELROUTE:
+      is_del_event = true;
+    case RTM_NEWROUTE: {
+      // Based on https://gist.github.com/Yawning/c70d804d4b8ae78cc698
+      // to find the interface used to reach the outside world
+
+      struct rtmsg *rtm = static_cast<struct rtmsg *>(NLMSG_DATA(nh));
+      ssize_t attrlen = RTM_PAYLOAD(nh);
+      struct rtattr *attr = RTM_RTA(rtm);
+      bool has_gateway = false;
+      bool has_destination = false;
+      int temp_idx = -1;
+      uint32_t priority = 0;
+
+      /* Find the message(s) concerting the main routing table, each message
+       * corresponds to a single routing table entry.
+       */
+      if (rtm->rtm_table != RT_TABLE_MAIN) {
+        return NL_OK;
+      }
+
+      /* Parse all the attributes for a single routing table entry. */
+      for (; RTA_OK(attr, attrlen); attr = RTA_NEXT(attr, attrlen)) {
+        /* Determine if this routing table entry corresponds to the default
+         * route by seeing if it has a gateway, and if a destination addr is
+         * set, that it is all 0s.
+         */
+        switch (attr->rta_type) {
+          case RTA_GATEWAY:
+            /* The gateway of the route.
+             *
+             * If someone ever needs to figure out the gateway address as well,
+             * it's here as the attribute payload.
+             */
+            inet_ntop(net->family_, RTA_DATA(attr), temp_gw_addr, sizeof(temp_gw_addr));
+            has_gateway = true;
+            break;
+          case RTA_DST: {
+            /* The destination address.
+             * Should be either missing, or maybe all 0s.  Accept both.
+             */
+            const uint32_t nr_zeroes = (net->family_ == AF_INET) ? 4 : 16;
+            unsigned char c = 0;
+            size_t dstlen = RTA_PAYLOAD(attr);
+            if (dstlen != nr_zeroes) {
+              break;
+            }
+            for (uint32_t i = 0; i < dstlen; i += 1) {
+              c |= *((unsigned char *)RTA_DATA(attr) + i);
+            }
+            has_destination = (c == 0);
+            break;
+          }
+          case RTA_OIF:
+            /* The output interface index. */
+            temp_idx = *static_cast<int *>(RTA_DATA(attr));
+            break;
+          case RTA_PRIORITY:
+            priority = *(uint32_t *)RTA_DATA(attr);
+            break;
+          default:
+            break;
+        }
+      }
+
+      // Check if we have a default route.
+      if (has_gateway && !has_destination && temp_idx != -1) {
+        // Check if this is the first default route we see, or if this new
+        // route have a higher priority.
+        if (!is_del_event && ((net->ifid_ == -1) || (priority < net->route_priority))) {
+          // Clear if's state for the case were there is a higher priority
+          // route on a different interface.
+          net->clearIface();
+          net->ifid_ = temp_idx;
+          net->route_priority = priority;
+          net->gwaddr_ = temp_gw_addr;
+          spdlog::debug("network: new default route via {} on if{} metric {}", temp_gw_addr,
+                        temp_idx, priority);
+
+          /* Ask ifname associated with temp_idx as well as carrier status */
+          struct ifinfomsg ifinfo_hdr = {
+              .ifi_family = AF_UNSPEC,
+              .ifi_index = temp_idx,
+          };
+          int err;
+          err = nl_send_simple(net->ev_sock_, RTM_GETLINK, NLM_F_REQUEST, &ifinfo_hdr,
+                               sizeof(ifinfo_hdr));
+          if (err < 0) {
+            spdlog::error("network: failed to ask link info: {}", err);
+            /* Ask for a dump of all links instead */
+            net->want_link_dump_ = true;
+          }
+
+          /* Also ask for the address. Asking for a addresses of a specific
+           * interface doesn't seems to work so ask for a dump of all
+           * addresses. */
+          net->want_addr_dump_ = true;
+          net->askForStateDump();
+          net->thread_timer_.wake_up();
+        } else if (is_del_event && temp_idx == net->ifid_ && net->route_priority == priority) {
+          spdlog::debug("network: default route deleted {}/if{} metric {}", net->ifname_, temp_idx,
+                        priority);
+
+          net->clearIface();
+          net->dp.emit();
+          /* Ask for a dump of all routes in case another one is already
+           * setup. If there's none, there'll be an event with new one
+           * later. */
+          net->want_route_dump_ = true;
+          net->askForStateDump();
+        }
+      }
+      break;
     }
-    break;
-  }
   }
 
   return NL_OK;
@@ -702,30 +687,26 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
 void waybar::modules::Network::askForStateDump(void) {
   /* We need to wait until the current dump is done before sending new
    * messages. handleEventsDone() is called when a dump is done. */
-  if (dump_in_progress_)
+  if (dump_in_progress_) return;
-    return;
 
   struct rtgenmsg rt_hdr = {
-    .rtgen_family = AF_UNSPEC,
+      .rtgen_family = AF_UNSPEC,
   };
 
   if (want_route_dump_) {
     rt_hdr.rtgen_family = family_;
-    nl_send_simple(ev_sock_, RTM_GETROUTE, NLM_F_DUMP,
+    nl_send_simple(ev_sock_, RTM_GETROUTE, NLM_F_DUMP, &rt_hdr, sizeof(rt_hdr));
-                   &rt_hdr, sizeof (rt_hdr));
     want_route_dump_ = false;
     dump_in_progress_ = true;
 
   } else if (want_link_dump_) {
-    nl_send_simple(ev_sock_, RTM_GETLINK, NLM_F_DUMP,
+    nl_send_simple(ev_sock_, RTM_GETLINK, NLM_F_DUMP, &rt_hdr, sizeof(rt_hdr));
-                   &rt_hdr, sizeof (rt_hdr));
     want_link_dump_ = false;
     dump_in_progress_ = true;
 
   } else if (want_addr_dump_) {
     rt_hdr.rtgen_family = family_;
-    nl_send_simple(ev_sock_, RTM_GETADDR, NLM_F_DUMP,
+    nl_send_simple(ev_sock_, RTM_GETADDR, NLM_F_DUMP, &rt_hdr, sizeof(rt_hdr));
-                   &rt_hdr, sizeof (rt_hdr));
     want_addr_dump_ = false;
     dump_in_progress_ = true;
   }
@@ -739,10 +720,10 @@ int waybar::modules::Network::handleEventsDone(struct nl_msg *msg, void *data) {
 }
 
 int waybar::modules::Network::handleScan(struct nl_msg *msg, void *data) {
-  auto              net = static_cast<waybar::modules::Network *>(data);
+  auto net = static_cast<waybar::modules::Network *>(data);
-  auto              gnlh = static_cast<genlmsghdr *>(nlmsg_data(nlmsg_hdr(msg)));
+  auto gnlh = static_cast<genlmsghdr *>(nlmsg_data(nlmsg_hdr(msg)));
-  struct nlattr *   tb[NL80211_ATTR_MAX + 1];
+  struct nlattr *tb[NL80211_ATTR_MAX + 1];
-  struct nlattr *   bss[NL80211_BSS_MAX + 1];
+  struct nlattr *bss[NL80211_BSS_MAX + 1];
   struct nla_policy bss_policy[NL80211_BSS_MAX + 1]{};
   bss_policy[NL80211_BSS_TSF].type = NLA_U64;
   bss_policy[NL80211_BSS_FREQUENCY].type = NLA_U32;
@@ -754,8 +735,8 @@ int waybar::modules::Network::handleScan(struct nl_msg *msg, void *data) {
   bss_policy[NL80211_BSS_SIGNAL_UNSPEC].type = NLA_U8;
   bss_policy[NL80211_BSS_STATUS].type = NLA_U32;
 
-  if (nla_parse(
+  if (nla_parse(tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0),
-          tb, NL80211_ATTR_MAX, genlmsg_attrdata(gnlh, 0), genlmsg_attrlen(gnlh, 0), nullptr) < 0) {
+                nullptr) < 0) {
     return NL_SKIP;
   }
   if (tb[NL80211_ATTR_BSS] == nullptr) {
@@ -775,16 +756,16 @@ int waybar::modules::Network::handleScan(struct nl_msg *msg, void *data) {
 
 void waybar::modules::Network::parseEssid(struct nlattr **bss) {
   if (bss[NL80211_BSS_INFORMATION_ELEMENTS] != nullptr) {
-    auto       ies = static_cast<char *>(nla_data(bss[NL80211_BSS_INFORMATION_ELEMENTS]));
+    auto ies = static_cast<char *>(nla_data(bss[NL80211_BSS_INFORMATION_ELEMENTS]));
-    auto       ies_len = nla_len(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
+    auto ies_len = nla_len(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
     const auto hdr_len = 2;
     while (ies_len > hdr_len && ies[0] != 0) {
       ies_len -= ies[1] + hdr_len;
       ies += ies[1] + hdr_len;
     }
     if (ies_len > hdr_len && ies_len > ies[1] + hdr_len) {
-      auto        essid_begin = ies + hdr_len;
+      auto essid_begin = ies + hdr_len;
-      auto        essid_end = essid_begin + ies[1];
+      auto essid_end = essid_begin + ies[1];
       std::string essid_raw;
       std::copy(essid_begin, essid_end, std::back_inserter(essid_raw));
       essid_ = Glib::Markup::escape_text(essid_raw);
@@ -804,8 +785,10 @@ void waybar::modules::Network::parseSignal(struct nlattr **bss) {
     const int hardwareOptimum = -45;
     const int hardwareMin = -90;
     const int strength =
-        100 - ((abs(signal_strength_dbm_ - hardwareOptimum) / double{hardwareOptimum - hardwareMin}) * 100);
+        100 -
-    signal_strength_ = std::clamp(strength, 0, 100);  
+        ((abs(signal_strength_dbm_ - hardwareOptimum) / double{hardwareOptimum - hardwareMin}) *
+         100);
+    signal_strength_ = std::clamp(strength, 0, 100);
 
     if (signal_strength_dbm_ >= -50) {
       signal_strength_app_ = "Great Connectivity";
@@ -829,7 +812,7 @@ void waybar::modules::Network::parseSignal(struct nlattr **bss) {
 void waybar::modules::Network::parseFreq(struct nlattr **bss) {
   if (bss[NL80211_BSS_FREQUENCY] != nullptr) {
     // in GHz
-    frequency_ = (double) nla_get_u32(bss[NL80211_BSS_FREQUENCY]) / 1000;
+    frequency_ = (double)nla_get_u32(bss[NL80211_BSS_FREQUENCY]) / 1000;
   }
 }
 
@@ -853,9 +836,8 @@ auto waybar::modules::Network::getInfo() -> void {
   if (nl_msg == nullptr) {
     return;
   }
-  if (genlmsg_put(
+  if (genlmsg_put(nl_msg, NL_AUTO_PORT, NL_AUTO_SEQ, nl80211_id_, 0, NLM_F_DUMP,
-          nl_msg, NL_AUTO_PORT, NL_AUTO_SEQ, nl80211_id_, 0, NLM_F_DUMP, NL80211_CMD_GET_SCAN, 0) ==
+                  NL80211_CMD_GET_SCAN, 0) == nullptr ||
-          nullptr ||
       nla_put_u32(nl_msg, NL80211_ATTR_IFINDEX, ifid_) < 0) {
     nlmsg_free(nl_msg);
     return;

src/modules/pulseaudio.cpp

@@ -50,15 +50,14 @@ void waybar::modules::Pulseaudio::contextStateCb(pa_context *c, void *data) {
     case PA_CONTEXT_READY:
       pa_context_get_server_info(c, serverInfoCb, data);
       pa_context_set_subscribe_callback(c, subscribeCb, data);
-      pa_context_subscribe(
+      pa_context_subscribe(c,
-          c,
+                           static_cast<enum pa_subscription_mask>(
-          static_cast<enum pa_subscription_mask>(static_cast<int>(PA_SUBSCRIPTION_MASK_SERVER) |
+                               static_cast<int>(PA_SUBSCRIPTION_MASK_SERVER) |
-                                                 static_cast<int>(PA_SUBSCRIPTION_MASK_SINK) |
+                               static_cast<int>(PA_SUBSCRIPTION_MASK_SINK) |
-                                                 static_cast<int>(PA_SUBSCRIPTION_MASK_SINK_INPUT) |
+                               static_cast<int>(PA_SUBSCRIPTION_MASK_SINK_INPUT) |
-                                                 static_cast<int>(PA_SUBSCRIPTION_MASK_SOURCE) |
+                               static_cast<int>(PA_SUBSCRIPTION_MASK_SOURCE) |
-                                                 static_cast<int>(PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT)),
+                               static_cast<int>(PA_SUBSCRIPTION_MASK_SOURCE_OUTPUT)),
-          nullptr,
+                           nullptr, nullptr);
-          nullptr);
       break;
     case PA_CONTEXT_FAILED:
       pa->mainloop_api_->quit(pa->mainloop_api_, 1);
@@ -81,16 +80,16 @@ bool waybar::modules::Pulseaudio::handleScroll(GdkEventScroll *e) {
   if (dir == SCROLL_DIR::NONE) {
     return true;
   }
-  if (config_["reverse-scrolling"].asInt() == 1){
+  if (config_["reverse-scrolling"].asInt() == 1) {
     if (dir == SCROLL_DIR::UP) {
       dir = SCROLL_DIR::DOWN;
     } else if (dir == SCROLL_DIR::DOWN) {
       dir = SCROLL_DIR::UP;
     }
   }
-  double      volume_tick = static_cast<double>(PA_VOLUME_NORM) / 100;
+  double volume_tick = static_cast<double>(PA_VOLUME_NORM) / 100;
   pa_volume_t change = volume_tick;
-  pa_cvolume  pa_volume = pa_volume_;
+  pa_cvolume pa_volume = pa_volume_;
   // isDouble returns true for integers as well, just in case
   if (config_["scroll-step"].isDouble()) {
     change = round(config_["scroll-step"].asDouble() * volume_tick);
@@ -111,7 +110,7 @@ bool waybar::modules::Pulseaudio::handleScroll(GdkEventScroll *e) {
 /*
  * Called when an event we subscribed to occurs.
  */
-void waybar::modules::Pulseaudio::subscribeCb(pa_context *                 context,
+void waybar::modules::Pulseaudio::subscribeCb(pa_context *context,
                                               pa_subscription_event_type_t type, uint32_t idx,
                                               void *data) {
   unsigned facility = type & PA_SUBSCRIPTION_EVENT_FACILITY_MASK;
@@ -164,8 +163,7 @@ void waybar::modules::Pulseaudio::sourceInfoCb(pa_context * /*context*/, const p
  */
 void waybar::modules::Pulseaudio::sinkInfoCb(pa_context * /*context*/, const pa_sink_info *i,
                                              int /*eol*/, void *data) {
-  if (i == nullptr)
+  if (i == nullptr) return;
-    return;
 
   auto pa = static_cast<waybar::modules::Pulseaudio *>(data);
   if (pa->current_sink_name_ == i->name) {
@@ -212,15 +210,7 @@ void waybar::modules::Pulseaudio::serverInfoCb(pa_context *context, const pa_ser
 }
 
 static const std::array<std::string, 9> ports = {
-    "headphone",
+    "headphone", "speaker", "hdmi", "headset", "hands-free", "portable", "car", "hifi", "phone",
-    "speaker",
-    "hdmi",
-    "headset",
-    "hands-free",
-    "portable",
-    "car",
-    "hifi",
-    "phone",
 };
 
 const std::vector<std::string> waybar::modules::Pulseaudio::getPulseIcon() const {
@@ -238,11 +228,11 @@ const std::vector<std::string> waybar::modules::Pulseaudio::getPulseIcon() const
 
 auto waybar::modules::Pulseaudio::update() -> void {
   auto format = format_;
-  std::string                 tooltip_format;
+  std::string tooltip_format;
   if (!alt_) {
     std::string format_name = "format";
-    if (monitor_.find("a2dp_sink") != std::string::npos || // PulseAudio
+    if (monitor_.find("a2dp_sink") != std::string::npos ||  // PulseAudio
-        monitor_.find("a2dp-sink") != std::string::npos) { // PipeWire
+        monitor_.find("a2dp-sink") != std::string::npos) {  // PipeWire
       format_name = format_name + "-bluetooth";
       label_.get_style_context()->add_class("bluetooth");
     } else {
@@ -260,8 +250,7 @@ auto waybar::modules::Pulseaudio::update() -> void {
       label_.get_style_context()->remove_class("muted");
       label_.get_style_context()->remove_class("sink-muted");
     }
-    format =
+    format = config_[format_name].isString() ? config_[format_name].asString() : format;
-      config_[format_name].isString() ? config_[format_name].asString() : format;
   }
   // TODO: find a better way to split source/sink
   std::string format_source = "{volume}%";
@@ -277,13 +266,10 @@ auto waybar::modules::Pulseaudio::update() -> void {
     }
   }
   format_source = fmt::format(format_source, fmt::arg("volume", source_volume_));
-  label_.set_markup(fmt::format(format,
+  label_.set_markup(fmt::format(
-                                fmt::arg("desc", desc_),
+      format, fmt::arg("desc", desc_), fmt::arg("volume", volume_),
-                                fmt::arg("volume", volume_),
+      fmt::arg("format_source", format_source), fmt::arg("source_volume", source_volume_),
-                                fmt::arg("format_source", format_source),
+      fmt::arg("source_desc", source_desc_), fmt::arg("icon", getIcon(volume_, getPulseIcon()))));
-                                fmt::arg("source_volume", source_volume_),
-                                fmt::arg("source_desc", source_desc_),
-                                fmt::arg("icon", getIcon(volume_, getPulseIcon()))));
   getState(volume_);
 
   if (tooltipEnabled()) {
@@ -292,13 +278,10 @@ auto waybar::modules::Pulseaudio::update() -> void {
     }
     if (!tooltip_format.empty()) {
       label_.set_tooltip_text(fmt::format(
-        tooltip_format,
+          tooltip_format, fmt::arg("desc", desc_), fmt::arg("volume", volume_),
-        fmt::arg("desc", desc_),
+          fmt::arg("format_source", format_source), fmt::arg("source_volume", source_volume_),
-        fmt::arg("volume", volume_),
+          fmt::arg("source_desc", source_desc_),
-        fmt::arg("format_source", format_source),
+          fmt::arg("icon", getIcon(volume_, getPulseIcon()))));
-        fmt::arg("source_volume", source_volume_),
-        fmt::arg("source_desc", source_desc_),
-        fmt::arg("icon", getIcon(volume_, getPulseIcon()))));
     } else {
       label_.set_tooltip_text(desc_);
     }

src/modules/river/tags.cpp

@@ -1,3 +1,5 @@
+#include "modules/river/tags.hpp"
+
 #include <gtkmm/button.h>
 #include <gtkmm/label.h>
 #include <spdlog/spdlog.h>
@@ -6,7 +8,6 @@
 #include <algorithm>
 
 #include "client.hpp"
-#include "modules/river/tags.hpp"
 #include "xdg-output-unstable-v1-client-protocol.h"
 
 namespace waybar::modules::river {
@@ -44,7 +45,7 @@ static void listen_command_failure(void *data,
   spdlog::error("failure when selecting/toggling tags {}", output);
 }
 
-static const zriver_command_callback_v1_listener command_callback_listener_impl {
+static const zriver_command_callback_v1_listener command_callback_listener_impl{
     .success = listen_command_success,
     .failure = listen_command_failure,
 };
@@ -77,7 +78,6 @@ static void handle_global_remove(void *data, struct wl_registry *registry, uint3
   /* Ignore event */
 }
 
-
 static const wl_registry_listener registry_listener_impl = {.global = handle_global,
                                                             .global_remove = handle_global_remove};
 
@@ -89,7 +89,7 @@ Tags::Tags(const std::string &id, const waybar::Bar &bar, const Json::Value &con
       bar_(bar),
       box_{bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0},
       output_status_{nullptr} {
-  struct wl_display * display = Client::inst()->wl_display;
+  struct wl_display *display = Client::inst()->wl_display;
   struct wl_registry *registry = wl_display_get_registry(display);
   wl_registry_add_listener(registry, &registry_listener_impl, this);
   wl_display_roundtrip(display);
@@ -119,7 +119,7 @@ Tags::Tags(const std::string &id, const waybar::Bar &bar, const Json::Value &con
 
   std::vector<std::string> tag_labels(num_tags);
   for (uint32_t tag = 0; tag < num_tags; ++tag) {
-    tag_labels[tag] = std::to_string(tag+1);
+    tag_labels[tag] = std::to_string(tag + 1);
   }
   const Json::Value custom_labels = config["tag-labels"];
   if (custom_labels.isArray() && !custom_labels.empty()) {
@@ -134,8 +134,10 @@ Tags::Tags(const std::string &id, const waybar::Bar &bar, const Json::Value &con
     button.set_relief(Gtk::RELIEF_NONE);
     box_.pack_start(button, false, false, 0);
     if (!config_["disable-click"].asBool()) {
-      button.signal_clicked().connect(sigc::bind(sigc::mem_fun(*this, &Tags::handle_primary_clicked), i));
+      button.signal_clicked().connect(
-      button.signal_button_press_event().connect(sigc::bind(sigc::mem_fun(*this, &Tags::handle_button_press), i));
+          sigc::bind(sigc::mem_fun(*this, &Tags::handle_primary_clicked), i));
+      button.signal_button_press_event().connect(
+          sigc::bind(sigc::mem_fun(*this, &Tags::handle_button_press), i));
     }
     button.show();
     i <<= 1;

src/modules/simpleclock.cpp

@@ -1,4 +1,5 @@
 #include "modules/simpleclock.hpp"
+
 #include <time.h>
 
 waybar::modules::Clock::Clock(const std::string& id, const Json::Value& config)
@@ -13,7 +14,7 @@ waybar::modules::Clock::Clock(const std::string& id, const Json::Value& config)
 }
 
 auto waybar::modules::Clock::update() -> void {
-  tzset(); // Update timezone information
+  tzset();  // Update timezone information
   auto now = std::chrono::system_clock::now();
   auto localtime = fmt::localtime(std::chrono::system_clock::to_time_t(now));
   auto text = fmt::format(format_, localtime);

src/modules/sndio.cpp

@@ -1,14 +1,16 @@
 #include "modules/sndio.hpp"
+
+#include <fmt/format.h>
+#include <poll.h>
+#include <spdlog/spdlog.h>
+
 #include <algorithm>
 #include <cstdlib>
-#include <poll.h>
-#include <fmt/format.h>
-#include <spdlog/spdlog.h>
 
 namespace waybar::modules {
 
 void ondesc(void *arg, struct sioctl_desc *d, int curval) {
-  auto self = static_cast<Sndio*>(arg);
+  auto self = static_cast<Sndio *>(arg);
   if (d == NULL) {
     // d is NULL when the list is done
     return;
@@ -17,7 +19,7 @@ void ondesc(void *arg, struct sioctl_desc *d, int curval) {
 }
 
 void onval(void *arg, unsigned int addr, unsigned int val) {
-  auto self = static_cast<Sndio*>(arg);
+  auto self = static_cast<Sndio *>(arg);
   self->put_val(addr, val);
 }
 
@@ -52,10 +54,8 @@ Sndio::Sndio(const std::string &id, const Json::Value &config)
   event_box_.show();
 
   event_box_.add_events(Gdk::SCROLL_MASK | Gdk::SMOOTH_SCROLL_MASK | Gdk::BUTTON_PRESS_MASK);
-  event_box_.signal_scroll_event().connect(
+  event_box_.signal_scroll_event().connect(sigc::mem_fun(*this, &Sndio::handleScroll));
-    sigc::mem_fun(*this, &Sndio::handleScroll));
+  event_box_.signal_button_press_event().connect(sigc::mem_fun(*this, &Sndio::handleToggle));
-  event_box_.signal_button_press_event().connect(
-    sigc::mem_fun(*this, &Sndio::handleToggle));
 
   thread_ = [this] {
     dp.emit();
@@ -80,7 +80,7 @@ Sndio::Sndio(const std::string &id, const Json::Value &config)
       while (thread_.isRunning()) {
         try {
           connect_to_sndio();
-        } catch(std::runtime_error const& e) {
+        } catch (std::runtime_error const &e) {
           // avoid leaking hdl_
           if (hdl_) {
             sioctl_close(hdl_);
@@ -98,9 +98,7 @@ Sndio::Sndio(const std::string &id, const Json::Value &config)
   };
 }
 
-Sndio::~Sndio() {
+Sndio::~Sndio() { sioctl_close(hdl_); }
-  sioctl_close(hdl_);
-}
 
 auto Sndio::update() -> void {
   auto format = format_;
@@ -112,9 +110,7 @@ auto Sndio::update() -> void {
     label_.get_style_context()->remove_class("muted");
   }
 
-  label_.set_markup(fmt::format(format,
+  label_.set_markup(fmt::format(format, fmt::arg("volume", vol), fmt::arg("raw_value", volume_)));
-                                fmt::arg("volume", vol),
-                                fmt::arg("raw_value", volume_)));
 
   ALabel::update();
 }
@@ -177,7 +173,7 @@ bool Sndio::handleScroll(GdkEventScroll *e) {
   return true;
 }
 
-bool Sndio::handleToggle(GdkEventButton* const& e) {
+bool Sndio::handleToggle(GdkEventButton *const &e) {
   // toggle mute only when no user provided events are configured
   if (config_["on-click"].isString()) {
     return AModule::handleToggle(e);

src/modules/sni/host.cpp

@@ -1,4 +1,5 @@
 #include "modules/sni/host.hpp"
+
 #include <fmt/ostream.h>
 #include <spdlog/spdlog.h>
 
@@ -32,8 +33,7 @@ Host::~Host() {
 }
 
 void Host::busAcquired(const Glib::RefPtr<Gio::DBus::Connection>& conn, Glib::ustring name) {
-  watcher_id_ = Gio::DBus::watch_name(conn,
+  watcher_id_ = Gio::DBus::watch_name(conn, "org.kde.StatusNotifierWatcher",
-                                      "org.kde.StatusNotifierWatcher",
                                       sigc::mem_fun(*this, &Host::nameAppeared),
                                       sigc::mem_fun(*this, &Host::nameVanished));
 }
@@ -45,13 +45,8 @@ void Host::nameAppeared(const Glib::RefPtr<Gio::DBus::Connection>& conn, const G
     return;
   }
   cancellable_ = g_cancellable_new();
-  sn_watcher_proxy_new(conn->gobj(),
+  sn_watcher_proxy_new(conn->gobj(), G_DBUS_PROXY_FLAGS_NONE, "org.kde.StatusNotifierWatcher",
-                       G_DBUS_PROXY_FLAGS_NONE,
+                       "/StatusNotifierWatcher", cancellable_, &Host::proxyReady, this);
-                       "org.kde.StatusNotifierWatcher",
-                       "/StatusNotifierWatcher",
-                       cancellable_,
-                       &Host::proxyReady,
-                       this);
 }
 
 void Host::nameVanished(const Glib::RefPtr<Gio::DBus::Connection>& conn, const Glib::ustring name) {
@@ -62,7 +57,7 @@ void Host::nameVanished(const Glib::RefPtr<Gio::DBus::Connection>& conn, const G
 }
 
 void Host::proxyReady(GObject* src, GAsyncResult* res, gpointer data) {
-  GError*    error = nullptr;
+  GError* error = nullptr;
   SnWatcher* watcher = sn_watcher_proxy_new_finish(res, &error);
   if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
     spdlog::error("Host: {}", error->message);
@@ -76,8 +71,8 @@ void Host::proxyReady(GObject* src, GAsyncResult* res, gpointer data) {
     g_error_free(error);
     return;
   }
-  sn_watcher_call_register_host(
+  sn_watcher_call_register_host(host->watcher_, host->object_path_.c_str(), host->cancellable_,
-      host->watcher_, host->object_path_.c_str(), host->cancellable_, &Host::registerHost, data);
+                                &Host::registerHost, data);
 }
 
 void Host::registerHost(GObject* src, GAsyncResult* res, gpointer data) {

src/modules/sni/item.cpp

@@ -31,7 +31,7 @@ struct fmt::formatter<Glib::VariantBase> : formatter<std::string> {
 namespace waybar::modules::SNI {
 
 static const Glib::ustring SNI_INTERFACE_NAME = sn_item_interface_info()->name;
-static const unsigned      UPDATE_DEBOUNCE_TIME = 10;
+static const unsigned UPDATE_DEBOUNCE_TIME = 10;
 
 Item::Item(const std::string& bn, const std::string& op, const Json::Value& config, const Bar& bar)
     : bus_name(bn),
@@ -49,7 +49,7 @@ Item::Item(const std::string& bn, const std::string& op, const Json::Value& conf
     show_passive_ = config["show-passive-items"].asBool();
   }
 
-  auto &window = const_cast<Bar &>(bar).window;
+  auto& window = const_cast<Bar&>(bar).window;
   window.signal_configure_event().connect_notify(sigc::mem_fun(*this, &Item::onConfigure));
   event_box.add(image);
   event_box.add_events(Gdk::BUTTON_PRESS_MASK | Gdk::SCROLL_MASK | Gdk::SMOOTH_SCROLL_MASK);
@@ -62,18 +62,12 @@ Item::Item(const std::string& bn, const std::string& op, const Json::Value& conf
   cancellable_ = Gio::Cancellable::create();
 
   auto interface = Glib::wrap(sn_item_interface_info(), true);
-  Gio::DBus::Proxy::create_for_bus(Gio::DBus::BusType::BUS_TYPE_SESSION,
+  Gio::DBus::Proxy::create_for_bus(Gio::DBus::BusType::BUS_TYPE_SESSION, bus_name, object_path,
-                                   bus_name,
+                                   SNI_INTERFACE_NAME, sigc::mem_fun(*this, &Item::proxyReady),
-                                   object_path,
+                                   cancellable_, interface);
-                                   SNI_INTERFACE_NAME,
-                                   sigc::mem_fun(*this, &Item::proxyReady),
-                                   cancellable_,
-                                   interface);
 }
 
-void Item::onConfigure(GdkEventConfigure* ev) {
+void Item::onConfigure(GdkEventConfigure* ev) { this->updateImage(); }
-  this->updateImage();
-}
 
 void Item::proxyReady(Glib::RefPtr<Gio::AsyncResult>& result) {
   try {
@@ -167,16 +161,10 @@ void Item::setProperty(const Glib::ustring& name, Glib::VariantBase& value) {
     }
   } catch (const Glib::Error& err) {
     spdlog::warn("Failed to set tray item property: {}.{}, value = {}, err = {}",
-                 id.empty() ? bus_name : id,
+                 id.empty() ? bus_name : id, name, value, err.what());
-                 name,
-                 value,
-                 err.what());
   } catch (const std::exception& err) {
     spdlog::warn("Failed to set tray item property: {}.{}, value = {}, err = {}",
-                 id.empty() ? bus_name : id,
+                 id.empty() ? bus_name : id, name, value, err.what());
-                 name,
-                 value,
-                 err.what());
   }
 }
 
@@ -199,8 +187,7 @@ void Item::getUpdatedProperties() {
   auto params = Glib::VariantContainerBase::create_tuple(
       {Glib::Variant<Glib::ustring>::create(SNI_INTERFACE_NAME)});
   proxy_->call("org.freedesktop.DBus.Properties.GetAll",
-               sigc::mem_fun(*this, &Item::processUpdatedProperties),
+               sigc::mem_fun(*this, &Item::processUpdatedProperties), params);
-               params);
 };
 
 void Item::processUpdatedProperties(Glib::RefPtr<Gio::AsyncResult>& _result) {
@@ -266,11 +253,11 @@ Glib::RefPtr<Gdk::Pixbuf> Item::extractPixBuf(GVariant* variant) {
     return Glib::RefPtr<Gdk::Pixbuf>{};
   }
   GVariant* val;
-  gint      lwidth = 0;
+  gint lwidth = 0;
-  gint      lheight = 0;
+  gint lheight = 0;
-  gint      width;
+  gint width;
-  gint      height;
+  gint height;
-  guchar*   array = nullptr;
+  guchar* array = nullptr;
   while (g_variant_iter_loop(it, "(ii@ay)", &width, &height, &val)) {
     if (width > 0 && height > 0 && val != nullptr && width * height > lwidth * lheight) {
       auto size = g_variant_get_size(val);
@@ -303,14 +290,8 @@ Glib::RefPtr<Gdk::Pixbuf> Item::extractPixBuf(GVariant* variant) {
       array[i + 2] = array[i + 3];
       array[i + 3] = alpha;
     }
-    return Gdk::Pixbuf::create_from_data(array,
+    return Gdk::Pixbuf::create_from_data(array, Gdk::Colorspace::COLORSPACE_RGB, true, 8, lwidth,
-                                         Gdk::Colorspace::COLORSPACE_RGB,
+                                         lheight, 4 * lwidth, &pixbuf_data_deleter);
-                                         true,
-                                         8,
-                                         lwidth,
-                                         lheight,
-                                         4 * lwidth,
-                                         &pixbuf_data_deleter);
   }
   return Glib::RefPtr<Gdk::Pixbuf>{};
 }
@@ -318,7 +299,7 @@ Glib::RefPtr<Gdk::Pixbuf> Item::extractPixBuf(GVariant* variant) {
 void Item::updateImage() {
   auto pixbuf = getIconPixbuf();
   auto scaled_icon_size = getScaledIconSize();
- 
+
   if (!pixbuf) {
     pixbuf = getIconByName("image-missing", getScaledIconSize());
   }
@@ -349,7 +330,7 @@ Glib::RefPtr<Gdk::Pixbuf> Item::getIconPixbuf() {
     }
   } catch (Glib::Error& e) {
     spdlog::error("Item '{}': {}", id, static_cast<std::string>(e.what()));
-  } 
+  }
   return getIconByName("image-missing", getScaledIconSize());
 }
 
@@ -374,15 +355,15 @@ Glib::RefPtr<Gdk::Pixbuf> Item::getIconByName(const std::string& name, int reque
     tmp_size = request_size;
   }
   if (!icon_theme_path.empty() &&
-      icon_theme->lookup_icon(
+      icon_theme->lookup_icon(name.c_str(), tmp_size,
-          name.c_str(), tmp_size, Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE)) {
+                              Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE)) {
-    return icon_theme->load_icon(
+    return icon_theme->load_icon(name.c_str(), tmp_size,
-        name.c_str(), tmp_size, Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE);
+                                 Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE);
   }
   Glib::RefPtr<Gtk::IconTheme> default_theme = Gtk::IconTheme::get_default();
   default_theme->rescan_if_needed();
-  return default_theme->load_icon(
+  return default_theme->load_icon(name.c_str(), tmp_size,
-      name.c_str(), tmp_size, Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE);
+                                  Gtk::IconLookupFlags::ICON_LOOKUP_FORCE_SIZE);
 }
 
 double Item::getScaledIconSize() {

src/modules/sni/tray.cpp

@@ -1,4 +1,5 @@
 #include "modules/sni/tray.hpp"
+
 #include <spdlog/spdlog.h>
 
 namespace waybar::modules::SNI {

src/modules/sni/watcher.cpp

@@ -1,4 +1,5 @@
 #include "modules/sni/watcher.hpp"
+
 #include <spdlog/spdlog.h>
 
 using namespace waybar::modules::SNI;
@@ -29,8 +30,8 @@ Watcher::~Watcher() {
 
 void Watcher::busAcquired(const Glib::RefPtr<Gio::DBus::Connection>& conn, Glib::ustring name) {
   GError* error = nullptr;
-  g_dbus_interface_skeleton_export(
+  g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(watcher_), conn->gobj(),
-      G_DBUS_INTERFACE_SKELETON(watcher_), conn->gobj(), "/StatusNotifierWatcher", &error);
+                                   "/StatusNotifierWatcher", &error);
   if (error != nullptr) {
     // Don't print an error when a watcher is already present
     if (error->code != 2) {
@@ -39,10 +40,10 @@ void Watcher::busAcquired(const Glib::RefPtr<Gio::DBus::Connection>& conn, Glib:
     g_error_free(error);
     return;
   }
-  g_signal_connect_swapped(
+  g_signal_connect_swapped(watcher_, "handle-register-item",
-      watcher_, "handle-register-item", G_CALLBACK(&Watcher::handleRegisterItem), this);
+                           G_CALLBACK(&Watcher::handleRegisterItem), this);
-  g_signal_connect_swapped(
+  g_signal_connect_swapped(watcher_, "handle-register-host",
-      watcher_, "handle-register-host", G_CALLBACK(&Watcher::handleRegisterHost), this);
+                           G_CALLBACK(&Watcher::handleRegisterHost), this);
 }
 
 gboolean Watcher::handleRegisterHost(Watcher* obj, GDBusMethodInvocation* invocation,
@@ -55,22 +56,16 @@ gboolean Watcher::handleRegisterHost(Watcher* obj, GDBusMethodInvocation* invoca
     object_path = service;
   }
   if (g_dbus_is_name(bus_name) == FALSE) {
-    g_dbus_method_invocation_return_error(invocation,
+    g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
-                                          G_DBUS_ERROR,
+                                          "D-Bus bus name '%s' is not valid", bus_name);
-                                          G_DBUS_ERROR_INVALID_ARGS,
-                                          "D-Bus bus name '%s' is not valid",
-                                          bus_name);
     return TRUE;
   }
   auto watch = gfWatchFind(obj->hosts_, bus_name, object_path);
   if (watch != nullptr) {
     g_dbus_method_invocation_return_error(
-        invocation,
+        invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
-        G_DBUS_ERROR,
-        G_DBUS_ERROR_INVALID_ARGS,
         "Status Notifier Host with bus name '%s' and object path '%s' is already registered",
-        bus_name,
+        bus_name, object_path);
-        object_path);
     return TRUE;
   }
   watch = gfWatchNew(GF_WATCH_TYPE_HOST, service, bus_name, object_path, obj);
@@ -93,18 +88,14 @@ gboolean Watcher::handleRegisterItem(Watcher* obj, GDBusMethodInvocation* invoca
     object_path = service;
   }
   if (g_dbus_is_name(bus_name) == FALSE) {
-    g_dbus_method_invocation_return_error(invocation,
+    g_dbus_method_invocation_return_error(invocation, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS,
-                                          G_DBUS_ERROR,
+                                          "D-Bus bus name '%s' is not valid", bus_name);
-                                          G_DBUS_ERROR_INVALID_ARGS,
-                                          "D-Bus bus name '%s' is not valid",
-                                          bus_name);
     return TRUE;
   }
   auto watch = gfWatchFind(obj->items_, bus_name, object_path);
   if (watch != nullptr) {
     g_warning("Status Notifier Item with bus name '%s' and object path '%s' is already registered",
-              bus_name,
+              bus_name, object_path);
-              object_path);
     sn_watcher_complete_register_item(obj->watcher_, invocation);
     return TRUE;
   }
@@ -152,13 +143,8 @@ Watcher::GfWatch* Watcher::gfWatchNew(GfWatchType type, const gchar* service, co
   watch->service = g_strdup(service);
   watch->bus_name = g_strdup(bus_name);
   watch->object_path = g_strdup(object_path);
-  watch->watch_id = g_bus_watch_name(G_BUS_TYPE_SESSION,
+  watch->watch_id = g_bus_watch_name(G_BUS_TYPE_SESSION, bus_name, G_BUS_NAME_WATCHER_FLAGS_NONE,
-                                     bus_name,
+                                     nullptr, &Watcher::nameVanished, watch, nullptr);
-                                     G_BUS_NAME_WATCHER_FLAGS_NONE,
-                                     nullptr,
-                                     &Watcher::nameVanished,
-                                     watch,
-                                     nullptr);
   return watch;
 }
 
@@ -183,12 +169,12 @@ void Watcher::updateRegisteredItems(SnWatcher* obj) {
   GVariantBuilder builder;
   g_variant_builder_init(&builder, G_VARIANT_TYPE("as"));
   for (GSList* l = items_; l != nullptr; l = g_slist_next(l)) {
-    auto   watch = static_cast<GfWatch*>(l->data);
+    auto watch = static_cast<GfWatch*>(l->data);
     gchar* item = g_strdup_printf("%s%s", watch->bus_name, watch->object_path);
     g_variant_builder_add(&builder, "s", item);
     g_free(item);
   }
-  GVariant*     variant = g_variant_builder_end(&builder);
+  GVariant* variant = g_variant_builder_end(&builder);
   const gchar** items = g_variant_get_strv(variant, nullptr);
   sn_watcher_set_registered_items(obj, items);
   g_variant_unref(variant);

src/modules/sway/bar.cpp

@@ -79,11 +79,8 @@ void BarIpcClient::onIpcEvent(const struct Ipc::ipc_response& res) {
 }
 
 void BarIpcClient::onConfigUpdate(const swaybar_config& config) {
-  spdlog::info("config update for {}: id {}, mode {}, hidden_state {}",
+  spdlog::info("config update for {}: id {}, mode {}, hidden_state {}", bar_.bar_id, config.id,
-               bar_.bar_id,
+               config.mode, config.hidden_state);
-               config.id,
-               config.mode,
-               config.hidden_state);
   bar_config_ = config;
   update();
 }

src/modules/sway/ipc/client.cpp

@@ -1,4 +1,5 @@
 #include "modules/sway/ipc/client.hpp"
+
 #include <fcntl.h>
 
 namespace waybar::modules::sway {
@@ -35,8 +36,8 @@ const std::string Ipc::getSocketPath() const {
   std::string str;
   {
     std::string str_buf;
-    FILE*       in;
+    FILE* in;
-    char        buf[512] = {0};
+    char buf[512] = {0};
     if ((in = popen("sway --get-socketpath 2>/dev/null", "r")) == nullptr) {
       throw std::runtime_error("Failed to get socket path");
     }
@@ -76,7 +77,7 @@ int Ipc::open(const std::string& socketPath) const {
 struct Ipc::ipc_response Ipc::recv(int fd) {
   std::string header;
   header.resize(ipc_header_size_);
-  auto   data32 = reinterpret_cast<uint32_t*>(header.data() + ipc_magic_.size());
+  auto data32 = reinterpret_cast<uint32_t*>(header.data() + ipc_magic_.size());
   size_t total = 0;
 
   while (total < ipc_header_size_) {

src/modules/sway/language.cpp

@@ -51,8 +51,8 @@ void Language::onCmd(const struct Ipc::ipc_response& res) {
 
   try {
     std::lock_guard<std::mutex> lock(mutex_);
-    auto                        payload = parser_.parse(res.payload);
+    auto payload = parser_.parse(res.payload);
-    std::vector<std::string>    used_layouts;
+    std::vector<std::string> used_layouts;
     // Display current layout of a device with a maximum count of layouts, expecting that all will
     // be OK
     Json::ArrayIndex max_id = 0, max = 0;
@@ -83,7 +83,7 @@ void Language::onEvent(const struct Ipc::ipc_response& res) {
 
   try {
     std::lock_guard<std::mutex> lock(mutex_);
-    auto                        payload = parser_.parse(res.payload)["input"];
+    auto payload = parser_.parse(res.payload)["input"];
     if (payload["type"].asString() == "keyboard") {
       set_current_layout(payload[XKB_ACTIVE_LAYOUT_NAME_KEY].asString());
     }
@@ -95,21 +95,18 @@ void Language::onEvent(const struct Ipc::ipc_response& res) {
 
 auto Language::update() -> void {
   std::lock_guard<std::mutex> lock(mutex_);
-  auto display_layout = trim(fmt::format(format_,
+  auto display_layout = trim(fmt::format(
-                                         fmt::arg("short", layout_.short_name),
+      format_, fmt::arg("short", layout_.short_name),
-                                         fmt::arg("shortDescription", layout_.short_description),
+      fmt::arg("shortDescription", layout_.short_description), fmt::arg("long", layout_.full_name),
-                                         fmt::arg("long", layout_.full_name),
+      fmt::arg("variant", layout_.variant), fmt::arg("flag", layout_.country_flag())));
-                                         fmt::arg("variant", layout_.variant),
-                                         fmt::arg("flag", layout_.country_flag())));
   label_.set_markup(display_layout);
   if (tooltipEnabled()) {
     if (tooltip_format_ != "") {
-      auto tooltip_display_layout = trim(fmt::format(tooltip_format_,
+      auto tooltip_display_layout = trim(
-                                                     fmt::arg("short", layout_.short_name),
+          fmt::format(tooltip_format_, fmt::arg("short", layout_.short_name),
-                                                     fmt::arg("shortDescription", layout_.short_description),
+                      fmt::arg("shortDescription", layout_.short_description),
-                                                     fmt::arg("long", layout_.full_name),
+                      fmt::arg("long", layout_.full_name), fmt::arg("variant", layout_.variant),
-                                                     fmt::arg("variant", layout_.variant),
+                      fmt::arg("flag", layout_.country_flag())));
-                                                     fmt::arg("flag", layout_.country_flag())));
       label_.set_tooltip_markup(tooltip_display_layout);
     } else {
       label_.set_tooltip_markup(display_layout);
@@ -129,7 +126,7 @@ auto Language::set_current_layout(std::string current_layout) -> void {
 auto Language::init_layouts_map(const std::vector<std::string>& used_layouts) -> void {
   std::map<std::string, std::vector<Layout*>> found_by_short_names;
   XKBContext xkb_context;
-  auto                                        layout = xkb_context.next_layout();
+  auto layout = xkb_context.next_layout();
   for (; layout != nullptr; layout = xkb_context.next_layout()) {
     if (std::find(used_layouts.begin(), used_layouts.end(), layout->full_name) ==
         used_layouts.end()) {
@@ -155,8 +152,7 @@ auto Language::init_layouts_map(const std::vector<std::string>& used_layouts) ->
   std::map<std::string, int> short_name_to_number_map;
   for (const auto& used_layout_name : used_layouts) {
     auto found = layouts_map_.find(used_layout_name);
-    if (found == layouts_map_.end())
+    if (found == layouts_map_.end()) continue;
-      continue;
     auto used_layout = &found->second;
     auto layouts_with_same_name_list = found_by_short_names[used_layout->short_name];
     if (layouts_with_same_name_list.size() < 2) {
@@ -169,10 +165,8 @@ auto Language::init_layouts_map(const std::vector<std::string>& used_layouts) ->
 
     if (displayed_short_flag != static_cast<std::byte>(0)) {
       int& number = short_name_to_number_map[used_layout->short_name];
-      used_layout->short_name =
+      used_layout->short_name = used_layout->short_name + std::to_string(number);
-          used_layout->short_name + std::to_string(number);
+      used_layout->short_description = used_layout->short_description + std::to_string(number);
-      used_layout->short_description =
-          used_layout->short_description + std::to_string(number);
       ++number;
     }
   }
@@ -194,18 +188,19 @@ auto Language::XKBContext::next_layout() -> Layout* {
     return nullptr;
   }
 
-  auto        description = std::string(rxkb_layout_get_description(xkb_layout_));
+  auto description = std::string(rxkb_layout_get_description(xkb_layout_));
-  auto        name = std::string(rxkb_layout_get_name(xkb_layout_));
+  auto name = std::string(rxkb_layout_get_name(xkb_layout_));
-  auto        variant_ = rxkb_layout_get_variant(xkb_layout_);
+  auto variant_ = rxkb_layout_get_variant(xkb_layout_);
   std::string variant = variant_ == nullptr ? "" : std::string(variant_);
-  auto        short_description_ = rxkb_layout_get_brief(xkb_layout_);
+  auto short_description_ = rxkb_layout_get_brief(xkb_layout_);
   std::string short_description;
   if (short_description_ != nullptr) {
     short_description = std::string(short_description_);
     base_layouts_by_name_.emplace(name, xkb_layout_);
   } else {
     auto base_layout = base_layouts_by_name_[name];
-    short_description = base_layout == nullptr ? "" : std::string(rxkb_layout_get_brief(base_layout));
+    short_description =
+        base_layout == nullptr ? "" : std::string(rxkb_layout_get_brief(base_layout));
   }
   delete layout_;
   layout_ = new Layout{description, name, variant, short_description};

src/modules/sway/mode.cpp

@@ -1,4 +1,5 @@
 #include "modules/sway/mode.hpp"
+
 #include <spdlog/spdlog.h>
 
 namespace waybar::modules::sway {
@@ -21,7 +22,7 @@ Mode::Mode(const std::string& id, const Json::Value& config)
 void Mode::onEvent(const struct Ipc::ipc_response& res) {
   try {
     std::lock_guard<std::mutex> lock(mutex_);
-    auto                        payload = parser_.parse(res.payload);
+    auto payload = parser_.parse(res.payload);
     if (payload["change"] != "default") {
       if (payload["pango_markup"].asBool()) {
         mode_ = payload["change"].asString();

src/modules/sway/window.cpp

@@ -70,11 +70,11 @@ std::optional<Glib::ustring> getIconName(const std::string& app_id) {
     }
     return icon_name;
   } catch (Glib::FileError& error) {
-    spdlog::warn(
+    spdlog::warn("Error while loading desktop file {}: {}", desktop_file_path.value(),
-        "Error while loading desktop file {}: {}", desktop_file_path.value(), error.what().c_str());
+                 error.what().c_str());
   } catch (Glib::KeyFileError& error) {
-    spdlog::warn(
+    spdlog::warn("Error while loading desktop file {}: {}", desktop_file_path.value(),
-        "Error while loading desktop file {}: {}", desktop_file_path.value(), error.what().c_str());
+                 error.what().c_str());
   }
   return {};
 }
@@ -114,8 +114,8 @@ auto Window::update() -> void {
     bar_.window.get_style_context()->remove_class("solo");
     bar_.window.get_style_context()->remove_class("empty");
   }
-  label_.set_markup(fmt::format(format_, fmt::arg("title", rewriteTitle(window_)),
+  label_.set_markup(
-                                fmt::arg("app_id", app_id_)));
+      fmt::format(format_, fmt::arg("title", rewriteTitle(window_)), fmt::arg("app_id", app_id_)));
   if (tooltipEnabled()) {
     label_.set_tooltip_text(window_);
   }
@@ -126,28 +126,26 @@ auto Window::update() -> void {
 int leafNodesInWorkspace(const Json::Value& node) {
   auto const& nodes = node["nodes"];
   auto const& floating_nodes = node["floating_nodes"];
-  if(nodes.empty() && floating_nodes.empty()) {
+  if (nodes.empty() && floating_nodes.empty()) {
-    if(node["type"] == "workspace")
+    if (node["type"] == "workspace")
       return 0;
     else
       return 1;
   }
   int sum = 0;
   if (!nodes.empty()) {
-    for(auto const& node : nodes)
+    for (auto const& node : nodes) sum += leafNodesInWorkspace(node);
-      sum += leafNodesInWorkspace(node);
   }
   if (!floating_nodes.empty()) {
-    for(auto const& node : floating_nodes)
+    for (auto const& node : floating_nodes) sum += leafNodesInWorkspace(node);
-      sum += leafNodesInWorkspace(node);
   }
   return sum;
 }
 
 std::tuple<std::size_t, int, std::string, std::string> gfnWithWorkspace(
-    const Json::Value& nodes, std::string& output, const Json::Value& config_,
+    const Json::Value& nodes, std::string& output, const Json::Value& config_, const Bar& bar_,
-    const Bar& bar_, Json::Value& parentWorkspace) {
+    Json::Value& parentWorkspace) {
-  for(auto const& node : nodes) {
+  for (auto const& node : nodes) {
     if (node["output"].isString()) {
       output = node["output"].asString();
     }
@@ -156,25 +154,22 @@ std::tuple<std::size_t, int, std::string, std::string> gfnWithWorkspace(
       if ((!config_["all-outputs"].asBool() && output == bar_.output->name) ||
           config_["all-outputs"].asBool()) {
         auto app_id = node["app_id"].isString() ? node["app_id"].asString()
-                      : node["window_properties"]["instance"].asString();
+                                                : node["window_properties"]["instance"].asString();
         int nb = node.size();
-        if(parentWorkspace != 0)
+        if (parentWorkspace != 0) nb = leafNodesInWorkspace(parentWorkspace);
-          nb = leafNodesInWorkspace(parentWorkspace);
+        return {nb, node["id"].asInt(), Glib::Markup::escape_text(node["name"].asString()), app_id};
-        return {nb,
-          node["id"].asInt(),
-          Glib::Markup::escape_text(node["name"].asString()),
-          app_id};
       }
     }
     // iterate
-    if(node["type"] == "workspace")
+    if (node["type"] == "workspace") parentWorkspace = node;
-      parentWorkspace = node;
+    auto [nb, id, name, app_id] =
-    auto [nb, id, name, app_id] = gfnWithWorkspace(node["nodes"], output, config_, bar_, parentWorkspace);
+        gfnWithWorkspace(node["nodes"], output, config_, bar_, parentWorkspace);
     if (id > -1 && !name.empty()) {
       return {nb, id, name, app_id};
     }
     // Search for floating node
-    std::tie(nb, id, name, app_id) = gfnWithWorkspace(node["floating_nodes"], output, config_, bar_, parentWorkspace);
+    std::tie(nb, id, name, app_id) =
+        gfnWithWorkspace(node["floating_nodes"], output, config_, bar_, parentWorkspace);
     if (id > -1 && !name.empty()) {
       return {nb, id, name, app_id};
     }

src/modules/sway/workspaces.cpp

@@ -13,7 +13,7 @@ namespace waybar::modules::sway {
 int Workspaces::convertWorkspaceNameToNum(std::string name) {
   if (isdigit(name[0])) {
     errno = 0;
-    char *    endptr = NULL;
+    char *endptr = NULL;
     long long parsed_num = strtoll(name.c_str(), &endptr, 10);
     if (errno != 0 || parsed_num > INT32_MAX || parsed_num < 0 || endptr == name.c_str()) {
       return -1;
@@ -65,11 +65,9 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
     try {
       {
         std::lock_guard<std::mutex> lock(mutex_);
-        auto                        payload = parser_.parse(res.payload);
+        auto payload = parser_.parse(res.payload);
         workspaces_.clear();
-        std::copy_if(payload.begin(),
+        std::copy_if(payload.begin(), payload.end(), std::back_inserter(workspaces_),
-                     payload.end(),
-                     std::back_inserter(workspaces_),
                      [&](const auto &workspace) {
                        return !config_["all-outputs"].asBool()
                                   ? workspace["output"].asString() == bar_.output->name
@@ -78,12 +76,12 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
 
         // adding persistent workspaces (as per the config file)
         if (config_["persistent_workspaces"].isObject()) {
-          const Json::Value &            p_workspaces = config_["persistent_workspaces"];
+          const Json::Value &p_workspaces = config_["persistent_workspaces"];
           const std::vector<std::string> p_workspaces_names = p_workspaces.getMemberNames();
 
           for (const std::string &p_w_name : p_workspaces_names) {
             const Json::Value &p_w = p_workspaces[p_w_name];
-            auto               it =
+            auto it =
                 std::find_if(payload.begin(), payload.end(), [&p_w_name](const Json::Value &node) {
                   return node["name"].asString() == p_w_name;
                 });
@@ -133,10 +131,10 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
         // unnumbered workspaces behind numbered ones when computing the sort
         // attribute.
         int max_num = -1;
-        for (auto & workspace : workspaces_) {
+        for (auto &workspace : workspaces_) {
           max_num = std::max(workspace["num"].asInt(), max_num);
         }
-        for (auto & workspace : workspaces_) {
+        for (auto &workspace : workspaces_) {
           auto workspace_num = workspace["num"].asInt();
           if (workspace_num > -1) {
             workspace["sort"] = workspace_num;
@@ -144,13 +142,12 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
             workspace["sort"] = ++max_num;
           }
         }
-        std::sort(workspaces_.begin(),
+        std::sort(workspaces_.begin(), workspaces_.end(),
-                  workspaces_.end(),
                   [](const Json::Value &lhs, const Json::Value &rhs) {
                     auto lname = lhs["name"].asString();
                     auto rname = rhs["name"].asString();
-                    int  l = lhs["sort"].asInt();
+                    int l = lhs["sort"].asInt();
-                    int  r = rhs["sort"].asInt();
+                    int r = rhs["sort"].asInt();
 
                     if (l == r) {
                       // In case both integers are the same, lexicographical
@@ -161,7 +158,6 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
 
                     return l < r;
                   });
-
       }
       dp.emit();
     } catch (const std::exception &e) {
@@ -173,9 +169,8 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
 bool Workspaces::filterButtons() {
   bool needReorder = false;
   for (auto it = buttons_.begin(); it != buttons_.end();) {
-    auto ws = std::find_if(workspaces_.begin(), workspaces_.end(), [it](const auto &node) {
+    auto ws = std::find_if(workspaces_.begin(), workspaces_.end(),
-      return node["name"].asString() == it->first;
+                           [it](const auto &node) { return node["name"].asString() == it->first; });
-    });
     if (ws == workspaces_.end() ||
         (!config_["all-outputs"].asBool() && (*ws)["output"].asString() != bar_.output->name)) {
       it = buttons_.erase(it);
@@ -189,7 +184,7 @@ bool Workspaces::filterButtons() {
 
 auto Workspaces::update() -> void {
   std::lock_guard<std::mutex> lock(mutex_);
-  bool                        needReorder = filterButtons();
+  bool needReorder = filterButtons();
   for (auto it = workspaces_.begin(); it != workspaces_.end(); ++it) {
     auto bit = buttons_.find((*it)["name"].asString());
     if (bit == buttons_.end()) {
@@ -231,10 +226,8 @@ auto Workspaces::update() -> void {
     std::string output = (*it)["name"].asString();
     if (config_["format"].isString()) {
       auto format = config_["format"].asString();
-      output = fmt::format(format,
+      output = fmt::format(format, fmt::arg("icon", getIcon(output, *it)),
-                           fmt::arg("icon", getIcon(output, *it)),
+                           fmt::arg("value", output), fmt::arg("name", trimWorkspaceName(output)),
-                           fmt::arg("value", output),
-                           fmt::arg("name", trimWorkspaceName(output)),
                            fmt::arg("index", (*it)["num"].asString()));
     }
     if (!config_["disable-markup"].asBool()) {
@@ -249,7 +242,7 @@ auto Workspaces::update() -> void {
 }
 
 Gtk::Button &Workspaces::addButton(const Json::Value &node) {
-  auto   pair = buttons_.emplace(node["name"].asString(), node["name"].asString());
+  auto pair = buttons_.emplace(node["name"].asString(), node["name"].asString());
   auto &&button = pair.first->second;
   box_.pack_start(button, false, false, 0);
   button.set_name("sway-workspace-" + node["name"].asString());
@@ -258,22 +251,18 @@ Gtk::Button &Workspaces::addButton(const Json::Value &node) {
     button.signal_pressed().connect([this, node] {
       try {
         if (node["target_output"].isString()) {
-          ipc_.sendCmd(
+          ipc_.sendCmd(IPC_COMMAND,
-              IPC_COMMAND,
+                       fmt::format(workspace_switch_cmd_ + "; move workspace to output \"{}\"; " +
-              fmt::format(workspace_switch_cmd_ + "; move workspace to output \"{}\"; " + workspace_switch_cmd_,
+                                       workspace_switch_cmd_,
-                          "--no-auto-back-and-forth",
+                                   "--no-auto-back-and-forth", node["name"].asString(),
-                          node["name"].asString(),
+                                   node["target_output"].asString(), "--no-auto-back-and-forth",
-                          node["target_output"].asString(),
+                                   node["name"].asString()));
-                          "--no-auto-back-and-forth",
-                          node["name"].asString()));
         } else {
-          ipc_.sendCmd(
+          ipc_.sendCmd(IPC_COMMAND, fmt::format("workspace {} \"{}\"",
-              IPC_COMMAND,
+                                                config_["disable-auto-back-and-forth"].asBool()
-              fmt::format("workspace {} \"{}\"",
+                                                    ? "--no-auto-back-and-forth"
-                          config_["disable-auto-back-and-forth"].asBool()
+                                                    : "",
-                            ? "--no-auto-back-and-forth"
+                                                node["name"].asString()));
-                            : "",
-                          node["name"].asString()));
         }
       } catch (const std::exception &e) {
         spdlog::error("Workspaces: {}", e.what());
@@ -316,9 +305,8 @@ bool Workspaces::handleScroll(GdkEventScroll *e) {
   std::string name;
   {
     std::lock_guard<std::mutex> lock(mutex_);
-    auto it = std::find_if(workspaces_.begin(), workspaces_.end(), [](const auto &workspace) {
+    auto it = std::find_if(workspaces_.begin(), workspaces_.end(),
-      return workspace["focused"].asBool();
+                           [](const auto &workspace) { return workspace["focused"].asBool(); });
-    });
     if (it == workspaces_.end()) {
       return true;
     }
@@ -334,9 +322,7 @@ bool Workspaces::handleScroll(GdkEventScroll *e) {
     }
   }
   try {
-    ipc_.sendCmd(
+    ipc_.sendCmd(IPC_COMMAND, fmt::format(workspace_switch_cmd_, "--no-auto-back-and-forth", name));
-        IPC_COMMAND,
-        fmt::format(workspace_switch_cmd_, "--no-auto-back-and-forth", name));
   } catch (const std::exception &e) {
     spdlog::error("Workspaces: {}", e.what());
   }
@@ -344,7 +330,7 @@ bool Workspaces::handleScroll(GdkEventScroll *e) {
 }
 
 const std::string Workspaces::getCycleWorkspace(std::vector<Json::Value>::iterator it,
-                                                bool                               prev) const {
+                                                bool prev) const {
   if (prev && it == workspaces_.begin() && !config_["disable-scroll-wraparound"].asBool()) {
     return (*(--workspaces_.end()))["name"].asString();
   }

src/modules/temperature.cpp

@@ -1,4 +1,5 @@
 #include "modules/temperature.hpp"
+
 #include <filesystem>
 
 waybar::modules::Temperature::Temperature(const std::string& id, const Json::Value& config)
@@ -6,7 +7,10 @@ waybar::modules::Temperature::Temperature(const std::string& id, const Json::Val
   if (config_["hwmon-path"].isString()) {
     file_path_ = config_["hwmon-path"].asString();
   } else if (config_["hwmon-path-abs"].isString() && config_["input-filename"].isString()) {
-    file_path_ = (*std::filesystem::directory_iterator(config_["hwmon-path-abs"].asString())).path().string() + "/" + config_["input-filename"].asString();
+    file_path_ = (*std::filesystem::directory_iterator(config_["hwmon-path-abs"].asString()))
+                     .path()
+                     .string() +
+                 "/" + config_["input-filename"].asString();
   } else {
     auto zone = config_["thermal-zone"].isInt() ? config_["thermal-zone"].asInt() : 0;
     file_path_ = fmt::format("/sys/class/thermal/thermal_zone{}/temp", zone);
@@ -35,7 +39,7 @@ auto waybar::modules::Temperature::update() -> void {
     label_.get_style_context()->remove_class("critical");
   }
 
-  if(format.empty()) {
+  if (format.empty()) {
     event_box_.hide();
     return;
   } else {
@@ -43,8 +47,7 @@ auto waybar::modules::Temperature::update() -> void {
   }
 
   auto max_temp = config_["critical-threshold"].isInt() ? config_["critical-threshold"].asInt() : 0;
-  label_.set_markup(fmt::format(format,
+  label_.set_markup(fmt::format(format, fmt::arg("temperatureC", temperature_c),
-                                fmt::arg("temperatureC", temperature_c),
                                 fmt::arg("temperatureF", temperature_f),
                                 fmt::arg("temperatureK", temperature_k),
                                 fmt::arg("icon", getIcon(temperature_c, "", max_temp))));
@@ -53,10 +56,9 @@ auto waybar::modules::Temperature::update() -> void {
     if (config_["tooltip-format"].isString()) {
       tooltip_format = config_["tooltip-format"].asString();
     }
-    label_.set_tooltip_text(fmt::format(tooltip_format,
+    label_.set_tooltip_text(fmt::format(tooltip_format, fmt::arg("temperatureC", temperature_c),
-                                fmt::arg("temperatureC", temperature_c),
+                                        fmt::arg("temperatureF", temperature_f),
-                                fmt::arg("temperatureF", temperature_f),
+                                        fmt::arg("temperatureK", temperature_k)));
-                                fmt::arg("temperatureK", temperature_k)));
   }
   // Call parent update
   ALabel::update();
@@ -72,7 +74,7 @@ float waybar::modules::Temperature::getTemperature() {
     getline(temp, line);
   }
   temp.close();
-  auto                           temperature_c = std::strtol(line.c_str(), nullptr, 10) / 1000.0;
+  auto temperature_c = std::strtol(line.c_str(), nullptr, 10) / 1000.0;
   return temperature_c;
 }
 

src/modules/upower/upower.cpp

@@ -68,13 +68,9 @@ UPower::UPower(const std::string& id, const Json::Value& config)
     box_.signal_query_tooltip().connect(sigc::mem_fun(*this, &UPower::show_tooltip_callback));
   }
 
-  upowerWatcher_id = g_bus_watch_name(G_BUS_TYPE_SYSTEM,
+  upowerWatcher_id = g_bus_watch_name(G_BUS_TYPE_SYSTEM, "org.freedesktop.UPower",
-                                      "org.freedesktop.UPower",
+                                      G_BUS_NAME_WATCHER_FLAGS_AUTO_START, upowerAppear,
-                                      G_BUS_NAME_WATCHER_FLAGS_AUTO_START,
+                                      upowerDisappear, this, NULL);
-                                      upowerAppear,
-                                      upowerDisappear,
-                                      this,
-                                      NULL);
 
   GError* error = NULL;
   client = up_client_new_full(NULL, &error);
@@ -87,16 +83,10 @@ UPower::UPower(const std::string& id, const Json::Value& config)
   if (!login1_connection) {
     throw std::runtime_error("Unable to connect to the SYSTEM Bus!...");
   } else {
-    login1_id = g_dbus_connection_signal_subscribe(login1_connection,
+    login1_id = g_dbus_connection_signal_subscribe(
-                                                   "org.freedesktop.login1",
+        login1_connection, "org.freedesktop.login1", "org.freedesktop.login1.Manager",
-                                                   "org.freedesktop.login1.Manager",
+        "PrepareForSleep", "/org/freedesktop/login1", NULL, G_DBUS_SIGNAL_FLAGS_NONE,
-                                                   "PrepareForSleep",
+        prepareForSleep_cb, this, NULL);
-                                                   "/org/freedesktop/login1",
-                                                   NULL,
-                                                   G_DBUS_SIGNAL_FLAGS_NONE,
-                                                   prepareForSleep_cb,
-                                                   this,
-                                                   NULL);
   }
 
   event_box_.signal_button_press_event().connect(sigc::mem_fun(*this, &UPower::handleToggle));
@@ -284,26 +274,15 @@ auto UPower::update() -> void {
   // Don't update widget if the UPower service isn't running
   if (!upowerRunning) return;
 
-  UpDeviceKind  kind;
+  UpDeviceKind kind;
   UpDeviceState state;
-  double        percentage;
+  double percentage;
-  gint64        time_empty;
+  gint64 time_empty;
-  gint64        time_full;
+  gint64 time_full;
-  gchar*        icon_name;
+  gchar* icon_name;
 
-  g_object_get(displayDevice,
+  g_object_get(displayDevice, "kind", &kind, "state", &state, "percentage", &percentage,
-               "kind",
+               "icon-name", &icon_name, "time-to-empty", &time_empty, "time-to-full", &time_full,
-               &kind,
-               "state",
-               &state,
-               "percentage",
-               &percentage,
-               "icon-name",
-               &icon_name,
-               "time-to-empty",
-               &time_empty,
-               "time-to-full",
-               &time_full,
                NULL);
 
   bool displayDeviceValid =
@@ -357,9 +336,9 @@ auto UPower::update() -> void {
     default:
       break;
   }
-  std::string label_format = fmt::format(showAltText ? format_alt : format,
+  std::string label_format =
-                                         fmt::arg("percentage", percentString),
+      fmt::format(showAltText ? format_alt : format, fmt::arg("percentage", percentString),
-                                         fmt::arg("time", time_format));
+                  fmt::arg("time", time_format));
   // Only set the label text if it doesn't only contain spaces
   bool onlySpaces = true;
   for (auto& character : label_format) {

src/modules/upower/upower_tooltip.cpp

@@ -35,7 +35,7 @@ uint UPowerTooltip::updateTooltip(Devices& devices) {
   uint deviceCount = 0;
   // Adds all valid devices
   for (auto pair : devices) {
-    UpDevice*   device = pair.second;
+    UpDevice* device = pair.second;
     std::string objectPath = pair.first;
 
     if (!G_IS_OBJECT(device)) continue;
@@ -43,23 +43,13 @@ uint UPowerTooltip::updateTooltip(Devices& devices) {
     Gtk::Box* box = new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL, tooltipSpacing);
 
     UpDeviceKind kind;
-    double       percentage;
+    double percentage;
-    gchar*       native_path;
+    gchar* native_path;
-    gchar*       model;
+    gchar* model;
-    gchar*       icon_name;
+    gchar* icon_name;
 
-    g_object_get(device,
+    g_object_get(device, "kind", &kind, "percentage", &percentage, "native-path", &native_path,
-                 "kind",
+                 "model", &model, "icon-name", &icon_name, NULL);
-                 &kind,
-                 "percentage",
-                 &percentage,
-                 "native-path",
-                 &native_path,
-                 "model",
-                 &model,
-                 "icon-name",
-                 &icon_name,
-                 NULL);
 
     // Skip Line_Power and BAT0 devices
     if (kind == UP_DEVICE_KIND_LINE_POWER || native_path == NULL || strlen(native_path) == 0 ||

src/modules/wlr/workspace_manager.cpp

@@ -13,8 +13,8 @@
 
 namespace waybar::modules::wlr {
 
-uint32_t                           WorkspaceGroup::workspace_global_id = 0;
+uint32_t WorkspaceGroup::workspace_global_id = 0;
-uint32_t                           WorkspaceManager::group_global_id = 0;
+uint32_t WorkspaceManager::group_global_id = 0;
 std::map<std::string, std::string> Workspace::icons_map_;
 
 WorkspaceManager::WorkspaceManager(const std::string &id, const waybar::Bar &bar,
@@ -156,8 +156,7 @@ WorkspaceManager::~WorkspaceManager() {
 }
 
 auto WorkspaceManager::remove_workspace_group(uint32_t id) -> void {
-  auto it = std::find_if(groups_.begin(),
+  auto it = std::find_if(groups_.begin(), groups_.end(),
-                         groups_.end(),
                          [id](const std::unique_ptr<WorkspaceGroup> &g) { return g->id() == id; });
 
   if (it == groups_.end()) {
@@ -170,7 +169,7 @@ auto WorkspaceManager::remove_workspace_group(uint32_t id) -> void {
 auto WorkspaceManager::commit() -> void { zext_workspace_manager_v1_commit(workspace_manager_); }
 
 WorkspaceGroup::WorkspaceGroup(const Bar &bar, Gtk::Box &box, const Json::Value &config,
-                               WorkspaceManager               &manager,
+                               WorkspaceManager &manager,
                                zext_workspace_group_handle_v1 *workspace_group_handle, uint32_t id)
     : bar_(bar),
       box_(box),
@@ -257,8 +256,7 @@ auto WorkspaceGroup::update() -> void {
 }
 
 auto WorkspaceGroup::remove_workspace(uint32_t id) -> void {
-  auto it = std::find_if(workspaces_.begin(),
+  auto it = std::find_if(workspaces_.begin(), workspaces_.end(),
-                         workspaces_.end(),
                          [id](const std::unique_ptr<Workspace> &w) { return w->id() == id; });
 
   if (it == workspaces_.end()) {
@@ -353,8 +351,8 @@ Workspace::~Workspace() {
 }
 
 auto Workspace::update() -> void {
-  label_.set_markup(fmt::format(
+  label_.set_markup(fmt::format(format_, fmt::arg("name", name_),
-      format_, fmt::arg("name", name_), fmt::arg("icon", with_icon_ ? get_icon() : "")));
+                                fmt::arg("icon", with_icon_ ? get_icon() : "")));
 }
 
 auto Workspace::handle_state(const std::vector<uint32_t> &state) -> void {

src/modules/wlr/workspace_manager_binding.cpp

@@ -1,6 +1,7 @@
 #include "modules/wlr/workspace_manager_binding.hpp"
 
 #include <spdlog/spdlog.h>
+
 #include <cstdint>
 
 #include "client.hpp"
@@ -23,7 +24,7 @@ static const wl_registry_listener registry_listener_impl = {.global = handle_glo
                                                             .global_remove = handle_global_remove};
 
 void add_registry_listener(void *data) {
-  wl_display * display = Client::inst()->wl_display;
+  wl_display *display = Client::inst()->wl_display;
   wl_registry *registry = wl_display_get_registry(display);
 
   wl_registry_add_listener(registry, &registry_listener_impl, data);
@@ -89,7 +90,7 @@ static const zext_workspace_group_handle_v1_listener workspace_group_impl = {
     .remove = workspace_group_handle_remove};
 
 void add_workspace_group_listener(zext_workspace_group_handle_v1 *workspace_group_handle,
-                                  void *                          data) {
+                                  void *data) {
   zext_workspace_group_handle_v1_add_listener(workspace_group_handle, &workspace_group_impl, data);
 }
 
@@ -100,7 +101,7 @@ void workspace_handle_name(void *data, struct zext_workspace_handle_v1 *_, const
 void workspace_handle_coordinates(void *data, struct zext_workspace_handle_v1 *_,
                                   struct wl_array *coordinates) {
   std::vector<uint32_t> coords_vec;
-  auto                  coords = static_cast<uint32_t *>(coordinates->data);
+  auto coords = static_cast<uint32_t *>(coordinates->data);
   for (size_t i = 0; i < coordinates->size / sizeof(uint32_t); ++i) {
     coords_vec.push_back(coords[i]);
   }
@@ -111,7 +112,7 @@ void workspace_handle_coordinates(void *data, struct zext_workspace_handle_v1 *_
 void workspace_handle_state(void *data, struct zext_workspace_handle_v1 *workspace_handle,
                             struct wl_array *state) {
   std::vector<uint32_t> state_vec;
-  auto                  states = static_cast<uint32_t *>(state->data);
+  auto states = static_cast<uint32_t *>(state->data);
   for (size_t i = 0; i < state->size / sizeof(uint32_t); ++i) {
     state_vec.push_back(states[i]);
   }

src/util/rfkill.cpp

@@ -39,8 +39,8 @@ waybar::util::Rfkill::Rfkill(const enum rfkill_type rfkill_type) : rfkill_type_(
     fd_ = -1;
     return;
   }
-  Glib::signal_io().connect(
+  Glib::signal_io().connect(sigc::mem_fun(*this, &Rfkill::on_event), fd_,
-      sigc::mem_fun(*this, &Rfkill::on_event), fd_, Glib::IO_IN | Glib::IO_ERR | Glib::IO_HUP);
+                            Glib::IO_IN | Glib::IO_ERR | Glib::IO_HUP);
 }
 
 waybar::util::Rfkill::~Rfkill() {
@@ -52,7 +52,7 @@ waybar::util::Rfkill::~Rfkill() {
 bool waybar::util::Rfkill::on_event(Glib::IOCondition cond) {
   if (cond & Glib::IO_IN) {
     struct rfkill_event event;
-    ssize_t             len;
+    ssize_t len;
 
     len = read(fd_, &event, sizeof(event));
     if (len < 0) {

src/util/ustring_clen.cpp

@@ -1,6 +1,6 @@
 #include "util/ustring_clen.hpp"
 
-int ustring_clen(const Glib::ustring &str){
+int ustring_clen(const Glib::ustring &str) {
   int total = 0;
   for (auto i = str.begin(); i != str.end(); ++i) {
     total += g_unichar_iswide(*i) + 1;

test/SafeSignal.cpp

@@ -20,12 +20,12 @@ using remove_cvref_t = typename std::remove_cv<typename std::remove_reference<T>
  */
 TEST_CASE_METHOD(GlibTestsFixture, "SafeSignal basic functionality", "[signal][thread][util]") {
   const int NUM_EVENTS = 100;
-  int       count = 0;
+  int count = 0;
-  int       last_value = 0;
+  int last_value = 0;
 
   SafeSignal<int, std::string> test_signal;
 
-  const auto  main_tid = std::this_thread::get_id();
+  const auto main_tid = std::this_thread::get_id();
   std::thread producer;
 
   // timeout the test in 500ms
@@ -63,7 +63,7 @@ TEST_CASE_METHOD(GlibTestsFixture, "SafeSignal basic functionality", "[signal][t
 
 template <typename T>
 struct TestObject {
-  T        value;
+  T value;
   unsigned copied = 0;
   unsigned moved = 0;
 
@@ -93,7 +93,7 @@ struct TestObject {
   }
 
   bool operator==(T other) const { return value == other; }
-       operator T() const { return value; }
+  operator T() const { return value; }
 };
 
 /*
@@ -101,7 +101,7 @@ struct TestObject {
  */
 TEST_CASE_METHOD(GlibTestsFixture, "SafeSignal copy/move counter", "[signal][thread][util]") {
   const int NUM_EVENTS = 3;
-  int       count = 0;
+  int count = 0;
 
   SafeSignal<TestObject<int>> test_signal;
 

test/main.cpp

@@ -12,7 +12,7 @@ int main(int argc, char* argv[]) {
   Glib::init();
 
   session.applyCommandLine(argc, argv);
-  const auto  logger = spdlog::default_logger();
+  const auto logger = spdlog::default_logger();
   const auto& reporter_name = session.config().getReporterName();
   if (reporter_name == "tap") {
     spdlog::set_pattern("# [%l] %v");