refactor: lint

.clang-format

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

include/ALabel.hpp

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

include/AModule.hpp

@@ -51,8 +51,7 @@ class AModule : public IModule {
       {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_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/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"

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"

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"
 

include/modules/clock.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <date/tz.h>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 

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"
 

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"

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"

include/modules/inhibitor.hpp

@@ -1,9 +1,9 @@
 #pragma once
 
-#include <memory>
-
 #include <gio/gio.h>
 
+#include <memory>
+
 #include "ALabel.hpp"
 #include "bar.hpp"
 

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>

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"
 

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>

include/modules/mpd/state.inl.hpp

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

include/modules/network.hpp

@@ -7,6 +7,7 @@
 #include <netlink/genl/genl.h>
 #include <netlink/netlink.h>
 #include <sys/epoll.h>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 #ifdef WANT_RFKILL

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 {

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 {

include/modules/sndio.hpp

@@ -1,7 +1,9 @@
 #pragma once
 
 #include <sndio.h>
+
 #include <vector>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 

include/modules/sni/host.hpp

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

include/modules/sni/tray.hpp

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

include/modules/sway/ipc/client.hpp

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

include/modules/sway/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;
@@ -40,6 +36,7 @@ class Language : public ALabel, public sigc::trackable {
     XKBContext();
     ~XKBContext();
     auto next_layout() -> Layout*;
+
    private:
     rxkb_context* context_ = nullptr;
     rxkb_layout* xkb_layout_ = nullptr;

include/modules/sway/mode.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include "ALabel.hpp"
 #include "bar.hpp"
 #include "client.hpp"

include/modules/sway/window.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include <tuple>
 
 #include "AIconLabel.hpp"

include/modules/sway/workspaces.hpp

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

include/modules/temperature.hpp

@@ -1,7 +1,9 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include <fstream>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 

include/modules/wlr/taskbar.hpp

@@ -1,37 +1,32 @@
 #pragma once
 
+#include <gdk/gdk.h>
+#include <glibmm/refptr.h>
+#include <gtkmm/box.h>
+#include <gtkmm/button.h>
+#include <gtkmm/icontheme.h>
+#include <gtkmm/image.h>
+#include <gtkmm/label.h>
+#include <wayland-client.h>
+
+#include <map>
+#include <memory>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "client.hpp"
 #include "giomm/desktopappinfo.h"
 #include "util/json.hpp"
-
-#include <memory>
-#include <string>
-#include <vector>
-#include <map>
-#include <unordered_set>
-
-#include <gdk/gdk.h>
-
-#include <glibmm/refptr.h>
-
-#include <gtkmm/box.h>
-#include <gtkmm/button.h>
-#include <gtkmm/image.h>
-#include <gtkmm/label.h>
-#include <gtkmm/icontheme.h>
-
-#include <wayland-client.h>
 #include "wlr-foreign-toplevel-management-unstable-v1-client-protocol.h"
 
-
 namespace waybar::modules::wlr {
 
 class Taskbar;
 
-class Task
+class Task {
-{
  public:
   Task(const waybar::Bar &, const Json::Value &, Taskbar *,
        struct zwlr_foreign_toplevel_handle_v1 *, struct wl_seat *);
@@ -83,7 +78,8 @@ class Task
   std::string repr() const;
   std::string state_string(bool = false) const;
   void set_app_info_from_app_id_list(const std::string &app_id_list);
-    bool image_load_icon(Gtk::Image& image, const Glib::RefPtr<Gtk::IconTheme>& icon_theme, Glib::RefPtr<Gio::DesktopAppInfo> app_info, int size);
+  bool image_load_icon(Gtk::Image &image, const Glib::RefPtr<Gtk::IconTheme> &icon_theme,
+                       Glib::RefPtr<Gio::DesktopAppInfo> app_info, int size);
   void hide_if_ignored();
 
  public:
@@ -128,9 +124,7 @@ class Task
 
 using TaskPtr = std::unique_ptr<Task>;
 
-
+class Taskbar : public waybar::AModule {
-class Taskbar : public waybar::AModule
-{
  public:
   Taskbar(const std::string &, const waybar::Bar &, const Json::Value &);
   ~Taskbar();

include/modules/wlr/workspace_manager_binding.hpp

@@ -3,6 +3,8 @@
 namespace waybar::modules::wlr {
 void add_registry_listener(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/clara.hpp

@@ -27,7 +27,6 @@
 #endif
 #endif
 
-
 // ----------- #included from clara_textflow.hpp -----------
 
 // TextFlowCpp
@@ -51,8 +50,8 @@
 #define CLARA_TEXTFLOW_CONFIG_CONSOLE_WIDTH 80
 #endif
 
-
+namespace clara {
-namespace clara { namespace TextFlow {
+namespace TextFlow {
 
 inline auto isWhitespace(char c) -> bool {
   static std::string chars = " \t\n\r";
@@ -88,9 +87,7 @@ namespace clara { namespace TextFlow {
     bool m_suffix = false;
 
     iterator(Column const &column, size_t stringIndex)
-            :   m_column( column ),
+        : m_column(column), m_stringIndex(stringIndex) {}
-                m_stringIndex( stringIndex )
-            {}
 
     auto line() const -> std::string const & { return m_column.m_strings[m_stringIndex]; }
 
@@ -98,10 +95,8 @@ namespace clara { namespace TextFlow {
       assert(at > 0);
       assert(at <= line().size());
 
-                return at == line().size() ||
+      return at == line().size() || (isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
-                       ( isWhitespace( line()[at] ) && !isWhitespace( line()[at-1] ) ) ||
+             isBreakableBefore(line()[at]) || isBreakableAfter(line()[at - 1]);
-                       isBreakableBefore( line()[at] ) ||
-                       isBreakableAfter( line()[at-1] );
     }
 
     void calcLength() {
@@ -110,18 +105,14 @@ namespace clara { namespace TextFlow {
       m_suffix = false;
       auto width = m_column.m_width - indent();
       m_end = m_pos;
-                while( m_end < line().size() && line()[m_end] != '\n' )
+      while (m_end < line().size() && line()[m_end] != '\n') ++m_end;
-                    ++m_end;
 
       if (m_end < m_pos + width) {
         m_len = m_end - m_pos;
-                }
+      } else {
-                else {
         size_t len = width;
-                    while (len > 0 && !isBoundary(m_pos + len))
+        while (len > 0 && !isBoundary(m_pos + len)) --len;
-                        --len;
+        while (len > 0 && isWhitespace(line()[m_pos + len - 1])) --len;
-                    while (len > 0 && isWhitespace( line()[m_pos + len - 1] ))
-                        --len;
 
         if (len > 0) {
           m_len = len;
@@ -133,7 +124,8 @@ namespace clara { namespace TextFlow {
     }
 
     auto indent() const -> size_t {
-                auto initial = m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
+      auto initial =
+          m_pos == 0 && m_stringIndex == 0 ? m_column.m_initialIndent : std::string::npos;
       return initial == std::string::npos ? m_column.m_indent : initial;
     }
 
@@ -150,10 +142,10 @@ namespace clara { namespace TextFlow {
 
     explicit iterator(Column const &column) : m_column(column) {
       assert(m_column.m_width > m_column.m_indent);
-                assert( m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent );
+      assert(m_column.m_initialIndent == std::string::npos ||
+             m_column.m_width > m_column.m_initialIndent);
       calcLength();
-                if( m_len == 0 )
+      if (m_len == 0) m_stringIndex++;  // Empty string
-                    m_stringIndex++; // Empty string
     }
 
     auto operator*() const -> std::string {
@@ -167,15 +159,13 @@ namespace clara { namespace TextFlow {
       if (m_pos < line().size() && line()[m_pos] == '\n')
         m_pos += 1;
       else
-                    while( m_pos < line().size() && isWhitespace( line()[m_pos] ) )
+        while (m_pos < line().size() && isWhitespace(line()[m_pos])) ++m_pos;
-                        ++m_pos;
 
       if (m_pos == line().size()) {
         m_pos = 0;
         ++m_stringIndex;
       }
-                if( m_stringIndex < m_column.m_strings.size() )
+      if (m_stringIndex < m_column.m_strings.size()) calcLength();
-                    calcLength();
       return *this;
     }
     auto operator++(int) -> iterator {
@@ -185,14 +175,10 @@ namespace clara { namespace TextFlow {
     }
 
     auto operator==(iterator const &other) const -> bool {
-                return
+      return m_pos == other.m_pos && m_stringIndex == other.m_stringIndex &&
-                    m_pos == other.m_pos &&
-                    m_stringIndex == other.m_stringIndex &&
              &m_column == &other.m_column;
     }
-            auto operator !=( iterator const& other ) const -> bool {
+    auto operator!=(iterator const &other) const -> bool { return !operator==(other); }
-                return !operator==( other );
-            }
   };
   using const_iterator = iterator;
 
@@ -238,18 +224,14 @@ namespace clara { namespace TextFlow {
 };
 
 class Spacer : public Column {
-
  public:
-        explicit Spacer( size_t spaceWidth ) : Column( "" ) {
+  explicit Spacer(size_t spaceWidth) : Column("") { width(spaceWidth); }
-            width( spaceWidth );
-        }
 };
 
 class Columns {
   std::vector<Column> m_columns;
 
  public:
-
   class iterator {
     friend Columns;
     struct EndTag {};
@@ -258,14 +240,10 @@ namespace clara { namespace TextFlow {
     std::vector<Column::iterator> m_iterators;
     size_t m_activeIterators;
 
-            iterator( Columns const& columns, EndTag )
+    iterator(Columns const &columns, EndTag) : m_columns(columns.m_columns), m_activeIterators(0) {
-            :   m_columns( columns.m_columns ),
-                m_activeIterators( 0 )
-            {
       m_iterators.reserve(m_columns.size());
 
-                for( auto const& col : m_columns )
+      for (auto const &col : m_columns) m_iterators.push_back(col.end());
-                    m_iterators.push_back( col.end() );
     }
 
    public:
@@ -276,13 +254,10 @@ namespace clara { namespace TextFlow {
     using iterator_category = std::forward_iterator_tag;
 
     explicit iterator(Columns const &columns)
-            :   m_columns( columns.m_columns ),
+        : m_columns(columns.m_columns), m_activeIterators(m_columns.size()) {
-                m_activeIterators( m_columns.size() )
-            {
       m_iterators.reserve(m_columns.size());
 
-                for( auto const& col : m_columns )
+      for (auto const &col : m_columns) m_iterators.push_back(col.begin());
-                    m_iterators.push_back( col.begin() );
     }
 
     auto operator==(iterator const &other) const -> bool {
@@ -303,8 +278,7 @@ namespace clara { namespace TextFlow {
             padding = std::string(width - col.size(), ' ');
           else
             padding = "";
-                    }
+        } else {
-                    else {
           padding += std::string(width, ' ');
         }
       }
@@ -312,8 +286,7 @@ namespace clara { namespace TextFlow {
     }
     auto operator++() -> iterator & {
       for (size_t i = 0; i < m_columns.size(); ++i) {
-                    if (m_iterators[i] != m_columns[i].end())
+        if (m_iterators[i] != m_columns[i].end()) ++m_iterators[i];
-                        ++m_iterators[i];
       }
       return *this;
     }
@@ -339,7 +312,6 @@ namespace clara { namespace TextFlow {
   }
 
   inline friend std::ostream &operator<<(std::ostream &os, Columns const &cols) {
-
     bool first = true;
     for (auto line : cols) {
       if (first)
@@ -364,19 +336,20 @@ namespace clara { namespace TextFlow {
   cols += other;
   return cols;
 }
-}}
+}  // namespace TextFlow
+}  // namespace clara
 
 #endif  // CLARA_TEXTFLOW_HPP_INCLUDED
 
 // ----------- end of #include from clara_textflow.hpp -----------
 // ........... back in clara.hpp
 
-
+#include <algorithm>
 #include <memory>
 #include <set>
-#include <algorithm>
 
-#if !defined(CLARA_PLATFORM_WINDOWS) && ( defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) )
+#if !defined(CLARA_PLATFORM_WINDOWS) && \
+    (defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER))
 #define CLARA_PLATFORM_WINDOWS
 #endif
 
@@ -408,25 +381,17 @@ namespace detail {
   std::vector<std::string> m_args;
 
  public:
-        Args( int argc, char const* const* argv )
+  Args(int argc, char const *const *argv) : m_exeName(argv[0]), m_args(argv + 1, argv + argc) {}
-            : m_exeName(argv[0]),
-              m_args(argv + 1, argv + argc) {}
 
   Args(std::initializer_list<std::string> args)
-        :   m_exeName( *args.begin() ),
+      : m_exeName(*args.begin()), m_args(args.begin() + 1, args.end()) {}
-            m_args( args.begin()+1, args.end() )
-        {}
 
-        auto exeName() const -> std::string {
+  auto exeName() const -> std::string { return m_exeName; }
-            return m_exeName;
-        }
 };
 
-    // Wraps a token coming from a token stream. These may not directly correspond to strings as a single string
+// Wraps a token coming from a token stream. These may not directly correspond to strings as a
-    // may encode an option + its argument if the : or = form is used
+// single string may encode an option + its argument if the : or = form is used
-    enum class TokenType {
+enum class TokenType { Option, Argument };
-        Option, Argument
-    };
 struct Token {
   TokenType type;
   std::string token;
@@ -451,8 +416,7 @@ namespace detail {
     m_tokenBuffer.resize(0);
 
     // Skip any empty strings
-            while( it != itEnd && it->empty() )
+    while (it != itEnd && it->empty()) ++it;
-                ++it;
 
     if (it != itEnd) {
       auto const &next = *it;
@@ -481,13 +445,9 @@ namespace detail {
  public:
   explicit TokenStream(Args const &args) : TokenStream(args.m_args.begin(), args.m_args.end()) {}
 
-        TokenStream( Iterator it, Iterator itEnd ) : it( it ), itEnd( itEnd ) {
+  TokenStream(Iterator it, Iterator itEnd) : it(it), itEnd(itEnd) { loadBuffer(); }
-            loadBuffer();
-        }
 
-        explicit operator bool() const {
+  explicit operator bool() const { return !m_tokenBuffer.empty() || it != itEnd; }
-            return !m_tokenBuffer.empty() || it != itEnd;
-        }
 
   auto count() const -> size_t { return m_tokenBuffer.size() + (itEnd - it); }
 
@@ -505,20 +465,16 @@ namespace detail {
     if (m_tokenBuffer.size() >= 2) {
       m_tokenBuffer.erase(m_tokenBuffer.begin());
     } else {
-                if( it != itEnd )
+      if (it != itEnd) ++it;
-                    ++it;
       loadBuffer();
     }
     return *this;
   }
 };
 
-
 class ResultBase {
  public:
-        enum Type {
+  enum Type { Ok, LogicError, RuntimeError };
-            Ok, LogicError, RuntimeError
-        };
 
  protected:
   ResultBase(Type type) : m_type(type) {}
@@ -541,26 +497,20 @@ namespace detail {
   ResultValueBase(Type type) : ResultBase(type) {}
 
   ResultValueBase(ResultValueBase const &other) : ResultBase(other) {
-            if( m_type == ResultBase::Ok )
+    if (m_type == ResultBase::Ok) new (&m_value) T(other.m_value);
-                new( &m_value ) T( other.m_value );
   }
 
-        ResultValueBase( Type, T const &value ) : ResultBase( Ok ) {
+  ResultValueBase(Type, T const &value) : ResultBase(Ok) { new (&m_value) T(value); }
-            new( &m_value ) T( value );
-        }
 
   auto operator=(ResultValueBase const &other) -> ResultValueBase & {
-            if( m_type == ResultBase::Ok )
+    if (m_type == ResultBase::Ok) m_value.~T();
-                m_value.~T();
     ResultBase::operator=(other);
-            if( m_type == ResultBase::Ok )
+    if (m_type == ResultBase::Ok) new (&m_value) T(other.m_value);
-                new( &m_value ) T( other.m_value );
     return *this;
   }
 
   ~ResultValueBase() override {
-            if( m_type == Ok )
+    if (m_type == Ok) m_value.~T();
-                m_value.~T();
   }
 
   union {
@@ -579,17 +529,21 @@ namespace detail {
  public:
   template <typename U>
   explicit BasicResult(BasicResult<U> const &other)
-        :   ResultValueBase<T>( other.type() ),
+      : ResultValueBase<T>(other.type()), m_errorMessage(other.errorMessage()) {
-            m_errorMessage( other.errorMessage() )
-        {
     assert(type() != ResultBase::Ok);
   }
 
   template <typename U>
-        static auto ok( U const &value ) -> BasicResult { return { ResultBase::Ok, value }; }
+  static auto ok(U const &value) -> BasicResult {
+    return {ResultBase::Ok, value};
+  }
   static auto ok() -> BasicResult { return {ResultBase::Ok}; }
-        static auto logicError( std::string const &message ) -> BasicResult { return { ResultBase::LogicError, message }; }
+  static auto logicError(std::string const &message) -> BasicResult {
-        static auto runtimeError( std::string const &message ) -> BasicResult { return { ResultBase::RuntimeError, message }; }
+    return {ResultBase::LogicError, message};
+  }
+  static auto runtimeError(std::string const &message) -> BasicResult {
+    return {ResultBase::RuntimeError, message};
+  }
 
   explicit operator bool() const { return m_type == ResultBase::Ok; }
   auto type() const -> ResultBase::Type { return m_type; }
@@ -597,21 +551,17 @@ namespace detail {
 
  protected:
   void enforceOk() const override {
-
     // Errors shouldn't reach this point, but if they do
     // the actual error message will be in m_errorMessage
     assert(m_type != ResultBase::LogicError);
     assert(m_type != ResultBase::RuntimeError);
-            if( m_type != ResultBase::Ok )
+    if (m_type != ResultBase::Ok) std::abort();
-                std::abort();
   }
 
   std::string m_errorMessage;  // Only populated if resultType is an error
 
   BasicResult(ResultBase::Type type, std::string const &message)
-        :   ResultValueBase<T>(type),
+      : ResultValueBase<T>(type), m_errorMessage(message) {
-            m_errorMessage(message)
-        {
     assert(m_type != ResultBase::Ok);
   }
 
@@ -619,17 +569,12 @@ namespace detail {
   using ResultBase::m_type;
 };
 
-    enum class ParseResultType {
+enum class ParseResultType { Matched, NoMatch, ShortCircuitAll, ShortCircuitSame };
-        Matched, NoMatch, ShortCircuitAll, ShortCircuitSame
-    };
 
 class ParseState {
  public:
-
   ParseState(ParseResultType type, TokenStream const &remainingTokens)
-        : m_type(type),
+      : m_type(type), m_remainingTokens(remainingTokens) {}
-          m_remainingTokens( remainingTokens )
-        {}
 
   auto type() const -> ParseResultType { return m_type; }
   auto remainingTokens() const -> TokenStream { return m_remainingTokens; }
@@ -664,22 +609,24 @@ namespace detail {
 }
 inline auto convertInto(std::string const &source, bool &target) -> ParserResult {
   std::string srcLC = source;
-        std::transform( srcLC.begin(), srcLC.end(), srcLC.begin(), []( char c ) { return static_cast<char>( ::tolower(c) ); } );
+  std::transform(srcLC.begin(), srcLC.end(), srcLC.begin(),
+                 [](char c) { return static_cast<char>(::tolower(c)); });
   if (srcLC == "y" || srcLC == "1" || srcLC == "true" || srcLC == "yes" || srcLC == "on")
     target = true;
   else if (srcLC == "n" || srcLC == "0" || srcLC == "false" || srcLC == "no" || srcLC == "off")
     target = false;
   else
-            return ParserResult::runtimeError( "Expected a boolean value but did not recognise: '" + source + "'" );
+    return ParserResult::runtimeError("Expected a boolean value but did not recognise: '" + source +
+                                      "'");
   return ParserResult::ok(ParseResultType::Matched);
 }
 #ifdef CLARA_CONFIG_OPTIONAL_TYPE
 template <typename T>
-    inline auto convertInto( std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T>& target ) -> ParserResult {
+inline auto convertInto(std::string const &source, CLARA_CONFIG_OPTIONAL_TYPE<T> &target)
+    -> ParserResult {
   T temp;
   auto result = convertInto(source, temp);
-        if( result )
+  if (result) target = std::move(temp);
-            target = std::move(temp);
   return result;
 }
 #endif  // CLARA_CONFIG_OPTIONAL_TYPE
@@ -711,9 +658,7 @@ namespace detail {
 
   explicit BoundValueRef(T &ref) : m_ref(ref) {}
 
-        auto setValue( std::string const &arg ) -> ParserResult override {
+  auto setValue(std::string const &arg) -> ParserResult override { return convertInto(arg, m_ref); }
-            return convertInto( arg, m_ref );
-        }
 };
 
 template <typename T>
@@ -727,8 +672,7 @@ namespace detail {
   auto setValue(std::string const &arg) -> ParserResult override {
     T temp;
     auto result = convertInto(arg, temp);
-            if( result )
+    if (result) m_ref.push_back(temp);
-                m_ref.push_back( temp );
     return result;
   }
 };
@@ -746,7 +690,8 @@ namespace detail {
 
 template <typename ReturnType>
 struct LambdaInvoker {
-        static_assert( std::is_same<ReturnType, ParserResult>::value, "Lambda must return void or clara::ParserResult" );
+  static_assert(std::is_same<ReturnType, ParserResult>::value,
+                "Lambda must return void or clara::ParserResult");
 
   template <typename L, typename ArgType>
   static auto invoke(L const &lambda, ArgType const &arg) -> ParserResult {
@@ -767,12 +712,10 @@ namespace detail {
 inline auto invokeLambda(L const &lambda, std::string const &arg) -> ParserResult {
   ArgType temp{};
   auto result = convertInto(arg, temp);
-        return !result
+  return !result ? result
-           ? result
                  : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke(lambda, temp);
 }
 
-
 template <typename L>
 struct BoundLambda : BoundValueRefBase {
   L m_lambda;
@@ -790,7 +733,8 @@ namespace detail {
   L m_lambda;
 
   static_assert(UnaryLambdaTraits<L>::isValid, "Supplied lambda must take exactly one argument");
-        static_assert( std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value, "flags must be boolean" );
+  static_assert(std::is_same<typename UnaryLambdaTraits<L>::ArgType, bool>::value,
+                "flags must be boolean");
 
   explicit BoundFlagLambda(L const &lambda) : m_lambda(lambda) {}
 
@@ -807,7 +751,8 @@ namespace detail {
  public:
   virtual ~ParserBase() = default;
   virtual auto validate() const -> Result { return Result::ok(); }
-        virtual auto parse( std::string const& exeName, TokenStream const &tokens) const -> InternalParseResult  = 0;
+  virtual auto parse(std::string const &exeName, TokenStream const &tokens) const
+      -> InternalParseResult = 0;
   virtual auto cardinality() const -> size_t { return 1; }
 
   auto parse(Args const &args) const -> InternalParseResult {
@@ -839,15 +784,11 @@ namespace detail {
  public:
   template <typename T>
   ParserRefImpl(T &ref, std::string const &hint)
-        :   m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
+      : m_ref(std::make_shared<BoundValueRef<T>>(ref)), m_hint(hint) {}
-            m_hint( hint )
-        {}
 
   template <typename LambdaT>
   ParserRefImpl(LambdaT const &ref, std::string const &hint)
-        :   m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
+      : m_ref(std::make_shared<BoundLambda<LambdaT>>(ref)), m_hint(hint) {}
-            m_hint(hint)
-        {}
 
   auto operator()(std::string const &description) -> DerivedT & {
     m_description = description;
@@ -864,9 +805,7 @@ namespace detail {
     return static_cast<DerivedT &>(*this);
   };
 
-        auto isOptional() const -> bool {
+  auto isOptional() const -> bool { return m_optionality == Optionality::Optional; }
-            return m_optionality == Optionality::Optional;
-        }
 
   auto cardinality() const -> size_t override {
     if (m_ref->isContainer())
@@ -906,11 +845,8 @@ namespace detail {
 
   auto name() const -> std::string { return *m_name; }
   auto set(std::string const &newName) -> ParserResult {
-
     auto lastSlash = newName.find_last_of("\\/");
-            auto filename = ( lastSlash == std::string::npos )
+    auto filename = (lastSlash == std::string::npos) ? newName : newName.substr(lastSlash + 1);
-                    ? newName
-                    : newName.substr( lastSlash+1 );
 
     *m_name = filename;
     if (m_ref)
@@ -926,8 +862,7 @@ namespace detail {
 
   auto parse(std::string const &, TokenStream const &tokens) const -> InternalParseResult override {
     auto validationResult = validate();
-            if( !validationResult )
+    if (!validationResult) return InternalParseResult(validationResult);
-                return InternalParseResult( validationResult );
 
     auto remainingTokens = tokens;
     auto const &token = *remainingTokens;
@@ -960,7 +895,8 @@ namespace detail {
 
  public:
   template <typename LambdaT>
-        explicit Opt( LambdaT const &ref ) : ParserRefImpl( std::make_shared<BoundFlagLambda<LambdaT>>( ref ) ) {}
+  explicit Opt(LambdaT const &ref)
+      : ParserRefImpl(std::make_shared<BoundFlagLambda<LambdaT>>(ref)) {}
 
   explicit Opt(bool &ref) : ParserRefImpl(std::make_shared<BoundFlagRef>(ref)) {}
 
@@ -985,16 +921,14 @@ namespace detail {
         oss << ", ";
       oss << opt;
     }
-            if( !m_hint.empty() )
+    if (!m_hint.empty()) oss << " <" << m_hint << ">";
-                oss << " <" << m_hint << ">";
     return {{oss.str(), m_description}};
   }
 
   auto isMatch(std::string const &optToken) const -> bool {
     auto normalisedToken = normaliseOpt(optToken);
     for (auto const &name : m_optNames) {
-                if( normaliseOpt( name ) == normalisedToken )
+      if (normaliseOpt(name) == normalisedToken) return true;
-                    return true;
     }
     return false;
   }
@@ -1003,8 +937,7 @@ namespace detail {
 
   auto parse(std::string const &, TokenStream const &tokens) const -> InternalParseResult override {
     auto validationResult = validate();
-            if( !validationResult )
+    if (!validationResult) return InternalParseResult(validationResult);
-                return InternalParseResult( validationResult );
 
     auto remainingTokens = tokens;
     if (remainingTokens && remainingTokens->type == TokenType::Option) {
@@ -1013,8 +946,7 @@ namespace detail {
         if (m_ref->isFlag()) {
           auto flagRef = static_cast<detail::BoundFlagRefBase *>(m_ref.get());
           auto result = flagRef->setFlag(true);
-                        if( !result )
+          if (!result) return InternalParseResult(result);
-                            return InternalParseResult( result );
           if (result.value() == ParseResultType::ShortCircuitAll)
             return InternalParseResult::ok(ParseState(result.value(), remainingTokens));
         } else {
@@ -1026,8 +958,7 @@ namespace detail {
           if (argToken.type != TokenType::Argument)
             return InternalParseResult::runtimeError("Expected argument following " + token.token);
           auto result = valueRef->setValue(argToken.token);
-                        if( !result )
+          if (!result) return InternalParseResult(result);
-                            return InternalParseResult( result );
           if (result.value() == ParseResultType::ShortCircuitAll)
             return InternalParseResult::ok(ParseState(result.value(), remainingTokens));
         }
@@ -1038,17 +969,14 @@ namespace detail {
   }
 
   auto validate() const -> Result override {
-            if( m_optNames.empty() )
+    if (m_optNames.empty()) return Result::logicError("No options supplied to Opt");
-                return Result::logicError( "No options supplied to Opt" );
     for (auto const &name : m_optNames) {
-                if( name.empty() )
+      if (name.empty()) return Result::logicError("Option name cannot be empty");
-                    return Result::logicError( "Option name cannot be empty" );
 #ifdef CLARA_PLATFORM_WINDOWS
       if (name[0] != '-' && name[0] != '/')
         return Result::logicError("Option name must begin with '-' or '/'");
 #else
-                if( name[0] != '-' )
+      if (name[0] != '-') return Result::logicError("Option name must begin with '-'");
-                    return Result::logicError( "Option name must begin with '-'" );
 #endif
     }
     return ParserRefImpl::validate();
@@ -1060,18 +988,12 @@ namespace detail {
       : Opt([&](bool flag) {
           showHelpFlag = flag;
           return ParserResult::ok(ParseResultType::ShortCircuitAll);
-            })
+        }) {
-        {
+    static_cast<Opt &> (*this)("display usage information")["-?"]["-h"]["--help"].optional();
-            static_cast<Opt &>( *this )
-                    ("display usage information")
-                    ["-?"]["-h"]["--help"]
-                    .optional();
   }
 };
 
-
 struct Parser : ParserBase {
-
   mutable ExeName m_exeName;
   std::vector<Opt> m_options;
   std::vector<Arg> m_args;
@@ -1104,9 +1026,13 @@ namespace detail {
 
   // Forward deprecated interface with '+' instead of '|'
   template <typename T>
-        auto operator+=( T const &other ) -> Parser & { return operator|=( other ); }
+  auto operator+=(T const &other) -> Parser & {
+    return operator|=(other);
+  }
   template <typename T>
-        auto operator+( T const &other ) const -> Parser { return operator|( other ); }
+  auto operator+(T const &other) const -> Parser {
+    return operator|(other);
+  }
 
   auto getHelpColumns() const -> std::vector<HelpColumns> {
     std::vector<HelpColumns> cols;
@@ -1119,7 +1045,8 @@ namespace detail {
 
   void writeToStream(std::ostream &os) const {
     if (!m_exeName.name().empty()) {
-                os << "usage:\n" << "  " << m_exeName.name() << " ";
+      os << "usage:\n"
+         << "  " << m_exeName.name() << " ";
       bool required = true, first = true;
       for (auto const &arg : m_args) {
         if (first)
@@ -1131,28 +1058,22 @@ namespace detail {
           required = false;
         }
         os << "<" << arg.hint() << ">";
-                    if( arg.cardinality() == 0 )
+        if (arg.cardinality() == 0) os << " ... ";
-                        os << " ... ";
       }
-                if( !required )
+      if (!required) os << "]";
-                    os << "]";
+      if (!m_options.empty()) os << " options";
-                if( !m_options.empty() )
-                    os << " options";
       os << "\n\nwhere options are:" << std::endl;
     }
 
     auto rows = getHelpColumns();
     size_t consoleWidth = CLARA_CONFIG_CONSOLE_WIDTH;
     size_t optWidth = 0;
-            for( auto const &cols : rows )
+    for (auto const &cols : rows) optWidth = (std::max)(optWidth, cols.left.size() + 2);
-                optWidth = (std::max)(optWidth, cols.left.size() + 2);
 
     optWidth = (std::min)(optWidth, consoleWidth / 2);
 
     for (auto const &cols : rows) {
-                auto row =
+      auto row = TextFlow::Column(cols.left).width(optWidth).indent(2) + TextFlow::Spacer(4) +
-                        TextFlow::Column( cols.left ).width( optWidth ).indent( 2 ) +
-                        TextFlow::Spacer(4) +
                  TextFlow::Column(cols.right).width(consoleWidth - 7 - optWidth);
       os << row << std::endl;
     }
@@ -1166,21 +1087,19 @@ namespace detail {
   auto validate() const -> Result override {
     for (auto const &opt : m_options) {
       auto result = opt.validate();
-                if( !result )
+      if (!result) return result;
-                    return result;
     }
     for (auto const &arg : m_args) {
       auto result = arg.validate();
-                if( !result )
+      if (!result) return result;
-                    return result;
     }
     return Result::ok();
   }
 
   using ParserBase::parse;
 
-        auto parse( std::string const& exeName, TokenStream const &tokens ) const -> InternalParseResult override {
+  auto parse(std::string const &exeName, TokenStream const &tokens) const
-
+      -> InternalParseResult override {
     struct ParserInfo {
       ParserBase const *parser = nullptr;
       size_t count = 0;
@@ -1204,10 +1123,10 @@ namespace detail {
 
       for (size_t i = 0; i < totalParsers; ++i) {
         auto &parseInfo = parseInfos[i];
-                    if( parseInfo.parser->cardinality() == 0 || parseInfo.count < parseInfo.parser->cardinality() ) {
+        if (parseInfo.parser->cardinality() == 0 ||
+            parseInfo.count < parseInfo.parser->cardinality()) {
           result = parseInfo.parser->parse(exeName, result.value().remainingTokens());
-                        if (!result)
+          if (!result) return result;
-                            return result;
           if (result.value().type() != ParseResultType::NoMatch) {
             tokenParsed = true;
             ++parseInfo.count;
@@ -1216,10 +1135,10 @@ namespace detail {
         }
       }
 
-                if( result.value().type() == ParseResultType::ShortCircuitAll )
+      if (result.value().type() == ParseResultType::ShortCircuitAll) return result;
-                    return result;
       if (!tokenParsed)
-                    return InternalParseResult::runtimeError( "Unrecognised token: " + result.value().remainingTokens()->token );
+        return InternalParseResult::runtimeError("Unrecognised token: " +
+                                                 result.value().remainingTokens()->token);
     }
     // !TBD Check missing required options
     return result;
@@ -1233,7 +1152,6 @@ namespace detail {
 }
 }  // namespace detail
 
-
 // A Combined parser
 using detail::Parser;
 
@@ -1258,7 +1176,6 @@ using detail::ParseResultType;
 // Result type for parser operation
 using detail::ParserResult;
 
-
 }  // namespace clara
 
 #endif  // CLARA_HPP_INCLUDED

include/util/format.hpp

@@ -5,15 +5,14 @@
 
 class pow_format {
  public:
-    pow_format(long long val, std::string&& unit, bool binary = false):
+  pow_format(long long val, std::string&& unit, bool binary = false)
-      val_(val), unit_(unit), binary_(binary) { };
+      : val_(val), unit_(unit), binary_(binary){};
 
   long long val_;
   std::string unit_;
   bool binary_;
 };
 
-
 namespace fmt {
 template <>
 struct formatter<pow_format> {
@@ -77,16 +76,16 @@ namespace fmt {
         format = "{coefficient:.3g}{prefix}{unit}";
         break;
     }
-          return format_to(ctx.out(), format
+    return format_to(
-              , fmt::arg("coefficient", fraction)
+        ctx.out(), format, fmt::arg("coefficient", fraction),
-              , fmt::arg("prefix", std::string() + units[pow] + ((s.binary_ && pow) ? "i" : ""))
+        fmt::arg("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> {
@@ -95,5 +94,4 @@ namespace fmt {
     return formatter<std::string>::format(value, ctx);
   }
 };
-}
+}  // namespace fmt
-

include/util/sleeper_thread.hpp

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

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 { AModule::update(); }
-}
-
-auto ALabel::update() -> void {
-  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,14 +1,17 @@
 #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);
@@ -18,7 +21,8 @@ AModule::AModule(const Json::Value& config, const std::string& name, const std::
     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;
@@ -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{
+      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()) {
@@ -63,10 +70,14 @@ bool AModule::handleToggle(GdkEventButton* const& e) {
 
 AModule::SCROLL_DIR AModule::getScrollDir(GdkEventScroll* e) {
   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);
     }
   }
@@ -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);
     }
   }
 
@@ -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);
@@ -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

@@ -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");
   }
@@ -169,8 +169,8 @@ auto waybar::Client::setupCss(const std::string &css_file) -> void {
     throw std::runtime_error("Can't open style file");
   }
   // there's always only one screen
-  style_context_->add_provider_for_screen(
+  style_context_->add_provider_for_screen(Gdk::Screen::get_default(), css_provider_,
-      Gdk::Screen::get_default(), css_provider_, GTK_STYLE_PROVIDER_PRIORITY_USER);
+                                          GTK_STYLE_PROVIDER_PRIORITY_USER);
 }
 
 void waybar::Client::bindInterfaces() {
@@ -224,8 +224,8 @@ int waybar::Client::main(int argc, char *argv[]) {
   if (!log_level.empty()) {
     spdlog::set_level(spdlog::level::from_str(log_level));
   }
-  gtk_app = Gtk::Application::create(
+  gtk_app = Gtk::Application::create(argc, argv, "fr.arouillard.waybar",
-      argc, argv, "fr.arouillard.waybar", Gio::APPLICATION_HANDLES_COMMAND_LINE);
+                                     Gio::APPLICATION_HANDLES_COMMAND_LINE);
   gdk_display = Gdk::Display::get_default();
   if (!gdk_display) {
     throw std::runtime_error("Can't find display");
@@ -244,6 +244,4 @@ int waybar::Client::main(int argc, char *argv[]) {
   return 0;
 }
 
-void waybar::Client::reset() {
+void waybar::Client::reset() { gtk_app->quit(); }
-  gtk_app->quit();
-}

src/config.cpp

@@ -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) {

src/group.cpp

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

src/main.cpp

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

src/modules/backlight.cpp

@@ -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()) {

src/modules/battery.cpp

@@ -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;
 }
 
@@ -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

@@ -24,42 +24,36 @@ 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"]) {
       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); }),
                          trimmed_format.end());
     if (trimmed_format.find("{" + kCalendarPlaceholder + "}") != std::string::npos) {
@@ -86,7 +80,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() {
@@ -120,7 +115,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);
     }
   }
@@ -148,7 +145,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();
@@ -219,7 +217,8 @@ auto waybar::modules::Clock::weekdays_header(const date::weekday& first_dow, std
   os << "\n";
 }
 
-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 "";
   }

src/modules/cpu/bsd.cpp

@@ -1,11 +1,12 @@
-#include "modules/cpu.hpp"
-
-#include <sys/types.h>
-#include <sys/sysctl.h>
 #include <spdlog/spdlog.h>
-#include <cstdlib>            // malloc
+#include <sys/sysctl.h>
+#include <sys/types.h>
 #include <unistd.h>  // sysconf
+
 #include <cmath>    // NAN
+#include <cstdlib>  // malloc
+
+#include "modules/cpu.hpp"
 
 #if defined(__NetBSD__) || defined(__OpenBSD__)
 #include <sys/sched.h>
@@ -101,7 +102,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

@@ -95,7 +95,8 @@ 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;

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() {
@@ -51,10 +52,7 @@ 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",
-        "/cpuinfo_max_freq"
-      };
       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;

src/modules/custom.cpp

@@ -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()) {

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

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

@@ -10,8 +10,7 @@ using DBus = std::unique_ptr<GDBusConnection, void(*)(GDBusConnection*)>;
 
 auto dbus() -> DBus {
   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);
@@ -23,9 +22,7 @@ auto dbus() -> DBus {
     GError* error = nullptr;
     g_dbus_connection_close_sync(connection, nullptr, &error);
     if (error) {
-        spdlog::error(
+      spdlog::error("g_bus_connection_close_sync failed(): {}", error->message);
-            "g_bus_connection_close_sync failed(): {}",
-            error->message);
       g_error_free(error);
     }
   };
@@ -38,28 +35,13 @@ auto getLocks(const DBus& bus, const std::string& inhibitors) -> int {
   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",
                                             "sleep",
                                             "handle-power-key",
                                             "handle-suspend-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,17 +112,13 @@ 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::format(format_, fmt::arg("status", status_text),
                                 fmt::arg("icon", getIcon(0, status_text))));
   label_.get_style_context()->add_class(status_text);
 
@@ -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,27 +68,31 @@ 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()
+                          ? 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()
+                           ? 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()
+                             ? config_["format"]["scrolllock"].asString()
                              : "{name} {icon}"),
-      interval_(std::chrono::seconds(config_["interval"].isUInt() ? config_["interval"].asUInt() : 1)),
+      interval_(
+          std::chrono::seconds(config_["interval"].isUInt() ? config_["interval"].asUInt() : 1)),
       icon_locked_(config_["format-icons"]["locked"].isString()
                        ? config_["format-icons"]["locked"].asString()
                        : "locked"),

src/modules/memory/bsd.cpp

@@ -1,9 +1,9 @@
-#include "modules/memory.hpp"
-
-#include <sys/types.h>
 #include <sys/sysctl.h>
+#include <sys/types.h>
 #include <unistd.h>  // getpagesize
 
+#include "modules/memory.hpp"
+
 #if defined(__DragonFly__)
 #include <sys/vmmeter.h>  // struct vmstats
 #elif defined(__NetBSD__)
@@ -43,21 +43,15 @@ 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
@@ -77,9 +71,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

@@ -54,31 +54,24 @@ 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("swapTotal", total_swap_gigabytes),
           fmt::arg("percentage", used_ram_percentage),
-                                    fmt::arg("swapPercentage", used_swap_percentage),
+          fmt::arg("swapPercentage", used_swap_percentage), fmt::arg("used", used_ram_gigabytes),
-                                    fmt::arg("used", used_ram_gigabytes),
+          fmt::arg("swapUsed", used_swap_gigabytes), fmt::arg("avail", available_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("percentage", used_ram_percentage),
-                                            fmt::arg("swapPercentage", used_swap_percentage),
+            fmt::arg("swapPercentage", used_swap_percentage), fmt::arg("used", used_ram_gigabytes),
-                                            fmt::arg("used", used_ram_gigabytes),
+            fmt::arg("swapUsed", used_swap_gigabytes), fmt::arg("avail", available_ram_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/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 {
@@ -148,28 +149,23 @@ void waybar::modules::MPD::setLabel() {
   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());
 
   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

@@ -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);
   }
 }
@@ -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"
@@ -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;
@@ -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";
   }
@@ -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")),
@@ -436,8 +428,7 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
 
       // Check if the interface goes "down" and if we want to detect the
       // external interface.
-    if (net->ifid_ != -1 && !(ifi->ifi_flags & IFF_UP)
+      if (net->ifid_ != -1 && !(ifi->ifi_flags & IFF_UP) && !net->config_["interface"].isString()) {
-        && !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_);
@@ -537,15 +528,13 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
           case IFA_ADDRESS: {
             char ipaddr[INET6_ADDRSTRLEN];
             if (!is_del_event) {
-          net->ipaddr_ = inet_ntop(ifa->ifa_family, RTA_DATA(ifa_rta),
+              net->ipaddr_ = inet_ntop(ifa->ifa_family, RTA_DATA(ifa_rta), ipaddr, sizeof(ipaddr));
-                                   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,
+                  net->netmask_ = inet_ntop(ifa->ifa_family, &netmask, ipaddr, sizeof(ipaddr));
-                                      ipaddr, sizeof (ipaddr));
                 }
                 case AF_INET6: {
                   struct in6_addr netmask;
@@ -555,8 +544,7 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
                     if (v > 8) v = 8;
                     netmask.s6_addr[i] = ~0 << v;
                   }
-            net->netmask_ = inet_ntop(ifa->ifa_family, &netmask,
+                  net->netmask_ = inet_ntop(ifa->ifa_family, &netmask, ipaddr, sizeof(ipaddr));
-                                      ipaddr, sizeof (ipaddr));
                 }
               }
               spdlog::debug("network: {}, new addr {}/{}", net->ifname_, net->ipaddr_, net->cidr_);
@@ -564,10 +552,8 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
               net->ipaddr_.clear();
               net->cidr_ = 0;
               net->netmask_.clear();
-          spdlog::debug("network: {} addr deleted {}/{}",
+              spdlog::debug("network: {} addr deleted {}/{}", net->ifname_,
-                        net->ifname_,
+                            inet_ntop(ifa->ifa_family, RTA_DATA(ifa_rta), ipaddr, sizeof(ipaddr)),
-                        inet_ntop(ifa->ifa_family, RTA_DATA(ifa_rta),
-                                  ipaddr, sizeof (ipaddr)),
                             ifa->ifa_prefixlen);
             }
             net->dp.emit();
@@ -593,7 +579,6 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
       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.
        */
@@ -656,7 +641,8 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
           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);
+          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 = {
@@ -664,8 +650,8 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
               .ifi_index = temp_idx,
           };
           int err;
-        err = nl_send_simple(net->ev_sock_, RTM_GETLINK, NLM_F_REQUEST,
+          err = nl_send_simple(net->ev_sock_, RTM_GETLINK, NLM_F_REQUEST, &ifinfo_hdr,
-                             &ifinfo_hdr, sizeof (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 */
@@ -678,10 +664,9 @@ int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
           net->want_addr_dump_ = true;
           net->askForStateDump();
           net->thread_timer_.wake_up();
-      } else if (is_del_event && temp_idx == net->ifid_
+        } else if (is_del_event && temp_idx == net->ifid_ && net->route_priority == priority) {
-                 && net->route_priority == priority) {
+          spdlog::debug("network: default route deleted {}/if{} metric {}", net->ifname_, temp_idx,
-        spdlog::debug("network: default route deleted {}/if{} metric {}",
+                        priority);
-                      net->ifname_, temp_idx, priority);
 
           net->clearIface();
           net->dp.emit();
@@ -702,8 +687,7 @@ 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,
@@ -711,21 +695,18 @@ void waybar::modules::Network::askForStateDump(void) {
 
   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;
   }
@@ -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) {
@@ -804,7 +785,9 @@ 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 -
+        ((abs(signal_strength_dbm_ - hardwareOptimum) / double{hardwareOptimum - hardwareMin}) *
+         100);
     signal_strength_ = std::clamp(strength, 0, 100);
 
     if (signal_strength_dbm_ >= -50) {
@@ -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_INPUT) |
                                static_cast<int>(PA_SUBSCRIPTION_MASK_SOURCE) |
                                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);
@@ -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 {
@@ -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,11 +278,8 @@ 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("format_source", format_source),
-        fmt::arg("source_volume", source_volume_),
           fmt::arg("source_desc", source_desc_),
           fmt::arg("icon", getIcon(volume_, getPulseIcon()))));
     } else {

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 {
@@ -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};
 
@@ -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)

src/modules/sndio.cpp

@@ -1,9 +1,11 @@
 #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 {
 
@@ -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();
@@ -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();
 }

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) {
@@ -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

@@ -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) {
@@ -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>{};
 }
@@ -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;
 }
 

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 {

src/modules/sway/language.cpp

@@ -95,20 +95,17 @@ 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("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())));
       label_.set_tooltip_markup(tooltip_display_layout);
     } else {
@@ -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;
     }
   }
@@ -205,7 +199,8 @@ auto Language::XKBContext::next_layout() -> Layout* {
     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 {

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_);
   }
@@ -134,19 +134,17 @@ int leafNodesInWorkspace(const Json::Value& node) {
   }
   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) {
     if (node["output"].isString()) {
       output = node["output"].asString();
@@ -158,23 +156,20 @@ std::tuple<std::size_t, int, std::string, std::string> gfnWithWorkspace(
         auto app_id = node["app_id"].isString() ? node["app_id"].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

@@ -67,9 +67,7 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
         std::lock_guard<std::mutex> lock(mutex_);
         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
@@ -144,8 +142,7 @@ 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();
@@ -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);
@@ -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()) {
@@ -258,18 +251,14 @@ 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(),
-                          "--no-auto-back-and-forth",
                                    node["name"].asString()));
         } else {
-          ipc_.sendCmd(
+          ipc_.sendCmd(IPC_COMMAND, fmt::format("workspace {} \"{}\"",
-              IPC_COMMAND,
-              fmt::format("workspace {} \"{}\"",
                                                 config_["disable-auto-back-and-forth"].asBool()
                                                     ? "--no-auto-back-and-forth"
                                                     : "",
@@ -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());
   }

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);
@@ -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,8 +56,7 @@ 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("temperatureK", temperature_k)));
   }

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));
@@ -291,19 +281,8 @@ auto UPower::update() -> void {
   gint64 time_full;
   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,8 +336,8 @@ 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));
   // Only set the label text if it doesn't only contain spaces
   bool onlySpaces = true;

src/modules/upower/upower_tooltip.cpp

@@ -48,18 +48,8 @@ uint UPowerTooltip::updateTooltip(Devices& devices) {
     gchar* model;
     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/taskbar.cpp

@@ -1,10 +1,11 @@
 #include "modules/wlr/taskbar.hpp"
 
-#include "glibmm/error.h"
+#include <fmt/core.h>
-#include "glibmm/fileutils.h"
+#include <gdkmm/monitor.h>
-#include "glibmm/refptr.h"
+#include <gio/gdesktopappinfo.h>
-#include "util/format.hpp"
+#include <giomm/desktopappinfo.h>
-#include "util/string.hpp"
+#include <gtkmm/icontheme.h>
+#include <spdlog/spdlog.h>
 
 #include <algorithm>
 #include <cctype>
@@ -14,22 +15,16 @@
 #include <sstream>
 #include <utility>
 
-#include <fmt/core.h>
+#include "glibmm/error.h"
-#include <gdkmm/monitor.h>
+#include "glibmm/fileutils.h"
-
+#include "glibmm/refptr.h"
-#include <gtkmm/icontheme.h>
+#include "util/format.hpp"
-
+#include "util/string.hpp"
-#include <giomm/desktopappinfo.h>
-#include <gio/gdesktopappinfo.h>
-
-#include <spdlog/spdlog.h>
-
 
 namespace waybar::modules::wlr {
 
 /* Icon loading functions */
-static std::vector<std::string> search_prefix()
+static std::vector<std::string> search_prefix() {
-{
   std::vector<std::string> prefixes = {""};
 
   auto xdg_data_dirs = std::getenv("XDG_DATA_DIRS");
@@ -52,14 +47,12 @@ static std::vector<std::string> search_prefix()
   std::string home_dir = std::getenv("HOME");
   prefixes.push_back(home_dir + "/.local/share/");
 
-    for (auto& p : prefixes)
+  for (auto &p : prefixes) spdlog::debug("Using 'desktop' search path prefix: {}", p);
-        spdlog::debug("Using 'desktop' search path prefix: {}", p);
 
   return prefixes;
 }
 
-static Glib::RefPtr<Gdk::Pixbuf> load_icon_from_file(std::string icon_path, int size)
+static Glib::RefPtr<Gdk::Pixbuf> load_icon_from_file(std::string icon_path, int size) {
-{
   try {
     auto pb = Gdk::Pixbuf::create_from_file(icon_path, size, size);
     return pb;
@@ -68,26 +61,19 @@ static Glib::RefPtr<Gdk::Pixbuf> load_icon_from_file(std::string icon_path, int
   }
 }
 
-static Glib::RefPtr<Gio::DesktopAppInfo> get_app_info_by_name(const std::string& app_id)
+static Glib::RefPtr<Gio::DesktopAppInfo> get_app_info_by_name(const std::string &app_id) {
-{
   static std::vector<std::string> prefixes = search_prefix();
 
-    std::vector<std::string> app_folders = {
+  std::vector<std::string> app_folders = {"", "applications/", "applications/kde/",
-        "",
+                                          "applications/org.kde."};
-        "applications/",
-        "applications/kde/",
-        "applications/org.kde."
-    };
 
-    std::vector<std::string> suffixes = {
+  std::vector<std::string> suffixes = {"", ".desktop"};
-        "",
-        ".desktop"
-    };
 
   for (auto &prefix : prefixes) {
     for (auto &folder : app_folders) {
       for (auto &suffix : suffixes) {
-                    auto app_info_ = Gio::DesktopAppInfo::create_from_filename(prefix + folder + app_id + suffix);
+        auto app_info_ =
+            Gio::DesktopAppInfo::create_from_filename(prefix + folder + app_id + suffix);
         if (!app_info_) {
           continue;
         }
@@ -100,8 +86,7 @@ static Glib::RefPtr<Gio::DesktopAppInfo> get_app_info_by_name(const std::string&
   return {};
 }
 
-Glib::RefPtr<Gio::DesktopAppInfo> get_desktop_app_info(const std::string &app_id)
+Glib::RefPtr<Gio::DesktopAppInfo> get_desktop_app_info(const std::string &app_id) {
-{
   auto app_info = get_app_info_by_name(app_id);
   if (app_info) {
     return app_info;
@@ -137,8 +122,7 @@ void Task::set_app_info_from_app_id_list(const std::string& app_id_list) {
 
   /* Wayfire sends a list of app-id's in space separated format, other compositors
    * send a single app-id, but in any case this works fine */
-    while (stream >> app_id)
+  while (stream >> app_id) {
-    {
     app_info_ = get_desktop_app_info(app_id);
     if (app_info_) {
       return;
@@ -167,19 +151,18 @@ void Task::set_app_info_from_app_id_list(const std::string& app_id_list) {
 }
 
 static std::string get_icon_name_from_icon_theme(const Glib::RefPtr<Gtk::IconTheme> &icon_theme,
-        const std::string &app_id)
+                                                 const std::string &app_id) {
-{
+  if (icon_theme->lookup_icon(app_id, 24)) return app_id;
-    if (icon_theme->lookup_icon(app_id, 24))
-        return app_id;
 
   return "";
 }
 
-bool Task::image_load_icon(Gtk::Image& image, const Glib::RefPtr<Gtk::IconTheme>& icon_theme, Glib::RefPtr<Gio::DesktopAppInfo> app_info, int size)
+bool Task::image_load_icon(Gtk::Image &image, const Glib::RefPtr<Gtk::IconTheme> &icon_theme,
-{
+                           Glib::RefPtr<Gio::DesktopAppInfo> app_info, int size) {
   std::string ret_icon_name = "unknown";
   if (app_info) {
-		std::string icon_name = get_icon_name_from_icon_theme(icon_theme, app_info->get_startup_wm_class());
+    std::string icon_name =
+        get_icon_name_from_icon_theme(icon_theme, app_info->get_startup_wm_class());
     if (!icon_name.empty()) {
       ret_icon_name = icon_name;
     } else {
@@ -212,48 +195,40 @@ bool Task::image_load_icon(Gtk::Image& image, const Glib::RefPtr<Gtk::IconTheme>
 uint32_t Task::global_id = 0;
 
 static void tl_handle_title(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle,
-        const char *title)
+                            const char *title) {
-{
   return static_cast<Task *>(data)->handle_title(title);
 }
 
 static void tl_handle_app_id(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle,
-        const char *app_id)
+                             const char *app_id) {
-{
   return static_cast<Task *>(data)->handle_app_id(app_id);
 }
 
 static void tl_handle_output_enter(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle,
-        struct wl_output *output)
+                                   struct wl_output *output) {
-{
   return static_cast<Task *>(data)->handle_output_enter(output);
 }
 
 static void tl_handle_output_leave(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle,
-        struct wl_output *output)
+                                   struct wl_output *output) {
-{
   return static_cast<Task *>(data)->handle_output_leave(output);
 }
 
 static void tl_handle_state(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle,
-        struct wl_array *state)
+                            struct wl_array *state) {
-{
   return static_cast<Task *>(data)->handle_state(state);
 }
 
-static void tl_handle_done(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle)
+static void tl_handle_done(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle) {
-{
   return static_cast<Task *>(data)->handle_done();
 }
 
 static void tl_handle_parent(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle,
-        struct zwlr_foreign_toplevel_handle_v1 *parent)
+                             struct zwlr_foreign_toplevel_handle_v1 *parent) {
-{
   /* This is explicitly left blank */
 }
 
-static void tl_handle_closed(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle)
+static void tl_handle_closed(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle) {
-{
   return static_cast<Task *>(data)->handle_closed();
 }
 
@@ -269,11 +244,14 @@ static const struct zwlr_foreign_toplevel_handle_v1_listener toplevel_handle_imp
 };
 
 Task::Task(const waybar::Bar &bar, const Json::Value &config, Taskbar *tbar,
-        struct zwlr_foreign_toplevel_handle_v1 *tl_handle, struct wl_seat *seat) :
+           struct zwlr_foreign_toplevel_handle_v1 *tl_handle, struct wl_seat *seat)
-    bar_{bar}, config_{config}, tbar_{tbar}, handle_{tl_handle}, seat_{seat},
+    : bar_{bar},
+      config_{config},
+      tbar_{tbar},
+      handle_{tl_handle},
+      seat_{seat},
       id_{global_id++},
-    content_{bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0}
+      content_{bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0} {
-{
   zwlr_foreign_toplevel_handle_v1_add_listener(handle_, &toplevel_handle_impl, this);
 
   button_.set_relief(Gtk::RELIEF_NONE);
@@ -321,16 +299,14 @@ Task::Task(const waybar::Bar &bar, const Json::Value &config, Taskbar *tbar,
   }
 
   /* Handle click events if configured */
-    if (config_["on-click"].isString() || config_["on-click-middle"].isString()
+  if (config_["on-click"].isString() || config_["on-click-middle"].isString() ||
-            || config_["on-click-right"].isString()) {
+      config_["on-click-right"].isString()) {
     button_.add_events(Gdk::BUTTON_PRESS_MASK);
-        button_.signal_button_press_event().connect(
+    button_.signal_button_press_event().connect(sigc::mem_fun(*this, &Task::handle_clicked), false);
-                sigc::mem_fun(*this, &Task::handle_clicked), false);
   }
 }
 
-Task::~Task()
+Task::~Task() {
-{
   if (handle_) {
     zwlr_foreign_toplevel_handle_v1_destroy(handle_);
     handle_ = nullptr;
@@ -341,25 +317,19 @@ Task::~Task()
   }
 }
 
-std::string Task::repr() const
+std::string Task::repr() const {
-{
   std::stringstream ss;
-    ss << "Task (" << id_ << ") " << title_ << " [" << app_id_ << "] <"
+  ss << "Task (" << id_ << ") " << title_ << " [" << app_id_ << "] <" << (active() ? "A" : "a")
-       << (active() ? "A" : "a")
+     << (maximized() ? "M" : "m") << (minimized() ? "I" : "i") << (fullscreen() ? "F" : "f") << ">";
-       << (maximized() ? "M" : "m")
-       << (minimized() ? "I" : "i")
-       << (fullscreen() ? "F" : "f")
-       << ">";
 
   return ss.str();
 }
 
-std::string Task::state_string(bool shortened) const
+std::string Task::state_string(bool shortened) const {
-{
   std::stringstream ss;
   if (shortened)
-        ss << (minimized() ? "m" : "") << (maximized() ? "M" : "")
+    ss << (minimized() ? "m" : "") << (maximized() ? "M" : "") << (active() ? "A" : "")
-           << (active() ? "A" : "") << (fullscreen() ? "F" : "");
+       << (fullscreen() ? "F" : "");
   else
     ss << (minimized() ? "minimized " : "") << (maximized() ? "maximized " : "")
        << (active() ? "active " : "") << (fullscreen() ? "fullscreen " : "");
@@ -371,14 +341,12 @@ std::string Task::state_string(bool shortened) const
     return res.substr(0, res.size() - 1);
 }
 
-void Task::handle_title(const char *title)
+void Task::handle_title(const char *title) {
-{
   title_ = title;
   hide_if_ignored();
 }
 
-void Task::hide_if_ignored()
+void Task::hide_if_ignored() {
-{
   if (tbar_->ignore_list().count(app_id_) || tbar_->ignore_list().count(title_)) {
     ignored_ = true;
     if (button_visible_) {
@@ -395,15 +363,15 @@ void Task::hide_if_ignored()
   }
 }
 
-void Task::handle_app_id(const char *app_id)
+void Task::handle_app_id(const char *app_id) {
-{
   app_id_ = app_id;
   hide_if_ignored();
 
   auto ids_replace_map = tbar_->app_ids_replace_map();
   if (ids_replace_map.count(app_id_)) {
     auto replaced_id = ids_replace_map[app_id_];
-		spdlog::debug(fmt::format("Task ({}) [{}] app_id was replaced with {}", id_, app_id_, replaced_id));
+    spdlog::debug(
+        fmt::format("Task ({}) [{}] app_id was replaced with {}", id_, app_id_, replaced_id));
     app_id_ = replaced_id;
   }
 
@@ -433,8 +401,7 @@ void Task::handle_app_id(const char *app_id)
     spdlog::debug("Couldn't find icon for {}", app_id_);
 }
 
-void Task::handle_output_enter(struct wl_output *output)
+void Task::handle_output_enter(struct wl_output *output) {
-{
   if (ignored_) {
     spdlog::debug("{} is ignored", repr());
     return;
@@ -451,8 +418,7 @@ void Task::handle_output_enter(struct wl_output *output)
   }
 }
 
-void Task::handle_output_leave(struct wl_output *output)
+void Task::handle_output_leave(struct wl_output *output) {
-{
   spdlog::debug("{} left output {}", repr(), (void *)output);
 
   if (button_visible_ && !tbar_->all_outputs() && tbar_->show_output(output)) {
@@ -464,25 +430,19 @@ void Task::handle_output_leave(struct wl_output *output)
   }
 }
 
-void Task::handle_state(struct wl_array *state)
+void Task::handle_state(struct wl_array *state) {
-{
   state_ = 0;
   size_t size = state->size / sizeof(uint32_t);
   for (size_t i = 0; i < size; ++i) {
     auto entry = static_cast<uint32_t *>(state->data)[i];
-        if (entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_MAXIMIZED)
+    if (entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_MAXIMIZED) state_ |= MAXIMIZED;
-            state_ |= MAXIMIZED;
+    if (entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_MINIMIZED) state_ |= MINIMIZED;
-        if (entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_MINIMIZED)
+    if (entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_ACTIVATED) state_ |= ACTIVE;
-            state_ |= MINIMIZED;
+    if (entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_FULLSCREEN) state_ |= FULLSCREEN;
-        if (entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_ACTIVATED)
-            state_ |= ACTIVE;
-        if (entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_FULLSCREEN)
-            state_ |= FULLSCREEN;
   }
 }
 
-void Task::handle_done()
+void Task::handle_done() {
-{
   spdlog::debug("{} changed", repr());
 
   if (state_ & MAXIMIZED) {
@@ -515,8 +475,7 @@ void Task::handle_done()
   tbar_->dp.emit();
 }
 
-void Task::handle_closed()
+void Task::handle_closed() {
-{
   spdlog::debug("{} closed", repr());
   zwlr_foreign_toplevel_handle_v1_destroy(handle_);
   handle_ = nullptr;
@@ -527,8 +486,7 @@ void Task::handle_closed()
   tbar_->remove_task(id_);
 }
 
-bool Task::handle_clicked(GdkEventButton *bt)
+bool Task::handle_clicked(GdkEventButton *bt) {
-{
   std::string action;
   if (config_["on-click"].isString() && bt->button == 1)
     action = config_["on-click"].asString();
@@ -550,8 +508,7 @@ bool Task::handle_clicked(GdkEventButton *bt)
       minimize(true);
     else
       activate();
-    }
+  } else if (action == "maximize")
-    else if (action == "maximize")
     maximize(!maximized());
   else if (action == "fullscreen")
     fullscreen(!fullscreen());
@@ -563,18 +520,11 @@ bool Task::handle_clicked(GdkEventButton *bt)
   return true;
 }
 
-bool Task::operator==(const Task &o) const
+bool Task::operator==(const Task &o) const { return o.id_ == id_; }
-{
-    return o.id_ == id_;
-}
 
-bool Task::operator!=(const Task &o) const
+bool Task::operator!=(const Task &o) const { return o.id_ != id_; }
-{
-    return o.id_ != id_;
-}
 
-void Task::update()
+void Task::update() {
-{
   bool markup = config_["markup"].isBool() ? config_["markup"].asBool() : false;
   std::string title = title_;
   std::string name = name_;
@@ -585,13 +535,9 @@ void Task::update()
     app_id = Glib::Markup::escape_text(app_id);
   }
   if (!format_before_.empty()) {
-        auto txt = fmt::format(format_before_,
+    auto txt = fmt::format(format_before_, fmt::arg("title", title), fmt::arg("name", name),
-                    fmt::arg("title", title),
+                           fmt::arg("app_id", app_id), fmt::arg("state", state_string()),
-                    fmt::arg("name", name),
+                           fmt::arg("short_state", state_string(true)));
-                    fmt::arg("app_id", app_id),
-                    fmt::arg("state", state_string()),
-                    fmt::arg("short_state", state_string(true))
-                );
     if (markup)
       text_before_.set_markup(txt);
     else
@@ -599,13 +545,9 @@ void Task::update()
     text_before_.show();
   }
   if (!format_after_.empty()) {
-        auto txt = fmt::format(format_after_,
+    auto txt = fmt::format(format_after_, fmt::arg("title", title), fmt::arg("name", name),
-                    fmt::arg("title", title),
+                           fmt::arg("app_id", app_id), fmt::arg("state", state_string()),
-                    fmt::arg("name", name),
+                           fmt::arg("short_state", state_string(true)));
-                    fmt::arg("app_id", app_id),
-                    fmt::arg("state", state_string()),
-                    fmt::arg("short_state", state_string(true))
-                );
     if (markup)
       text_after_.set_markup(txt);
     else
@@ -614,13 +556,9 @@ void Task::update()
   }
 
   if (!format_tooltip_.empty()) {
-        auto txt = fmt::format(format_tooltip_,
+    auto txt = fmt::format(format_tooltip_, fmt::arg("title", title), fmt::arg("name", name),
-                    fmt::arg("title", title),
+                           fmt::arg("app_id", app_id), fmt::arg("state", state_string()),
-                    fmt::arg("name", name),
+                           fmt::arg("short_state", state_string(true)));
-                    fmt::arg("app_id", app_id),
-                    fmt::arg("state", state_string()),
-                    fmt::arg("short_state", state_string(true))
-                );
     if (markup)
       button_.set_tooltip_markup(txt);
     else
@@ -628,30 +566,25 @@ void Task::update()
   }
 }
 
-void Task::maximize(bool set)
+void Task::maximize(bool set) {
-{
   if (set)
     zwlr_foreign_toplevel_handle_v1_set_maximized(handle_);
   else
     zwlr_foreign_toplevel_handle_v1_unset_maximized(handle_);
 }
 
-void Task::minimize(bool set)
+void Task::minimize(bool set) {
-{
   if (set)
     zwlr_foreign_toplevel_handle_v1_set_minimized(handle_);
   else
     zwlr_foreign_toplevel_handle_v1_unset_minimized(handle_);
 }
 
-void Task::activate()
+void Task::activate() { zwlr_foreign_toplevel_handle_v1_activate(handle_, seat_); }
-{
-    zwlr_foreign_toplevel_handle_v1_activate(handle_, seat_);
-}
 
-void Task::fullscreen(bool set)
+void Task::fullscreen(bool set) {
-{
+  if (zwlr_foreign_toplevel_handle_v1_get_version(handle_) <
-    if (zwlr_foreign_toplevel_handle_v1_get_version(handle_) < ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_SET_FULLSCREEN_SINCE_VERSION) {
+      ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_SET_FULLSCREEN_SINCE_VERSION) {
     spdlog::warn("Foreign toplevel manager server does not support for set/unset fullscreen.");
     return;
   }
@@ -662,16 +595,11 @@ void Task::fullscreen(bool set)
     zwlr_foreign_toplevel_handle_v1_unset_fullscreen(handle_);
 }
 
-void Task::close()
+void Task::close() { zwlr_foreign_toplevel_handle_v1_close(handle_); }
-{
-    zwlr_foreign_toplevel_handle_v1_close(handle_);
-}
-
 
 /* Taskbar class implementation */
 static void handle_global(void *data, struct wl_registry *registry, uint32_t name,
-        const char *interface, uint32_t version)
+                          const char *interface, uint32_t version) {
-{
   if (std::strcmp(interface, zwlr_foreign_toplevel_manager_v1_interface.name) == 0) {
     static_cast<Taskbar *>(data)->register_manager(registry, name, version);
   } else if (std::strcmp(interface, wl_seat_interface.name) == 0) {
@@ -679,22 +607,19 @@ static void handle_global(void *data, struct wl_registry *registry, uint32_t nam
   }
 }
 
-static void handle_global_remove(void *data, struct wl_registry *registry, uint32_t name)
+static void handle_global_remove(void *data, struct wl_registry *registry, uint32_t name) {
-{
   /* Nothing to do here */
 }
 
-static const wl_registry_listener registry_listener_impl = {
+static const wl_registry_listener registry_listener_impl = {.global = handle_global,
-    .global = handle_global,
+                                                            .global_remove = handle_global_remove};
-    .global_remove = handle_global_remove
-};
 
 Taskbar::Taskbar(const std::string &id, const waybar::Bar &bar, const Json::Value &config)
     : waybar::AModule(config, "taskbar", id, false, false),
       bar_(bar),
       box_{bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0},
-      manager_{nullptr}, seat_{nullptr}
+      manager_{nullptr},
-{
+      seat_{nullptr} {
   box_.set_name("taskbar");
   if (!id.empty()) {
     box_.get_style_context()->add_class(id);
@@ -756,8 +681,7 @@ Taskbar::Taskbar(const std::string &id, const waybar::Bar &bar, const Json::Valu
   icon_themes_.push_back(Gtk::IconTheme::get_default());
 }
 
-Taskbar::~Taskbar()
+Taskbar::~Taskbar() {
-{
   if (manager_) {
     struct wl_display *display = Client::inst()->wl_display;
     /*
@@ -776,8 +700,7 @@ Taskbar::~Taskbar()
   }
 }
 
-void Taskbar::update()
+void Taskbar::update() {
-{
   for (auto &t : tasks_) {
     t->update();
   }
@@ -786,13 +709,11 @@ void Taskbar::update()
 }
 
 static void tm_handle_toplevel(void *data, struct zwlr_foreign_toplevel_manager_v1 *manager,
-        struct zwlr_foreign_toplevel_handle_v1 *tl_handle)
+                               struct zwlr_foreign_toplevel_handle_v1 *tl_handle) {
-{
   return static_cast<Taskbar *>(data)->handle_toplevel_create(tl_handle);
 }
 
-static void tm_handle_finished(void *data, struct zwlr_foreign_toplevel_manager_v1 *manager)
+static void tm_handle_finished(void *data, struct zwlr_foreign_toplevel_manager_v1 *manager) {
-{
   return static_cast<Taskbar *>(data)->handle_finished();
 }
 
@@ -801,22 +722,23 @@ static const struct zwlr_foreign_toplevel_manager_v1_listener toplevel_manager_i
     .finished = tm_handle_finished,
 };
 
-void Taskbar::register_manager(struct wl_registry *registry, uint32_t name, uint32_t version)
+void Taskbar::register_manager(struct wl_registry *registry, uint32_t name, uint32_t version) {
-{
   if (manager_) {
     spdlog::warn("Register foreign toplevel manager again although already existing!");
     return;
   }
   if (version < ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_SET_FULLSCREEN_SINCE_VERSION) {
-        spdlog::warn("Foreign toplevel manager server does not have the appropriate version."
+    spdlog::warn(
-                " To be able to use all features, you need at least version 2, but server is version {}", version);
+        "Foreign toplevel manager server does not have the appropriate version."
+        " To be able to use all features, you need at least version 2, but server is version {}",
+        version);
   }
 
   // limit version to a highest supported by the client protocol file
   version = std::min<uint32_t>(version, zwlr_foreign_toplevel_manager_v1_interface.version);
 
-    manager_ = static_cast<struct zwlr_foreign_toplevel_manager_v1 *>(wl_registry_bind(registry, name,
+  manager_ = static_cast<struct zwlr_foreign_toplevel_manager_v1 *>(
-            &zwlr_foreign_toplevel_manager_v1_interface, version));
+      wl_registry_bind(registry, name, &zwlr_foreign_toplevel_manager_v1_interface, version));
 
   if (manager_)
     zwlr_foreign_toplevel_manager_v1_add_listener(manager_, &toplevel_manager_impl, this);
@@ -824,8 +746,7 @@ void Taskbar::register_manager(struct wl_registry *registry, uint32_t name, uint
     spdlog::debug("Failed to register manager");
 }
 
-void Taskbar::register_seat(struct wl_registry *registry, uint32_t name, uint32_t version)
+void Taskbar::register_seat(struct wl_registry *registry, uint32_t name, uint32_t version) {
-{
   if (seat_) {
     spdlog::warn("Register seat again although already existing!");
     return;
@@ -835,34 +756,22 @@ void Taskbar::register_seat(struct wl_registry *registry, uint32_t name, uint32_
   seat_ = static_cast<wl_seat *>(wl_registry_bind(registry, name, &wl_seat_interface, version));
 }
 
-void Taskbar::handle_toplevel_create(struct zwlr_foreign_toplevel_handle_v1 *tl_handle)
+void Taskbar::handle_toplevel_create(struct zwlr_foreign_toplevel_handle_v1 *tl_handle) {
-{
   tasks_.push_back(std::make_unique<Task>(bar_, config_, this, tl_handle, seat_));
 }
 
-void Taskbar::handle_finished()
+void Taskbar::handle_finished() {
-{
   zwlr_foreign_toplevel_manager_v1_destroy(manager_);
   manager_ = nullptr;
 }
 
-void Taskbar::add_button(Gtk::Button &bt)
+void Taskbar::add_button(Gtk::Button &bt) { box_.pack_start(bt, false, false); }
-{
-    box_.pack_start(bt, false, false);
-}
 
-void Taskbar::move_button(Gtk::Button &bt, int pos)
+void Taskbar::move_button(Gtk::Button &bt, int pos) { box_.reorder_child(bt, pos); }
-{
-    box_.reorder_child(bt, pos);
-}
 
-void Taskbar::remove_button(Gtk::Button &bt)
+void Taskbar::remove_button(Gtk::Button &bt) { box_.remove(bt); }
-{
-    box_.remove(bt);
-}
 
-void Taskbar::remove_task(uint32_t id)
+void Taskbar::remove_task(uint32_t id) {
-{
   auto it = std::find_if(std::begin(tasks_), std::end(tasks_),
                          [id](const TaskPtr &p) { return p->id() == id; });
 
@@ -874,20 +783,22 @@ void Taskbar::remove_task(uint32_t id)
   tasks_.erase(it);
 }
 
-bool Taskbar::show_output(struct wl_output *output) const
+bool Taskbar::show_output(struct wl_output *output) const {
-{
   return output == gdk_wayland_monitor_get_wl_output(bar_.output->monitor->gobj());
 }
 
-bool Taskbar::all_outputs() const
+bool Taskbar::all_outputs() const {
-{
   return config_["all-outputs"].isBool() && config_["all-outputs"].asBool();
 }
 
-const std::vector<Glib::RefPtr<Gtk::IconTheme>>& Taskbar::icon_themes() const { return icon_themes_; }
+const std::vector<Glib::RefPtr<Gtk::IconTheme>> &Taskbar::icon_themes() const {
+  return icon_themes_;
+}
 
 const std::unordered_set<std::string> &Taskbar::ignore_list() const { return ignore_list_; }
 
-const std::map<std::string, std::string>& Taskbar::app_ids_replace_map() const { return app_ids_replace_map_; }
+const std::map<std::string, std::string> &Taskbar::app_ids_replace_map() const {
+  return app_ids_replace_map_;
+}
 
 } /* namespace waybar::modules::wlr */

src/modules/wlr/workspace_manager.cpp

@@ -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()) {
@@ -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"

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() {