chore: 0.7.0

refactor: AModule (#387 )
refactor: AModule
2023-12-21 10:22:59 +01:00 · 2019-06-22 18:17:16 +02:00 · 2019-06-22 18:15:50 +02:00 · 2019-06-22 18:15:34 +02:00 · 2019-06-18 09:43:34 +02:00 · 2019-06-17 20:42:19 +02:00
49 changed files with 775 additions and 735 deletions
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@ -0,0 +1,3 @@
+# These are supported funding model platforms
+
+custom: https://paypal.me/ARouillard
--- a/README.md
+++ b/README.md
@ -2,7 +2,8 @@

 > Highly customizable Wayland bar for Sway and Wlroots based compositors.<br>
 > Available in Arch [community](https://www.archlinux.org/packages/community/x86_64/waybar/) or
-[AUR](https://aur.archlinux.org/packages/waybar-git/) and [openSUSE](https://build.opensuse.org/package/show/X11:Wayland/waybar)
+[AUR](https://aur.archlinux.org/packages/waybar-git/) and [openSUSE](https://build.opensuse.org/package/show/X11:Wayland/waybar)<br>
+> *Waybar [examples](https://github.com/Alexays/Waybar/wiki/Examples)*

 **Current features**
 - Sway (Workspaces, Binding mode, Focused window name)
@ -42,6 +43,7 @@ $ waybar
 gtkmm3
 jsoncpp
 libinput
+
 libsigc++
 fmt
 wayland
--- a/include/ALabel.hpp
+++ b/include/ALabel.hpp
@ -1,40 +1,30 @@
 #pragma once

 #include <glibmm/markup.h>
-#include <gtkmm/eventbox.h>
 #include <gtkmm/label.h>
 #include <json/json.h>
-#include "IModule.hpp"
+#include "AModule.hpp"

 namespace waybar {

-class ALabel : public IModule {
+class ALabel : public AModule {
 public:
-  ALabel(const Json::Value &, const std::string &format, uint16_t interval = 0);
-  virtual ~ALabel();
+  ALabel(const Json::Value &, const std::string &, const std::string &, const std::string &format,
+         uint16_t interval = 0);
+  virtual ~ALabel() = default;
  virtual auto        update() -> void;
  virtual std::string getIcon(uint16_t, const std::string &alt = "", uint16_t max = 0);
-  virtual             operator Gtk::Widget &();

 protected:
-  bool tooltipEnabled();
-
-  Gtk::EventBox              event_box_;
  Gtk::Label                 label_;
-  const Json::Value &        config_;
  std::string                format_;
  std::string                click_param;
-  std::mutex                 mutex_;
  const std::chrono::seconds interval_;
  bool                       alt_ = false;
  std::string                default_format_;

-  virtual bool handleToggle(GdkEventButton *const &ev);
-  virtual bool handleScroll(GdkEventScroll *);
+  virtual bool        handleToggle(GdkEventButton *const &e);
  virtual std::string getState(uint8_t value, bool lesser = false);
-
- private:
-  std::vector<int> pid_;
 };

 }  // namespace waybar
--- a/include/AModule.hpp
+++ b/include/AModule.hpp
@ -0,0 +1,40 @@
+#pragma once
+
+#include <glibmm/dispatcher.h>
+#include <glibmm/markup.h>
+#include <gtkmm/eventbox.h>
+#include <json/json.h>
+#include "IModule.hpp"
+
+namespace waybar {
+
+class AModule : public IModule {
+ public:
+  AModule(const Json::Value &, const std::string &, const std::string &,
+          bool enable_click = false, bool enable_scroll = false);
+  virtual ~AModule();
+  virtual auto update() -> void;
+  virtual      operator Gtk::Widget &();
+
+  Glib::Dispatcher dp;
+
+ protected:
+  enum SCROLL_DIR { NONE, UP, DOWN, LEFT, RIGHT };
+
+  SCROLL_DIR getScrollDir(GdkEventScroll *e);
+  bool       tooltipEnabled();
+
+  const Json::Value &config_;
+  Gtk::EventBox      event_box_;
+  std::string        click_param_;
+
+  virtual bool handleToggle(GdkEventButton *const &ev);
+  virtual bool handleScroll(GdkEventScroll *);
+
+ private:
+  std::vector<int> pid_;
+  gdouble          distance_scrolled_y_;
+  gdouble          distance_scrolled_x_;
+};
+
+}  // namespace waybar
--- a/include/IModule.hpp
+++ b/include/IModule.hpp
@ -1,7 +1,5 @@
 #pragma once

-#include <glibmm/dispatcher.h>
-#include <gtkmm/box.h>
 #include <gtkmm/widget.h>

 namespace waybar {
@ -11,7 +9,6 @@ class IModule {
  virtual ~IModule() = default;
  virtual auto     update() -> void = 0;
  virtual          operator Gtk::Widget &() = 0;
-  Glib::Dispatcher dp;  // Hmmm Maybe I should create an abstract class ?
 };

 }  // namespace waybar
--- a/include/bar.hpp
+++ b/include/bar.hpp
@ -4,8 +4,9 @@
 #include <gtkmm/cssprovider.h>
 #include <gtkmm/main.h>
 #include <gtkmm/window.h>
+#include <gtkmm/box.h>
 #include <json/json.h>
-#include "IModule.hpp"
+#include "AModule.hpp"
 #include "idle-inhibit-unstable-v1-client-protocol.h"
 #include "wlr-layer-shell-unstable-v1-client-protocol.h"
 #include "xdg-output-unstable-v1-client-protocol.h"
@ -38,13 +39,13 @@ class Bar {
  bool                          vertical = false;

 private:
-  static constexpr const char* MIN_HEIGHT_MSG =
+  static constexpr const char *MIN_HEIGHT_MSG =
      "Requested height: {} exceeds the minimum height: {} required by the modules";
-  static constexpr const char* MIN_WIDTH_MSG =
+  static constexpr const char *MIN_WIDTH_MSG =
      "Requested width: {} exceeds the minimum width: {} required by the modules";
-  static constexpr const char* BAR_SIZE_MSG =
+  static constexpr const char *BAR_SIZE_MSG =
      "Bar configured (width: {}, height: {}) for output: {}";
-  static constexpr const char* SIZE_DEFINED =
+  static constexpr const char *SIZE_DEFINED =
      "{} size is defined in the config file so it will stay like that";
  static void layerSurfaceHandleConfigure(void *, struct zwlr_layer_surface_v1 *, uint32_t,
                                          uint32_t, uint32_t);
@ -52,6 +53,8 @@ class Bar {

  void destroyOutput();
  void onConfigure(GdkEventConfigure *ev);
+  void onRealize();
+  void onMap(GdkEventAny *ev);
  void setMarginsAndZone(uint32_t height, uint32_t width);
  auto setupWidgets() -> void;
  void getModules(const Factory &, const std::string &);
@ -66,13 +69,14 @@ class Bar {
  } margins_;
  uint32_t                                      width_ = 0;
  uint32_t                                      height_ = 1;
+  uint8_t                                       anchor_;
  Gtk::Box                                      left_;
  Gtk::Box                                      center_;
  Gtk::Box                                      right_;
  Gtk::Box                                      box_;
-  std::vector<std::unique_ptr<waybar::IModule>> modules_left_;
-  std::vector<std::unique_ptr<waybar::IModule>> modules_center_;
-  std::vector<std::unique_ptr<waybar::IModule>> modules_right_;
+  std::vector<std::unique_ptr<waybar::AModule>> modules_left_;
+  std::vector<std::unique_ptr<waybar::AModule>> modules_center_;
+  std::vector<std::unique_ptr<waybar::AModule>> modules_right_;
 };

 }  // namespace waybar
--- a/include/client.hpp
+++ b/include/client.hpp
@ -26,14 +26,15 @@ class Client {

 private:
  Client() = default;
-  void              setupConfigs(const std::string &config, const std::string &style);
-  void              bindInterfaces();
-  const std::string getValidPath(const std::vector<std::string> &paths);
+  std::tuple<const std::string, const std::string> getConfigs(const std::string &config,
+                                                              const std::string &style) const;
+  void                                             bindInterfaces();
+  const std::string getValidPath(const std::vector<std::string> &paths) const;
  void              handleOutput(std::unique_ptr<struct waybar_output> &output);
  bool isValidOutput(const Json::Value &config, std::unique_ptr<struct waybar_output> &output);
-  auto setupConfig() -> void;
-  auto setupCss() -> void;
-  std::unique_ptr<struct waybar_output>& getOutput(uint32_t wl_name);
+  auto setupConfig(const std::string &config_file) -> void;
+  auto setupCss(const std::string &css_file) -> void;
+  std::unique_ptr<struct waybar_output> &getOutput(uint32_t wl_name);
  std::vector<Json::Value> getOutputConfigs(std::unique_ptr<struct waybar_output> &output);

  static void handleGlobal(void *data, struct wl_registry *registry, uint32_t name,
@ -46,8 +47,6 @@ class Client {
  static void handleDescription(void *, struct zxdg_output_v1 *, const char *);

  Json::Value                                        config_;
-  std::string                                        css_file_;
-  std::string                                        config_file_;
  Glib::RefPtr<Gtk::StyleContext>                    style_context_;
  Glib::RefPtr<Gtk::CssProvider>                     css_provider_;
  std::vector<std::unique_ptr<struct waybar_output>> outputs_;
--- a/include/factory.hpp
+++ b/include/factory.hpp
@ -37,7 +37,7 @@ namespace waybar {
 class Factory {
 public:
  Factory(const Bar& bar, const Json::Value& config);
-  IModule* makeModule(const std::string& name) const;
+  AModule* makeModule(const std::string& name) const;

 private:
  const Bar&         bar_;
--- a/include/modules/backlight.hpp
+++ b/include/modules/backlight.hpp
@ -47,7 +47,6 @@ class Backlight : public ALabel {
  template <class ForwardIt, class Inserter>
  static void enumerate_devices(ForwardIt first, ForwardIt last, Inserter inserter, udev *udev);

-  const std::string    name_;
  const std::string    preferred_device_;
  static constexpr int EPOLL_MAX_EVENTS = 16;

@ -57,6 +56,6 @@ class Backlight : public ALabel {
  std::mutex                udev_thread_mutex_;
  std::vector<BacklightDev> devices_;
  // thread must destruct before shared data
-  waybar::util::SleeperThread udev_thread_;
+  util::SleeperThread udev_thread_;
 };
 }  // namespace waybar::modules
--- a/include/modules/battery.hpp
+++ b/include/modules/battery.hpp
@ -31,19 +31,20 @@ class Battery : public ALabel {
 private:
  static inline const fs::path data_dir_ = "/sys/class/power_supply/";

-  void              getBatteries();
-  void              worker();
-  const std::string getAdapterStatus(uint8_t capacity) const;
+  void                                          getBatteries();
+  void                                          worker();
+  const std::string                             getAdapterStatus(uint8_t capacity) const;
  const std::tuple<uint8_t, float, std::string> getInfos() const;
-  const std::string formatTimeRemaining(float hoursRemaining);
+  const std::string                             formatTimeRemaining(float hoursRemaining);

-  util::SleeperThread   thread_;
-  util::SleeperThread   thread_timer_;
  std::vector<fs::path> batteries_;
  fs::path              adapter_;
  int                   fd_;
  std::vector<int>      wds_;
  std::string           old_status_;
+
+  util::SleeperThread   thread_;
+  util::SleeperThread   thread_timer_;
 };

 }  // namespace waybar::modules
--- a/include/modules/clock.hpp
+++ b/include/modules/clock.hpp
@ -14,7 +14,7 @@ class Clock : public ALabel {
  auto update() -> void;

 private:
-  waybar::util::SleeperThread thread_;
+  util::SleeperThread thread_;
 };

 }  // namespace waybar::modules
--- a/include/modules/cpu.hpp
+++ b/include/modules/cpu.hpp
@ -2,12 +2,12 @@

 #include <fmt/format.h>
 #include <sys/sysinfo.h>
-#include <fstream>
 #include <cstdint>
+#include <fstream>
 #include <numeric>
-#include <vector>
 #include <string>
 #include <utility>
+#include <vector>
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"

@ -26,7 +26,8 @@ class Cpu : public ALabel {
  std::vector<std::tuple<size_t, size_t>> parseCpuinfo();

  std::vector<std::tuple<size_t, size_t>> prev_times_;
-  waybar::util::SleeperThread             thread_;
+
+  util::SleeperThread thread_;
 };

 }  // namespace waybar::modules
--- a/include/modules/custom.hpp
+++ b/include/modules/custom.hpp
@ -12,7 +12,7 @@ namespace waybar::modules {

 class Custom : public ALabel {
 public:
-  Custom(const std::string&, const Json::Value&);
+  Custom(const std::string&, const std::string&, const Json::Value&);
  ~Custom();
  auto update() -> void;
  void refresh(int /*signal*/);
@ -25,17 +25,18 @@ class Custom : public ALabel {
  bool handleScroll(GdkEventScroll* e);
  bool handleToggle(GdkEventButton* const& e);

-  const std::string           name_;
-  std::string                 text_;
-  std::string                 alt_;
-  std::string                 tooltip_;
-  std::vector<std::string>    class_;
-  int                         percentage_;
-  waybar::util::SleeperThread thread_;
-  waybar::util::command::res  output_;
-  waybar::util::JsonParser    parser_;
-  FILE*                       fp_;
-  int                         pid_;
+  const std::string        name_;
+  std::string              text_;
+  std::string              alt_;
+  std::string              tooltip_;
+  std::vector<std::string> class_;
+  int                      percentage_;
+  FILE*                    fp_;
+  int                      pid_;
+  util::command::res       output_;
+  util::JsonParser         parser_;
+
+  util::SleeperThread thread_;
 };

 }  // namespace waybar::modules
--- a/include/modules/memory.hpp
+++ b/include/modules/memory.hpp
@ -15,10 +15,12 @@ class Memory : public ALabel {

 private:
  static inline const std::string data_dir_ = "/proc/meminfo";
-  unsigned long                   memtotal_;
-  unsigned long                   memfree_;
  void                            parseMeminfo();
-  waybar::util::SleeperThread     thread_;
+
+  unsigned long memtotal_;
+  unsigned long memfree_;
+
+  util::SleeperThread thread_;
 };

 }  // namespace waybar::modules
--- a/include/modules/network.hpp
+++ b/include/modules/network.hpp
@ -27,48 +27,50 @@ class Network : public ALabel {
  static int handleEvents(struct nl_msg*, void*);
  static int handleScan(struct nl_msg*, void*);

-  void worker();
-  void createInfoSocket();
-  void createEventSocket();
-  int  getExternalInterface(int skip_idx = -1);
-  void getInterfaceAddress();
-  int  netlinkRequest(void*, uint32_t, uint32_t groups = 0);
-  int  netlinkResponse(void*, uint32_t, uint32_t groups = 0);
-  void parseEssid(struct nlattr**);
-  void parseSignal(struct nlattr**);
-  void parseFreq(struct nlattr**);
-  bool associatedOrJoined(struct nlattr**);
-  bool checkInterface(struct ifinfomsg *rtif, std::string name);
-  int  getPreferredIface(int skip_idx = -1);
-  auto getInfo() -> void;
-  void clearIface();
-  bool wildcardMatch(const std::string& pattern, const std::string& text);
+  void              worker();
+  void              createInfoSocket();
+  void              createEventSocket();
+  int               getExternalInterface(int skip_idx = -1) const;
+  void              getInterfaceAddress();
+  int               netlinkRequest(void*, uint32_t, uint32_t groups = 0) const;
+  int               netlinkResponse(void*, uint32_t, uint32_t groups = 0) const;
+  void              parseEssid(struct nlattr**);
+  void              parseSignal(struct nlattr**);
+  void              parseFreq(struct nlattr**);
+  bool              associatedOrJoined(struct nlattr**);
+  bool              checkInterface(struct ifinfomsg* rtif, std::string name);
+  int               getPreferredIface(int skip_idx = -1) const;
+  auto              getInfo() -> void;
+  void              checkNewInterface(struct ifinfomsg* rtif);
+  const std::string getNetworkState() const;
+  void              clearIface();
+  bool              wildcardMatch(const std::string& pattern, const std::string& text) const;

-  waybar::util::SleeperThread thread_;
-  waybar::util::SleeperThread thread_timer_;
-  int                         ifid_;
-  int                         last_ext_iface_;
-  sa_family_t                 family_;
-  struct sockaddr_nl          nladdr_ = {0};
-  struct nl_sock*             sock_ = nullptr;
-  struct nl_sock*             ev_sock_ = nullptr;
-  int                         efd_;
-  int                         ev_fd_;
-  int                         nl80211_id_;
-  std::mutex                  mutex_;
+  int                ifid_;
+  sa_family_t        family_;
+  struct sockaddr_nl nladdr_ = {0};
+  struct nl_sock*    sock_ = nullptr;
+  struct nl_sock*    ev_sock_ = nullptr;
+  int                efd_;
+  int                ev_fd_;
+  int                nl80211_id_;
+  std::mutex         mutex_;

  unsigned long long bandwidth_down_total_;
  unsigned long long bandwidth_up_total_;

+  std::string state_;
  std::string essid_;
  std::string ifname_;
  std::string ipaddr_;
  std::string netmask_;
  int         cidr_;
-  bool        linked_;
  int32_t     signal_strength_dbm_;
  uint8_t     signal_strength_;
  uint32_t    frequency_;
+
+  util::SleeperThread thread_;
+  util::SleeperThread thread_timer_;
 };

 }  // namespace waybar::modules
--- a/include/modules/pulseaudio.hpp
+++ b/include/modules/pulseaudio.hpp
@ -21,14 +21,13 @@ class Pulseaudio : public ALabel {
  static void sourceInfoCb(pa_context*, const pa_source_info* i, int, void* data);
  static void serverInfoCb(pa_context*, const pa_server_info*, void*);
  static void volumeModifyCb(pa_context*, int, void*);
-  bool        handleVolume(GdkEventScroll* e);

+  bool              handleScroll(GdkEventScroll* e);
  const std::string getPortIcon() const;

  pa_threaded_mainloop* mainloop_;
  pa_mainloop_api*      mainloop_api_;
  pa_context*           context_;
-  bool                  scrolling_;
  // SINK
  uint32_t    sink_idx_{0};
  uint16_t    volume_;
--- a/include/modules/sni/tray.hpp
+++ b/include/modules/sni/tray.hpp
@ -1,7 +1,7 @@
 #pragma once

 #include <fmt/format.h>
-#include "IModule.hpp"
+#include "AModule.hpp"
 #include "bar.hpp"
 #include "modules/sni/host.hpp"
 #include "modules/sni/watcher.hpp"
@ -9,19 +9,17 @@

 namespace waybar::modules::SNI {

-class Tray : public IModule {
+class Tray : public AModule {
 public:
  Tray(const std::string&, const Bar&, const Json::Value&);
  ~Tray() = default;
  auto update() -> void;
-       operator Gtk::Widget&();

 private:
  void onAdd(std::unique_ptr<Item>& item);
  void onRemove(std::unique_ptr<Item>& item);

  static inline std::size_t nb_hosts_ = 0;
-  const Json::Value&        config_;
  Gtk::Box                  box_;
  SNI::Watcher              watcher_;
  SNI::Host                 host_;
--- a/include/modules/sway/ipc/client.hpp
+++ b/include/modules/sway/ipc/client.hpp
@ -5,7 +5,6 @@
 #include <sys/un.h>
 #include <unistd.h>
 #include <cstring>
-#include <iostream>
 #include <memory>
 #include <mutex>
 #include "ipc.hpp"
--- a/include/modules/sway/mode.hpp
+++ b/include/modules/sway/mode.hpp
@ -5,8 +5,8 @@
 #include "bar.hpp"
 #include "client.hpp"
 #include "modules/sway/ipc/client.hpp"
-#include "util/sleeper_thread.hpp"
 #include "util/json.hpp"
+#include "util/sleeper_thread.hpp"

 namespace waybar::modules::sway {

@ -20,10 +20,12 @@ class Mode : public ALabel, public sigc::trackable {
  void onEvent(const struct Ipc::ipc_response&);
  void worker();

-  waybar::util::SleeperThread thread_;
-  Ipc                         ipc_;
-  std::string                 mode_;
+  std::string      mode_;
  util::JsonParser parser_;
+  std::mutex       mutex_;
+
+  util::SleeperThread thread_;
+  Ipc                 ipc_;
 };

-}  // namespace waybar::modules::sway
+}  // namespace waybar::modules::sway
--- a/include/modules/sway/window.hpp
+++ b/include/modules/sway/window.hpp
@ -21,17 +21,21 @@ class Window : public ALabel, public sigc::trackable {
  void                                                   onEvent(const struct Ipc::ipc_response&);
  void                                                   onCmd(const struct Ipc::ipc_response&);
  void                                                   worker();
-  std::tuple<std::size_t, int, std::string, std::string> getFocusedNode(const Json::Value& nodes);
+  std::tuple<std::size_t, int, std::string, std::string> getFocusedNode(const Json::Value& nodes,
+                                                                        std::string&       output);
  void                                                   getTree();

-  const Bar&                  bar_;
-  waybar::util::SleeperThread thread_;
-  Ipc                         ipc_;
-  std::mutex                  mutex_;
-  std::string                 window_;
-  int                         windowId_;
-  std::string                 app_id_;
-  util::JsonParser            parser_;
+  const Bar&       bar_;
+  std::string      window_;
+  int              windowId_;
+  std::string      app_id_;
+  std::string      old_app_id_;
+  std::size_t      app_nb_;
+  util::JsonParser parser_;
+  std::mutex       mutex_;
+
+  util::SleeperThread thread_;
+  Ipc                 ipc_;
 };

 }  // namespace waybar::modules::sway
--- a/include/modules/sway/workspaces.hpp
+++ b/include/modules/sway/workspaces.hpp
@ -3,7 +3,7 @@
 #include <fmt/format.h>
 #include <gtkmm/button.h>
 #include <gtkmm/label.h>
-#include "IModule.hpp"
+#include "AModule.hpp"
 #include "bar.hpp"
 #include "client.hpp"
 #include "modules/sway/ipc/client.hpp"
@ -12,12 +12,11 @@

 namespace waybar::modules::sway {

-class Workspaces : public IModule, public sigc::trackable {
+class Workspaces : public AModule, public sigc::trackable {
 public:
  Workspaces(const std::string&, const waybar::Bar&, const Json::Value&);
  ~Workspaces() = default;
  auto update() -> void;
-       operator Gtk::Widget&();

 private:
  void              onCmd(const struct Ipc::ipc_response&);
@ -33,16 +32,15 @@ class Workspaces : public IModule, public sigc::trackable {
  bool              handleScroll(GdkEventScroll*);

  const Bar&                                   bar_;
-  const Json::Value&                           config_;
  std::vector<Json::Value>                     workspaces_;
  std::vector<std::string>                     workspaces_order_;
-  waybar::util::SleeperThread                  thread_;
-  std::mutex                                   mutex_;
  Gtk::Box                                     box_;
-  Ipc                                          ipc_;
  util::JsonParser                             parser_;
-  bool                                         scrolling_;
  std::unordered_map<std::string, Gtk::Button> buttons_;
+  std::mutex                                   mutex_;
+
+  util::SleeperThread thread_;
+  Ipc                 ipc_;
 };

 }  // namespace waybar::modules::sway
--- a/include/modules/temperature.hpp
+++ b/include/modules/temperature.hpp
@ -17,8 +17,8 @@ class Temperature : public ALabel {
  std::tuple<uint16_t, uint16_t> getTemperature();
  bool                           isCritical(uint16_t);

-  std::string                 file_path_;
-  waybar::util::SleeperThread thread_;
+  std::string         file_path_;
+  util::SleeperThread thread_;
 };

-}  // namespace waybar::modules
+}  // namespace waybar::modules
--- a/include/util/command.hpp
+++ b/include/util/command.hpp
@ -33,7 +33,7 @@ inline int close(FILE* fp, pid_t pid) {
  fclose(fp);
  while (waitpid(pid, &stat, 0) == -1) {
    if (errno != EINTR) {
-      stat = -1;
+      stat = 0;
      break;
    }
  }
@ -90,6 +90,8 @@ inline int32_t forkExec(std::string cmd) {
    setpgid(pid, pid);
    execl("/bin/sh", "sh", "-c", cmd.c_str(), (char*)0);
    exit(0);
+  } else {
+    signal(SIGCHLD,SIG_IGN);
  }

  return pid;
--- a/include/util/sleeper_thread.hpp
+++ b/include/util/sleeper_thread.hpp
@ -14,7 +14,10 @@ class SleeperThread {

  SleeperThread(std::function<void()> func)
      : thread_{[this, func] {
-          while (do_run_) func();
+          while (do_run_) {
+            signal_ = false;
+            func();
+          }
        }} {}

  SleeperThread& operator=(std::function<void()> func) {
@ -42,7 +45,10 @@ class SleeperThread {
  }

  auto wake_up() {
-    signal_ = true;
+    {
+      std::lock_guard<std::mutex> lck(mutex_);
+      signal_ = true;
+    }
    condvar_.notify_all();
  }

--- a/meson.build
+++ b/meson.build
@ -1,6 +1,6 @@
 project(
    'waybar', 'cpp', 'c',
-    version: '0.6.6',
+    version: '0.7.0',
    license: 'MIT',
    default_options : [
        'cpp_std=c++17',
@ -65,6 +65,7 @@ libmpdclient = dependency('libmpdclient', required: get_option('mpd'))

 src_files = files(
    'src/factory.cpp',
+    'src/AModule.cpp',
    'src/ALabel.cpp',
    'src/modules/memory.cpp',
    'src/modules/battery.cpp',
--- a/resources/custom_modules/mediaplayer.py
+++ b/resources/custom_modules/mediaplayer.py
@ -39,7 +39,7 @@ def on_metadata(player, metadata, manager):
        track_info = '{artist} - {title}'.format(artist=player.get_artist(),
                                                 title=player.get_title())

-    if player.props.status != 'Playing':
+    if player.props.status != 'Playing' and track_info:
        track_info = ' ' + track_info
    write_output(track_info, player)

--- a/resources/style.css
+++ b/resources/style.css
@ -7,10 +7,10 @@
 }

 window#waybar {
-    background: rgba(43, 48, 59, 0.5);
+    background-color: rgba(43, 48, 59, 0.5);
    border-bottom: 3px solid rgba(100, 114, 125, 0.5);
    color: #ffffff;
-    transition-property: background, background-color;
+    transition-property: background-color;
    transition-duration: .5s;
 }

@ -20,10 +20,10 @@ window#waybar.hidden {

 /*
 window#waybar.empty {
-    background: transparent;
+    background-color: transparent;
 }
 window#waybar.solo {
-    background: #FFFFFF;
+    background-color: #FFFFFF;
 }
 */

@ -39,13 +39,13 @@ window#waybar.chromium {
 /* https://github.com/Alexays/Waybar/wiki/FAQ#the-workspace-buttons-have-a-strange-hover-effect */
 #workspaces button {
    padding: 0 5px;
-    background: transparent;
+    background-color: transparent;
    color: #ffffff;
    border-bottom: 3px solid transparent;
 }

 #workspaces button.focused {
-    background: #64727D;
+    background-color: #64727D;
    border-bottom: 3px solid #ffffff;
 }

@ -54,13 +54,24 @@ window#waybar.chromium {
 }

 #mode {
-    background: #64727D;
+    background-color: #64727D;
    border-bottom: 3px solid #ffffff;
 }

-#clock, #battery, #cpu, #memory, #temperature, #backlight, #network, #pulseaudio, #custom-media, #tray, #mode, #idle_inhibitor {
+#clock,
+#battery,
+#cpu,
+#memory,
+#temperature,
+#backlight,
+#network,
+#pulseaudio,
+#custom-media,
+#tray,
+#mode,
+#idle_inhibitor {
    padding: 0 10px;
-    margin: 0 5px;
+    margin: 0 4px;
    color: #ffffff;
 }

@ -86,7 +97,7 @@ window#waybar.chromium {
 }

 #battery.critical:not(.charging) {
-    background: #f53c3c;
+    background-color: #f53c3c;
    color: #ffffff;
    animation-name: blink;
    animation-duration: 0.5s;
@ -100,56 +111,56 @@ label:focus {
 }

 #cpu {
-    background: #2ecc71;
+    background-color: #2ecc71;
    color: #000000;
 }

 #memory {
-    background: #9b59b6;
+    background-color: #9b59b6;
 }

 #backlight {
-    background: #90b1b1;
+    background-color: #90b1b1;
 }

 #network {
-    background: #2980b9;
+    background-color: #2980b9;
 }

 #network.disconnected {
-    background: #f53c3c;
+    background-color: #f53c3c;
 }

 #pulseaudio {
-    background: #f1c40f;
+    background-color: #f1c40f;
    color: #000000;
 }

 #pulseaudio.muted {
-    background: #90b1b1;
+    background-color: #90b1b1;
    color: #2a5c45;
 }

 #custom-media {
-    background: #66cc99;
+    background-color: #66cc99;
    color: #2a5c45;
    min-width: 100px;
 }

-.custom-spotify {
-    background: #66cc99;
+#custom-media.custom-spotify {
+    background-color: #66cc99;
 }

-.custom-vlc {
-    background: #ffa000;
+#custom-media.custom-vlc {
+    background-color: #ffa000;
 }

 #temperature {
-    background: #f0932b;
+    background-color: #f0932b;
 }

 #temperature.critical {
-    background: #eb4d4b;
+    background-color: #eb4d4b;
 }

 #tray {
@ -166,18 +177,18 @@ label:focus {
 }

 #mpd {
-    background: #66cc99;
+    background-color: #66cc99;
    color: #2a5c45;
 }

 #mpd.disconnected {
-    background: #f53c3c;
+    background-color: #f53c3c;
 }

 #mpd.stopped {
-    background: #90b1b1;
+    background-color: #90b1b1;
 }

 #mpd.paused {
-    background: #51a37a;
+    background-color: #51a37a;
 }
--- a/src/ALabel.cpp
+++ b/src/ALabel.cpp
@ -2,14 +2,21 @@
 #include <fmt/format.h>
 #include <util/command.hpp>

-waybar::ALabel::ALabel(const Json::Value& config, const std::string& format, uint16_t interval)
-    : config_(config),
+namespace waybar {
+
+ALabel::ALabel(const Json::Value& config, const std::string& name, const std::string& id,
+               const std::string& format, uint16_t interval)
+    : AModule(config, name, id, config["format-alt"].isString()),
      format_(config_["format"].isString() ? config_["format"].asString() : format),
      interval_(config_["interval"] == "once"
                    ? std::chrono::seconds(100000000)
                    : std::chrono::seconds(
                          config_["interval"].isUInt() ? config_["interval"].asUInt() : interval)),
      default_format_(format_) {
+  label_.set_name(name);
+  if (!id.empty()) {
+    label_.get_style_context()->add_class(id);
+  }
  event_box_.add(label_);
  if (config_["max-length"].isUInt()) {
    label_.set_max_width_chars(config_["max-length"].asUInt());
@ -19,97 +26,13 @@ waybar::ALabel::ALabel(const Json::Value& config, const std::string& format, uin
  if (config_["rotate"].isUInt()) {
    label_.set_angle(config["rotate"].asUInt());
  }
-
-  if (config_["format-alt"].isString()) {
-    event_box_.add_events(Gdk::BUTTON_PRESS_MASK);
-    event_box_.signal_button_press_event().connect(sigc::mem_fun(*this, &ALabel::handleToggle));
-  }
-
-  // configure events' user commands
-  if (config_["on-click"].isString() || config_["on-click-middle"].isString() ||
-      config_["on-click-backward"].isString() || config_["on-click-forward"].isString() ||
-      config_["on-click-right"].isString()) {
-    event_box_.add_events(Gdk::BUTTON_PRESS_MASK);
-    event_box_.signal_button_press_event().connect(sigc::mem_fun(*this, &ALabel::handleToggle));
-  }
-  if (config_["on-scroll-up"].isString() || config_["on-scroll-down"].isString()) {
-    event_box_.add_events(Gdk::SCROLL_MASK | Gdk::SMOOTH_SCROLL_MASK);
-    event_box_.signal_scroll_event().connect(sigc::mem_fun(*this, &ALabel::handleScroll));
-  }
 }

-waybar::ALabel::~ALabel() {
-  for (const auto& pid : pid_) {
-    if (pid != -1) {
-      kill(-pid, 9);
-    }
-  }
-}
-
-auto waybar::ALabel::update() -> void {
+auto ALabel::update() -> void {
  // Nothing here
 }

-bool waybar::ALabel::handleToggle(GdkEventButton* const& e) {
-  std::string format;
-  if (config_["on-click"].isString() && e->button == 1) {
-    format = config_["on-click"].asString();
-  } else if (config_["on-click-middle"].isString() && e->button == 2) {
-    format = config_["on-click-middle"].asString();
-  } else if (config_["on-click-right"].isString() && e->button == 3) {
-    format = config_["on-click-right"].asString();
-  } else if (config_["on-click-forward"].isString() && e->button == 8) {
-    format = config_["on-click-backward"].asString();
-  } else if (config_["on-click-backward"].isString() && e->button == 9) {
-    format = config_["on-click-forward"].asString();
-  }
-  if (!format.empty()) {
-    pid_.push_back(
-        waybar::util::command::forkExec(fmt::format(format, fmt::arg("arg", click_param))));
-  }
-  if (config_["format-alt-click"].isUInt() && e->button == config_["format-alt-click"].asUInt()) {
-    alt_ = !alt_;
-    if (alt_ && config_["format-alt"].isString()) {
-      format_ = config_["format-alt"].asString();
-    } else {
-      format_ = default_format_;
-    }
-  }
-
-  dp.emit();
-  return true;
-}
-
-bool waybar::ALabel::handleScroll(GdkEventScroll* e) {
-  // Avoid concurrent scroll event
-  std::lock_guard<std::mutex> lock(mutex_);
-  bool                        direction_up = false;
-
-  if (e->direction == GDK_SCROLL_UP) {
-    direction_up = true;
-  }
-  if (e->direction == GDK_SCROLL_DOWN) {
-    direction_up = false;
-  }
-  if (e->direction == GDK_SCROLL_SMOOTH) {
-    gdouble delta_x, delta_y;
-    gdk_event_get_scroll_deltas(reinterpret_cast<const GdkEvent*>(e), &delta_x, &delta_y);
-    if (delta_y < 0) {
-      direction_up = true;
-    } else if (delta_y > 0) {
-      direction_up = false;
-    }
-  }
-  if (direction_up && config_["on-scroll-up"].isString()) {
-    pid_.push_back(waybar::util::command::forkExec(config_["on-scroll-up"].asString()));
-  } else if (config_["on-scroll-down"].isString()) {
-    pid_.push_back(waybar::util::command::forkExec(config_["on-scroll-down"].asString()));
-  }
-  dp.emit();
-  return true;
-}
-
-std::string waybar::ALabel::getIcon(uint16_t percentage, const std::string& alt, uint16_t max) {
+std::string ALabel::getIcon(uint16_t percentage, const std::string& alt, uint16_t max) {
  auto format_icons = config_["format-icons"];
  if (format_icons.isObject()) {
    if (!alt.empty() && (format_icons[alt].isString() || format_icons[alt].isArray())) {
@ -129,7 +52,19 @@ std::string waybar::ALabel::getIcon(uint16_t percentage, const std::string& alt,
  return "";
 }

-std::string waybar::ALabel::getState(uint8_t value, bool lesser) {
+bool waybar::ALabel::handleToggle(GdkEventButton* const& e) {
+  if (config_["format-alt-click"].isUInt() && e->button == config_["format-alt-click"].asUInt()) {
+    alt_ = !alt_;
+    if (alt_ && config_["format-alt"].isString()) {
+      format_ = config_["format-alt"].asString();
+    } else {
+      format_ = default_format_;
+    }
+  }
+  return AModule::handleToggle(e);
+}
+
+std::string ALabel::getState(uint8_t value, bool lesser) {
  if (!config_["states"].isObject()) {
    return "";
  }
@ -158,8 +93,4 @@ std::string waybar::ALabel::getState(uint8_t value, bool lesser) {
  return valid_state;
 }

-bool waybar::ALabel::tooltipEnabled() {
-  return config_["tooltip"].isBool() ? config_["tooltip"].asBool() : true;
-}
-
-waybar::ALabel::operator Gtk::Widget&() { return event_box_; }
+}  // namespace waybar
--- a/src/AModule.cpp
+++ b/src/AModule.cpp
@ -0,0 +1,119 @@
+#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)
+    : config_(std::move(config)) {
+  // configure events' user commands
+  if (config_["on-click"].isString() || config_["on-click-middle"].isString() ||
+      config_["on-click-backward"].isString() || config_["on-click-forward"].isString() ||
+      config_["on-click-right"].isString() || enable_click) {
+    event_box_.add_events(Gdk::BUTTON_PRESS_MASK);
+    event_box_.signal_button_press_event().connect(sigc::mem_fun(*this, &AModule::handleToggle));
+  }
+  if (config_["on-scroll-up"].isString() || config_["on-scroll-down"].isString() || enable_scroll) {
+    event_box_.add_events(Gdk::SCROLL_MASK | Gdk::SMOOTH_SCROLL_MASK);
+    event_box_.signal_scroll_event().connect(sigc::mem_fun(*this, &AModule::handleScroll));
+  }
+}
+
+AModule::~AModule() {
+  for (const auto& pid : pid_) {
+    if (pid != -1) {
+      kill(-pid, 9);
+    }
+  }
+}
+
+auto AModule::update() -> void {
+  // Nothing here
+}
+
+bool AModule::handleToggle(GdkEventButton* const& e) {
+  std::string format;
+  if (config_["on-click"].isString() && e->button == 1) {
+    format = config_["on-click"].asString();
+  } else if (config_["on-click-middle"].isString() && e->button == 2) {
+    format = config_["on-click-middle"].asString();
+  } else if (config_["on-click-right"].isString() && e->button == 3) {
+    format = config_["on-click-right"].asString();
+  } else if (config_["on-click-forward"].isString() && e->button == 8) {
+    format = config_["on-click-backward"].asString();
+  } else if (config_["on-click-backward"].isString() && e->button == 9) {
+    format = config_["on-click-forward"].asString();
+  }
+  if (!format.empty()) {
+    pid_.push_back(util::command::forkExec(fmt::format(format, fmt::arg("arg", click_param_))));
+  }
+  dp.emit();
+  return true;
+}
+
+AModule::SCROLL_DIR AModule::getScrollDir(GdkEventScroll* e) {
+  switch (e -> direction) {
+    case GDK_SCROLL_UP: return SCROLL_DIR::UP;
+    case GDK_SCROLL_DOWN: 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};
+
+      distance_scrolled_y_ += e->delta_y;
+      distance_scrolled_x_ += e->delta_x;
+
+      gdouble threshold = 0;
+      if (config_["smooth-scrolling-threshold"].isNumeric()) {
+        threshold = config_["smooth-scrolling-threshold"].asDouble();
+      }
+
+      if (distance_scrolled_y_ < -threshold) {
+        dir = SCROLL_DIR::UP;
+      } else if (distance_scrolled_y_ > threshold) {
+        dir = SCROLL_DIR::DOWN;
+      } else if (distance_scrolled_x_ > threshold) {
+        dir = SCROLL_DIR::RIGHT;
+      } else if (distance_scrolled_x_ < -threshold) {
+        dir = SCROLL_DIR::LEFT;
+      }
+
+      switch (dir) {
+        case SCROLL_DIR::UP:
+        case SCROLL_DIR::DOWN:
+          distance_scrolled_y_ = 0;
+          break;
+        case SCROLL_DIR::LEFT:
+        case SCROLL_DIR::RIGHT:
+          distance_scrolled_x_ = 0;
+          break;
+        case SCROLL_DIR::NONE:
+          break;
+      }
+
+      return dir;
+    }
+    // Silence -Wreturn-type:
+    default: return SCROLL_DIR::NONE;
+  }
+}
+
+bool AModule::handleScroll(GdkEventScroll* e) {
+  auto dir = getScrollDir(e);
+  if (dir == SCROLL_DIR::UP && config_["on-scroll-up"].isString()) {
+    pid_.push_back(util::command::forkExec(config_["on-scroll-up"].asString()));
+  } else if (dir == SCROLL_DIR::DOWN && config_["on-scroll-down"].isString()) {
+    pid_.push_back(util::command::forkExec(config_["on-scroll-down"].asString()));
+  }
+  dp.emit();
+  return true;
+}
+
+bool AModule::tooltipEnabled() {
+  return config_["tooltip"].isBool() ? config_["tooltip"].asBool() : true;
+}
+
+AModule::operator Gtk::Widget&() { return event_box_; }
+
+}  // namespace waybar
--- a/src/bar.cpp
+++ b/src/bar.cpp
@ -9,6 +9,7 @@ waybar::Bar::Bar(struct waybar_output* w_output, const Json::Value& w_config)
      window{Gtk::WindowType::WINDOW_TOPLEVEL},
      surface(nullptr),
      layer_surface(nullptr),
+      anchor_(ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP),
      left_(Gtk::ORIENTATION_HORIZONTAL, 0),
      center_(Gtk::ORIENTATION_HORIZONTAL, 0),
      right_(Gtk::ORIENTATION_HORIZONTAL, 0),
@ -16,46 +17,33 @@ waybar::Bar::Bar(struct waybar_output* w_output, const Json::Value& w_config)
  window.set_title("waybar");
  window.set_name("waybar");
  window.set_decorated(false);
+  window.get_style_context()->add_class(output->name);

  if (config["position"] == "right" || config["position"] == "left") {
    height_ = 0;
    width_ = 1;
  }
+  height_ = config["height"].isUInt() ? config["height"].asUInt() : height_;
+  width_ = config["width"].isUInt() ? config["width"].asUInt() : width_;

-  auto gtk_window = window.gobj();
-  auto gtk_widget = GTK_WIDGET(gtk_window);
-  gtk_widget_realize(gtk_widget);
-  auto gdk_window = window.get_window()->gobj();
-  gdk_wayland_window_set_use_custom_surface(gdk_window);
-  surface = gdk_wayland_window_get_wl_surface(gdk_window);
+  window.signal_realize().connect_notify(sigc::mem_fun(*this, &Bar::onRealize));
+  window.signal_map_event().connect_notify(sigc::mem_fun(*this, &Bar::onMap));
+  window.signal_configure_event().connect_notify(sigc::mem_fun(*this, &Bar::onConfigure));
+  window.set_size_request(width_, height_);

-  std::size_t layer =
-      config["layer"] == "top" ? ZWLR_LAYER_SHELL_V1_LAYER_TOP : ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM;
-  auto client = waybar::Client::inst();
-  layer_surface = zwlr_layer_shell_v1_get_layer_surface(
-      client->layer_shell, surface, output->output, layer, "waybar");
-  static const struct zwlr_layer_surface_v1_listener layer_surface_listener = {
-      .configure = layerSurfaceHandleConfigure,
-      .closed = layerSurfaceHandleClosed,
-  };
-  zwlr_layer_surface_v1_add_listener(layer_surface, &layer_surface_listener, this);
-
-  auto height = config["height"].isUInt() ? config["height"].asUInt() : height_;
-  auto width = config["width"].isUInt() ? config["width"].asUInt() : width_;
-
-  std::size_t anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP;
  if (config["position"] == "bottom") {
-    anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
+    anchor_ = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
  } else if (config["position"] == "left") {
-    anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT;
+    anchor_ = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT;
  } else if (config["position"] == "right") {
-    anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
+    anchor_ = ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
  }
-  if (anchor == ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM || anchor == ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP) {
-    anchor |= ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
-  } else if (anchor == ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT ||
-             anchor == ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT) {
-    anchor |= ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
+  if (anchor_ == ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM ||
+      anchor_ == ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP) {
+    anchor_ |= ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
+  } else if (anchor_ == ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT ||
+             anchor_ == ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT) {
+    anchor_ |= ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
    left_ = Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0);
    center_ = Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0);
    right_ = Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0);
@ -63,17 +51,71 @@ waybar::Bar::Bar(struct waybar_output* w_output, const Json::Value& w_config)
    vertical = true;
  }

-  zwlr_layer_surface_v1_set_anchor(layer_surface, anchor);
-  zwlr_layer_surface_v1_set_size(layer_surface, width, height);
-  setMarginsAndZone(height, width);
+  setupWidgets();
+
+  if (window.get_realized()) {
+    onRealize();
+  }
+  window.show_all();
+}
+
+void waybar::Bar::onConfigure(GdkEventConfigure* ev) {
+  auto tmp_height = height_;
+  auto tmp_width = width_;
+  if (ev->height > static_cast<int>(height_)) {
+    // Default minimal value
+    if (height_ != 1) {
+      spdlog::warn(MIN_HEIGHT_MSG, height_, ev->height);
+    }
+    if (config["height"].isUInt()) {
+      spdlog::info(SIZE_DEFINED, "Height");
+    } else {
+      tmp_height = ev->height;
+    }
+  }
+  if (ev->width > static_cast<int>(width_)) {
+    // Default minimal value
+    if (width_ != 1) {
+      spdlog::warn(MIN_WIDTH_MSG, width_, ev->width);
+    }
+    if (config["width"].isUInt()) {
+      spdlog::info(SIZE_DEFINED, "Width");
+    } else {
+      tmp_width = ev->width;
+    }
+  }
+  if (tmp_width != width_ || tmp_height != height_) {
+    zwlr_layer_surface_v1_set_size(layer_surface, tmp_width, tmp_height);
+  }
+}
+
+void waybar::Bar::onRealize() {
+  auto gdk_window = window.get_window()->gobj();
+  gdk_wayland_window_set_use_custom_surface(gdk_window);
+}
+
+void waybar::Bar::onMap(GdkEventAny* ev) {
+  auto gdk_window = window.get_window()->gobj();
+  surface = gdk_wayland_window_get_wl_surface(gdk_window);
+
+  auto client = waybar::Client::inst();
+  auto layer =
+      config["layer"] == "top" ? ZWLR_LAYER_SHELL_V1_LAYER_TOP : ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM;
+  layer_surface = zwlr_layer_shell_v1_get_layer_surface(
+      client->layer_shell, surface, output->output, layer, "waybar");
+
+  zwlr_layer_surface_v1_set_keyboard_interactivity(layer_surface, false);
+  zwlr_layer_surface_v1_set_anchor(layer_surface, anchor_);
+  zwlr_layer_surface_v1_set_size(layer_surface, width_, height_);
+  setMarginsAndZone(height_, width_);
+  static const struct zwlr_layer_surface_v1_listener layer_surface_listener = {
+      .configure = layerSurfaceHandleConfigure,
+      .closed = layerSurfaceHandleClosed,
+  };
+  zwlr_layer_surface_v1_add_listener(layer_surface, &layer_surface_listener, this);

  wl_surface_commit(surface);
  wl_display_roundtrip(client->wl_display);
-
-  setupWidgets();
-
-  window.set_size_request(width_, height_);
-  window.signal_configure_event().connect_notify(sigc::mem_fun(*this, &Bar::onConfigure));
 }

 void waybar::Bar::setMarginsAndZone(uint32_t height, uint32_t width) {
@ -127,36 +169,6 @@ void waybar::Bar::setMarginsAndZone(uint32_t height, uint32_t width) {
  zwlr_layer_surface_v1_set_exclusive_zone(layer_surface, zone);
 }

-void waybar::Bar::onConfigure(GdkEventConfigure* ev) {
-  auto tmp_height = height_;
-  auto tmp_width = width_;
-  if (ev->height > static_cast<int>(height_)) {
-    // Default minimal value
-    if (height_ != 1) {
-      spdlog::warn(MIN_HEIGHT_MSG, height_, ev->height);
-    }
-    if (config["height"].isUInt()) {
-      spdlog::info(SIZE_DEFINED, "Height");
-    } else {
-      tmp_height = ev->height;
-    }
-  }
-  if (ev->width > static_cast<int>(width_)) {
-    // Default minimal value
-    if (width_ != 1) {
-      spdlog::warn(MIN_WIDTH_MSG, width_, ev->width);
-    }
-    if (config["width"].isUInt()) {
-      spdlog::info(SIZE_DEFINED, "Width");
-    } else {
-      tmp_width = ev->width;
-    }
-  }
-  if (tmp_width != width_ || tmp_height != height_) {
-    zwlr_layer_surface_v1_set_size(layer_surface, tmp_width, tmp_height);
-  }
-}
-
 // Converting string to button code rn as to avoid doing it later
 void waybar::Bar::setupAltFormatKeyForModule(const std::string& module_name) {
  if (config.isMember(module_name)) {
@ -229,9 +241,9 @@ void waybar::Bar::layerSurfaceHandleConfigure(void* data, struct zwlr_layer_surf
    auto zone = o->vertical ? width + o->margins_.right : height + o->margins_.bottom;
    zwlr_layer_surface_v1_set_exclusive_zone(o->layer_surface, zone);
    spdlog::info(BAR_SIZE_MSG,
-                             o->width_ == 1 ? "auto" : std::to_string(o->width_),
-                             o->height_ == 1 ? "auto" : std::to_string(o->height_),
-                             o->output->name);
+                 o->width_ == 1 ? "auto" : std::to_string(o->width_),
+                 o->height_ == 1 ? "auto" : std::to_string(o->height_),
+                 o->output->name);
    wl_surface_commit(o->surface);
  }
  zwlr_layer_surface_v1_ack_configure(surface, serial);
@ -239,7 +251,10 @@ void waybar::Bar::layerSurfaceHandleConfigure(void* data, struct zwlr_layer_surf

 void waybar::Bar::layerSurfaceHandleClosed(void* data, struct zwlr_layer_surface_v1* /*surface*/) {
  auto o = static_cast<waybar::Bar*>(data);
-  zwlr_layer_surface_v1_destroy(o->layer_surface);
+  if (o->layer_surface) {
+    zwlr_layer_surface_v1_destroy(o->layer_surface);
+    o->layer_surface = nullptr;
+  }
  o->modules_left_.clear();
  o->modules_center_.clear();
  o->modules_right_.clear();
@ -272,14 +287,11 @@ void waybar::Bar::getModules(const Factory& factory, const std::string& pos) {
          modules_right_.emplace_back(module);
        }
        module->dp.connect([module, &name] {
-          // Fix https://github.com/Alexays/Waybar/issues/320, proper way?
-          Glib::signal_idle().connect_once([module, &name] {
-            try {
-              module->update();
-            } catch (const std::exception& e) {
-              spdlog::error("{}: {}", name.asString(), e.what());
-            }
-          });
+          try {
+            module->update();
+          } catch (const std::exception& e) {
+            spdlog::error("{}: {}", name.asString(), e.what());
+          }
        });
      } catch (const std::exception& e) {
        spdlog::warn("module {}: {}", name.asString(), e.what());
@ -313,5 +325,4 @@ auto waybar::Bar::setupWidgets() -> void {
  for (auto const& module : modules_right_) {
    right_.pack_end(*module, false, false, 0);
  }
-  window.show_all();
 }
--- a/src/client.cpp
+++ b/src/client.cpp
@ -1,7 +1,7 @@
 #include "client.hpp"
+#include <spdlog/spdlog.h>
 #include <fstream>
 #include <iostream>
-#include <spdlog/spdlog.h>
 #include "util/clara.hpp"
 #include "util/json.hpp"

@ -10,7 +10,7 @@ waybar::Client *waybar::Client::inst() {
  return c;
 }

-const std::string waybar::Client::getValidPath(const std::vector<std::string> &paths) {
+const std::string waybar::Client::getValidPath(const std::vector<std::string> &paths) const {
  wordexp_t p;

  for (const std::string &path : paths) {
@ -172,31 +172,33 @@ void waybar::Client::handleDescription(void * /*data*/, struct zxdg_output_v1 *
  // Nothing here
 }

-void waybar::Client::setupConfigs(const std::string &config, const std::string &style) {
-  config_file_ = config.empty() ? getValidPath({
-                                      "$XDG_CONFIG_HOME/waybar/config",
-                                      "$HOME/.config/waybar/config",
-                                      "$HOME/waybar/config",
-                                      "/etc/xdg/waybar/config",
-                                      "./resources/config",
+std::tuple<const std::string, const std::string> waybar::Client::getConfigs(
+    const std::string &config, const std::string &style) const {
+  auto config_file = config.empty() ? getValidPath({
+                                          "$XDG_CONFIG_HOME/waybar/config",
+                                          "$HOME/.config/waybar/config",
+                                          "$HOME/waybar/config",
+                                          "/etc/xdg/waybar/config",
+                                          "./resources/config",
+                                      })
+                                    : config;
+  auto css_file = style.empty() ? getValidPath({
+                                      "$XDG_CONFIG_HOME/waybar/style.css",
+                                      "$HOME/.config/waybar/style.css",
+                                      "$HOME/waybar/style.css",
+                                      "/etc/xdg/waybar/style.css",
+                                      "./resources/style.css",
                                  })
-                                : config;
-  css_file_ = style.empty() ? getValidPath({
-                                  "$XDG_CONFIG_HOME/waybar/style.css",
-                                  "$HOME/.config/waybar/style.css",
-                                  "$HOME/waybar/style.css",
-                                  "/etc/xdg/waybar/style.css",
-                                  "./resources/style.css",
-                              })
-                            : style;
-  if (css_file_.empty() || config_file_.empty()) {
+                                : style;
+  if (css_file.empty() || config_file.empty()) {
    throw std::runtime_error("Missing required resources files");
  }
-  spdlog::info("Resources files: {}, {}", config_file_, css_file_);
+  spdlog::info("Resources files: {}, {}", config_file, css_file);
+  return {config_file, css_file};
 }

-auto waybar::Client::setupConfig() -> void {
-  std::ifstream file(config_file_);
+auto waybar::Client::setupConfig(const std::string &config_file) -> void {
+  std::ifstream file(config_file);
  if (!file.is_open()) {
    throw std::runtime_error("Can't open config file");
  }
@ -205,12 +207,12 @@ auto waybar::Client::setupConfig() -> void {
  config_ = parser.parse(str);
 }

-auto waybar::Client::setupCss() -> void {
+auto waybar::Client::setupCss(const std::string &css_file) -> void {
  css_provider_ = Gtk::CssProvider::create();
  style_context_ = Gtk::StyleContext::create();

  // Load our css file, wherever that may be hiding
-  if (!css_provider_->load_from_path(css_file_)) {
+  if (!css_provider_->load_from_path(css_file)) {
    throw std::runtime_error("Can't open style file");
  }
 }
@ -229,15 +231,6 @@ void waybar::Client::bindInterfaces() {
 }

 int waybar::Client::main(int argc, char *argv[]) {
-  gtk_app = Gtk::Application::create(argc, argv, "fr.arouillard.waybar");
-  gdk_display = Gdk::Display::get_default();
-  if (!gdk_display) {
-    throw std::runtime_error("Can't find display");
-  }
-  if (!GDK_IS_WAYLAND_DISPLAY(gdk_display->gobj())) {
-    throw std::runtime_error("Bar need to run under Wayland");
-  }
-  wl_display = gdk_wayland_display_get_wl_display(gdk_display->gobj());
  bool        show_help = false;
  bool        show_version = false;
  std::string config;
@ -268,9 +261,18 @@ int waybar::Client::main(int argc, char *argv[]) {
  if (!log_level.empty()) {
    spdlog::set_level(spdlog::level::from_str(log_level));
  }
-  setupConfigs(config, style);
-  setupConfig();
-  setupCss();
+  gtk_app = Gtk::Application::create(argc, argv, "fr.arouillard.waybar");
+  gdk_display = Gdk::Display::get_default();
+  if (!gdk_display) {
+    throw std::runtime_error("Can't find display");
+  }
+  if (!GDK_IS_WAYLAND_DISPLAY(gdk_display->gobj())) {
+    throw std::runtime_error("Bar need to run under Wayland");
+  }
+  wl_display = gdk_wayland_display_get_wl_display(gdk_display->gobj());
+  auto [config_file, css_file] = getConfigs(config, style);
+  setupConfig(config_file);
+  setupCss(css_file);
  bindInterfaces();
  gtk_app->hold();
  gtk_app->run();
--- a/src/factory.cpp
+++ b/src/factory.cpp
@ -2,7 +2,7 @@

 waybar::Factory::Factory(const Bar& bar, const Json::Value& config) : bar_(bar), config_(config) {}

-waybar::IModule* waybar::Factory::makeModule(const std::string& name) const {
+waybar::AModule* waybar::Factory::makeModule(const std::string& name) const {
  try {
    auto hash_pos = name.find('#');
    auto ref = name.substr(0, hash_pos);
@ -64,7 +64,7 @@ waybar::IModule* waybar::Factory::makeModule(const std::string& name) const {
      return new waybar::modules::Temperature(id, config_[name]);
    }
    if (ref.compare(0, 7, "custom/") == 0 && ref.size() > 7) {
-      return new waybar::modules::Custom(ref.substr(7), config_[name]);
+      return new waybar::modules::Custom(ref.substr(7), id, config_[name]);
    }
  } catch (const std::exception& e) {
    auto err = fmt::format("Disabling module \"{}\", {}", name, e.what());
--- a/src/modules/backlight.cpp
+++ b/src/modules/backlight.cpp
@ -88,12 +88,9 @@ int waybar::modules::Backlight::BacklightDev::get_max() const { return max_; }

 void waybar::modules::Backlight::BacklightDev::set_max(int max) { max_ = max; }

-waybar::modules::Backlight::Backlight(const std::string &name, const Json::Value &config)
-    : ALabel(config, "{percent}%", 2),
-      name_(name),
+waybar::modules::Backlight::Backlight(const std::string &id, const Json::Value &config)
+    : ALabel(config, "backlight", id, "{percent}%", 2),
      preferred_device_(config["device"].isString() ? config["device"].asString() : "") {
-  label_.set_name("backlight");
-
  // Get initial state
  {
    std::unique_ptr<udev, UdevDeleter> udev_check{udev_new()};
@ -181,7 +178,7 @@ auto waybar::modules::Backlight::update() -> void {
    const auto percent = best->get_max() == 0 ? 100 : best->get_actual() * 100 / best->get_max();
    label_.set_markup(fmt::format(
        format_, fmt::arg("percent", std::to_string(percent)), fmt::arg("icon", getIcon(percent))));
-   getState(percent);
+    getState(percent);
  } else {
    if (!previous_best_.has_value()) {
      return;
@ -213,7 +210,8 @@ void waybar::modules::Backlight::upsert_device(ForwardIt first, ForwardIt last,
  const char *name = udev_device_get_sysname(dev);
  check_nn(name);

-  const char *actual_brightness_attr = strcmp(name, "amdgpu_bl0") == 0 ? "brightness" : "actual_brightness";
+  const char *actual_brightness_attr =
+      strcmp(name, "amdgpu_bl0") == 0 ? "brightness" : "actual_brightness";

  const char *actual = udev_device_get_sysattr_value(dev, actual_brightness_attr);
  check_nn(actual);
--- a/src/modules/battery.cpp
+++ b/src/modules/battery.cpp
@ -2,11 +2,7 @@
 #include <spdlog/spdlog.h>

 waybar::modules::Battery::Battery(const std::string& id, const Json::Value& config)
-    : ALabel(config, "{capacity}%", 60) {
-  label_.set_name("battery");
-  if (!id.empty()) {
-    label_.get_style_context()->add_class(id);
-  }
+    : ALabel(config, "battery", id, "{capacity}%", 60) {
  getBatteries();
  fd_ = inotify_init1(IN_CLOEXEC);
  if (fd_ == -1) {
--- a/src/modules/clock.cpp
+++ b/src/modules/clock.cpp
@ -1,20 +1,13 @@
 #include "modules/clock.hpp"

 waybar::modules::Clock::Clock(const std::string& id, const Json::Value& config)
-    : ALabel(config, "{:%H:%M}", 60) {
-  label_.set_name("clock");
-  if (!id.empty()) {
-    label_.get_style_context()->add_class(id);
-  }
+    : ALabel(config, "clock", id, "{:%H:%M}", 60) {
  thread_ = [this] {
    dp.emit();
    auto now = std::chrono::system_clock::now();
    auto timeout = std::chrono::floor<std::chrono::seconds>(now + interval_);
-    auto time_s = std::chrono::time_point_cast<std::chrono::seconds>(timeout);
-    auto sub_m =
-        std::chrono::duration_cast<std::chrono::seconds>(time_s.time_since_epoch()).count() %
-        interval_.count();
-    thread_.sleep_until(timeout - std::chrono::seconds(sub_m));
+    auto diff = std::chrono::seconds(timeout.time_since_epoch().count() % interval_.count());
+    thread_.sleep_until(timeout - diff);
  };
 }

--- a/src/modules/cpu.cpp
+++ b/src/modules/cpu.cpp
@ -2,11 +2,7 @@
 #include <numeric>

 waybar::modules::Cpu::Cpu(const std::string& id, const Json::Value& config)
-    : ALabel(config, "{usage}%", 10) {
-  label_.set_name("cpu");
-  if (!id.empty()) {
-    label_.get_style_context()->add_class(id);
-  }
+    : ALabel(config, "cpu", id, "{usage}%", 10) {
  thread_ = [this] {
    dp.emit();
    thread_.sleep_for(interval_);
--- a/src/modules/custom.cpp
+++ b/src/modules/custom.cpp
@ -1,9 +1,9 @@
 #include "modules/custom.hpp"
 #include <spdlog/spdlog.h>

-waybar::modules::Custom::Custom(const std::string& name, const Json::Value& config)
-    : ALabel(config, "{}"), name_(name), fp_(nullptr), pid_(-1) {
-  label_.set_name("custom-" + name_);
+waybar::modules::Custom::Custom(const std::string& name, const std::string& id,
+                                const Json::Value& config)
+    : ALabel(config, "custom-" + name, id, "{}"), name_(name), fp_(nullptr), pid_(-1) {
  if (config_["exec"].isString()) {
    if (interval_.count() > 0) {
      delayWorker();
@ -25,14 +25,14 @@ void waybar::modules::Custom::delayWorker() {
  thread_ = [this] {
    bool can_update = true;
    if (config_["exec-if"].isString()) {
-      auto res = waybar::util::command::exec(config_["exec-if"].asString());
+      auto res = util::command::exec(config_["exec-if"].asString());
      if (res.exit_code != 0) {
        can_update = false;
        event_box_.hide();
      }
    }
    if (can_update) {
-      output_ = waybar::util::command::exec(config_["exec"].asString());
+      output_ = util::command::exec(config_["exec"].asString());
      dp.emit();
    }
    thread_.sleep_for(interval_);
@ -74,7 +74,7 @@ void waybar::modules::Custom::continuousWorker() {
  };
 }

-void waybar::modules::Custom::refresh(int sig /*signal*/) {
+void waybar::modules::Custom::refresh(int sig) {
  if (sig == SIGRTMIN + config_["signal"].asInt()) {
    thread_.wake_up();
  }
@ -102,29 +102,31 @@ auto waybar::modules::Custom::update() -> void {
    } else {
      parseOutputRaw();
    }
-
    auto str = fmt::format(format_,
                           text_,
                           fmt::arg("alt", alt_),
                           fmt::arg("icon", getIcon(percentage_, alt_)),
                           fmt::arg("percentage", percentage_));
-    label_.set_markup(str);
-    if (tooltipEnabled()) {
-      if (text_ == tooltip_) {
-        label_.set_tooltip_text(str);
-      } else {
-        label_.set_tooltip_text(tooltip_);
+    if (str.empty()) {
+      event_box_.hide();
+    } else {
+      label_.set_markup(str);
+      if (tooltipEnabled()) {
+        if (text_ == tooltip_) {
+          label_.set_tooltip_text(str);
+        } else {
+          label_.set_tooltip_text(tooltip_);
+        }
      }
+      auto classes = label_.get_style_context()->list_classes();
+      for (auto const& c : classes) {
+        label_.get_style_context()->remove_class(c);
+      }
+      for (auto const& c : class_) {
+        label_.get_style_context()->add_class(c);
+      }
+      event_box_.show();
    }
-    auto classes = label_.get_style_context()->list_classes();
-    for (auto const& c : classes) {
-      label_.get_style_context()->remove_class(c);
-    }
-    for (auto const& c : class_) {
-      label_.get_style_context()->add_class(c);
-    }
-
-    event_box_.show();
  }
 }

--- a/src/modules/idle_inhibitor.cpp
+++ b/src/modules/idle_inhibitor.cpp
@ -3,15 +3,11 @@

 waybar::modules::IdleInhibitor::IdleInhibitor(const std::string& id, const Bar& bar,
                                              const Json::Value& config)
-    : ALabel(config, "{status}"),
+    : ALabel(config, "idle_inhibitor", id, "{status}"),
      bar_(bar),
      status_("deactivated"),
      idle_inhibitor_(nullptr),
      pid_(-1) {
-  label_.set_name("idle_inhibitor");
-  if (!id.empty()) {
-    label_.get_style_context()->add_class(id);
-  }
  event_box_.add_events(Gdk::BUTTON_PRESS_MASK);
  event_box_.signal_button_press_event().connect(
      sigc::mem_fun(*this, &IdleInhibitor::handleToggle));
--- a/src/modules/memory.cpp
+++ b/src/modules/memory.cpp
@ -1,11 +1,7 @@
 #include "modules/memory.hpp"

 waybar::modules::Memory::Memory(const std::string& id, const Json::Value& config)
-    : ALabel(config, "{}%", 30) {
-  label_.set_name("memory");
-  if (!id.empty()) {
-    label_.get_style_context()->add_class(id);
-  }
+    : ALabel(config, "memory", id, "{}%", 30) {
  thread_ = [this] {
    dp.emit();
    thread_.sleep_for(interval_);
@ -15,12 +11,15 @@ waybar::modules::Memory::Memory(const std::string& id, const Json::Value& config
 auto waybar::modules::Memory::update() -> void {
  parseMeminfo();
  if (memtotal_ > 0 && memfree_ >= 0) {
-    int used_ram_percentage = 100 * (memtotal_ - memfree_) / memtotal_;
+    auto total_ram_gigabytes = memtotal_ / std::pow(1024, 2);
+    int  used_ram_percentage = 100 * (memtotal_ - memfree_) / memtotal_;
    auto used_ram_gigabytes = (memtotal_ - memfree_) / std::pow(1024, 2);
    auto available_ram_gigabytes = memfree_ / std::pow(1024, 2);

    getState(used_ram_percentage);
-    label_.set_markup(fmt::format(format_, used_ram_percentage,
+    label_.set_markup(fmt::format(format_,
+                                  used_ram_percentage,
+                                  fmt::arg("total", total_ram_gigabytes),
                                  fmt::arg("percentage", used_ram_percentage),
                                  fmt::arg("used", used_ram_gigabytes),
                                  fmt::arg("avail", available_ram_gigabytes)));
--- a/src/modules/mpd.cpp
+++ b/src/modules/mpd.cpp
@ -4,7 +4,7 @@
 #include <spdlog/spdlog.h>

 waybar::modules::MPD::MPD(const std::string& id, const Json::Value& config)
-    : ALabel(config, "{album} - {artist} - {title}", 5),
+    : ALabel(config, "mpd", id, "{album} - {artist} - {title}", 5),
      module_name_(id.empty() ? "mpd" : "mpd#" + id),
      server_(nullptr),
      port_(config_["port"].isUInt() ? config["port"].asUInt() : 0),
@ -21,11 +21,6 @@ waybar::modules::MPD::MPD(const std::string& id, const Json::Value& config)
    spdlog::warn("{}: `timeout` configuration should be an unsigned int", module_name_);
  }

-  label_.set_name("mpd");
-  if (!id.empty()) {
-    label_.get_style_context()->add_class(id);
-  }
-
  if (!config["server"].isNull()) {
    if (!config_["server"].isString()) {
      spdlog::warn("{}:`server` configuration should be a string", module_name_);
@ -261,7 +256,7 @@ void waybar::modules::MPD::tryConnect() {
    checkErrors(connection_.get());
    spdlog::info("{}: Connected to MPD", module_name_);
  } catch (std::runtime_error& e) {
-  spdlog::error("{}: Failed to connect to MPD: {}", module_name_, e.what());
+    spdlog::error("{}: Failed to connect to MPD: {}", module_name_, e.what());
    connection_.reset();
    alternate_connection_.reset();
  }
--- a/src/modules/network.cpp
+++ b/src/modules/network.cpp
@ -73,9 +73,8 @@ std::optional<unsigned long long> read_netstat(std::string_view category, std::s
 }  // namespace

 waybar::modules::Network::Network(const std::string &id, const Json::Value &config)
-    : ALabel(config, "{ifname}", 60),
+    : ALabel(config, "network", id, "{ifname}", 60),
      ifid_(-1),
-      last_ext_iface_(-1),
      family_(config["family"] == "ipv6" ? AF_INET6 : AF_INET),
      efd_(-1),
      ev_fd_(-1),
@ -83,11 +82,6 @@ waybar::modules::Network::Network(const std::string &id, const Json::Value &conf
      signal_strength_dbm_(0),
      signal_strength_(0),
      frequency_(0) {
-  label_.set_name("network");
-  if (!id.empty()) {
-    label_.get_style_context()->add_class(id);
-  }
-
  auto down_octets = read_netstat(BANDWIDTH_CATEGORY, BANDWIDTH_DOWN_TOTAL_KEY);
  auto up_octets = read_netstat(BANDWIDTH_CATEGORY, BANDWIDTH_UP_TOTAL_KEY);
  if (down_octets) {
@ -102,10 +96,11 @@ waybar::modules::Network::Network(const std::string &id, const Json::Value &conf
    bandwidth_up_total_ = 0;
  }

-  createInfoSocket();
  createEventSocket();
+  createInfoSocket();
  auto default_iface = getPreferredIface();
  if (default_iface != -1) {
+    ifid_ = default_iface;
    char ifname[IF_NAMESIZE];
    if_indextoname(default_iface, ifname);
    ifname_ = ifname;
@ -126,8 +121,11 @@ waybar::modules::Network::~Network() {
  }
  if (ev_sock_ != nullptr) {
    nl_socket_drop_membership(ev_sock_, RTNLGRP_LINK);
-    nl_socket_drop_membership(ev_sock_, RTNLGRP_IPV4_IFADDR);
-    nl_socket_drop_membership(ev_sock_, RTNLGRP_IPV6_IFADDR);
+    if (family_ == AF_INET) {
+      nl_socket_drop_membership(ev_sock_, RTNLGRP_IPV4_IFADDR);
+    } else {
+      nl_socket_drop_membership(ev_sock_, RTNLGRP_IPV6_IFADDR);
+    }
    nl_close(ev_sock_);
    nl_socket_free(ev_sock_);
  }
@ -137,17 +135,21 @@ waybar::modules::Network::~Network() {
  }
 }

-void waybar::modules::Network::createInfoSocket() {
+void waybar::modules::Network::createEventSocket() {
  ev_sock_ = nl_socket_alloc();
  nl_socket_disable_seq_check(ev_sock_);
  nl_socket_modify_cb(ev_sock_, NL_CB_VALID, NL_CB_CUSTOM, handleEvents, this);
-  nl_join_groups(ev_sock_, RTMGRP_LINK);
+  auto groups = RTMGRP_LINK | (family_ == AF_INET ? RTMGRP_IPV4_IFADDR : RTMGRP_IPV6_IFADDR);
+  nl_join_groups(ev_sock_, groups);  // Deprecated
  if (nl_connect(ev_sock_, NETLINK_ROUTE) != 0) {
    throw std::runtime_error("Can't connect network socket");
  }
  nl_socket_add_membership(ev_sock_, RTNLGRP_LINK);
-  nl_socket_add_membership(ev_sock_, RTNLGRP_IPV4_IFADDR);
-  nl_socket_add_membership(ev_sock_, RTNLGRP_IPV6_IFADDR);
+  if (family_ == AF_INET) {
+    nl_socket_add_membership(ev_sock_, RTNLGRP_IPV4_IFADDR);
+  } else {
+    nl_socket_add_membership(ev_sock_, RTNLGRP_IPV6_IFADDR);
+  }
  efd_ = epoll_create1(EPOLL_CLOEXEC);
  if (efd_ < 0) {
    throw std::runtime_error("Can't create epoll");
@ -174,7 +176,7 @@ void waybar::modules::Network::createInfoSocket() {
  }
 }

-void waybar::modules::Network::createEventSocket() {
+void waybar::modules::Network::createInfoSocket() {
  sock_ = nl_socket_alloc();
  if (genl_connect(sock_) != 0) {
    throw std::runtime_error("Can't connect to netlink socket");
@ -204,9 +206,7 @@ void waybar::modules::Network::worker() {
    int ec = epoll_wait(efd_, events.data(), EPOLL_MAX, -1);
    if (ec > 0) {
      for (auto i = 0; i < ec; i++) {
-        if (events[i].data.fd == nl_socket_get_fd(ev_sock_)) {
-          nl_recvmsgs_default(ev_sock_);
-        } else {
+        if (events[i].data.fd != nl_socket_get_fd(ev_sock_) || nl_recvmsgs_default(ev_sock_) < 0) {
          thread_.stop();
          break;
        }
@ -215,10 +215,16 @@ void waybar::modules::Network::worker() {
  };
 }

+const std::string waybar::modules::Network::getNetworkState() const {
+  if (ifid_ == -1) return "disconnected";
+  if (ipaddr_.empty()) return "linked";
+  if (essid_.empty()) return "ethernet";
+  return "wifi";
+}
+
 auto waybar::modules::Network::update() -> void {
-  std::string                 connectiontype;
-  std::string                 tooltip_format;
  std::lock_guard<std::mutex> lock(mutex_);
+  std::string                 tooltip_format;
  auto down_octets = read_netstat(BANDWIDTH_CATEGORY, BANDWIDTH_DOWN_TOTAL_KEY);
  auto up_octets = read_netstat(BANDWIDTH_CATEGORY, BANDWIDTH_UP_TOTAL_KEY);

@ -233,45 +239,22 @@ auto waybar::modules::Network::update() -> void {
    bandwidth_up = *up_octets - bandwidth_up_total_;
    bandwidth_up_total_ = *up_octets;
  }
-  if (ifid_ <= 0 || !linked_) {
-    if (config_["format-disconnected"].isString()) {
-      default_format_ = config_["format-disconnected"].asString();
-    }
-    if (config_["tooltip-format-disconnected"].isString()) {
-      tooltip_format = config_["tooltip-format-disconnected"].asString();
-    }
-    label_.get_style_context()->add_class("disconnected");
-    connectiontype = "disconnected";
-  } else {
-    if (essid_.empty()) {
-      if (config_["format-ethernet"].isString()) {
-        default_format_ = config_["format-ethernet"].asString();
-      }
-      if (config_["tooltip-format-ethernet"].isString()) {
-        tooltip_format = config_["tooltip-format-ethernet"].asString();
-      }
-      connectiontype = "ethernet";
-    } else if (ipaddr_.empty()) {
-      if (config_["format-linked"].isString()) {
-        default_format_ = config_["format-linked"].asString();
-      }
-      if (config_["tooltip-format-linked"].isString()) {
-        tooltip_format = config_["tooltip-format-linked"].asString();
-      }
-      connectiontype = "linked";
-    } else {
-      if (config_["format-wifi"].isString()) {
-        default_format_ = config_["format-wifi"].asString();
-      }
-      if (config_["tooltip-format-wifi"].isString()) {
-        tooltip_format = config_["tooltip-format-wifi"].asString();
-      }
-      connectiontype = "wifi";
-    }
-    label_.get_style_context()->remove_class("disconnected");
-  }
  if (!alt_) {
+    auto state = getNetworkState();
+    if (!state_.empty() && label_.get_style_context()->has_class(state_)) {
+      label_.get_style_context()->remove_class(state_);
+    }
+    if (config_["format-" + state].isString()) {
+      default_format_ = config_["format-" + state].asString();
+    }
+    if (config_["tooltip-format-" + state].isString()) {
+      tooltip_format = config_["tooltip-format-" + state].asString();
+    }
+    if (!label_.get_style_context()->has_class(state)) {
+      label_.get_style_context()->add_class(state);
+    }
    format_ = default_format_;
+    state_ = state;
  }
  getState(signal_strength_);

@ -305,7 +288,7 @@ auto waybar::modules::Network::update() -> void {
      fmt::arg("ipaddr", ipaddr_),
      fmt::arg("cidr", cidr_),
      fmt::arg("frequency", frequency_),
-      fmt::arg("icon", getIcon(signal_strength_, connectiontype)),
+      fmt::arg("icon", getIcon(signal_strength_, state_)),
      fmt::arg("bandwidthDownBits", pow_format(bandwidth_down * 8ull / interval_.count(), "b/s")),
      fmt::arg("bandwidthUpBits", pow_format(bandwidth_up * 8ull / interval_.count(), "b/s")),
      fmt::arg("bandwidthDownOctets", pow_format(bandwidth_down / interval_.count(), "o/s")),
@ -328,7 +311,7 @@ auto waybar::modules::Network::update() -> void {
          fmt::arg("ipaddr", ipaddr_),
          fmt::arg("cidr", cidr_),
          fmt::arg("frequency", frequency_),
-          fmt::arg("icon", getIcon(signal_strength_, connectiontype)),
+          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")),
@ -344,7 +327,7 @@ auto waybar::modules::Network::update() -> void {
 }

 // Based on https://gist.github.com/Yawning/c70d804d4b8ae78cc698
-int waybar::modules::Network::getExternalInterface(int skip_idx) {
+int waybar::modules::Network::getExternalInterface(int skip_idx) const {
  static const uint32_t route_buffer_size = 8192;
  struct nlmsghdr *     hdr = nullptr;
  struct rtmsg *        rt = nullptr;
@ -462,22 +445,19 @@ int waybar::modules::Network::getExternalInterface(int skip_idx) {
  } while (true);

 out:
-  last_ext_iface_ = ifidx;
  return ifidx;
 }

 void waybar::modules::Network::getInterfaceAddress() {
  unsigned int    cidrRaw;
  struct ifaddrs *ifaddr, *ifa;
-  ipaddr_.clear();
-  netmask_.clear();
  cidr_ = 0;
  int success = getifaddrs(&ifaddr);
  if (success != 0) {
    return;
  }
  ifa = ifaddr;
-  while (ifa != nullptr && ipaddr_.empty() && netmask_.empty()) {
+  while (ifa != nullptr) {
    if (ifa->ifa_addr != nullptr && ifa->ifa_addr->sa_family == family_ &&
        ifa->ifa_name == ifname_) {
      char ipaddr[INET6_ADDRSTRLEN];
@ -489,20 +469,20 @@ void waybar::modules::Network::getInterfaceAddress() {
      auto net_addr = reinterpret_cast<struct sockaddr_in *>(ifa->ifa_netmask);
      netmask_ = inet_ntop(family_, &net_addr->sin_addr, netmask, INET6_ADDRSTRLEN);
      cidrRaw = net_addr->sin_addr.s_addr;
-      linked_ = ifa->ifa_flags & IFF_RUNNING;
      unsigned int cidr = 0;
      while (cidrRaw) {
        cidr += cidrRaw & 1;
        cidrRaw >>= 1;
      }
      cidr_ = cidr;
+      break;
    }
    ifa = ifa->ifa_next;
  }
  freeifaddrs(ifaddr);
 }

-int waybar::modules::Network::netlinkRequest(void *req, uint32_t reqlen, uint32_t groups) {
+int waybar::modules::Network::netlinkRequest(void *req, uint32_t reqlen, uint32_t groups) const {
  struct sockaddr_nl sa = {};
  sa.nl_family = AF_NETLINK;
  sa.nl_groups = groups;
@ -516,7 +496,7 @@ int waybar::modules::Network::netlinkRequest(void *req, uint32_t reqlen, uint32_
  return sendmsg(nl_socket_get_fd(ev_sock_), &msg, 0);
 }

-int waybar::modules::Network::netlinkResponse(void *resp, uint32_t resplen, uint32_t groups) {
+int waybar::modules::Network::netlinkResponse(void *resp, uint32_t resplen, uint32_t groups) const {
  struct sockaddr_nl sa = {};
  sa.nl_family = AF_NETLINK;
  sa.nl_groups = groups;
@ -539,20 +519,23 @@ bool waybar::modules::Network::checkInterface(struct ifinfomsg *rtif, std::strin
    return config_["interface"].asString() == name ||
           wildcardMatch(config_["interface"].asString(), name);
  }
-  auto external_iface = getExternalInterface();
-  if (external_iface == -1) {
-    // Try with lastest working external iface
-    return last_ext_iface_ == rtif->ifi_index;
+  // getExternalInterface may need some delay to detect external interface
+  for (uint8_t tries = 0; tries < MAX_RETRY; tries += 1) {
+    auto external_iface = getExternalInterface();
+    if (external_iface > 0) {
+      return external_iface == rtif->ifi_index;
+    }
+    std::this_thread::sleep_for(std::chrono::milliseconds(500));
  }
-  return external_iface == rtif->ifi_index;
+  return false;
 }

-int waybar::modules::Network::getPreferredIface(int skip_idx) {
+int waybar::modules::Network::getPreferredIface(int skip_idx) const {
+  int ifid = -1;
  if (config_["interface"].isString()) {
-    ifid_ = if_nametoindex(config_["interface"].asCString());
-    if (ifid_ > 0) {
-      ifname_ = config_["interface"].asString();
-      return ifid_;
+    ifid = if_nametoindex(config_["interface"].asCString());
+    if (ifid > 0) {
+      return ifid;
    } else {
      // Try with wildcard
      struct ifaddrs *ifaddr, *ifa;
@ -561,24 +544,26 @@ int waybar::modules::Network::getPreferredIface(int skip_idx) {
        return -1;
      }
      ifa = ifaddr;
-      ifid_ = -1;
+      ifid = -1;
      while (ifa != nullptr) {
-        if (wildcardMatch(config_["interface"].asString(), ifa->ifa_name)) {
-          ifid_ = if_nametoindex(ifa->ifa_name);
+        if (ifa->ifa_addr->sa_family == family_ &&
+            wildcardMatch(config_["interface"].asString(), ifa->ifa_name)) {
+          ifid = if_nametoindex(ifa->ifa_name);
          break;
        }
        ifa = ifa->ifa_next;
      }
      freeifaddrs(ifaddr);
-      return ifid_;
+      return ifid;
    }
  }
-  ifid_ = getExternalInterface(skip_idx);
-  if (ifid_ > 0) {
-    char ifname[IF_NAMESIZE];
-    if_indextoname(ifid_, ifname);
-    ifname_ = ifname;
-    return ifid_;
+  // getExternalInterface may need some delay to detect external interface
+  for (uint8_t tries = 0; tries < MAX_RETRY; tries += 1) {
+    ifid = getExternalInterface(skip_idx);
+    if (ifid > 0) {
+      return ifid;
+    }
+    std::this_thread::sleep_for(std::chrono::milliseconds(500));
  }
  return -1;
 }
@ -591,64 +576,80 @@ void waybar::modules::Network::clearIface() {
  signal_strength_dbm_ = 0;
  signal_strength_ = 0;
  frequency_ = 0;
-  linked_ = false;
+}
+
+void waybar::modules::Network::checkNewInterface(struct ifinfomsg *rtif) {
+  auto new_iface = getPreferredIface(rtif->ifi_index);
+  if (new_iface != -1) {
+    ifid_ = new_iface;
+    char ifname[IF_NAMESIZE];
+    if_indextoname(new_iface, ifname);
+    ifname_ = ifname;
+    getInterfaceAddress();
+    thread_timer_.wake_up();
+  } else {
+    ifid_ = -1;
+    dp.emit();
+  }
 }

 int waybar::modules::Network::handleEvents(struct nl_msg *msg, void *data) {
  auto                        net = static_cast<waybar::modules::Network *>(data);
-  auto                        nh = nlmsg_hdr(msg);
  std::lock_guard<std::mutex> lock(net->mutex_);
-
-  if (nh->nlmsg_type == RTM_NEWADDR) {
-    auto rtif = static_cast<struct ifinfomsg *>(NLMSG_DATA(nh));
-    char ifname[IF_NAMESIZE];
-    if_indextoname(rtif->ifi_index, ifname);
-    // Auto detected network can also be assigned here
-    if ((net->ifid_ == -1 || rtif->ifi_index != net->ifid_) && net->checkInterface(rtif, ifname)) {
-      // If iface is different, clear data
-      if (rtif->ifi_index != net->ifid_) {
-        net->clearIface();
-      }
-      net->linked_ = true;
-      net->ifname_ = ifname;
-      net->ifid_ = rtif->ifi_index;
-    }
+  auto                        nh = nlmsg_hdr(msg);
+  auto                        ifi = static_cast<struct ifinfomsg *>(NLMSG_DATA(nh));
+  if (nh->nlmsg_type == RTM_DELADDR) {
    // Check for valid interface
-    if (rtif->ifi_index == net->ifid_) {
-      net->linked_ = true;
-      // Get Iface and WIFI info
-      net->getInterfaceAddress();
-      net->thread_timer_.wake_up();
-    }
-  } else if (nh->nlmsg_type == RTM_DELADDR) {
-    auto rtif = static_cast<struct ifinfomsg *>(NLMSG_DATA(nh));
-    // Check for valid interface
-    if (rtif->ifi_index == net->ifid_) {
+    if (ifi->ifi_index == net->ifid_) {
      net->ipaddr_.clear();
      net->netmask_.clear();
      net->cidr_ = 0;
-      net->dp.emit();
-    }
-  } else if (nh->nlmsg_type < RTM_NEWADDR) {
-    auto rtif = static_cast<struct ifinfomsg *>(NLMSG_DATA(nh));
-    char ifname[IF_NAMESIZE];
-    if_indextoname(rtif->ifi_index, ifname);
-    // Check for valid interface
-    if (rtif->ifi_flags & IFF_RUNNING && net->checkInterface(rtif, ifname)) {
-      net->linked_ = true;
-      net->ifname_ = ifname;
-      net->ifid_ = rtif->ifi_index;
-      net->dp.emit();
-    } else if (rtif->ifi_index == net->ifid_) {
-      net->clearIface();
-      // Check for a new interface and get info
-      auto new_iface = net->getPreferredIface(rtif->ifi_index);
-      if (new_iface != -1) {
-        net->getInterfaceAddress();
-        net->thread_timer_.wake_up();
+      if (!(ifi->ifi_flags & IFF_RUNNING)) {
+        net->clearIface();
+        // Check for a new interface and get info
+        net->checkNewInterface(ifi);
      } else {
        net->dp.emit();
      }
+      return NL_OK;
+    }
+  } else if (nh->nlmsg_type == RTM_NEWLINK || nh->nlmsg_type == RTM_DELLINK) {
+    char ifname[IF_NAMESIZE];
+    if_indextoname(ifi->ifi_index, ifname);
+    // Check for valid interface
+    if (ifi->ifi_index != net->ifid_ && net->checkInterface(ifi, ifname)) {
+      net->ifname_ = ifname;
+      net->ifid_ = ifi->ifi_index;
+      // Get Iface and WIFI info
+      net->getInterfaceAddress();
+      net->thread_timer_.wake_up();
+      return NL_OK;
+    } else if (ifi->ifi_index == net->ifid_ &&
+               (!(ifi->ifi_flags & IFF_RUNNING) || !(ifi->ifi_flags & IFF_UP) ||
+                !net->checkInterface(ifi, ifname))) {
+      net->clearIface();
+      // Check for a new interface and get info
+      net->checkNewInterface(ifi);
+      return NL_OK;
+    }
+  } else {
+    char ifname[IF_NAMESIZE];
+    if_indextoname(ifi->ifi_index, ifname);
+    // Auto detected network can also be assigned here
+    if (ifi->ifi_index != net->ifid_ && net->checkInterface(ifi, ifname)) {
+      // If iface is different, clear data
+      if (ifi->ifi_index != net->ifid_) {
+        net->clearIface();
+      }
+      net->ifname_ = ifname;
+      net->ifid_ = ifi->ifi_index;
+    }
+    // Check for valid interface
+    if (ifi->ifi_index == net->ifid_) {
+      // Get Iface and WIFI info
+      net->getInterfaceAddress();
+      net->thread_timer_.wake_up();
+      return NL_OK;
    }
  }
  return NL_SKIP;
@ -686,11 +687,10 @@ int waybar::modules::Network::handleScan(struct nl_msg *msg, void *data) {
  net->parseEssid(bss);
  net->parseSignal(bss);
  net->parseFreq(bss);
-  return NL_SKIP;
+  return NL_OK;
 }

 void waybar::modules::Network::parseEssid(struct nlattr **bss) {
-  essid_.clear();
  if (bss[NL80211_BSS_INFORMATION_ELEMENTS] != nullptr) {
    auto       ies = static_cast<char *>(nla_data(bss[NL80211_BSS_INFORMATION_ELEMENTS]));
    auto       ies_len = nla_len(bss[NL80211_BSS_INFORMATION_ELEMENTS]);
@ -763,7 +763,8 @@ auto waybar::modules::Network::getInfo() -> void {
 }

 // https://gist.github.com/rressi/92af77630faf055934c723ce93ae2495
-bool waybar::modules::Network::wildcardMatch(const std::string &pattern, const std::string &text) {
+bool waybar::modules::Network::wildcardMatch(const std::string &pattern,
+                                             const std::string &text) const {
  auto P = int(pattern.size());
  auto T = int(text.size());

--- a/src/modules/pulseaudio.cpp
+++ b/src/modules/pulseaudio.cpp
@ -1,21 +1,16 @@
 #include "modules/pulseaudio.hpp"

 waybar::modules::Pulseaudio::Pulseaudio(const std::string &id, const Json::Value &config)
-    : ALabel(config, "{volume}%"),
+    : ALabel(config, "pulseaudio", id, "{volume}%"),
      mainloop_(nullptr),
      mainloop_api_(nullptr),
      context_(nullptr),
-      scrolling_(false),
      sink_idx_(0),
      volume_(0),
      muted_(false),
      source_idx_(0),
      source_volume_(0),
      source_muted_(false) {
-  label_.set_name("pulseaudio");
-  if (!id.empty()) {
-    label_.get_style_context()->add_class(id);
-  }
  mainloop_ = pa_threaded_mainloop_new();
  if (mainloop_ == nullptr) {
    throw std::runtime_error("pa_mainloop_new() failed.");
@ -36,13 +31,6 @@ waybar::modules::Pulseaudio::Pulseaudio(const std::string &id, const Json::Value
    throw std::runtime_error("pa_mainloop_run() failed.");
  }
  pa_threaded_mainloop_unlock(mainloop_);
-
-  // define the pulse scroll events only when no user provided
-  // events are configured
-  if (!config["on-scroll-up"].isString() && !config["on-scroll-down"].isString()) {
-    event_box_.add_events(Gdk::SCROLL_MASK | Gdk::SMOOTH_SCROLL_MASK);
-    event_box_.signal_scroll_event().connect(sigc::mem_fun(*this, &Pulseaudio::handleVolume));
-  }
 }

 waybar::modules::Pulseaudio::~Pulseaudio() {
@ -78,50 +66,33 @@ void waybar::modules::Pulseaudio::contextStateCb(pa_context *c, void *data) {
  }
 }

-bool waybar::modules::Pulseaudio::handleVolume(GdkEventScroll *e) {
-  // Avoid concurrent scroll event
-  if (scrolling_) {
-    return false;
+bool waybar::modules::Pulseaudio::handleScroll(GdkEventScroll *e) {
+  // change the pulse volume only when no user provided
+  // events are configured
+  if (config_["on-scroll-up"].isString() || config_["on-scroll-down"].isString()) {
+    return AModule::handleScroll(e);
  }
-  bool        direction_up = false;
-  double      volume_tick = (double)PA_VOLUME_NORM / 100;
+  auto dir = AModule::getScrollDir(e);
+  if (dir == SCROLL_DIR::NONE) {
+    return true;
+  }
+  double      volume_tick = static_cast<double>(PA_VOLUME_NORM) / 100;
  pa_volume_t change = volume_tick;
  pa_cvolume  pa_volume = pa_volume_;
-  scrolling_ = true;
-  if (e->direction == GDK_SCROLL_UP) {
-    direction_up = true;
-  }
-  if (e->direction == GDK_SCROLL_DOWN) {
-    direction_up = false;
-  }
-
-  if (e->direction == GDK_SCROLL_SMOOTH) {
-    gdouble delta_x, delta_y;
-    gdk_event_get_scroll_deltas(reinterpret_cast<const GdkEvent *>(e), &delta_x, &delta_y);
-    if (delta_y < 0) {
-      direction_up = true;
-    } else if (delta_y > 0) {
-      direction_up = false;
-    }
-  }
-
  // isDouble returns true for integers as well, just in case
  if (config_["scroll-step"].isDouble()) {
    change = round(config_["scroll-step"].asDouble() * volume_tick);
  }
-
-  if (direction_up) {
+  if (dir == SCROLL_DIR::UP) {
    if (volume_ + 1 < 100) {
      pa_cvolume_inc(&pa_volume, change);
    }
-  } else {
+  } else if (dir == SCROLL_DIR::DOWN) {
    if (volume_ - 1 >= 0) {
      pa_cvolume_dec(&pa_volume, change);
    }
  }
-
  pa_context_set_sink_volume_by_index(context_, sink_idx_, &pa_volume, volumeModifyCb, this);
-
  return true;
 }

@ -132,6 +103,10 @@ void waybar::modules::Pulseaudio::subscribeCb(pa_context *                 conte
                                              pa_subscription_event_type_t type, uint32_t idx,
                                              void *data) {
  unsigned facility = type & PA_SUBSCRIPTION_EVENT_FACILITY_MASK;
+  unsigned operation = type & PA_SUBSCRIPTION_EVENT_TYPE_MASK;
+  if (operation != PA_SUBSCRIPTION_EVENT_CHANGE) {
+    return;
+  }
  if (facility == PA_SUBSCRIPTION_EVENT_SINK) {
    pa_context_get_sink_info_by_index(context, idx, sinkInfoCb, data);
  } else if (facility == PA_SUBSCRIPTION_EVENT_SOURCE) {
@ -249,7 +224,4 @@ auto waybar::modules::Pulseaudio::update() -> void {
  if (tooltipEnabled()) {
    label_.set_tooltip_text(desc_);
  }
-  if (scrolling_) {
-    scrolling_ = false;
-  }
 }
--- a/src/modules/sni/item.cpp
+++ b/src/modules/sni/item.cpp
@ -1,6 +1,6 @@
+#include "modules/sni/item.hpp"
 #include <glibmm/main.h>
 #include <spdlog/spdlog.h>
-#include "modules/sni/item.hpp"

 template <>
 struct fmt::formatter<Glib::ustring> : formatter<std::string> {
@ -334,7 +334,7 @@ void Item::makeMenu(GdkEventButton* const& ev) {
 bool Item::handleClick(GdkEventButton* const& ev) {
  auto parameters = Glib::VariantContainerBase::create_tuple(
      {Glib::Variant<int>::create(ev->x), Glib::Variant<int>::create(ev->y)});
-  if ((ev->button == 1 && item_is_menu) || ev->button == 3) {
+  if ((ev->button == 1 && (item_is_menu || !menu.empty())) || ev->button == 3) {
    makeMenu(ev);
    if (gtk_menu != nullptr) {
 #if GTK_CHECK_VERSION(3, 22, 0)
--- a/src/modules/sni/tray.cpp
+++ b/src/modules/sni/tray.cpp
@ -4,15 +4,16 @@
 namespace waybar::modules::SNI {

 Tray::Tray(const std::string& id, const Bar& bar, const Json::Value& config)
-    : config_(config),
+    : AModule(config, "tray", id),
      box_(bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0),
      watcher_(nb_hosts_),
      host_(nb_hosts_, config, std::bind(&Tray::onAdd, this, std::placeholders::_1),
            std::bind(&Tray::onRemove, this, std::placeholders::_1)) {
-  box_.set_name("tray");
  spdlog::warn(
      "For a functionnal tray you must have libappindicator-* installed and export "
      "XDG_CURRENT_DESKTOP=Unity");
+  box_.set_name("tray");
+  event_box_.add(box_);
  if (!id.empty()) {
    box_.get_style_context()->add_class(id);
  }
@ -41,6 +42,4 @@ auto Tray::update() -> void {
  }
 }

-Tray::operator Gtk::Widget&() { return box_; }
-
 }  // namespace waybar::modules::SNI
--- a/src/modules/sway/ipc/client.cpp
+++ b/src/modules/sway/ipc/client.cpp
@ -142,4 +142,4 @@ void Ipc::handleEvent() {
  signal_event.emit(res);
 }

-}  // namespace waybar::modules::sway
+}  // namespace waybar::modules::sway
--- a/src/modules/sway/mode.cpp
+++ b/src/modules/sway/mode.cpp
@ -3,11 +3,7 @@

 namespace waybar::modules::sway {

-Mode::Mode(const std::string& id, const Json::Value& config) : ALabel(config, "{}") {
-  label_.set_name("mode");
-  if (!id.empty()) {
-    label_.get_style_context()->add_class(id);
-  }
+Mode::Mode(const std::string& id, const Json::Value& config) : ALabel(config, "mode", id, "{}") {
  ipc_.subscribe(R"(["mode"])");
  ipc_.signal_event.connect(sigc::mem_fun(*this, &Mode::onEvent));
  // Launch worker
@ -17,6 +13,7 @@ Mode::Mode(const std::string& id, const Json::Value& config) : ALabel(config, "{

 void Mode::onEvent(const struct Ipc::ipc_response& res) {
  try {
+    std::lock_guard<std::mutex> lock(mutex_);
    auto payload = parser_.parse(res.payload);
    if (payload["change"] != "default") {
      mode_ = Glib::Markup::escape_text(payload["change"].asString());
--- a/src/modules/sway/window.cpp
+++ b/src/modules/sway/window.cpp
@ -4,13 +4,8 @@
 namespace waybar::modules::sway {

 Window::Window(const std::string& id, const Bar& bar, const Json::Value& config)
-    : ALabel(config, "{}"), bar_(bar), windowId_(-1) {
-  label_.set_name("window");
-  if (!id.empty()) {
-    label_.get_style_context()->add_class(id);
-  }
+    : ALabel(config, "window", id, "{}"), bar_(bar), windowId_(-1) {
  if (label_.get_max_width_chars() == -1) {
-    label_.set_hexpand(true);
    label_.set_ellipsize(Pango::EllipsizeMode::ELLIPSIZE_END);
  }
  ipc_.subscribe(R"(["window","workspace"])");
@ -28,33 +23,9 @@ void Window::onCmd(const struct Ipc::ipc_response& res) {
  try {
    std::lock_guard<std::mutex> lock(mutex_);
    auto payload = parser_.parse(res.payload);
-    auto [nb, id, name, app_id] = getFocusedNode(payload);
-    if (!app_id_.empty()) {
-      bar_.window.get_style_context()->remove_class(app_id_);
-    }
-    if (nb == 0) {
-      bar_.window.get_style_context()->remove_class("solo");
-      if (!bar_.window.get_style_context()->has_class("empty")) {
-        bar_.window.get_style_context()->add_class("empty");
-      }
-    } else if (nb == 1) {
-      bar_.window.get_style_context()->remove_class("empty");
-      if (!bar_.window.get_style_context()->has_class("solo")) {
-        bar_.window.get_style_context()->add_class("solo");
-      }
-      if (!app_id.empty() && !bar_.window.get_style_context()->has_class(app_id)) {
-        bar_.window.get_style_context()->add_class(app_id);
-      }
-    } else {
-      bar_.window.get_style_context()->remove_class("solo");
-      bar_.window.get_style_context()->remove_class("empty");
-    }
-    app_id_ = app_id;
-    if (windowId_ != id || window_ != name) {
-      windowId_ = id;
-      window_ = name;
-      dp.emit();
-    }
+    auto output = payload["ouput"].isString() ? payload["output"].asString() : "";
+    std::tie(app_nb_, windowId_, window_, app_id_) = getFocusedNode(payload["nodes"], output);
+    dp.emit();
  } catch (const std::exception& e) {
    spdlog::error("Window: {}", e.what());
  }
@ -71,6 +42,27 @@ void Window::worker() {
 }

 auto Window::update() -> void {
+  if (!old_app_id_.empty()) {
+    bar_.window.get_style_context()->remove_class(old_app_id_);
+  }
+  if (app_nb_ == 0) {
+    bar_.window.get_style_context()->remove_class("solo");
+    if (!bar_.window.get_style_context()->has_class("empty")) {
+      bar_.window.get_style_context()->add_class("empty");
+    }
+  } else if (app_nb_ == 1) {
+    bar_.window.get_style_context()->remove_class("empty");
+    if (!bar_.window.get_style_context()->has_class("solo")) {
+      bar_.window.get_style_context()->add_class("solo");
+    }
+    if (!app_id_.empty() && !bar_.window.get_style_context()->has_class(app_id_)) {
+      bar_.window.get_style_context()->add_class(app_id_);
+      old_app_id_ = app_id_;
+    }
+  } else {
+    bar_.window.get_style_context()->remove_class("solo");
+    bar_.window.get_style_context()->remove_class("empty");
+  }
  label_.set_markup(fmt::format(format_, window_));
  if (tooltipEnabled()) {
    label_.set_tooltip_text(window_);
@ -78,20 +70,28 @@ auto Window::update() -> void {
 }

 std::tuple<std::size_t, int, std::string, std::string> Window::getFocusedNode(
-    const Json::Value& nodes) {
-  for (auto const& node : nodes["nodes"]) {
-    if (node["focused"].asBool() && node["type"] == "con") {
-      if ((!config_["all-outputs"].asBool() && nodes["output"] == bar_.output->name) ||
+    const Json::Value& nodes, std::string& output) {
+  for (auto const& node : nodes) {
+    if (node["output"].isString()) {
+      output = node["output"].asString();
+    }
+    if (node["focused"].asBool() && (node["type"] == "con" || node["type"] == "floating_con")) {
+      if ((!config_["all-outputs"].asBool() && output == bar_.output->name) ||
          config_["all-outputs"].asBool()) {
        auto app_id = node["app_id"].isString() ? node["app_id"].asString()
                                                : node["window_properties"]["instance"].asString();
-        return {nodes["nodes"].size(),
+        return {nodes.size(),
                node["id"].asInt(),
                Glib::Markup::escape_text(node["name"].asString()),
                app_id};
      }
    }
-    auto [nb, id, name, app_id] = getFocusedNode(node);
+    auto [nb, id, name, app_id] = getFocusedNode(node["nodes"], output);
+    if (id > -1 && !name.empty()) {
+      return {nb, id, name, app_id};
+    }
+    // Search for floating node
+    std::tie(nb, id, name, app_id) = getFocusedNode(node["floating_nodes"], output);
    if (id > -1 && !name.empty()) {
      return {nb, id, name, app_id};
    }
--- a/src/modules/sway/workspaces.cpp
+++ b/src/modules/sway/workspaces.cpp
@ -4,19 +4,19 @@
 namespace waybar::modules::sway {

 Workspaces::Workspaces(const std::string &id, const Bar &bar, const Json::Value &config)
-    : bar_(bar),
-      config_(config),
-      box_(bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0),
-      scrolling_(false) {
+    : AModule(config, "workspaces", id, false, !config["disable-scroll"].asBool()),
+      bar_(bar),
+      box_(bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0) {
  box_.set_name("workspaces");
  if (!id.empty()) {
    box_.get_style_context()->add_class(id);
  }
+  event_box_.add(box_);
  ipc_.subscribe(R"(["workspace"])");
  ipc_.signal_event.connect(sigc::mem_fun(*this, &Workspaces::onEvent));
  ipc_.signal_cmd.connect(sigc::mem_fun(*this, &Workspaces::onCmd));
  ipc_.sendCmd(IPC_GET_WORKSPACES);
-  if (!config["disable-bar-scroll"].asBool()) {
+  if (config["enable-bar-scroll"].asBool()) {
    auto &window = const_cast<Bar &>(bar_).window;
    window.add_events(Gdk::SCROLL_MASK | Gdk::SMOOTH_SCROLL_MASK);
    window.signal_scroll_event().connect(sigc::mem_fun(*this, &Workspaces::handleScroll));
@ -36,9 +36,9 @@ void Workspaces::onEvent(const struct Ipc::ipc_response &res) {
 void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
  if (res.type == IPC_GET_WORKSPACES) {
    try {
-      auto payload = parser_.parse(res.payload);
-      if (payload.isArray()) {
+      {
        std::lock_guard<std::mutex> lock(mutex_);
+        auto                        payload = parser_.parse(res.payload);
        workspaces_.clear();
        std::copy_if(payload.begin(),
                     payload.end(),
@ -80,6 +80,7 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
              // Adding to all outputs
              Json::Value v;
              v["name"] = p_w_name;
+              v["target_output"] = "";
              workspaces_.emplace_back(std::move(v));
            }
          }
@ -90,16 +91,11 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
                      return lhs["name"].asString() < rhs["name"].asString();
                    });
        }
-
-        dp.emit();
      }
+      dp.emit();
    } catch (const std::exception &e) {
      spdlog::error("Workspaces: {}", e.what());
    }
-  } else {
-    if (scrolling_) {
-      scrolling_ = false;
-    }
  }
 }

@ -154,6 +150,11 @@ auto Workspaces::update() -> void {
    } else {
      button.get_style_context()->remove_class("urgent");
    }
+    if ((*it)["target_output"].isString()) {
+      button.get_style_context()->add_class("persistant");
+    } else {
+      button.get_style_context()->remove_class("persistant");
+    }
    if (needReorder) {
      box_.reorder_child(button, it - workspaces_.begin());
    }
@ -175,8 +176,8 @@ auto Workspaces::update() -> void {
 }

 Gtk::Button &Workspaces::addButton(const Json::Value &node) {
-  auto  pair = buttons_.emplace(node["name"].asString(), node["name"].asString());
-  auto &button = pair.first->second;
+  auto   pair = buttons_.emplace(node["name"].asString(), node["name"].asString());
+  auto &&button = pair.first->second;
  box_.pack_start(button, false, false, 0);
  button.set_relief(Gtk::RELIEF_NONE);
  button.signal_clicked().connect([this, node] {
@ -195,10 +196,6 @@ Gtk::Button &Workspaces::addButton(const Json::Value &node) {
      spdlog::error("Workspaces: {}", e.what());
    }
  });
-  if (!config_["disable-scroll"].asBool()) {
-    button.add_events(Gdk::SCROLL_MASK | Gdk::SMOOTH_SCROLL_MASK);
-    button.signal_scroll_event().connect(sigc::mem_fun(*this, &Workspaces::handleScroll));
-  }
  return button;
 }

@ -217,46 +214,27 @@ std::string Workspaces::getIcon(const std::string &name, const Json::Value &node
 }

 bool Workspaces::handleScroll(GdkEventScroll *e) {
-  // Avoid concurrent scroll event
-  if (scrolling_) {
-    return false;
+  auto dir = AModule::getScrollDir(e);
+  if (dir == SCROLL_DIR::NONE) {
+    return true;
+  }
+  std::lock_guard<std::mutex> lock(mutex_);
+  auto it = std::find_if(workspaces_.begin(), workspaces_.end(), [](const auto &workspace) {
+    return workspace["focused"].asBool();
+  });
+  if (it == workspaces_.end()) {
+    return true;
  }
  std::string name;
-  scrolling_ = true;
-  {
-    std::lock_guard<std::mutex> lock(mutex_);
-    auto it = std::find_if(workspaces_.begin(), workspaces_.end(), [](const auto &workspace) {
-      return workspace["focused"].asBool();
-    });
-    if (it == workspaces_.end()) {
-      scrolling_ = false;
-      return false;
-    }
-    switch (e->direction) {
-      case GDK_SCROLL_DOWN:
-      case GDK_SCROLL_RIGHT:
-        name = getCycleWorkspace(it, false);
-        break;
-      case GDK_SCROLL_UP:
-      case GDK_SCROLL_LEFT:
-        name = getCycleWorkspace(it, true);
-        break;
-      case GDK_SCROLL_SMOOTH:
-        gdouble delta_x, delta_y;
-        gdk_event_get_scroll_deltas(reinterpret_cast<const GdkEvent *>(e), &delta_x, &delta_y);
-        if (delta_y < 0) {
-          name = getCycleWorkspace(it, true);
-        } else if (delta_y > 0) {
-          name = getCycleWorkspace(it, false);
-        }
-        break;
-      default:
-        break;
-    }
-    if (name.empty() || name == (*it)["name"].asString()) {
-      scrolling_ = false;
-      return false;
-    }
+  if (dir == SCROLL_DIR::DOWN || dir == SCROLL_DIR::RIGHT) {
+    name = getCycleWorkspace(it, false);
+  } else if (dir == SCROLL_DIR::UP || dir == SCROLL_DIR::LEFT) {
+    name = getCycleWorkspace(it, true);
+  } else {
+    return true;
+  }
+  if (name == (*it)["name"].asString()) {
+    return true;
  }
  try {
    ipc_.sendCmd(IPC_COMMAND, fmt::format("workspace \"{}\"", name));
@ -305,6 +283,4 @@ void Workspaces::onButtonReady(const Json::Value &node, Gtk::Button &button) {
  }
 }

-Workspaces::operator Gtk::Widget &() { return box_; }
-
 }  // namespace waybar::modules::sway
--- a/src/modules/temperature.cpp
+++ b/src/modules/temperature.cpp
@ -1,7 +1,7 @@
 #include "modules/temperature.hpp"

 waybar::modules::Temperature::Temperature(const std::string& id, const Json::Value& config)
-    : ALabel(config, "{temperatureC}°C", 10) {
+    : ALabel(config, "temperature", id, "{temperatureC}°C", 10) {
  if (config_["hwmon-path"].isString()) {
    file_path_ = config_["hwmon-path"].asString();
  } else {
@ -12,10 +12,6 @@ waybar::modules::Temperature::Temperature(const std::string& id, const Json::Val
  if (!temp.is_open()) {
    throw std::runtime_error("Can't open " + file_path_);
  }
-  label_.set_name("temperature");
-  if (!id.empty()) {
-    label_.get_style_context()->add_class(id);
-  }
  thread_ = [this] {
    dp.emit();
    thread_.sleep_for(interval_);
@ -58,4 +54,4 @@ std::tuple<uint16_t, uint16_t> waybar::modules::Temperature::getTemperature() {
 bool waybar::modules::Temperature::isCritical(uint16_t temperature_c) {
  return config_["critical-threshold"].isInt() &&
         temperature_c >= config_["critical-threshold"].asInt();
-}
+}
Author	SHA1	Message	Date
Alex	9c8e39c30c	chore: 0.7.0	2019-06-22 18:17:16 +02:00
Alex	5b270dae0d	refactor: AModule (#387 ) refactor: AModule	2019-06-22 18:15:50 +02:00
Alex	c621afb0c4	Merge branch 'master' into clean	2019-06-22 18:15:34 +02:00
Alex	bcf4725349	Cleanup on clean branch (#391 ) Cleanup on clean branch	2019-06-18 09:43:34 +02:00
Patrick Hilhorst	12b30ca25f	AModule::getScrollDir: convert reset if-else into switch	2019-06-17 20:42:19 +02:00
Patrick Hilhorst	86d6668ed4	AModule::getScrollDir: convert if-else chain into switch statement	2019-06-17 20:40:13 +02:00
Patrick Hilhorst	7c85aec8e0	AModule::getScrollDir: get deltas in a more C++ way	2019-06-17 20:29:37 +02:00
Patrick Hilhorst	2c038d1977	AModule::getScrollDir: move `dir` inside the only scope it is relevant	2019-06-17 20:09:53 +02:00
Alex	ff9d598c16	fix: add proper mutex	2019-06-17 11:39:45 +02:00
Alex	71a9a75aad	refactor: remove fix workaround	2019-06-16 15:14:31 +02:00
Alex	05f796158b	fix: typo	2019-06-16 15:13:40 +02:00
Alex	1d2dd953e7	revert: default config	2019-06-16 15:09:26 +02:00
Alex	527144a440	refactor(pulseaudio): proper scroll override	2019-06-16 15:08:08 +02:00
Alex	cda6282277	Merge pull request #389 from Synthetica9/x-scroll AModule: handle X axis scrolling	2019-06-16 14:54:53 +02:00
Patrick Hilhorst	7f13478396	AModule: handle X axis scrolling	2019-06-16 13:17:34 +02:00
Alex	90a9c0e25f	refactor: get rid of some mutex	2019-06-15 15:01:03 +02:00
Alex	340ec7be91	refactor: AModule	2019-06-15 14:57:52 +02:00
Alex	e7eef6b493	Merge pull request #385 from nenad/patch/add-total-memory Expose total memory to the formatting directive	2019-06-15 11:16:30 +02:00
Nenad Stojanovikj	1b7068e61d	Expose total memory to the formatting directive	2019-06-14 22:48:16 +02:00
Alex	dabe2bebbb	feat(sway/window): handle floating nodes	2019-06-14 11:27:40 +02:00
Alex	486b5a5d38	fix(sway/window): check output recursively	2019-06-14 10:57:22 +02:00
Alex	11bbc3b24d	Fix twitchy scrolling on touchpads (#381 ) Fix twitchy scrolling on touchpads	2019-06-14 10:38:25 +02:00
Alex	7f74de977c	chore: 0.6.9	2019-06-14 10:27:41 +02:00
Alex	028b184f7b	fix(workspaces): persistant class with empty outputs	2019-06-12 09:50:33 +02:00
Alex	564fdcb369	fix(custom): exit status	2019-06-11 22:09:47 +02:00
Patrick Hilhorst	396f7d4525	Workspaces: implement horizontal continuous scrolling	2019-06-11 18:44:54 +02:00
Alex	3c9b533997	fix(window): avoid hexpand	2019-06-11 17:57:17 +02:00
Patrick Hilhorst	ae397c8fa2	ALabel: add smooth-scrolling-threshold	2019-06-11 17:56:10 +02:00
Alex	ec75be0bc3	fix(Tray): click behaviour	2019-06-11 17:53:16 +02:00
Patrick Hilhorst	ed4521d113	Workspaces: fix twitchy scrolling on touchpads Previously, any and all scroll events were interpreted as reason to switch workspaces. This resulted in twitchy behaviour, where the scrolling was practically unusable. Now, we pool all scroll values, and only scroll if the value is larger than the new config option "smooth-scrolling-threshold". If this option is not set, the behaviour is unchanged.	2019-06-11 17:22:24 +02:00
Alex	c2e9ed6091	feat(workspaces): add class to persistant workspaces	2019-06-11 14:08:48 +02:00
Alex	a37b4687ff	Revert "refactor(window): we don't need to subscribe workspace events" This reverts commit `648eecdd83`.	2019-06-11 14:06:31 +02:00
Alex	ee29a35aa5	Update README.md	2019-06-11 13:55:35 +02:00
Alex	0be8e200ce	adds the wl output name as a css class (#373 ) adds the wl output name as a css class	2019-06-10 12:15:05 +02:00
razic	46e5dd93d4	adds the wl output name as a css class now you can have a custom styling for each bar	2019-06-08 11:04:34 -07:00
Alex	2ee4a51546	chore: 0.6.8	2019-06-08 18:33:17 +02:00
Alex	91996a85c1	Merge pull request #372 from rianadon/patch-1 Increase specificity of media stylings	2019-06-08 18:28:42 +02:00
rianadon	460d25ac45	Increase specificity of media stylings Because of CSS specificity rules, the `#custom-media` style will always override the `custom-spotify` and `custom-vlc` styles, so the background of the media element is always green rather than sometimes orange when VLC is running. I added `#custom-media` in front of each of the class selectors to increase their specificity so they take precedence.	2019-06-07 22:18:06 -07:00
Alex	648eecdd83	refactor(window): we don't need to subscribe workspace events	2019-06-07 15:08:33 +02:00
Alex	f04ff38567	Merge pull request #370 from toke/bugfix/upstream-369 Prevent zombie apocalypse by ignoring SIGCHLD	2019-06-06 12:07:03 +02:00
Thomas Kerpe	d20a586734	Prevent zombie apocalypse by ignoring SIGCHLD Fixes Issue #369	2019-06-05 14:35:25 +02:00
Alex	1962caf144	refactor(window): gtk stuff in update method	2019-06-04 17:34:00 +02:00
Alex	9dbf057f58	fix(custom): hide on empty format	2019-06-03 09:50:35 +02:00
Alex	918146c16b	style: prefer background-color property	2019-05-31 17:20:14 +02:00
Alex	0b01b35c76	refactor(pulseaudio): only watch changes	2019-05-31 16:21:01 +02:00
Alex	f3fb955d75	chore: 0.6.7	2019-05-31 12:15:01 +02:00
Alex	fcf2d18a01	refactor: destroy threads first	2019-05-29 17:53:22 +02:00
Alex	b05d4cd413	fix(network): retry around all getExternalInterface	2019-05-29 16:17:40 +02:00
Alex	9b89fc6470	refactor: disable bar scroll by default	2019-05-28 16:11:33 +02:00
Alex	c06725aa69	fix(network): better disconnect handler	2019-05-28 11:21:59 +02:00
Alex	5ae5821929	refactor(network): re-add MAX_RETRY in order to detect external interface	2019-05-28 11:08:48 +02:00
Alex	74e40432e5	fix(network): linked state	2019-05-28 09:58:48 +02:00
Alex	6e69af8967	refactor(custon): avoid useless logic	2019-05-27 00:08:16 +02:00
Alex	be2fa743eb	refactor(custon): hide on empty text	2019-05-27 00:05:29 +02:00
Alex	5fdb122829	Create FUNDING.yml	2019-05-26 23:55:46 +02:00
Alex	6e73c6db61	refactor(network): remove last_ext_iface_	2019-05-26 23:16:09 +02:00
Alex	253366baf4	refactor(network): remove useless assignment	2019-05-26 22:40:29 +02:00
Alex	ecec02c8be	refactor(network): better events handler	2019-05-26 22:36:26 +02:00
Alex	070619fa34	revert: restore idle fix	2019-05-26 20:09:05 +02:00
Alex	d4ace4b4d8	fix(network): subscribe only wanted family	2019-05-26 20:06:27 +02:00
Alex	5fd92b3c28	fix(network): don't check IFF_UP	2019-05-26 19:53:10 +02:00
Alex	c0a39f34cd	refactor(network): don't clear ipaddr	2019-05-25 18:02:36 +02:00
Alex	2a9fa1a4b9	refactor(bar): onRealize, onMap	2019-05-25 17:50:45 +02:00
Alex	07147878a9	refactor(network): code cleaning	2019-05-24 09:49:56 +02:00
Alex	ffadd5c1a7	refactor: avoid useless class vars	2019-05-24 09:49:09 +02:00
Alex	2b34f3a30f	refactor: parse args before app creation	2019-05-23 10:13:49 +02:00
Alex	85d60f95c4	refactor(network): const methods	2019-05-22 22:20:50 +02:00
Alex	755d38d4d6	fix(custom): bad alloc	2019-05-22 19:46:56 +02:00
Alex	b673279a43	style: remove non wanted comment	2019-05-22 12:22:56 +02:00
Alex	9e1200ae32	refactor: also pass id to custom modules	2019-05-22 12:20:13 +02:00
Alex	e999cca7a6	style: don't specify included namespaces	2019-05-22 12:15:59 +02:00
Alex	d24d85bebf	refactor: move label name and id to label contructor	2019-05-22 12:06:24 +02:00
Alex	97bd637f5d	refactor(clock): avoid usless time_point_cast	2019-05-22 11:51:33 +02:00
Alex	23d4a811db	refactor(clock): avoid usless duration_cast	2019-05-22 11:48:02 +02:00