chore: v0.9.4

revert: restore eventfd

.clang-format

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

.editorconfig

@@ -0,0 +1,19 @@
+# EditorConfig configuration for Waybar
+# http://EditorConfig.org
+
+# Top-most EditorConfig file
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+charset = utf-8
+
+[*.{build,css}]
+indent_style = space
+indent_size = 4
+
+[*.{hpp,cpp}]
+indent_style = space
+indent_size = 2

.github/FUNDING.yml

@@ -0,0 +1,4 @@
+# These are supported funding model platforms
+
+github: Alexays
+custom: https://paypal.me/ARouillard

.travis.yml

@@ -1,18 +1,36 @@
-sudo: false
+language: cpp
 
 services:
     - docker
 
+git:
+    submodules: false
+
 env:
     - distro: debian
     - distro: archlinux
-    # - distro: opensuse
+    - distro: fedora
+    - distro: alpine
+    - distro: opensuse
 
 before_install:
     - docker pull alexays/waybar:${distro}
+    - find . -type f \( -name '*.cpp' -o -name '*.h' \) -print0 | xargs -r0 clang-format -i
 
 script:
     - echo FROM alexays/waybar:${distro} > Dockerfile
     - echo ADD . /root >> Dockerfile
     - docker build -t waybar .
-    - docker run waybar /bin/sh -c "cd /root && git clone https://github.com/swaywm/wlroots subprojects/wlroots && meson build && ninja -C build"
+    - docker run waybar /bin/sh -c "cd /root && meson build -Dman-pages=enabled && ninja -C build"
+
+jobs:
+  include:
+    - os: freebsd
+      compiler: clang
+      env:
+      before_install:
+        - sudo pkg install -y gtk-layer-shell gtkmm30 jsoncpp libdbusmenu
+               libfmt libmpdclient libudev-devd meson pulseaudio scdoc spdlog
+      script:
+        - meson build -Dman-pages=enabled
+        - ninja -C build

Dockerfiles/alpine

@@ -0,0 +1,5 @@
+# vim: ft=Dockerfile
+
+FROM alpine:latest
+
+RUN apk add --no-cache git meson alpine-sdk libinput-dev wayland-dev wayland-protocols mesa-dev libxkbcommon-dev eudev-dev pixman-dev gtkmm3-dev jsoncpp-dev pugixml-dev libnl3-dev pulseaudio-dev libmpdclient-dev scdoc

Dockerfiles/archlinux

@@ -1,4 +1,6 @@
+# vim: ft=Dockerfile
+
 FROM archlinux/base:latest
 
 RUN pacman -Syu --noconfirm && \
-    pacman -S git meson base-devel libinput wayland wayland-protocols pixman libxkbcommon mesa gtkmm3 jsoncpp --noconfirm
+    pacman -S git meson base-devel libinput wayland wayland-protocols pixman libxkbcommon mesa gtkmm3 jsoncpp pugixml scdoc libpulse libdbusmenu-gtk3 libmpdclient gobject-introspection --noconfirm

Dockerfiles/debian

@@ -1,5 +1,7 @@
+# vim: ft=Dockerfile
+
 FROM debian:sid
 
 RUN apt-get update && \
-    apt-get install -y build-essential meson ninja-build git pkg-config libinput10 libinput-dev wayland-protocols libwayland-client0 libwayland-cursor0 libwayland-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev libxkbcommon-dev libudev-dev libpixman-1-dev libgtkmm-3.0-dev libjsoncpp-dev && \
-    apt-get clean
+    apt-get install -y build-essential meson ninja-build git pkg-config libinput10 libpugixml-dev libinput-dev wayland-protocols libwayland-client0 libwayland-cursor0 libwayland-dev libegl1-mesa-dev libgles2-mesa-dev libgbm-dev libxkbcommon-dev libudev-dev libpixman-1-dev libgtkmm-3.0-dev libjsoncpp-dev scdoc libdbusmenu-gtk3-dev libnl-3-dev libnl-genl-3-dev libpulse-dev libmpdclient-dev gobject-introspection libgirepository1.0-dev && \
+    apt-get clean

Dockerfiles/fedora

@@ -0,0 +1,7 @@
+# vim: ft=Dockerfile
+
+FROM fedora:32
+
+RUN dnf install sway meson git libinput-devel wayland-devel wayland-protocols-devel pugixml-devel egl-wayland-devel mesa-libEGL-devel mesa-libGLES-devel mesa-libgbm-devel libxkbcommon-devel libudev-devel pixman-devel gtkmm30-devel jsoncpp-devel scdoc -y && \
+    dnf group install "C Development Tools and Libraries" -y && \
+    dnf clean all -y

Dockerfiles/opensuse

@@ -1,5 +1,7 @@
+# vim: ft=Dockerfile
+
 FROM opensuse/tumbleweed:latest
 
 RUN zypper -n up && \
     zypper -n install -t pattern devel_C_C++ && \
-    zypper -n install git meson clang libinput10 libinput-devel libwayland-client0 libwayland-cursor0 wayland-protocols-devel wayland-devel Mesa-libEGL-devel Mesa-libGLESv2-devel libgbm-devel libxkbcommon-devel libudev-devel libpixman-1-0-devel gtkmm3-devel jsoncpp-devel
+    zypper -n install git meson clang libinput10 libinput-devel pugixml-devel libwayland-client0 libwayland-cursor0 wayland-protocols-devel wayland-devel Mesa-libEGL-devel Mesa-libGLESv2-devel libgbm-devel libxkbcommon-devel libudev-devel libpixman-1-0-devel gtkmm3-devel jsoncpp-devel scdoc

Makefile

@@ -1,6 +1,6 @@
 .PHONY: build build-debug run clean default install
 
-default: run
+default: build
 
 build:
 	meson build

README.md

@@ -1,28 +1,42 @@
 # Waybar [![Travis](https://travis-ci.org/Alexays/Waybar.svg?branch=master)](https://travis-ci.org/Alexays/Waybar) [![Licence](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE) [![Paypal Donate](https://img.shields.io/badge/Donate-Paypal-2244dd.svg)](https://paypal.me/ARouillard)<br>![Waybar](https://raw.githubusercontent.com/alexays/waybar/master/preview-2.png)
-**Proof of concept**
 
 > Highly customizable Wayland bar for Sway and Wlroots based compositors.<br>
-> Available on [AUR](https://aur.archlinux.org/packages/waybar-git/) and [openSUSE](https://build.opensuse.org/package/show/X11:Wayland/waybar)
+> Available in Arch [community](https://www.archlinux.org/packages/community/x86_64/waybar/) or
+[AUR](https://aur.archlinux.org/packages/waybar-git/), [openSUSE](https://build.opensuse.org/package/show/X11:Wayland/waybar), and [Alpine Linux](https://pkgs.alpinelinux.org/packages?name=waybar)<br>
+> *Waybar [examples](https://github.com/Alexays/Waybar/wiki/Examples)*
 
-**Current features**
+#### Current features
 - Sway (Workspaces, Binding mode, Focused window name)
-- Tray (Beta) [#21](https://github.com/Alexays/Waybar/issues/21)
+- Tray [#21](https://github.com/Alexays/Waybar/issues/21)
 - Local time
 - Battery
 - Network
+- Bluetooth
 - Pulseaudio
+- Disk
 - Memory
 - Cpu load average
 - Temperature
+- MPD
 - Custom scripts
 - Multiple output configuration
 - And much more customizations
 
-**Configuration and Styling**
+#### Configuration and Styling
 
 [See the wiki for more details](https://github.com/Alexays/Waybar/wiki).
 
-**How to build**
+### Installation
+
+Waybar is available from a number of Linux distributions:
+
+[![Packaging status](https://repology.org/badge/vertical-allrepos/waybar.svg)](https://repology.org/project/waybar/versions)
+
+An Ubuntu PPA with more recent versions is available
+[here](https://launchpad.net/~nschloe/+archive/ubuntu/waybar).
+
+
+#### Building from source
 
 ```bash
 $ git clone https://github.com/Alexays/Waybar
@@ -40,17 +54,54 @@ $ waybar
 ```
 gtkmm3
 jsoncpp
-libinput
 libsigc++
 fmt
 wayland
-wlroots
+chrono-date
+spdlog
+libgtk-3-dev [gtk-layer-shell]
+gobject-introspection [gtk-layer-shell]
+libgirepository1.0-dev [gtk-layer-shell]
 libpulse [Pulseaudio module]
 libnl [Network module]
-sway [Sway modules]
+libappindicator-gtk3 [Tray module]
 libdbusmenu-gtk3 [Tray module]
+libmpdclient [MPD module]
 ```
 
+**Build dependencies**
+
+```
+cmake
+meson
+scdoc
+wayland-protocols
+```
+
+On Ubuntu you can install all the relevant dependencies using this command (tested with 19.10 and 20.04):
+
+```
+sudo apt install \
+  clang-tidy \
+  gobject-introspection \
+  libdbusmenu-gtk3-dev \
+  libfmt-dev \
+  libgirepository1.0-dev \
+  libgtk-3-dev \
+  libgtkmm-3.0-dev \
+  libinput-dev \
+  libjsoncpp-dev \
+  libmpdclient-dev \
+  libnl-3-dev \
+  libnl-genl-3-dev \
+  libpulse-dev \
+  libsigc++-2.0-dev \
+  libspdlog-dev \
+  libwayland-dev \
+  scdoc
+```
+
+
 Contributions welcome! - have fun :)<br>
 The style guidelines is [Google's](https://google.github.io/styleguide/cppguide.html)
 

include/ALabel.hpp

@@ -1,35 +1,31 @@
 #pragma once
 
-#include <json/json.h>
-#include "IModule.hpp"
 #include <glibmm/markup.h>
-#include <gtkmm/eventbox.h>
 #include <gtkmm/label.h>
+#include <json/json.h>
+#include "AModule.hpp"
 
 namespace waybar {
 
-class ALabel : public IModule {
-public:
-  ALabel(const Json::Value &, const std::string format, uint16_t interval = 0);
+class ALabel : public AModule {
+ public:
+  ALabel(const Json::Value &, const std::string &, const std::string &, const std::string &format,
+         uint16_t interval = 0, bool ellipsize = false, bool enable_click = false, bool enable_scroll = false);
   virtual ~ALabel() = default;
-  virtual auto update() -> void;
-  virtual std::string getIcon(uint16_t, const std::string &alt = "");
-  virtual operator Gtk::Widget &();
+  virtual auto        update() -> void;
+  virtual std::string getIcon(uint16_t, const std::string &alt = "", uint16_t max = 0);
+  virtual std::string getIcon(uint16_t, std::vector<std::string> &alts, uint16_t max = 0);
 
-protected:
-  bool tooltipEnabled();
-
-  Gtk::EventBox event_box_;
-  Gtk::Label label_;
-  const Json::Value &config_;
-  std::string format_;
-  std::mutex mutex_;
+ protected:
+  Gtk::Label                 label_;
+  std::string                format_;
+  std::string                click_param;
   const std::chrono::seconds interval_;
-  bool alt_ = false;
-  std::string default_format_;
+  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);
 };
 
-} // namespace waybar
+}  // namespace waybar

include/AModule.hpp

@@ -0,0 +1,41 @@
+#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 std::string  name_;
+  const Json::Value &config_;
+  Gtk::EventBox      event_box_;
+
+  virtual bool handleToggle(GdkEventButton *const &ev);
+  virtual bool handleScroll(GdkEventScroll *);
+
+ private:
+  std::vector<int> pid_;
+  gdouble          distance_scrolled_y_;
+  gdouble          distance_scrolled_x_;
+};
+
+}  // namespace waybar

include/IModule.hpp

@@ -1,17 +1,14 @@
 #pragma once
 
-#include <glibmm/dispatcher.h>
-#include <gtkmm/box.h>
 #include <gtkmm/widget.h>
 
 namespace waybar {
 
 class IModule {
-  public:
-    virtual ~IModule() = default;
-    virtual auto update() -> void = 0;
-    virtual operator Gtk::Widget &() = 0;
-    Glib::Dispatcher dp; // Hmmm Maybe I should create an abstract class ?
+ public:
+  virtual ~IModule() = default;
+  virtual auto     update() -> void = 0;
+  virtual          operator Gtk::Widget &() = 0;
 };
 
-}
+}  // namespace waybar

include/bar.hpp

@@ -1,72 +1,94 @@
 #pragma once
 
-#include <json/json.h>
+#include <gdkmm/monitor.h>
 #include <glibmm/refptr.h>
-#include <gtkmm/main.h>
+#include <gtkmm/box.h>
 #include <gtkmm/cssprovider.h>
+#include <gtkmm/main.h>
 #include <gtkmm/window.h>
+#include <json/json.h>
+#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"
-#include "idle-inhibit-unstable-v1-client-protocol.h"
-#include "IModule.hpp"
 
 namespace waybar {
 
-class Client;
 class Factory;
+struct waybar_output {
+  Glib::RefPtr<Gdk::Monitor> monitor;
+  std::string                name;
 
-class Bar {
-  public:
-    Bar(const Client&, std::unique_ptr<struct wl_output *>&&, uint32_t);
-    Bar(const Bar&) = delete;
-    ~Bar() = default;
-
-    auto toggle() -> void;
-    void handleSignal(int);
-
-    const Client& client;
-    Gtk::Window window;
-    struct wl_surface *surface;
-    struct zwlr_layer_surface_v1 *layer_surface;
-    std::unique_ptr<struct wl_output *> output;
-    std::string output_name;
-    uint32_t wl_name;
-    bool visible = true;
-  private:
-    static void handleLogicalPosition(void *, struct zxdg_output_v1 *, int32_t,
-      int32_t);
-    static void handleLogicalSize(void *, struct zxdg_output_v1 *, int32_t,
-      int32_t);
-    static void handleDone(void *, struct zxdg_output_v1 *);
-    static void handleName(void *, struct zxdg_output_v1 *, const char *);
-    static void handleDescription(void *, struct zxdg_output_v1 *,
-      const char *);
-    static void layerSurfaceHandleConfigure(void *,
-      struct zwlr_layer_surface_v1 *, uint32_t, uint32_t, uint32_t);
-    static void layerSurfaceHandleClosed(void *,
-      struct zwlr_layer_surface_v1 *);
-
-    void initBar();
-    bool isValidOutput(const Json::Value &config);
-    void destroyOutput();
-    auto setupConfig() -> void;
-    auto setupWidgets() -> void;
-    auto setupCss() -> void;
-    void getModules(const Factory&, const std::string&);
-
-    uint32_t width_ = 0;
-    uint32_t height_ = 30;
-    Json::Value config_;
-    Glib::RefPtr<Gtk::StyleContext> style_context_;
-    Glib::RefPtr<Gtk::CssProvider> css_provider_;
-    struct zxdg_output_v1 *xdg_output_;
-    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::unique_ptr<struct zxdg_output_v1, decltype(&zxdg_output_v1_destroy)> xdg_output = {
+      nullptr, &zxdg_output_v1_destroy};
 };
 
-}
+class Bar {
+ public:
+  Bar(struct waybar_output *w_output, const Json::Value &);
+  Bar(const Bar &) = delete;
+  ~Bar() = default;
+
+  auto toggle() -> void;
+  void handleSignal(int);
+
+  struct waybar_output *output;
+  Json::Value           config;
+  struct wl_surface *   surface;
+  bool                  visible = true;
+  bool                  vertical = false;
+  Gtk::Window           window;
+
+ private:
+  static constexpr const char *MIN_HEIGHT_MSG =
+      "Requested height: {} exceeds the minimum height: {} required by the modules";
+  static constexpr const char *MIN_WIDTH_MSG =
+      "Requested width: {} exceeds the minimum width: {} required by the modules";
+  static constexpr const char *BAR_SIZE_MSG =
+      "Bar configured (width: {}, height: {}) for output: {}";
+  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);
+  static void layerSurfaceHandleClosed(void *, struct zwlr_layer_surface_v1 *);
+
+#ifdef HAVE_GTK_LAYER_SHELL
+  /* gtk-layer-shell code */
+  void initGtkLayerShell();
+  void onConfigureGLS(GdkEventConfigure *ev);
+  void onMapGLS(GdkEventAny *ev);
+#endif
+  /* fallback layer-surface code */
+  void onConfigure(GdkEventConfigure *ev);
+  void onRealize();
+  void onMap(GdkEventAny *ev);
+  void setSurfaceSize(uint32_t width, uint32_t height);
+  /* common code */
+  void setExclusiveZone(uint32_t width, uint32_t height);
+  auto setupWidgets() -> void;
+  void getModules(const Factory &, const std::string &);
+  void setupAltFormatKeyForModule(const std::string &module_name);
+  void setupAltFormatKeyForModuleList(const char *module_list_name);
+
+  struct margins {
+    int top = 0;
+    int right = 0;
+    int bottom = 0;
+    int left = 0;
+  } margins_;
+  struct zwlr_layer_surface_v1 *layer_surface_;
+  // use gtk-layer-shell instead of handling layer surfaces directly
+  bool                                          use_gls_ = false;
+  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::AModule>> modules_left_;
+  std::vector<std::unique_ptr<waybar::AModule>> modules_center_;
+  std::vector<std::unique_ptr<waybar::AModule>> modules_right_;
+};
+
+}  // namespace waybar

include/client.hpp

@@ -1,41 +1,53 @@
 #pragma once
 
-#include <unistd.h>
-#include <wordexp.h>
 #include <fmt/format.h>
 #include <gdk/gdk.h>
-#include <wayland-client.h>
 #include <gdk/gdkwayland.h>
+#include <unistd.h>
+#include <wayland-client.h>
+#include <wordexp.h>
 #include "bar.hpp"
 
 namespace waybar {
 
 class Client {
-  public:
-    Client(int argc, char *argv[]);
-    int main(int argc, char *argv[]);
+ public:
+  static Client *inst();
+  int            main(int argc, char *argv[]);
 
-    Gtk::Main gtk_main;
-    std::string css_file;
-    std::string config_file;
-    Glib::RefPtr<Gdk::Display> gdk_display;
-    struct wl_display *wl_display = nullptr;
-    struct wl_registry *registry = nullptr;
-    struct zwlr_layer_shell_v1 *layer_shell = nullptr;
-    struct zxdg_output_manager_v1 *xdg_output_manager = nullptr;
-    struct wl_seat *seat = nullptr;
-    struct zwp_idle_inhibit_manager_v1 *idle_inhibit_manager = nullptr;
-    std::vector<std::unique_ptr<Bar>> bars;
+  Glib::RefPtr<Gtk::Application>      gtk_app;
+  Glib::RefPtr<Gdk::Display>          gdk_display;
+  struct wl_display *                 wl_display = nullptr;
+  struct wl_registry *                registry = nullptr;
+  struct zwlr_layer_shell_v1 *        layer_shell = nullptr;
+  struct zxdg_output_manager_v1 *     xdg_output_manager = nullptr;
+  struct zwp_idle_inhibit_manager_v1 *idle_inhibit_manager = nullptr;
+  std::vector<std::unique_ptr<Bar>>   bars;
 
-  private:
-    void setupConfigs(const std::string& config, const std::string& style);
-    void bindInterfaces();
-    const std::string getValidPath(std::vector<std::string> paths);
+ private:
+  Client() = default;
+  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(struct waybar_output &output);
+  bool isValidOutput(const Json::Value &config, struct waybar_output &output);
+  auto setupConfig(const std::string &config_file) -> void;
+  auto setupCss(const std::string &css_file) -> void;
+  struct waybar_output &getOutput(void *);
+  std::vector<Json::Value> getOutputConfigs(struct waybar_output &output);
 
-    static void handleGlobal(void *data, struct wl_registry *registry,
-      uint32_t name, const char *interface, uint32_t version);
-    static void handleGlobalRemove(void *data,
-      struct wl_registry *registry, uint32_t name);
+  static void handleGlobal(void *data, struct wl_registry *registry, uint32_t name,
+                           const char *interface, uint32_t version);
+  static void handleGlobalRemove(void *data, struct wl_registry *registry, uint32_t name);
+  static void handleOutputName(void *, struct zxdg_output_v1 *, const char *);
+  void        handleMonitorAdded(Glib::RefPtr<Gdk::Monitor> monitor);
+  void        handleMonitorRemoved(Glib::RefPtr<Gdk::Monitor> monitor);
+
+  Json::Value                     config_;
+  Glib::RefPtr<Gtk::StyleContext> style_context_;
+  Glib::RefPtr<Gtk::CssProvider>  css_provider_;
+  std::list<struct waybar_output> outputs_;
 };
 
-}
+}  // namespace waybar

include/factory.hpp

@@ -4,13 +4,26 @@
 #include "modules/clock.hpp"
 #ifdef HAVE_SWAY
 #include "modules/sway/mode.hpp"
-#include "modules/sway/workspaces.hpp"
 #include "modules/sway/window.hpp"
+#include "modules/sway/workspaces.hpp"
+#endif
+#ifdef HAVE_WLR
+#include "modules/wlr/taskbar.hpp"
+#endif
+#ifdef HAVE_RIVER
+#include "modules/river/tags.hpp"
+#endif
+#if defined(__linux__) && !defined(NO_FILESYSTEM)
+#include "modules/battery.hpp"
+#endif
+#if defined(HAVE_CPU_LINUX) || defined(HAVE_CPU_BSD)
+#include "modules/cpu.hpp"
 #endif
 #include "modules/idle_inhibitor.hpp"
-#include "modules/battery.hpp"
+#if defined(HAVE_MEMORY_LINUX) || defined(HAVE_MEMORY_BSD)
 #include "modules/memory.hpp"
-#include "modules/cpu.hpp"
+#endif
+#include "modules/disk.hpp"
 #ifdef HAVE_DBUSMENU
 #include "modules/sni/tray.hpp"
 #endif
@@ -23,20 +36,28 @@
 #ifdef HAVE_LIBPULSE
 #include "modules/pulseaudio.hpp"
 #endif
-#include "modules/temperature.hpp"
+#ifdef HAVE_LIBMPDCLIENT
+#include "modules/mpd.hpp"
+#endif
+#include "bar.hpp"
 #include "modules/custom.hpp"
+#include "modules/temperature.hpp"
+#if defined(__linux__)
+#  ifdef WANT_RFKILL
+#    include "modules/bluetooth.hpp"
+#  endif
+#endif
 
 namespace waybar {
 
-class Bar;
-
 class Factory {
-  public:
-    Factory(const Bar& bar, const Json::Value& config);
-    IModule* makeModule(const std::string &name) const;
-  private:
-    const Bar& bar_;
-    const Json::Value& config_;
+ public:
+  Factory(const Bar& bar, const Json::Value& config);
+  AModule* makeModule(const std::string& name) const;
+
+ private:
+  const Bar&         bar_;
+  const Json::Value& config_;
 };
 
-}
+}  // namespace waybar

include/modules/backlight.hpp

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

include/modules/battery.hpp

@@ -5,13 +5,14 @@
 #else
 #include <filesystem>
 #endif
-#include <fstream>
-#include <iostream>
 #include <fmt/format.h>
 #include <sys/inotify.h>
 #include <algorithm>
-#include "util/sleeper_thread.hpp"
+#include <fstream>
+#include <string>
+#include <vector>
 #include "ALabel.hpp"
+#include "util/sleeper_thread.hpp"
 
 namespace waybar::modules {
 
@@ -22,26 +23,28 @@ namespace fs = std::filesystem;
 #endif
 
 class Battery : public ALabel {
-  public:
-    Battery(const std::string&, const Json::Value&);
-    ~Battery();
-    auto update() -> void;
-  private:
-    static inline const fs::path data_dir_ = "/sys/class/power_supply/";
+ public:
+  Battery(const std::string&, const Json::Value&);
+  ~Battery();
+  auto update() -> void;
 
-    void getBatteries();
-    void worker();
-    const std::string getAdapterStatus(uint8_t capacity) const;
-    const std::tuple<uint8_t, std::string> getInfos() const;
-    const std::string getState(uint8_t) const;
+ private:
+  static inline const fs::path data_dir_ = "/sys/class/power_supply/";
 
-    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_;
+  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);
+
+  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

include/modules/bluetooth.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <fmt/format.h>
+#include "ALabel.hpp"
+
+#include <fmt/chrono.h>
+#include "util/sleeper_thread.hpp"
+#include "util/rfkill.hpp"
+
+namespace waybar::modules {
+
+class Bluetooth : public ALabel {
+ public:
+  Bluetooth(const std::string&, const Json::Value&);
+  ~Bluetooth() = default;
+  auto update() -> void;
+
+ private:
+  std::string           status_;
+  util::SleeperThread 	thread_;
+  util::SleeperThread 	intervall_thread_;
+
+  util::Rfkill rfkill_;
+};
+
+}  // namespace waybar::modules

include/modules/clock.hpp

@@ -1,19 +1,42 @@
 #pragma once
 
 #include <fmt/format.h>
-#include "fmt/time.h"
-#include "util/sleeper_thread.hpp"
+#if FMT_VERSION < 60000
+#include <fmt/time.h>
+#else
+#include <fmt/chrono.h>
+#endif
+#include <date/tz.h>
 #include "ALabel.hpp"
+#include "util/sleeper_thread.hpp"
 
 namespace waybar::modules {
 
-class Clock : public ALabel {
-  public:
-    Clock(const std::string&, const Json::Value&);
-    ~Clock() = default;
-    auto update() -> void;
-  private:
-    waybar::util::SleeperThread thread_;
+struct waybar_time {
+  std::locale locale;
+  date::zoned_seconds ztime;
 };
 
-}
+class Clock : public ALabel {
+ public:
+  Clock(const std::string&, const Json::Value&);
+  ~Clock() = default;
+  auto update() -> void;
+
+ private:
+  util::SleeperThread thread_;
+  std::locale locale_;
+  const date::time_zone* time_zone_;
+  bool fixed_time_zone_;
+  int time_zone_idx_;
+  date::year_month_day cached_calendar_ymd_;
+  std::string cached_calendar_text_;
+
+  bool handleScroll(GdkEventScroll* e);
+
+  auto calendar_text(const waybar_time& wtime) -> std::string;
+  auto weekdays_header(const date::weekday& first_dow, std::ostream& os) -> void;
+  auto first_day_of_week() -> date::weekday;
+};
+
+}  // namespace waybar::modules

include/modules/cpu.hpp

@@ -1,29 +1,32 @@
 #pragma once
 
 #include <fmt/format.h>
-#include <sys/sysinfo.h>
+#include <unistd.h>
+#include <cstdint>
 #include <fstream>
-#include <vector>
 #include <numeric>
-#include <iostream>
-#include "util/sleeper_thread.hpp"
+#include <string>
+#include <utility>
+#include <vector>
 #include "ALabel.hpp"
+#include "util/sleeper_thread.hpp"
 
 namespace waybar::modules {
 
 class Cpu : public ALabel {
-  public:
-    Cpu(const std::string&, const Json::Value&);
-    ~Cpu() = default;
-    auto update() -> void;
-  private:
-    static inline const std::string data_dir_ = "/proc/stat";
-    uint16_t getCpuLoad();
-    std::tuple<uint16_t, std::string> getCpuUsage();
-    std::vector<std::tuple<size_t, size_t>> parseCpuinfo();
+ public:
+  Cpu(const std::string&, const Json::Value&);
+  ~Cpu() = default;
+  auto update() -> void;
 
-    std::vector<std::tuple<size_t, size_t>> prev_times_;
-    waybar::util::SleeperThread thread_;
+ private:
+  uint16_t                                getCpuLoad();
+  std::tuple<uint16_t, std::string>       getCpuUsage();
+  std::vector<std::tuple<size_t, size_t>> parseCpuinfo();
+
+  std::vector<std::tuple<size_t, size_t>> prev_times_;
+
+  util::SleeperThread thread_;
 };
 
-}
+}  // namespace waybar::modules

include/modules/custom.hpp

@@ -1,38 +1,43 @@
 #pragma once
 
 #include <fmt/format.h>
-#include <iostream>
 #include <csignal>
-#include "util/sleeper_thread.hpp"
+#include <string>
+#include "ALabel.hpp"
 #include "util/command.hpp"
 #include "util/json.hpp"
-#include "ALabel.hpp"
+#include "util/sleeper_thread.hpp"
 
 namespace waybar::modules {
 
 class Custom : public ALabel {
-  public:
-    Custom(const std::string&, const Json::Value&);
-    ~Custom();
-    auto update() -> void;
-    void refresh(int /*signal*/);
-  private:
-    void delayWorker();
-    void continuousWorker();
-    void parseOutputRaw();
-    void parseOutputJson();
+ public:
+  Custom(const std::string&, const std::string&, const Json::Value&);
+  ~Custom();
+  auto update() -> void;
+  void refresh(int /*signal*/);
 
-    const std::string name_;
-    std::string text_;
-    std::string alt_;
-    std::string tooltip_;
-    std::string class_;
-    std::string prevclass_;
-    int percentage_;
-    waybar::util::SleeperThread thread_;
-    waybar::util::command::res output_;
-    waybar::util::JsonParser parser_;
-    FILE* fp_;
+ private:
+  void delayWorker();
+  void continuousWorker();
+  void parseOutputRaw();
+  void parseOutputJson();
+  void handleEvent();
+  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_;
+  FILE*                    fp_;
+  int                      pid_;
+  util::command::res       output_;
+  util::JsonParser         parser_;
+
+  util::SleeperThread thread_;
 };
 
-}
+}  // namespace waybar::modules

include/modules/disk.hpp

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <fstream>
+#include <sys/statvfs.h>
+#include "ALabel.hpp"
+#include "util/sleeper_thread.hpp"
+#include "util/format.hpp"
+
+namespace waybar::modules {
+
+class Disk : public ALabel {
+ public:
+  Disk(const std::string&, const Json::Value&);
+  ~Disk() = default;
+  auto update() -> void;
+
+ private:
+  util::SleeperThread thread_;
+  std::string path_;
+};
+
+}  // namespace waybar::modules

include/modules/idle_inhibitor.hpp

@@ -1,23 +1,25 @@
 #pragma once
 
 #include <fmt/format.h>
+#include "ALabel.hpp"
 #include "bar.hpp"
 #include "client.hpp"
-#include "ALabel.hpp"
 
 namespace waybar::modules {
 
-class IdleInhibitor: public ALabel {
-  public:
-    IdleInhibitor(const std::string&, const waybar::Bar&, const Json::Value&);
-    ~IdleInhibitor();
-    auto update() -> void;
-  private:
-    bool handleToggle(GdkEventButton* const& e);
+class IdleInhibitor : public ALabel {
+ public:
+  IdleInhibitor(const std::string&, const waybar::Bar&, const Json::Value&);
+  ~IdleInhibitor();
+  auto update() -> void;
 
-    const Bar& bar_;
-    std::string status_;
-    struct zwp_idle_inhibitor_v1 *idle_inhibitor_;
+ private:
+  bool handleToggle(GdkEventButton* const& e);
+
+  const Bar&                    bar_;
+  std::string                   status_;
+  struct zwp_idle_inhibitor_v1* idle_inhibitor_;
+  int                           pid_;
 };
 
-}
+}  // namespace waybar::modules

include/modules/memory.hpp

@@ -2,22 +2,24 @@
 
 #include <fmt/format.h>
 #include <fstream>
-#include "util/sleeper_thread.hpp"
+#include <unordered_map>
 #include "ALabel.hpp"
+#include "util/sleeper_thread.hpp"
 
 namespace waybar::modules {
 
 class Memory : public ALabel {
-  public:
-    Memory(const std::string&, const Json::Value&);
-    ~Memory() = default;
-    auto update() -> void;
-  private:
-    static inline const std::string data_dir_ = "/proc/meminfo";
-    unsigned long memtotal_;
-    unsigned long memfree_;
-    void parseMeminfo();
-    waybar::util::SleeperThread thread_;
+ public:
+  Memory(const std::string&, const Json::Value&);
+  ~Memory() = default;
+  auto update() -> void;
+
+ private:
+  void                            parseMeminfo();
+
+  std::unordered_map<std::string, unsigned long> meminfo_;
+
+  util::SleeperThread thread_;
 };
 
-}
+}  // namespace waybar::modules

include/modules/mpd.hpp

@@ -0,0 +1,74 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <mpd/client.h>
+#include <condition_variable>
+#include <thread>
+#include "ALabel.hpp"
+
+namespace waybar::modules {
+
+class MPD : public ALabel {
+ public:
+  MPD(const std::string&, const Json::Value&);
+  auto update() -> void;
+
+ private:
+  std::thread periodic_updater();
+  std::string getTag(mpd_tag_type type, unsigned idx = 0);
+  void        setLabel();
+  std::string getStateIcon();
+  std::string getOptionIcon(std::string optionName, bool activated);
+
+  std::thread event_listener();
+
+  // Assumes `connection_lock_` is locked
+  void tryConnect();
+  // If checking errors on the main connection, make sure to lock it using
+  // `connection_lock_` before calling checkErrors
+  void checkErrors(mpd_connection* conn);
+
+  // Assumes `connection_lock_` is locked
+  void fetchState();
+  void waitForEvent();
+
+  bool handlePlayPause(GdkEventButton* const&);
+
+  bool stopped();
+  bool playing();
+  bool paused();
+
+  const std::string module_name_;
+
+  using unique_connection = std::unique_ptr<mpd_connection, decltype(&mpd_connection_free)>;
+  using unique_status = std::unique_ptr<mpd_status, decltype(&mpd_status_free)>;
+  using unique_song = std::unique_ptr<mpd_song, decltype(&mpd_song_free)>;
+
+  // Not using unique_ptr since we don't manage the pointer
+  // (It's either nullptr, or from the config)
+  const char*    server_;
+  const unsigned port_;
+
+  unsigned timeout_;
+
+  // We need a mutex here because we can trigger updates from multiple thread:
+  // the event based updates, the periodic updates needed for the elapsed time,
+  // and the click play/pause feature
+  std::mutex        connection_lock_;
+  unique_connection connection_;
+  // The alternate connection will be used to wait for events: since it will
+  // be blocking (idle) we can't send commands via this connection
+  //
+  // No lock since only used in the event listener thread
+  unique_connection alternate_connection_;
+
+  // Protect them using the `connection_lock_`
+  unique_status status_;
+  mpd_state     state_;
+  unique_song   song_;
+
+  // To make sure the previous periodic_updater stops before creating a new one
+  std::mutex periodic_lock_;
+};
+
+}  // namespace waybar::modules

include/modules/network.hpp

@@ -1,62 +1,84 @@
 #pragma once
 
-#include <net/if.h>
 #include <arpa/inet.h>
-#include <ifaddrs.h>
-#include <netlink/netlink.h>
-#include <netlink/genl/genl.h>
-#include <netlink/genl/ctrl.h>
-#include <linux/nl80211.h>
-#include <sys/epoll.h>
 #include <fmt/format.h>
-#include "util/sleeper_thread.hpp"
+#include <ifaddrs.h>
+#include <linux/nl80211.h>
+#include <net/if.h>
+#include <netlink/genl/ctrl.h>
+#include <netlink/genl/genl.h>
+#include <netlink/netlink.h>
+#include <sys/epoll.h>
 #include "ALabel.hpp"
+#include "util/sleeper_thread.hpp"
+#ifdef WANT_RFKILL
+#include "util/rfkill.hpp"
+#endif
 
 namespace waybar::modules {
 
 class Network : public ALabel {
-  public:
-    Network(const std::string&, const Json::Value&);
-    ~Network();
-    auto update() -> void;
-  private:
-    static const uint8_t MAX_RETRY = 5;
-    static const uint8_t EPOLL_MAX = 255;
+ public:
+  Network(const std::string&, const Json::Value&);
+  ~Network();
+  auto update() -> void;
 
-    static int handleScan(struct nl_msg*, void*);
+ private:
+  static const uint8_t MAX_RETRY = 5;
+  static const uint8_t EPOLL_MAX = 200;
 
-    void worker();
-    void disconnected();
-    void createInfoSocket();
-    void createEventSocket();
-    int getExternalInterface();
-    void getInterfaceAddress();
-    void handleEvents();
-    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**);
-    bool associatedOrJoined(struct nlattr**);
-    auto getInfo() -> void;
+  static int handleEvents(struct nl_msg*, void*);
+  static int handleScan(struct nl_msg*, void*);
 
-    waybar::util::SleeperThread thread_;
-    waybar::util::SleeperThread thread_timer_;
-    int ifid_;
-    sa_family_t family_;
-    struct sockaddr_nl nladdr_ = {0};
-    struct nl_sock* sk_ = nullptr;
-    int info_sock_;
-    int efd_;
-    int ev_fd_;
-    int nl80211_id_;
+  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, bool wait = true) 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;
 
-    std::string essid_;
-    std::string ifname_;
-    std::string ipaddr_;
-    std::string netmask_;
-    int cidr_;
-    int32_t signal_strength_dbm_;
-    uint8_t signal_strength_;
+  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_;
+  int32_t     signal_strength_dbm_;
+  uint8_t     signal_strength_;
+  uint32_t    frequency_;
+
+  util::SleeperThread thread_;
+  util::SleeperThread thread_timer_;
+#ifdef WANT_RFKILL
+  util::SleeperThread thread_rfkill_;
+
+  util::Rfkill rfkill_;
+#endif
 };
 
-}
+}  // namespace waybar::modules

include/modules/pulseaudio.hpp

@@ -4,36 +4,48 @@
 #include <pulse/pulseaudio.h>
 #include <pulse/volume.h>
 #include <algorithm>
+#include <array>
 #include "ALabel.hpp"
 
 namespace waybar::modules {
 
 class Pulseaudio : public ALabel {
-  public:
-    Pulseaudio(const std::string&, const Json::Value&);
-    ~Pulseaudio();
-    auto update() -> void;
-  private:
-    static void subscribeCb(pa_context*, pa_subscription_event_type_t,
-      uint32_t, void*);
-    static void contextStateCb(pa_context*, void*);
-    static void sinkInfoCb(pa_context*, const pa_sink_info*, int, void*);
-    static void serverInfoCb(pa_context*, const pa_server_info*, void*);
-    static void volumeModifyCb(pa_context*, int, void*);
-    bool handleScroll(GdkEventScroll* e);
+ public:
+  Pulseaudio(const std::string&, const Json::Value&);
+  ~Pulseaudio();
+  auto update() -> void;
 
-    const std::string getPortIcon() const;
+ private:
+  static void subscribeCb(pa_context*, pa_subscription_event_type_t, uint32_t, void*);
+  static void contextStateCb(pa_context*, void*);
+  static void sinkInfoCb(pa_context*, const pa_sink_info*, int, void*);
+  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*);
 
-    pa_threaded_mainloop* mainloop_;
-    pa_mainloop_api* mainloop_api_;
-    pa_context* context_;
-    uint32_t sink_idx_{0};
-    uint16_t volume_;
-    pa_cvolume pa_volume_;
-    bool muted_;
-    std::string port_name_;
-    std::string desc_;
-    bool scrolling_;
+  bool              handleScroll(GdkEventScroll* e);
+  const std::string getPortIcon() const;
+
+  pa_threaded_mainloop* mainloop_;
+  pa_mainloop_api*      mainloop_api_;
+  pa_context*           context_;
+  // SINK
+  uint32_t    sink_idx_{0};
+  uint16_t    volume_;
+  pa_cvolume  pa_volume_;
+  bool        muted_;
+  std::string port_name_;
+  std::string form_factor_;
+  std::string desc_;
+  std::string monitor_;
+  std::string default_sink_name_;
+  // SOURCE
+  uint32_t    source_idx_{0};
+  uint16_t    source_volume_;
+  bool        source_muted_;
+  std::string source_port_name_;
+  std::string source_desc_;
+  std::string default_source_name_;
 };
 
 }  // namespace waybar::modules

include/modules/river/tags.hpp

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <gtkmm/button.h>
+#include <wayland-client.h>
+
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "river-status-unstable-v1-client-protocol.h"
+#include "xdg-output-unstable-v1-client-protocol.h"
+
+namespace waybar::modules::river {
+
+class Tags : public waybar::AModule {
+ public:
+  Tags(const std::string &, const waybar::Bar &, const Json::Value &);
+  ~Tags();
+
+  // Handlers for wayland events
+  void handle_focused_tags(uint32_t tags);
+  void handle_view_tags(struct wl_array *tags);
+
+  struct zriver_status_manager_v1 *status_manager_;
+
+ private:
+  const waybar::Bar &      bar_;
+  Gtk::Box                 box_;
+  std::vector<Gtk::Button> buttons_;
+  struct zriver_output_status_v1 *output_status_;
+};
+
+} /* namespace waybar::modules::river */

include/modules/sni/host.hpp

@@ -1,42 +1,43 @@
 #pragma once
 
-#include <glibmm/refptr.h>
+#include <dbus-status-notifier-watcher.h>
 #include <giomm.h>
+#include <glibmm/refptr.h>
 #include <json/json.h>
 #include <tuple>
-#include <dbus-status-notifier-watcher.h>
 #include "modules/sni/item.hpp"
 
 namespace waybar::modules::SNI {
 
 class Host {
-  public:
-    Host(const std::size_t id, const Json::Value&,
-      const std::function<void(std::unique_ptr<Item>&)>&,
-      const std::function<void(std::unique_ptr<Item>&)>&);
-    ~Host();
-  private:
-    void busAcquired(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring);
-    void nameAppeared(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring, const Glib::ustring&);
-    void nameVanished(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring);
-    static void proxyReady(GObject*, GAsyncResult*, gpointer);
-    static void registerHost(GObject*, GAsyncResult*, gpointer);
-    static void itemRegistered(SnWatcher*, const gchar*, gpointer);
-    static void itemUnregistered(SnWatcher*, const gchar*, gpointer);
+ public:
+  Host(const std::size_t id, const Json::Value&, const std::function<void(std::unique_ptr<Item>&)>&,
+       const std::function<void(std::unique_ptr<Item>&)>&);
+  ~Host();
 
-    std::tuple<std::string, std::string> getBusNameAndObjectPath(const std::string);
-    void addRegisteredItem(std::string service);
+ private:
+  void        busAcquired(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring);
+  void        nameAppeared(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring,
+                           const Glib::ustring&);
+  void        nameVanished(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring);
+  static void proxyReady(GObject*, GAsyncResult*, gpointer);
+  static void registerHost(GObject*, GAsyncResult*, gpointer);
+  static void itemRegistered(SnWatcher*, const gchar*, gpointer);
+  static void itemUnregistered(SnWatcher*, const gchar*, gpointer);
 
-    std::vector<std::unique_ptr<Item>> items_;
-    const std::string bus_name_;
-    const std::string object_path_;
-    std::size_t bus_name_id_;
-    std::size_t watcher_id_;
-    GCancellable* cancellable_ = nullptr;
-    SnWatcher* watcher_ = nullptr;
-    const Json::Value &config_;
-    const std::function<void(std::unique_ptr<Item>&)> on_add_;
-    const std::function<void(std::unique_ptr<Item>&)> on_remove_;
+  std::tuple<std::string, std::string> getBusNameAndObjectPath(const std::string);
+  void                                 addRegisteredItem(std::string service);
+
+  std::vector<std::unique_ptr<Item>>                items_;
+  const std::string                                 bus_name_;
+  const std::string                                 object_path_;
+  std::size_t                                       bus_name_id_;
+  std::size_t                                       watcher_id_;
+  GCancellable*                                     cancellable_ = nullptr;
+  SnWatcher*                                        watcher_ = nullptr;
+  const Json::Value&                                config_;
+  const std::function<void(std::unique_ptr<Item>&)> on_add_;
+  const std::function<void(std::unique_ptr<Item>&)> on_remove_;
 };
 
-}
+}  // namespace waybar::modules::SNI

include/modules/sni/item.hpp

@@ -1,63 +1,71 @@
 #pragma once
 
 #include <dbus-status-notifier-item.h>
+#include <giomm/dbusproxy.h>
 #include <glibmm/refptr.h>
 #include <gtkmm/eventbox.h>
-#include <gtkmm/image.h>
 #include <gtkmm/icontheme.h>
+#include <gtkmm/image.h>
 #include <gtkmm/menu.h>
 #include <json/json.h>
 #include <libdbusmenu-gtk/dbusmenu-gtk.h>
-#ifdef FILESYSTEM_EXPERIMENTAL
-#include <experimental/filesystem>
-#else
-#include <filesystem>
-#endif
+#include <sigc++/trackable.h>
 
 namespace waybar::modules::SNI {
 
-class Item {
-public:
-  Item(std::string, std::string, const Json::Value&);
+class Item : public sigc::trackable {
+ public:
+  Item(const std::string&, const std::string&, const Json::Value&);
   ~Item() = default;
 
   std::string bus_name;
   std::string object_path;
 
-  int icon_size;
-  int effective_icon_size;
-  Gtk::Image image;
+  int           icon_size;
+  int           effective_icon_size;
+  Gtk::Image    image;
   Gtk::EventBox event_box;
-  std::string category;
-  std::string id;
-  std::string status;
+  std::string   category;
+  std::string   id;
+  std::string   status;
 
-  std::string title;
-  int32_t window_id;
-  std::string icon_name;
-  Glib::RefPtr<Gdk::Pixbuf> icon_pixmap;
-  std::string overlay_icon_name;
-  std::string attention_icon_name;
-  std::string attention_movie_name;
-  std::string icon_theme_path;
-  std::string menu;
-  DbusmenuGtkMenu *dbus_menu = nullptr;
-  Gtk::Menu *gtk_menu = nullptr;
-  bool item_is_menu;
+  std::string                  title;
+  int32_t                      window_id;
+  std::string                  icon_name;
+  Glib::RefPtr<Gdk::Pixbuf>    icon_pixmap;
+  Glib::RefPtr<Gtk::IconTheme> icon_theme;
+  std::string                  overlay_icon_name;
+  std::string                  attention_icon_name;
+  std::string                  attention_movie_name;
+  std::string                  icon_theme_path;
+  std::string                  menu;
+  DbusmenuGtkMenu*             dbus_menu = nullptr;
+  Gtk::Menu*                   gtk_menu = nullptr;
+  /**
+   * ItemIsMenu flag means that the item only supports the context menu.
+   * Default value is true because libappindicator supports neither ItemIsMenu nor Activate method
+   * while compliant SNI implementation would always reset the flag to desired value.
+   */
+  bool item_is_menu = true;
 
-private:
-  static void proxyReady(GObject *obj, GAsyncResult *res, gpointer data);
-  static void getAll(GObject *obj, GAsyncResult *res, gpointer data);
+ private:
+  void proxyReady(Glib::RefPtr<Gio::AsyncResult>& result);
+  void setProperty(const Glib::ustring& name, Glib::VariantBase& value);
+  void getUpdatedProperties();
+  void processUpdatedProperties(Glib::RefPtr<Gio::AsyncResult>& result);
+  void onSignal(const Glib::ustring& sender_name, const Glib::ustring& signal_name,
+                const Glib::VariantContainerBase& arguments);
 
-  void updateImage();
-  Glib::RefPtr<Gdk::Pixbuf> extractPixBuf(GVariant *variant);
-  Glib::RefPtr<Gdk::Pixbuf> getIconByName(std::string name, int size);
-  static void onMenuDestroyed(Item *self);
-  bool makeMenu(GdkEventButton *const &ev);
-  bool handleClick(GdkEventButton *const & /*ev*/);
+  void                      updateImage();
+  Glib::RefPtr<Gdk::Pixbuf> extractPixBuf(GVariant* variant);
+  Glib::RefPtr<Gdk::Pixbuf> getIconByName(const std::string& name, int size);
+  static void               onMenuDestroyed(Item* self, GObject* old_menu_pointer);
+  void                      makeMenu();
+  bool                      handleClick(GdkEventButton* const& /*ev*/);
 
-  GCancellable *cancellable_ = nullptr;
-  SnItem *proxy_ = nullptr;
+  Glib::RefPtr<Gio::DBus::Proxy> proxy_;
+  Glib::RefPtr<Gio::Cancellable> cancellable_;
+  bool                           update_pending_;
 };
 
-} // namespace waybar::modules::SNI
+}  // namespace waybar::modules::SNI

include/modules/sni/tray.hpp

@@ -1,29 +1,28 @@
 #pragma once
 
 #include <fmt/format.h>
+#include "AModule.hpp"
 #include "bar.hpp"
-#include "util/json.hpp"
-#include "IModule.hpp"
-#include "modules/sni/watcher.hpp"
 #include "modules/sni/host.hpp"
+#include "modules/sni/watcher.hpp"
+#include "util/json.hpp"
 
 namespace waybar::modules::SNI {
 
-class Tray : public IModule {
-  public:
-    Tray(const std::string&, 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);
+class Tray : public AModule {
+ public:
+  Tray(const std::string&, const Bar&, const Json::Value&);
+  ~Tray() = default;
+  auto update() -> void;
 
-    static inline std::size_t nb_hosts_ = 0;
-    const Json::Value& config_;
-    Gtk::Box box_;
-    SNI::Watcher watcher_ ;
-    SNI::Host host_;
+ private:
+  void onAdd(std::unique_ptr<Item>& item);
+  void onRemove(std::unique_ptr<Item>& item);
+
+  static inline std::size_t nb_hosts_ = 0;
+  Gtk::Box                  box_;
+  SNI::Watcher::singleton   watcher_;
+  SNI::Host                 host_;
 };
 
-}
+}  // namespace waybar::modules::SNI

include/modules/sni/watcher.hpp

@@ -1,48 +1,56 @@
 #pragma once
 
+#include <dbus-status-notifier-watcher.h>
 #include <giomm.h>
 #include <glibmm/refptr.h>
-#include <dbus-status-notifier-watcher.h>
 
 namespace waybar::modules::SNI {
 
 class Watcher {
-public:
+ private:
   Watcher();
-  ~Watcher() = default;
 
-private:
+ public:
+  ~Watcher();
+
+  using singleton = std::shared_ptr<Watcher>;
+  static singleton getInstance() {
+    static std::weak_ptr<Watcher> weak;
+
+    std::shared_ptr<Watcher> strong = weak.lock();
+    if (!strong) {
+      strong = std::shared_ptr<Watcher>(new Watcher());
+      weak = strong;
+    }
+    return strong;
+  }
+
+ private:
   typedef enum { GF_WATCH_TYPE_HOST, GF_WATCH_TYPE_ITEM } GfWatchType;
 
   typedef struct {
     GfWatchType type;
-    Watcher *watcher;
-    gchar *service;
-    gchar *bus_name;
-    gchar *object_path;
-    guint watch_id;
+    Watcher *   watcher;
+    gchar *     service;
+    gchar *     bus_name;
+    gchar *     object_path;
+    guint       watch_id;
   } GfWatch;
 
-  void busAcquired(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring);
-  static gboolean handleRegisterHost(Watcher *, GDBusMethodInvocation *,
-                                     const gchar *);
-  static gboolean handleRegisterItem(Watcher *, GDBusMethodInvocation *,
-                                     const gchar *);
-  static GfWatch *gfWatchFind(GSList *list, const gchar *bus_name,
-                              const gchar *object_path);
-  static GfWatch *gfWatchNew(GfWatchType, const gchar *, const gchar *,
-                             const gchar *, Watcher *);
-  static void nameVanished(GDBusConnection *connection, const char *name,
-                           gpointer data);
+  void            busAcquired(const Glib::RefPtr<Gio::DBus::Connection> &, Glib::ustring);
+  static gboolean handleRegisterHost(Watcher *, GDBusMethodInvocation *, const gchar *);
+  static gboolean handleRegisterItem(Watcher *, GDBusMethodInvocation *, const gchar *);
+  static GfWatch *gfWatchFind(GSList *list, const gchar *bus_name, const gchar *object_path);
+  static GfWatch *gfWatchNew(GfWatchType, const gchar *, const gchar *, const gchar *, Watcher *);
+  static void     nameVanished(GDBusConnection *connection, const char *name, gpointer data);
+  static void     gfWatchFree(gpointer data);
 
   void updateRegisteredItems(SnWatcher *obj);
 
-  uint32_t bus_name_id_;
-  uint32_t watcher_id_;
-  GSList *hosts_ = nullptr;
-  GSList *items_ = nullptr;
+  uint32_t   bus_name_id_;
+  GSList *   hosts_ = nullptr;
+  GSList *   items_ = nullptr;
   SnWatcher *watcher_ = nullptr;
 };
 
-} // namespace waybar::modules::SNI
-
+}  // namespace waybar::modules::SNI

include/modules/sway/ipc/client.hpp

@@ -1,40 +1,49 @@
 #pragma once
 
-#include <iostream>
-#include <cstring>
-#include <unistd.h>
+#include <sigc++/sigc++.h>
 #include <sys/socket.h>
 #include <sys/un.h>
+#include <unistd.h>
+#include <cstring>
+#include <memory>
+#include <mutex>
 #include "ipc.hpp"
+#include "util/sleeper_thread.hpp"
 
 namespace waybar::modules::sway {
 
 class Ipc {
-public:
+ public:
   Ipc();
   ~Ipc();
 
   struct ipc_response {
-    uint32_t size;
-    uint32_t type;
+    uint32_t    size;
+    uint32_t    type;
     std::string payload;
   };
 
-  struct ipc_response sendCmd(uint32_t type, const std::string &payload = "") const;
-  void subscribe(const std::string &payload) const;
-  struct ipc_response handleEvent() const;
+  sigc::signal<void, const struct ipc_response &> signal_event;
+  sigc::signal<void, const struct ipc_response &> signal_cmd;
 
-protected:
+  void sendCmd(uint32_t type, const std::string &payload = "");
+  void subscribe(const std::string &payload);
+  void handleEvent();
+  void setWorker(std::function<void()> &&func);
+
+ protected:
   static inline const std::string ipc_magic_ = "i3-ipc";
-  static inline const size_t ipc_header_size_ = ipc_magic_.size() + 8;
+  static inline const size_t      ipc_header_size_ = ipc_magic_.size() + 8;
 
-  const std::string getSocketPath() const;
-  int open(const std::string &) const;
-  struct ipc_response send(int fd, uint32_t type, const std::string &payload = "") const;
-  struct ipc_response recv(int fd) const;
+  const std::string   getSocketPath() const;
+  int                 open(const std::string &) const;
+  struct ipc_response send(int fd, uint32_t type, const std::string &payload = "");
+  struct ipc_response recv(int fd);
 
-  int fd_;
-  int fd_event_;
+  int                 fd_;
+  int                 fd_event_;
+  std::mutex          mutex_;
+  util::SleeperThread thread_;
 };
 
-} // namespace waybar::modules::sway
+}  // namespace waybar::modules::sway

include/modules/sway/mode.hpp

@@ -1,28 +1,27 @@
 #pragma once
 
 #include <fmt/format.h>
+#include "ALabel.hpp"
 #include "bar.hpp"
 #include "client.hpp"
-#include "util/sleeper_thread.hpp"
-#include "util/json.hpp"
-#include "ALabel.hpp"
 #include "modules/sway/ipc/client.hpp"
+#include "util/json.hpp"
 
 namespace waybar::modules::sway {
 
-class Mode : public ALabel {
-  public:
-    Mode(const std::string&, const waybar::Bar&, const Json::Value&);
-    ~Mode() = default;
-    auto update() -> void;
-  private:
-    void worker();
-    
-    const Bar& bar_;
-    waybar::util::SleeperThread thread_;
-    util::JsonParser parser_;
-    Ipc ipc_;
-    std::string mode_;
+class Mode : public ALabel, public sigc::trackable {
+ public:
+  Mode(const std::string&, const Json::Value&);
+  ~Mode() = default;
+  auto update() -> void;
+
+ private:
+  void onEvent(const struct Ipc::ipc_response&);
+
+  std::string      mode_;
+  util::JsonParser parser_;
+  std::mutex       mutex_;
+  Ipc              ipc_;
 };
 
-}
+}  // namespace waybar::modules::sway

include/modules/sway/window.hpp

@@ -2,31 +2,36 @@
 
 #include <fmt/format.h>
 #include <tuple>
+#include "ALabel.hpp"
 #include "bar.hpp"
 #include "client.hpp"
-#include "util/sleeper_thread.hpp"
-#include "util/json.hpp"
-#include "ALabel.hpp"
 #include "modules/sway/ipc/client.hpp"
+#include "util/json.hpp"
 
 namespace waybar::modules::sway {
 
-class Window : public ALabel {
-  public:
-    Window(const std::string&, const waybar::Bar&, const Json::Value&);
-    ~Window() = default;
-    auto update() -> void;
-  private:
-    void worker();
-    std::tuple<int, std::string> getFocusedNode(Json::Value nodes);
-    void getFocusedWindow();
+class Window : public ALabel, public sigc::trackable {
+ public:
+  Window(const std::string&, const waybar::Bar&, const Json::Value&);
+  ~Window() = default;
+  auto update() -> void;
 
-    const Bar& bar_;
-    waybar::util::SleeperThread thread_;
-    util::JsonParser parser_;
-    Ipc ipc_;
-    std::string window_;
-    int windowId_;
+ private:
+  void                                                   onEvent(const struct Ipc::ipc_response&);
+  void                                                   onCmd(const struct Ipc::ipc_response&);
+  std::tuple<std::size_t, int, std::string, std::string> getFocusedNode(const Json::Value& nodes,
+                                                                        std::string&       output);
+  void                                                   getTree();
+
+  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_;
+  Ipc              ipc_;
 };
 
-}
+}  // namespace waybar::modules::sway

include/modules/sway/workspaces.hpp

@@ -1,42 +1,48 @@
 #pragma once
 
+#include <unordered_map>
 #include <fmt/format.h>
+#include <gtkmm/button.h>
+#include <gtkmm/label.h>
+#include <unordered_map>
+#include "AModule.hpp"
 #include "bar.hpp"
 #include "client.hpp"
-#include "util/sleeper_thread.hpp"
-#include "util/json.hpp"
-#include "IModule.hpp"
 #include "modules/sway/ipc/client.hpp"
-#include <gtkmm/button.h>
+#include "util/json.hpp"
 
 namespace waybar::modules::sway {
 
-class Workspaces : public IModule {
-  public:
-    Workspaces(const std::string&, const waybar::Bar&, const Json::Value&);
-    ~Workspaces() = default;
-    auto update() -> void;
-    operator Gtk::Widget &();
-  private:
-    void worker();
-    void addWorkspace(const Json::Value&);
-		void onButtonReady(const Json::Value&, Gtk::Button&);
-    std::string getIcon(const std::string&, const Json::Value&);
-    bool handleScroll(GdkEventScroll*);
-    const std::string getCycleWorkspace(uint8_t current, bool prev) const;
-    uint16_t getWorkspaceIndex(const std::string &name) const;
-    std::string trimWorkspaceName(std::string);
+class Workspaces : public AModule, public sigc::trackable {
+ public:
+  Workspaces(const std::string&, const waybar::Bar&, const Json::Value&);
+  ~Workspaces() = default;
+  auto update() -> void;
 
-    const Bar& bar_;
-    const Json::Value& config_;
-    Json::Value workspaces_;
-    waybar::util::SleeperThread thread_;
-    Gtk::Box box_;
-    util::JsonParser parser_;
-    Ipc ipc_;
-    std::mutex mutex_;
-    bool scrolling_;
-    std::unordered_map<std::string, Gtk::Button> buttons_;
+ private:
+  static inline const std::string workspace_switch_cmd_ = "workspace --no-auto-back-and-forth \"{}\"";
+
+  static int convertWorkspaceNameToNum(std::string name);
+
+  void              onCmd(const struct Ipc::ipc_response&);
+  void              onEvent(const struct Ipc::ipc_response&);
+  bool              filterButtons();
+  Gtk::Button&      addButton(const Json::Value&);
+  void              onButtonReady(const Json::Value&, Gtk::Button&);
+  std::string       getIcon(const std::string&, const Json::Value&);
+  const std::string getCycleWorkspace(std::vector<Json::Value>::iterator, bool prev) const;
+  uint16_t          getWorkspaceIndex(const std::string& name) const;
+  std::string       trimWorkspaceName(std::string);
+  bool              handleScroll(GdkEventScroll*);
+
+  const Bar&                                   bar_;
+  std::vector<Json::Value>                     workspaces_;
+  std::vector<std::string>                     workspaces_order_;
+  Gtk::Box                                     box_;
+  util::JsonParser                             parser_;
+  std::unordered_map<std::string, Gtk::Button> buttons_;
+  std::mutex                                   mutex_;
+  Ipc                                          ipc_;
 };
 
-}
+}  // namespace waybar::modules::sway

include/modules/temperature.hpp

@@ -2,22 +2,23 @@
 
 #include <fmt/format.h>
 #include <fstream>
-#include "util/sleeper_thread.hpp"
 #include "ALabel.hpp"
+#include "util/sleeper_thread.hpp"
 
 namespace waybar::modules {
 
 class Temperature : public ALabel {
-  public:
-    Temperature(const std::string&, const Json::Value&);
-    ~Temperature() = default;
-    auto update() -> void;
-  private:
-    std::tuple<uint16_t, uint16_t> getTemperature();
-    bool isCritical(uint16_t);
+ public:
+  Temperature(const std::string&, const Json::Value&);
+  ~Temperature() = default;
+  auto update() -> void;
 
-    std::string file_path_;
-    waybar::util::SleeperThread thread_;
+ private:
+  float               getTemperature();
+  bool                isCritical(uint16_t);
+
+  std::string         file_path_;
+  util::SleeperThread thread_;
 };
 
-}
+}  // namespace waybar::modules

include/modules/wlr/taskbar.hpp

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

include/util/command.hpp

@@ -1,25 +1,25 @@
 #pragma once
 
-#include <sys/wait.h>
 #include <giomm.h>
+#include <spdlog/spdlog.h>
+#include <sys/wait.h>
 #include <unistd.h>
 
+#include <array>
+
+extern std::mutex reap_mtx;
+extern std::list<pid_t> reap;
+
 namespace waybar::util::command {
 
 struct res {
-  int exit_code;
+  int         exit_code;
   std::string out;
 };
 
-inline struct res exec(const std::string cmd)
-{
-  FILE* fp(popen(cmd.c_str(), "r"));
-  if (!fp) {
-    return { -1, "" };
-  }
-
+inline std::string read(FILE* fp) {
   std::array<char, 128> buffer = {0};
-  std::string output;
+  std::string           output;
   while (feof(fp) == 0) {
     if (fgets(buffer.data(), 128, fp) != nullptr) {
       output += buffer.data();
@@ -27,27 +27,114 @@ inline struct res exec(const std::string cmd)
   }
 
   // Remove last newline
-  if (!output.empty() && output[output.length()-1] == '\n') {
-    output.erase(output.length()-1);
+  if (!output.empty() && output[output.length() - 1] == '\n') {
+    output.erase(output.length() - 1);
   }
-  int exit_code = WEXITSTATUS(pclose(fp));
-  return {exit_code, output};
+  return output;
 }
 
-inline bool forkExec(std::string cmd) {
-  if (cmd == "") return true;
+inline int close(FILE* fp, pid_t pid) {
+  int stat = -1;
+  pid_t ret;
 
-  int32_t pid = fork();
+  fclose(fp);
+  do {
+    ret = waitpid(pid, &stat, WCONTINUED | WUNTRACED);
+
+    if (WIFEXITED(stat)) {
+      spdlog::debug("Cmd exited with code {}", WEXITSTATUS(stat));
+    } else if (WIFSIGNALED(stat)) {
+      spdlog::debug("Cmd killed by {}", WTERMSIG(stat));
+    } else if (WIFSTOPPED(stat)) {
+      spdlog::debug("Cmd stopped by {}", WSTOPSIG(stat));
+    } else if (WIFCONTINUED(stat)) {
+      spdlog::debug("Cmd continued");
+    } else if (ret == -1) {
+      spdlog::debug("waitpid failed: {}", strerror(errno));
+    } else {
+      break;
+    }
+  } while (!WIFEXITED(stat) && !WIFSIGNALED(stat));
+  return stat;
+}
+
+inline FILE* open(const std::string& cmd, int& pid) {
+  if (cmd == "") return nullptr;
+  int fd[2];
+  pipe(fd);
+
+  pid_t child_pid = fork();
+
+  if (child_pid < 0) {
+    spdlog::error("Unable to exec cmd {}, error {}", cmd.c_str(), strerror(errno));
+    return nullptr;
+  }
+
+  if (!child_pid) {
+    int err;
+    sigset_t mask;
+    sigfillset(&mask);
+    // Reset sigmask
+    err = pthread_sigmask(SIG_UNBLOCK, &mask, nullptr);
+    if (err != 0) spdlog::error("pthread_sigmask in open failed: {}", strerror(err));
+    ::close(fd[0]);
+    dup2(fd[1], 1);
+    setpgid(child_pid, child_pid);
+    execlp("/bin/sh", "sh", "-c", cmd.c_str(), (char*)0);
+    exit(0);
+  } else {
+    ::close(fd[1]);
+  }
+  pid = child_pid;
+  return fdopen(fd[0], "r");
+}
+
+inline struct res exec(const std::string& cmd) {
+  int  pid;
+  auto fp = command::open(cmd, pid);
+  if (!fp) return {-1, ""};
+  auto output = command::read(fp);
+  auto stat = command::close(fp, pid);
+  return {WEXITSTATUS(stat), output};
+}
+
+inline struct res execNoRead(const std::string& cmd) {
+  int  pid;
+  auto fp = command::open(cmd, pid);
+  if (!fp) return {-1, ""};
+  auto stat = command::close(fp, pid);
+  return {WEXITSTATUS(stat), ""};
+}
+
+inline int32_t forkExec(const std::string& cmd) {
+  if (cmd == "") return -1;
+
+  pid_t pid = fork();
 
   if (pid < 0) {
-    printf("Unable to exec cmd %s, error %s", cmd.c_str(), strerror(errno));
-    return false;
+    spdlog::error("Unable to exec cmd {}, error {}", cmd.c_str(), strerror(errno));
+    return pid;
   }
 
   // Child executes the command
-  if (!pid) execl("/bin/sh", "sh", "-c", cmd.c_str(), (char*)0);
+  if (!pid) {
+    int err;
+    sigset_t mask;
+    sigfillset(&mask);
+    // Reset sigmask
+    err = pthread_sigmask(SIG_UNBLOCK, &mask, nullptr);
+    if (err != 0) spdlog::error("pthread_sigmask in forkExec failed: {}", strerror(err));
+    setpgid(pid, pid);
+    execl("/bin/sh", "sh", "-c", cmd.c_str(), (char*)0);
+    exit(0);
+  } else {
+    reap_mtx.lock();
+    reap.push_back(pid);
+    reap_mtx.unlock();
+    spdlog::debug("Added child to reap list: {}", pid);
+  }
 
-  return true;
+  return pid;
 }
 
 }  // namespace waybar::util::command

include/util/format.hpp

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

include/util/json.hpp

@@ -5,27 +5,24 @@
 namespace waybar::util {
 
 struct JsonParser {
+  JsonParser() {}
 
-  JsonParser()
-    : reader_(builder_.newCharReader())
-  {}
-
-  const Json::Value parse(const std::string& data) const
-  {
-    Json::Value root;
-    std::string err;
-    bool res =
-      reader_->parse(data.c_str(), data.c_str() + data.size(), &root, &err);
-    if (!res)
-      throw std::runtime_error(err);
+  const Json::Value parse(const std::string& data) const {
+    Json::Value root(Json::objectValue);
+    if (data.empty()) {
+      return root;
+    }
+    std::unique_ptr<Json::CharReader> const reader(builder_.newCharReader());
+    std::string                             err;
+    bool res = reader->parse(data.c_str(), data.c_str() + data.size(), &root, &err);
+    if (!res) throw std::runtime_error(err);
     return root;
   }
 
   ~JsonParser() = default;
 
-private:
+ private:
   Json::CharReaderBuilder builder_;
-  std::unique_ptr<Json::CharReader> const reader_;
 };
 
-}
+}  // namespace waybar::util

include/util/rfkill.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <linux/rfkill.h>
+
+namespace waybar::util {
+
+class Rfkill {
+ public:
+  Rfkill(enum rfkill_type rfkill_type);
+  ~Rfkill() = default;
+  void waitForEvent();
+  bool getState() const;
+
+ private:
+  enum rfkill_type rfkill_type_;
+  int              state_ = 0;
+};
+
+}  // namespace waybar::util

include/util/sleeper_thread.hpp

@@ -1,25 +1,26 @@
 #pragma once
 
 #include <chrono>
+#include <condition_variable>
 #include <ctime>
 #include <functional>
-#include <condition_variable>
 #include <thread>
 
 namespace waybar::util {
 
 class SleeperThread {
-public:
+ public:
   SleeperThread() = default;
 
   SleeperThread(std::function<void()> func)
-    : thread_{[this, func] {
-        while (do_run_) func();
-      }}
-  {}
+      : thread_{[this, func] {
+          while (do_run_) {
+            signal_ = false;
+            func();
+          }
+        }} {}
 
-  SleeperThread& operator=(std::function<void()> func)
-  {
+  SleeperThread& operator=(std::function<void()> func) {
     thread_ = std::thread([this, func] {
       while (do_run_) {
         signal_ = false;
@@ -29,54 +30,55 @@ public:
     return *this;
   }
 
-  bool isRunning() const
-  {
-    return do_run_;
-  }
+  bool isRunning() const { return do_run_; }
 
-  auto sleep_for(std::chrono::system_clock::duration dur)
-  {
+  auto sleep_for(std::chrono::system_clock::duration dur) {
     std::unique_lock lk(mutex_);
     return condvar_.wait_for(lk, dur, [this] { return signal_ || !do_run_; });
   }
 
-  auto sleep_until(std::chrono::time_point<std::chrono::system_clock,
-    std::chrono::system_clock::duration> time_point)
-  {
+  auto sleep_until(
+      std::chrono::time_point<std::chrono::system_clock, std::chrono::system_clock::duration>
+          time_point) {
     std::unique_lock lk(mutex_);
     return condvar_.wait_until(lk, time_point, [this] { return signal_ || !do_run_; });
   }
 
-  auto wake_up()
-  {
-    signal_ = true;
+  auto wake_up() {
+    {
+      std::lock_guard<std::mutex> lck(mutex_);
+      signal_ = true;
+    }
     condvar_.notify_all();
   }
 
-  auto stop()
-  {
+  auto stop() {
     {
       std::lock_guard<std::mutex> lck(mutex_);
       signal_ = true;
       do_run_ = false;
     }
     condvar_.notify_all();
+    auto handle = thread_.native_handle();
+    if (handle != 0) {
+      // TODO: find a proper way to terminate thread...
+      pthread_cancel(handle);
+    }
   }
 
-  ~SleeperThread()
-  {
+  ~SleeperThread() {
     stop();
     if (thread_.joinable()) {
       thread_.join();
     }
   }
 
-private:
-  std::thread thread_;
+ private:
+  std::thread             thread_;
   std::condition_variable condvar_;
-  std::mutex mutex_;
-  bool do_run_ = true;
-  bool signal_ = false;
+  std::mutex              mutex_;
+  bool                    do_run_ = true;
+  bool                    signal_ = false;
 };
 
-}
+}  // namespace waybar::util

man/waybar-backlight.5.scd

@@ -0,0 +1,75 @@
+waybar-backlight(5)
+
+# NAME
+
+waybar - backlight module
+
+# DESCRIPTION
+
+The *backlight* module displays the current backlight level.
+
+# CONFIGURATION
+
+*interval*: ++
+	typeof: integer ++
+	default: 2 ++
+	The interval in which information gets polled.
+
+*format*: ++
+	typeof: string ++
+	default: {percent}% ++
+	The format, how information should be displayed. On {} data gets inserted.
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in characters the module should display.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*states*: ++
+	typeof: array ++
+	A number of backlight states which get activated on certain brightness levels.
+
+*on-click*: ++
+	typeof: string ++
+	Command to execute when the module is clicked.
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when the module is right clicked.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when performing a scroll up on the module.
+
+*on-scroll-down*: ++
+	typeof: string
+	Command to execute when performing a scroll down on the module.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double
+	Threshold to be used when scrolling.
+
+# EXAMPLE:
+
+```
+"backlight": {
+    "device": "intel_backlight",
+    "format": "{percent}% {icon}",
+    "format-icons": ["", ""]
+}
+```
+
+# STYLE
+
+- *#backlight*

man/waybar-battery.5.scd

@@ -0,0 +1,148 @@
+waybar-battery(5)
+
+# NAME
+
+waybar - battery module
+
+# DESCRIPTION
+
+The *battery* module displays the current capacity and state (eg. charging) of your battery.
+
+# CONFIGURATION
+
+*bat*: ++
+	typeof: string ++
+	The battery to monitor, as in /sys/class/power_supply/ instead of auto detect.
+
+*adapter*: ++
+	typeof: string ++
+	The adapter to monitor, as in /sys/class/power_supply/ instead of auto detect.
+
+*full-at*: ++
+	typeof: integer ++
+	Define the max percentage of the battery, useful for an old battery, e.g. 96
+
+*interval*: ++
+	typeof: integer ++
+	default: 60 ++
+	The interval in which the information gets polled.
+
+*states*: ++
+	typeof: array ++
+	A number of battery states which get activated on certain capacity levels. See *waybar-states(5)*.
+
+*format*: ++
+	typeof: string ++
+	default: {capacity}% ++
+	The format, how the time should be displayed.
+
+*format-time*: ++
+	typeof: string ++
+	default: {H} h {M} min ++
+	The format, how the time should be displayed.
+
+*format-icons*: ++
+	typeof: array/object ++
+	Based on the current capacity, the corresponding icon gets selected. ++
+	The order is *low* to *high*. Or by the state if it is an object.
+
+*max-length*: ++
+	typeof: integer++
+	The maximum length in character the module should display.
+
+*rotate*: ++
+	typeof: integer++
+	Positive value to rotate the text label.
+
+*on-click*: ++
+	typeof: string ++
+	Command to execute when clicked on the module.
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when you right clicked on the module.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when scrolling up on the module.
+
+*on-scroll-down*: ++
+	typeof: string ++
+	Command to execute when scrolling down on the module.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
+
+# FORMAT REPLACEMENTS
+
+*{capacity}*: Capacity in percentage
+
+*{icon}*: Icon, as defined in *format-icons*.
+
+*{time}*: Estimate of time until full or empty. Note that this is based on the power draw at the last refresh time, not an average.
+
+# TIME FORMAT
+
+The *battery* module allows you to define how time should be formatted via *format-time*.
+
+The two arguments are:
+*{H}*: Hours
+*{M}*: Minutes
+
+# CUSTOM FORMATS
+
+The *battery* module allows to define custom formats based on up to two factors. The best fitting format will be selected.
+
+*format-<state>*: With *states*, a custom format can be set depending on the capacity of your battery.
+
+*format-<status>*: With the status, a custom format can be set depending on the status in /sys/class/power_supply/<bat>/status (in lowercase).
+
+*format-<status>-<state>*: You can also set a custom format depending on both values.
+
+# STATES
+
+- Every entry (*state*) consists of a *<name>* (typeof: *string*) and a *<value>* (typeof: *integer*).
+	- The state can be addressed as a CSS class in the *style.css*. The name of the CSS class is the *<name>* of the state.	Each class gets activated when the current capacity is equal or below the configured *<value>*.
+	- Also each state can have its own *format*. Those con be configured via *format-<name>*. Or if you want to differentiate a bit more even as *format-<status>-<state>*. For more information see *custom-formats*.
+
+
+
+# EXAMPLES
+
+```
+"battery": {
+    "bat": "BAT2",
+    "interval": 60,
+    "states": {
+        "warning": 30,
+        "critical": 15
+    },
+    "format": "{capacity}% {icon}",
+    "format-icons": ["", "", "", "", ""],
+    "max-length": 25
+}
+```
+
+# STYLE
+
+- *#battery*
+- *#battery.<status>*
+	- *<status>* is the value of /sys/class/power_supply/<bat>/status in lowercase.
+- *#battery.<state>*
+	- *<state>* can be defined in the *config*. For more information see *states*.
+- *#battery.<status>.<state>*
+	- Combination of both *<status>* and *<state>*.

man/waybar-bluetooth.5.scd

@@ -0,0 +1,94 @@
+waybar-bluetooth(5)
+
+# NAME
+
+waybar - bluetooth module
+
+# DESCRIPTION
+
+The *bluetooth* module displays information about the status of the device's bluetooth device.
+
+# CONFIGURATION
+
+Addressed by *bluetooth*
+
+*interval*: ++
+	typeof: integer ++
+	default: 60 ++
+	The interval in which the bluetooth state gets updated.
+
+*format*: ++
+	typeof: string  ++
+	default: *{icon}* ++
+	The format, how information should be displayed. This format is used when other formats aren't specified.
+
+*format-icons*: ++
+	typeof: array/object ++
+	Based on the device status, the corresponding icon gets selected. ++
+	The order is *low* to *high*. Or by the state if it is an object.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in character the module should display.
+
+*on-click*: ++
+	typeof: string ++
+	Command to execute when clicked on the module.
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when you right clicked on the module.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when scrolling up on the module.
+
+*on-scroll-down*: ++
+	typeof: string ++
+	Command to execute when scrolling down on the module.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: *true* ++
+	Option to disable tooltip on hover.
+
+*tooltip-format*: ++
+	typeof: string ++
+	The format, how information should be displayed in the tooltip. This format is used when other formats aren't specified.
+
+# FORMAT REPLACEMENTS
+
+*{status}*: Status of the bluetooth device.
+
+*{icon}*: Icon, as defined in *format-icons*.
+
+# EXAMPLES
+
+```
+"bluetooth": {
+	"format": "{icon}",
+	"format-alt": "bluetooth: {status}",
+	"interval": 30,
+	"format-icons": {
+		"enabled": "",
+		"disabled": ""
+	},
+	"tooltip-format": "{status}"
+}
+```
+
+# STYLE
+
+- *#bluetooth*

man/waybar-clock.5.scd

@@ -0,0 +1,98 @@
+waybar-clock(5)
+
+# NAME
+
+waybar - clock module
+
+# DESCRIPTION
+
+The *clock* module displays the current date and time.
+
+# CONFIGURATION
+
+*interval*: ++
+	typeof: integer ++
+	default: 60 ++
+	The interval in which the information gets polled.
+
+*format*: ++
+	typeof: string ++
+	default: {:%H:%M} ++
+	The format, how the date and time should be displayed. ++
+	It uses the format of the date library. See https://howardhinnant.github.io/date/date.html#to_stream_formatting for details.
+
+*timezone*: ++
+	typeof: string ++
+	default: inferred local timezone ++
+	The timezone to display the time in, e.g. America/New_York.
+
+*timezones*: ++
+	typeof: list of strings ++
+	A list of timezones to use for time display, changed using the scroll wheel. ++
+	Use "" to represent the system's local timezone.  Using %Z in the format or tooltip format is useful to track which time zone is currently displayed.
+
+*locale*: ++
+	typeof: string ++
+	default: inferred from current locale ++
+	A locale to be used to display the time. Intended to render times in custom timezones with the proper language and format.
+
+*today-format*: ++
+	typeof: string ++
+	default: <b><u>{}</u></b> ++
+	The format of today's date in the calendar.
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in character the module should display.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*on-click*: ++
+	typeof: string ++
+	Command to execute when clicked on the module.
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when you right clicked on the module.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when scrolling up on the module.
+
+*on-scroll-down*: ++
+	typeof: string ++
+	Command to execute when scrolling down on the module.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
+View all valid format options in *strftime(3)*.
+
+# FORMAT REPLACEMENTS
+
+*{calendar}*: Current month calendar
+
+# EXAMPLES
+
+```
+"clock": {
+    "interval": 60,
+    "format": "{:%H:%M}",
+    "max-length": 25
+}
+```
+
+# STYLE
+
+- *#clock*

man/waybar-cpu.5.scd

@@ -0,0 +1,86 @@
+waybar-cpu(5)
+
+# NAME
+
+waybar - cpu module
+
+# DESCRIPTION
+
+The *cpu* module displays the current cpu utilization.
+
+# CONFIGURATION
+
+*interval*: ++
+	typeof: integer ++
+	default: 10 ++
+	The interval in which the information gets polled.
+
+*format*: ++
+	typeof: string  ++
+	default: {usage}% ++
+	The format, how information should be displayed. On {} data gets inserted.
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in character the module should display.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*states*: ++
+	typeof: array ++
+	A number of cpu usage states which get activated on certain usage levels. See *waybar-states(5)*.
+
+*on-click*: ++
+	typeof: string  ++
+	Command to execute when clicked on the module.
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when you right clicked on the module.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when scrolling up on the module.
+
+*on-scroll-down*: ++
+	typeof: string ++
+	Command to execute when scrolling down on the module.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
+
+# FORMAT REPLACEMENTS
+
+*{load}*: Current cpu load.
+
+*{usage}*: Current cpu usage.
+
+# EXAMPLE
+
+```
+"cpu": {
+	"interval": 10,
+	"format": "{}% ",
+	"max-length": 10
+}
+```
+
+# STYLE
+
+- *#cpu*

man/waybar-custom.5.scd

@@ -0,0 +1,210 @@
+waybar-custom(5)
+
+# NAME
+
+waybar - custom module
+
+# DESCRIPTION
+
+The *custom* module displays either the output of a script or static text.
+To display static text, specify only the *format* field.
+
+# CONFIGURATION
+
+Addressed by *custom/<name>*
+
+*exec*: ++
+	typeof: string ++
+	The path to the script, which should be executed.
+
+*exec-if*: ++
+	typeof: string ++
+	The path to a script, which determines if the script in *exec* should be executed.
+	*exec* will be executed if the exit code of *exec-if* equals 0.
+
+*exec-on-event*: ++
+	typeof: bool ++
+	default: true ++
+	If an event command is set (e.g. *on-click* or *on-scroll-up*) then re-execute the script after
+	executing the event command.
+
+*return-type*: ++
+	typeof: string ++
+	See *return-type*
+
+*interval*: ++
+	typeof: integer ++
+	The interval (in seconds) in which the information gets polled.
+	Use *once* if you want to execute the module only on startup.
+	You can update it manually with a signal. If no *interval* is defined,
+	it is assumed that the out script loops it self.
+
+*restart-interval*: ++
+	typeof: integer ++
+	The restart interval (in seconds).
+	Can't be used with the *interval* option, so only with continuous scripts.
+	Once the script exit, it'll be re-executed after the *restart-interval*.
+
+*signal*: ++
+	typeof: integer ++
+	The signal number used to update the module.
+	The number is valid between 1 and N, where *SIGRTMIN+N* = *SIGRTMAX*.
+
+*format*: ++
+	typeof: string ++
+	default: {} ++
+	The format, how information should be displayed. On {} data gets inserted.
+
+*format-icons*: ++
+	typeof: array ++
+	Based on the set percentage, the corresponding icon gets selected. The order is *low* to *high*.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in character the module should display.
+
+*on-click*: ++
+	typeof: string ++
+	Command to execute when clicked on the module.
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when you right clicked on the module.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when scrolling up on the module.
+
+*on-scroll-down*: ++
+	typeof: string ++
+	Command to execute when scrolling down on the module.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
+
+*escape*: ++
+	typeof: bool ++
+	default: false ++
+	Option to enable escaping of script output.
+
+# RETURN-TYPE
+
+When *return-type* is set to *json*, Waybar expects the *exec*-script  to output its data in JSON format.
+This should look like this:
+
+```
+{"text": "$text", "tooltip": "$tooltip", "class": "$class", "percentage": $percentage }
+```
+
+The *class* parameter also accepts an array of strings.
+
+If nothing or an invalid option is specified, Waybar expects i3blocks style output. Values are *newline* separated.
+This should look like this:
+
+```
+$text\\n$tooltip\\n$class*
+```
+
+*class* is a CSS class, to apply different styles in *style.css*
+
+# FORMAT REPLACEMENTS
+
+*{}*: Output of the script.
+
+*{percentage}* Percentage which can be set via a json return-type.
+
+*{icon}*: An icon from 'format-icons' according to percentage.
+
+# EXAMPLES
+
+## Spotify:
+
+```
+"custom/spotify": {
+	"format": " {}",
+	"max-length": 40,
+	"interval": 30, // Remove this if your script is endless and write in loop
+	"exec": "$HOME/.config/waybar/mediaplayer.sh 2> /dev/null", // Script in resources folder
+	"exec-if": "pgrep spotify"
+}
+```
+
+## mpd:
+
+```
+"custom/mpd": {
+	"format": "♪ {}",
+	//"max-length": 15,
+	"interval": 10,
+	"exec": "mpc current",
+	"exec-if": "pgrep mpd",
+	"on-click": "mpc toggle",
+	"on-click-right": "sonata"
+}
+```
+
+## cmus:
+
+```
+"custom/cmus": {
+	"format": "♪ {}",
+	//"max-length": 15,
+	"interval": 10,
+	"exec": "cmus-remote -C \"format_print '%a - %t'\"", // artist - title
+	"exec-if": "pgrep cmus",
+	"on-click": "cmus-remote -u",                        //toggle pause
+	"escape": true                                       //handle markup entities
+}
+```
+
+## Pacman
+
+```
+
+"custom/pacman": {
+	"format": "{}  ",
+	"interval": "once",
+	"exec": "pacman_packages",
+	"on-click": "update-system",
+	"signal": 8
+}
+```
+
+## Alternate Pacman
+
+```
+"custom/pacman": {
+	"format": "{}  ",
+	"interval": 3600,                     // every hour
+	"exec": "checkupdates | wc -l",       // # of updates
+	"exec-if": "exit 0",                  // always run; consider advanced run conditions
+	"on-click": "termite -e 'sudo pacman -Syu'; pkill -SIGRTMIN+8 waybar", // update system
+	"signal": 8
+}
+```
+
+You can use the signal and update the number of available packages with *pkill -RTMIN+8 waybar*.
+
+# STYLE
+
+- *#custom-<name>*
+- *#custom-<name>.<class>*
+- *<class>* can be set by the script. For more information see *return-type*

man/waybar-disk.5.scd

@@ -0,0 +1,101 @@
+waybar-disk(5)
+
+# NAME
+
+waybar - disk module
+
+# DESCRIPTION
+
+The *disk* module displays the current disk space used.
+
+# CONFIGURATION
+
+Addressed by *disk*
+
+*path*: ++
+	typeof: string ++
+	default: "/" ++
+	Any path residing in the filesystem or mountpoint for which the information should be displayed.
+
+*interval*: ++
+	typeof: integer++
+	default: 30 ++
+	The interval in which the information gets polled.
+
+*format*: ++
+	typeof: string ++
+	default: "{percentage_used}%" ++
+	The format, how information should be displayed.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in character the module should display.
+
+*on-click*: ++
+	typeof: string ++
+	Command to execute when clicked on the module.
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when you right clicked on the module.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when scrolling up on the module.
+
+*on-scroll-down*: ++
+	typeof: string ++
+	Command to execute when scrolling down on the module.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
+
+*tooltip-format*: ++
+	typeof: string ++
+	default: "{used} out of {total} used ({percentage_used}%)" ++
+	The format of the information displayed in the tooltip.
+
+# FORMAT REPLACEMENTS
+
+*{percentage_used}*: Percentage of disk in use.
+
+*{percentage_free}*: Percentage of free disk space
+
+*{total}*: Total amount of space on the disk, partition or mountpoint.
+
+*{used}*: Amount of used disk space.
+
+*{free}*: Amount of available disk space for normal users.
+
+*{path}*: The path specified in the configuration.
+
+# EXAMPLES
+
+```
+"disk": {
+	"interval": 30,
+	"format": "{percentage_free}% free on {path}",
+}
+```
+
+# STYLE
+
+- *#disk*

man/waybar-idle-inhibitor.5.scd

@@ -0,0 +1,79 @@
+waybar-idle-inhibitor(5)
+
+# NAME
+
+waybar - idle_inhibitor module
+
+# DESCRIPTION
+
+The *idle_inhibitor* module can inhibiting the idle behavior such as screen blanking, locking, and
+screensaving, also known as "presentation mode".
+
+# CONFIGURATION
+
+*format*: ++
+	typeof: string ++
+	The format, how the state should be displayed.
+
+*format-icons*: ++
+	typeof: array ++
+	Based on the current state, the corresponding icon gets selected.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in character the module should display.
+
+*on-click*: ++
+	typeof: string ++
+	Command to execute when clicked on the module. A click also toggles the state
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when you right clicked on the module.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when scrolling up on the module.
+
+*on-scroll-down*: ++
+	typeof: string ++
+	Command to execute when scrolling down on the module.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
+
+# FORMAT REPLACEMENTS
+
+*{status}*: status (*activated* or *deactivated*)
+
+*{icon}*: Icon, as defined in *format-icons*
+
+# EXAMPLES
+
+```
+"idle_inhibitor": {
+	"format": "{icon}",
+	"format-icons": {
+	    "activated": "",
+	    "deactivated": ""
+	}
+}
+```

man/waybar-memory.5.scd

@@ -0,0 +1,101 @@
+waybar-memory(5)
+
+# NAME
+
+waybar - memory module
+
+# DESCRIPTION
+
+The *memory* module displays the current memory utilization.
+
+# CONFIGURATION
+
+Addressed by *memory*
+
+*interval*: ++
+	typeof: integer++
+	default: 30 ++
+	The interval in which the information gets polled.
+
+*format*: ++
+	typeof: string ++
+	default: {percentage}% ++
+	The format, how information should be displayed.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*states*: ++
+	typeof: array ++
+	A number of memory utilization states which get activated on certain percentage thresholds. See *waybar-states(5)*.
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in character the module should display.
+
+*on-click*: ++
+	typeof: string ++
+	Command to execute when clicked on the module.
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when you right clicked on the module.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when scrolling up on the module.
+
+*on-scroll-down*: ++
+	typeof: string ++
+	Command to execute when scrolling down on the module.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
+
+# FORMAT REPLACEMENTS
+
+*{percentage}*: Percentage of memory in use.
+
+*{total}*: Amount of total memory available in GiB.
+
+*{used}*: Amount of used memory in GiB.
+
+*{avail}*: Amount of available memory in GiB.
+
+# EXAMPLES
+
+```
+"memory": {
+	"interval": 30,
+	"format": "{}% ",
+	"max-length": 10
+}
+```
+
+## FORMATTED MEMORY VALUES
+
+```
+"memory": {
+	"interval": 30,
+	"format": "{used:0.1f}G/{total:0.1f}G "
+}
+```
+
+# STYLE
+
+- *#memory*

man/waybar-mpd.5.scd

@@ -0,0 +1,216 @@
+waybar-mpd(5)
+
+# NAME
+
+waybar - mpd module
+
+# DESCRIPTION
+
+The *mpd* module displays information about a running "Music Player Daemon" instance.
+
+# CONFIGURATION
+
+Addressed by *mpd*
+
+*server*: ++
+	typeof: string ++
+	The network address or Unix socket path of the MPD server. If empty, connect to the default host.
+
+*port*: ++
+	typeof: integer ++
+	The port MPD listens to. If empty, use the default port.
+
+*interval*: ++
+	typeof: integer++
+	default: 5 ++
+	The interval in which the connection to the MPD server is retried
+
+*timeout*: ++
+	typeof: integer++
+	default: 30 ++
+	The timeout for the connection. Change this if your MPD server has a low `connection_timeout` setting
+
+*unknown-tag*: ++
+	typeof: string ++
+	default: "N/A" ++
+	The text to display when a tag is not present in the current song, but used in `format`
+
+*format*: ++
+	typeof: string ++
+	default: "{album} - {artist} - {title}" ++
+	Information displayed when a song is playing.
+
+*format-stopped*: ++
+	typeof: string ++
+	default: "stopped" ++
+	Information displayed when the player is stopped.
+
+*format-paused*: ++
+	typeof: string ++
+	This format is used when a song is paused.
+
+*format-disconnected*: ++
+	typeof: string ++
+	default: "disconnected" ++
+	Information displayed when the MPD server can't be reached.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
+
+*tooltip-format*: ++
+	typeof: string ++
+	default: "MPD (connected)" ++
+	Tooltip information displayed when connected to MPD.
+
+*tooltip-format-disconnected*: ++
+	typeof: string ++
+	default: "MPD (disconnected)" ++
+	Tooltip information displayed when the MPD server can't be reached.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in character the module should display.
+
+*on-click*: ++
+	typeof: string ++
+	Command to execute when clicked on the module.
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when you right clicked on the module.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when scrolling up on the module.
+
+*on-scroll-down*: ++
+	typeof: string ++
+	Command to execute when scrolling down on the module.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
+*state-icons*: ++
+	typeof: object ++
+	default: {} ++
+	Icon to show depending on the play/pause state of the player (*{ "playing": "...", "paused": "..." }*)
+
+*consume-icons*: ++
+	typeof: object ++
+	default: {} ++
+	Icon to show depending on the "consume" option (*{ "on": "...", "off": "..." }*)
+
+*random-icons*: ++
+	typeof: object ++
+	default: {} ++
+	Icon to show depending on the "random" option (*{ "on": "...", "off": "..." }*)
+
+*repeat-icons*: ++
+	typeof: object ++
+	default: {} ++
+	Icon to show depending on the "repeat" option (*{ "on": "...", "off": "..." }*)
+
+*single-icons*: ++
+	typeof: object ++
+	default: {} ++
+	Icon to show depending on the "single" option (*{ "on": "...", "off": "..." }*)
+
+# FORMAT REPLACEMENTS
+
+## WHEN PLAYING/PAUSED
+
+*{artist}*: The artist of the current song
+
+*{albumArtist}*: The artist of the current album
+
+*{album}*: The album of the current song
+
+*{title}*: The title of the current song
+
+*{date}*: The date of the current song
+
+*{elapsedTime}*: The current position of the current song. To format as a date/time (see example configuration)
+
+*{totalTime}*: The length of the current song. To format as a date/time (see example configuration)
+
+*{songPosition}*: The position of the current song.
+
+*{queueLength}*: The length of the current queue.
+
+*{stateIcon}*: The icon corresponding the playing or paused status of the player (see *state-icons* option)
+
+*{consumeIcon}*: The icon corresponding the "consume" option (see *consume-icons* option)
+
+*{randomIcon}*: The icon corresponding the "random" option (see *random-icons* option)
+
+*{repeatIcon}*: The icon corresponding the "repeat" option (see *repeat-icons* option)
+
+*{singleIcon}*: The icon corresponding the "single" option (see *single-icons* option)
+
+
+## WHEN STOPPED
+
+*{consumeIcon}*: The icon corresponding the "consume" option (see *consume-icons* option)
+
+*{randomIcon}*: The icon corresponding the "random" option (see *random-icons* option)
+
+*{repeatIcon}*: The icon corresponding the "repeat" option (see *repeat-icons* option)
+
+*{singleIcon}*: The icon corresponding the "single" option (see *single-icons* option)
+
+## WHEN DISCONNECTED
+
+Currently, no format replacements when disconnected.
+
+# EXAMPLES
+
+```
+"mpd": {
+	"format": "{stateIcon} {consumeIcon}{randomIcon}{repeatIcon}{singleIcon}{artist} - {album} - {title} ({elapsedTime:%M:%S}/{totalTime:%M:%S}) ",
+	"format-disconnected": "Disconnected ",
+	"format-stopped": "{consumeIcon}{randomIcon}{repeatIcon}{singleIcon}Stopped ",
+	"interval": 2,
+	"consume-icons": {
+		"on": " " // Icon shows only when "consume" is on
+	},
+	"random-icons": {
+		"off": "<span color=\"#f53c3c\"></span> ", // Icon grayed out when "random" is off
+		"on": " "
+	},
+	"repeat-icons": {
+		"on": " "
+	},
+	"single-icons": {
+		"on": "1 "
+	},
+	"state-icons": {
+		"paused": "",
+		"playing": ""
+	},
+	"tooltip-format": "MPD (connected)",
+	"tooltip-format-disconnected": "MPD (disconnected)"
+}
+```
+
+# STYLE
+
+- *#mpd*
+- *#mpd.disconnected*
+- *#mpd.stopped*
+- *#mpd.playing*
+- *#mpd.paused*

man/waybar-network.5.scd

@@ -0,0 +1,173 @@
+waybar-network(5)
+
+# NAME
+
+waybar - network module
+
+# DESCRIPTION
+
+The *network* module displays information about the current network connections.
+
+# CONFIGURATION
+
+Addressed by *network*
+
+*interface*: ++
+	typeof: string ++
+	Use the defined interface instead of auto detection. Accepts wildcard.
+
+*interval*: ++
+	typeof: integer ++
+	default: 60 ++
+	The interval in which the network information gets polled (e.g. signal strength).
+
+*family*: ++
+	typeof: string ++
+	default: *ipv4* ++
+	The address family that is used for the format replacement {ipaddr} and to determine if a network connection is present.
+
+*format*: ++
+	typeof: string  ++
+	default: *{ifname}* ++
+	The format, how information should be displayed. This format is used when other formats aren't specified.
+
+*format-ethernet*: ++
+	typeof: string ++
+	This format is used when an ethernet interface is displayed.
+
+*format-wifi*: ++
+	typeof: string ++
+	This format is used when a wireless interface is displayed.
+
+*format-linked*: ++
+	typeof: string ++
+	This format is used when a linked interface with no ip address is displayed.
+
+*format-disconnected*: ++
+	typeof: string ++
+	This format is used when the displayed interface is disconnected.
+
+*format-disabled*: ++
+	typeof: string ++
+	This format is used when the displayed interface is disabled.
+
+*format-icons*: ++
+	typeof: array/object ++
+	Based on the current signal strength, the corresponding icon gets selected. ++
+	The order is *low* to *high*. Or by the state if it is an object.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in character the module should display.
+
+*on-click*: ++
+	typeof: string ++
+	Command to execute when clicked on the module.
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when you right clicked on the module.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when scrolling up on the module.
+
+*on-scroll-down*: ++
+	typeof: string ++
+	Command to execute when scrolling down on the module.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: *true* ++
+	Option to disable tooltip on hover.
+
+*tooltip-format*: ++
+	typeof: string ++
+	The format, how information should be displayed in the tooltip. This format is used when other formats aren't specified.
+
+*tooltip-format-ethernet*: ++
+	typeof: string ++
+	This format is used when an ethernet interface is displayed.
+
+*tooltip-format-wifi*: ++
+	typeof: string ++
+	This format is used when a wireless interface is displayed.
+
+*tooltip-format-disconnected*: ++
+	typeof: string ++
+	This format is used when the displayed interface is disconnected.
+
+*tooltip-format-disabled*: ++
+	typeof: string ++
+	This format is used when the displayed interface is disabled.
+
+# FORMAT REPLACEMENTS
+
+*{ifname}*: Name of the network interface.
+
+*{ipaddr}*: The first IP of the interface.
+
+*{netmask}*: The subnetmask corresponding to the IP.
+
+*{cidr}*: The subnetmask corresponding to the IP in CIDR notation.
+
+*{essid}*: Name (SSID) of the wireless network.
+
+*{signalStrength}*: Signal strength of the wireless network.
+
+*{signaldBm}*: Signal strength of the wireless network in dBm.
+
+*{frequency}*: Frequency of the wireless network in MHz.
+
+*{bandwidthUpBits}*: Instant up speed in bits/seconds.
+
+*{bandwidthDownBits}*: Instant down speed in bits/seconds.
+
+*{bandwidthUpOctets}*: Instant up speed in octets/seconds.
+
+*{bandwidthDownOctets}*: Instant down speed in octets/seconds.
+
+*{icon}*: Icon, as defined in *format-icons*.
+
+# EXAMPLES
+
+```
+"network": {
+	"interface": "wlp2s0",
+	"format": "{ifname}",
+	"format-wifi": "{essid} ({signalStrength}%) ",
+	"format-ethernet": "{ifname} ",
+	"format-disconnected": "", //An empty format will hide the module.
+	"format-disconnected": "",
+	"tooltip-format": "{ifname}",
+	"tooltip-format-wifi": "{essid} ({signalStrength}%) ",
+	"tooltip-format-ethernet": "{ifname} ",
+	"tooltip-format-disconnected": "Disconnected",
+	"max-length": 50
+}
+```
+
+# STYLE
+
+- *#network*
+- *#network.disconnected*
+- *#network.disabled*
+- *#network.linked*
+- *#network.ethernet*
+- *#network.wifi*

man/waybar-pulseaudio.5.scd

@@ -0,0 +1,143 @@
+waybar-pulseaudio(5)
+
+# NAME
+
+waybar - pulseaudio module
+
+# DESCRIPTION
+
+The *pulseaudio* module displays the current volume reported by PulseAudio.
+
+Additionally you can control the volume by scrolling *up* or *down* while the cursor is over the module.
+
+# CONFIGURATION
+
+*format*: ++
+	typeof: string  ++
+	default: {volume}% ++
+	The format, how information should be displayed. This format is used when other formats aren't specified.
+
+*format-bluetooth*: ++
+	typeof: string ++
+	This format is used when using bluetooth speakers.
+
+*format-muted*: ++
+	typeof: string ++
+	This format is used when the sound is muted.
+
+*format-source*: ++
+	typeof: string ++
+	default: {volume}% ++
+	This format used for the source.
+
+*format-source-muted*: ++
+	typeof: string ++
+	This format is used when the source is muted.
+
+*format-icons*: ++
+	typeof: array ++
+	Based on the current port-name and volume, the corresponding icon gets selected. The order is *low* to *high*. See *Icons*.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*states*: ++
+	typeof: array ++
+	A number of volume states which get activated on certain volume levels. See *waybar-states(5)*
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in character the module should display.
+
+*scroll-step*: ++
+	typeof: float ++
+	default: 1.0 ++
+	The speed in which to change the volume when scrolling.
+
+*on-click*: ++
+	typeof: string ++
+	Command to execute when clicked on the module.
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when you right clicked on the module.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when scrolling up on the module. This replaces the default behaviour of volume control.
+
+*on-scroll-down*: ++
+	typeof: string ++
+	Command to execute when scrolling down on the module. This replaces the default behaviour of volume control.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
+
+# FORMAT REPLACEMENTS
+
+*{desc}*: Pulseaudio port's description, for bluetooth it'll be the device name.
+
+*{volume}*: Volume in percentage.
+
+*{icon}*: Icon, as defined in *format-icons*.
+
+*{format_source}*: Source format, *format-source*, *format-source-muted*.
+
+# ICONS:
+
+The following strings for *format-icons* are supported.
+If they are found in the current PulseAudio port name, the corresponding icons will be selected.
+
+- *default* (Shown, when no other port is found)
+- *headphone*
+- *speaker*
+- *hdmi*
+- *headset*
+- *hands-free*
+- *portable*
+- *car*
+- *hifi*
+- *phone*
+
+
+# EXAMPLES
+
+```
+"pulseaudio": {
+	"format": "{volume}% {icon}",
+	"format-bluetooth": "{volume}% {icon}",
+	"format-muted": "",
+	"format-icons": {
+		"headphones": "",
+		"handsfree": "",
+		"headset": "",
+		"phone": "",
+		"portable": "",
+		"car": "",
+		"default": ["", ""]
+	},
+	"scroll-step": 1,
+	"on-click": "pavucontrol"
+}
+```
+
+# STYLE
+
+- *#pulseaudio*
+- *#pulseaudio.bluetooth*
+- *#pulseaudio.muted*

man/waybar-river-tags.5.scd

@@ -0,0 +1,38 @@
+waybar-river-tags(5)
+
+# NAME
+
+waybar - river tags module
+
+# DESCRIPTION
+
+The *tags* module displays the current state of tags in river.
+
+# CONFIGURATION
+
+Addressed by *river/tags*
+
+*num-tags*: ++
+    typeof: uint ++
+    default: 9 ++
+    The number of tags that should be displayed.
+
+# EXAMPLE
+
+```
+"river/tags": {
+    "num-tags": 5
+}
+```
+
+# STYLE
+
+- *#tags button*
+- *#tags button.occupied*
+- *#tags button.focused*
+
+Note that a tag can be both occupied and focused at the same time.
+
+# SEE ALSO
+
+waybar(5), river(1)

man/waybar-states.5.scd

@@ -0,0 +1,43 @@
+waybar-states(5)
+
+# OVERVIEW
+
+Some modules support 'states' which allows percentage values to be used as styling triggers to
+apply a class when the value matches the declared state value.
+
+# STATES
+
+- Every entry (*state*) consists of a *<name>* (typeof: *string*) and a *<value>* (typeof: *integer*).
+
+	- The state can be addressed as a CSS class in the *style.css*. The name of the CSS class is the *<name>* of the state.
+	  Each class gets activated when the current capacity is equal or below the configured *<value>*.
+
+	- Also each state can have its own *format*.
+	  Those con be configured via *format-<name>*.
+	  Or if you want to differentiate a bit more even as *format-<status>-<state>*.
+
+# EXAMPLE
+
+```
+"battery": {
+	"bat": "BAT2",
+	"interval": 60,
+	"states": {
+		"warning": 30,
+		"critical": 15
+	},
+	"format": "{capacity}% {icon}",
+	"format-icons": ["", "", "", "", ""],
+	"max-length": 25
+}
+```
+
+# STYLING STATES
+
+- *#battery.<state>*
+  - *<state>* can be defined in the *config*.
+
+# EXAMPLE:
+
+- *#battery.warning: { background: orange; }*
+- *#battery.critical: { background: red; }*

man/waybar-sway-mode.5.scd

@@ -0,0 +1,72 @@
+waybar-sway-mode(5)
+
+# NAME
+
+waybar - sway mode module
+
+# DESCRIPTION
+
+The *mode* module displays the current binding mode of Sway
+
+# CONFIGURATION
+
+Addressed by *sway/mode*
+
+*format*: ++
+	typeof: string  ++
+	default: {} ++
+	The format, how information should be displayed. On {} data gets inserted.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in character the module should display.
+
+*on-click*: ++
+	typeof: string ++
+	Command to execute when clicked on the module.
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when you right clicked on the module.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when scrolling up on the module.
+
+*on-scroll-down*: ++
+	typeof: string ++
+	Command to execute when scrolling down on the module.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
+
+# EXAMPLES
+
+```
+"sway/window": {
+    "format": " {}",
+    "max-length": 50
+}
+```
+
+# STYLE
+
+- *#mode*

man/waybar-sway-window.5.scd

@@ -0,0 +1,75 @@
+waybar-sway-window(5)
+
+# NAME
+
+waybar - sway window module
+
+# DESCRIPTION
+
+The *window* module displays the title of the currently focused window in Sway
+
+# CONFIGURATION
+
+Addressed by *sway/window*
+
+*format*: ++
+	typeof: string ++
+	default: {} ++
+	The format, how information should be displayed. On {} data gets inserted.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in character the module should display.
+
+*on-click*: ++
+	typeof: string ++
+	Command to execute when clicked on the module.
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when you right clicked on the module.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when scrolling up on the module.
+
+*on-scroll-down*: ++
+	typeof: string ++
+	Command to execute when scrolling down on the module.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
+
+# EXAMPLES
+
+```
+"sway/window": {
+    "format": "{}",
+    "max-length": 50
+}
+```
+
+# STYLE
+
+- *#window*
+- *window#waybar.empty* When no windows is in the workspace
+- *window#waybar.solo* When one window is in the workspace
+- *window#waybar.<app_id>* Where *app_id* is the app_id or *instance* name like (*chromium*) of the only window in the workspace

man/waybar-sway-workspaces.5.scd

@@ -0,0 +1,142 @@
+waybar-sway-workspaces(5)
+
+# NAME
+
+waybar - sway workspaces module
+
+# DESCRIPTION
+
+The *workspaces* module displays the currently used workspaces in Sway.
+
+# CONFIGURATION
+
+Addressed by *sway/workspaces*
+
+*all-outputs*: ++
+    typeof: bool ++
+    default: false ++
+    If set to false, workspaces will only be shown on the output they are on. If set to true all workspaces will be shown on every output.
+
+*format*: ++
+    typeof: string ++
+    default: {value} ++
+    The format, how information should be displayed.
+
+*format-icons*: ++
+    typeof: array ++
+    Based on the workspace name and state, the corresponding icon gets selected. See *icons*.
+
+*disable-scroll*: ++
+    typeof: bool ++
+    default: false ++
+    If set to false, you can scroll to cycle through workspaces. If set to true this behaviour is disabled.
+
+*disable-click*: ++
+    typeof: bool ++
+    default: false ++
+    If set to false, you can click to change workspace. If set to true this behaviour is disabled.
+
+*smooth-scrolling-threshold*: ++
+    typeof: double ++
+    Threshold to be used when scrolling.
+
+*disable-scroll-wraparound*: ++
+    typeof: bool ++
+    default: false ++
+    If set to false, scrolling on the workspace indicator will wrap around to the first workspace when reading the end, and vice versa. If set to true this behavior is disabled.
+
+*enable-bar-scroll*: ++
+    typeof: bool ++
+    default: false ++
+    If set to false, you can't scroll to cycle throughout workspaces from the entire bar. If set to true this behaviour is enabled.
+
+*disable-markup*: ++
+    typeof: bool ++
+    default: false ++
+    If set to true, button label will escape pango markup.
+
+*current-only*: ++
+    typeof: bool ++
+    default: false ++
+    If set to true. Only focused workspaces will be shown.
+
+*persistent_workspaces*: ++
+    typeof: json (see below) ++
+    default: empty ++
+    Lists workspaces that should always be shown, even when non existent
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*numeric-first*: ++
+	typeof: bool ++
+	Whether to put workspaces starting with numbers before workspaces that do not start with a number.
+
+# FORMAT REPLACEMENTS
+
+*{value}*: Name of the workspace, as defined by sway.
+
+*{name}*: Number stripped from workspace value.
+
+*{icon}*: Icon, as defined in *format-icons*.
+
+*{index}*: Index of the workspace.
+
+# ICONS
+
+Additional to workspace name matching, the following *format-icons* can be set.
+
+- *default*: Will be shown, when no string matches is found.
+- *urgent*: Will be shown, when workspace is flagged as urgent
+- *focused*: Will be shown, when workspace is focused
+- *persistent*: Will be shown, when workspace is persistent one.
+
+# PERSISTENT WORKSPACES
+
+Each entry of *persistent_workspace* names a workspace that should always be shown.
+Associated with that value is a list of outputs indicating *where* the workspace should be shown,
+an empty list denoting all outputs.
+
+```
+"sway/workspaces": {
+    "persistent_workspaces": {
+        "3": [], // Always show a workspace with name '3', on all outputs if it does not exists
+        "4": ["eDP-1"], // Always show a workspace with name '4', on output 'eDP-1' if it does not exists
+        "5": ["eDP-1", "DP-2"] // Always show a workspace with name '5', on outputs 'eDP-1' and 'DP-2' if it does not exists
+    }
+}
+```
+
+n.b.: the list of outputs can be obtained from command line using *swaymsg -t get_outputs*
+
+# EXAMPLES
+
+```
+"sway/workspaces": {
+    "disable-scroll": true,
+    "all-outputs": true,
+    "numeric-first": false,
+    "format": "{name}: {icon}",
+    "format-icons": {
+        "1": "",
+        "2": "",
+        "3": "",
+        "4": "",
+        "5": "",
+        "urgent": "",
+        "focused": "",
+        "default": ""
+    }
+}
+```
+
+# Style
+
+- *#workspaces button*
+- *#workspaces button.visible*
+- *#workspaces button.focused*
+- *#workspaces button.urgent*
+- *#workspaces button.persistent*
+- *#workspaces button.current_output*
+- *#workspaces button#sway-workspace-${name}*

man/waybar-temperature.5.scd

@@ -0,0 +1,117 @@
+waybar-temperature(5)
+
+# NAME
+
+waybar - temperature module
+
+# DESCRIPTION
+
+The *temperature* module displays the current temperature from a thermal zone.
+
+# CONFIGURATION
+
+Addressed by *temperature*
+
+*thermal-zone*: ++
+	typeof: integer ++
+	The thermal zone, as in */sys/class/thermal/*.
+
+*hwmon-path*: ++
+	typeof: string ++
+	The temperature path to use, e.g. */sys/class/hwmon/hwmon2/temp1_input* instead of one in */sys/class/thermal/*.
+
+*hwmon-path-abs*: ++
+	typeof: string ++
+	The path of the hwmon-directory of the device, e.g. */sys/devices/pci0000:00/0000:00:18.3/hwmon*. (Note that the subdirectory *hwmon/hwmon#*, where *#* is a number is not part of the path!) Has to be used together with *input-filename*.
+
+*input-filename*: ++
+	typeof: string ++
+	The temperature filename of your *hwmon-path-abs*, e.g. *temp1_input*
+
+*critical-threshold*: ++
+	typeof: integer ++
+	The threshold before it is considered critical (Celsius).
+
+*interval*: ++
+	typeof: integer ++
+	default: 10 ++
+	The interval in which the information gets polled.
+
+*format-critical*: ++
+	typeof: string ++
+	The format to use when temperature is considered critical
+
+*format*: ++
+	typeof: string  ++
+	default: {temperatureC}°C ++
+	The format (Celsius/Fahrenheit/Kelvin) in which the temperature should be displayed.
+
+*format-icons*: ++
+	typeof: array ++
+	Based on the current temperature (Celsius) and *critical-threshold* if available, the corresponding icon gets selected. The order is *low* to *high*.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in characters the module should display.
+
+*on-click*: ++
+	typeof: string ++
+	Command to execute when you clicked on the module.
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when you right clicked on the module.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when scrolling up on the module.
+
+*on-scroll-down*: ++
+	typeof: string ++
+	Command to execute when scrolling down on the module.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
+
+# FORMAT REPLACEMENTS
+
+*{temperatureC}*: Temperature in Celsius.
+
+*{temperatureF}*: Temperature in Fahrenheit.
+
+*{temperatureK}*: Temperature in Kelvin.
+
+# EXAMPLES
+
+```
+ "temperature": {
+	// "thermal-zone": 2,
+	// "hwmon-path": "/sys/class/hwmon/hwmon2/temp1_input",
+	// "critical-threshold": 80,
+	// "format-critical": "{temperatureC}°C ",
+	"format": "{temperatureC}°C "
+}
+```
+
+# STYLE
+
+- *#temperature*
+- *#temperature.critical*

man/waybar-tray.5.scd

@@ -0,0 +1,39 @@
+waybar-tray(5)
+
+# NAME
+
+waybar - tray module
+
+# DESCRIPTION
+
+_WARNING_ *tray* is still in beta. There may me bugs. Breaking changes may occur.
+
+# CONFIGURATION
+
+Addressed by *tray*
+
+*icon-size*: ++
+    typeof: integer ++
+    Defines the size of the tray icons.
+
+*spacing*: ++
+    typeof: integer ++
+    Defines the spacing between the tray icons.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+# EXAMPLES
+
+```
+"tray": {
+    "icon-size": 21,
+    "spacing": 10
+}
+
+```
+
+# STYLE
+
+- *#tray*

man/waybar-wlr-taskbar.5.scd

@@ -0,0 +1,111 @@
+waybar-wlr-taskbar(5)
+
+# NAME
+
+wlroots - Taskbar module
+
+# DESCRIPTION
+
+The *taskbar* module displays the currently open applications. This module requires
+a compositor that implements the foreign-toplevel-manager interface.
+
+# CONFIGURATION
+
+Addressed by *wlr/taskbar*
+
+*all-outputs*: ++
+	typeof: bool ++
+	default: false ++
+	If set to false applications on the waybar's current output will be shown. Otherwise all applications are shown.
+
+*format*: ++
+	typeof: string ++
+	default: {icon} ++
+	The format, how information should be displayed.
+
+*icon-theme*: ++
+	typeof: array|string ++
+	The names of the icon-themes that should be used to find an icon. The list will be traversed from left to right. If omitted, the system default will be used.
+
+*icon-size*: ++
+	typeof: integer ++
+	default: 16 ++
+	The size of the icon.
+
+*markup*: ++
+	typeof: bool ++
+	default: false ++
+	If set to true, pango markup will be accepted in format and tooltip-format.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	If set to false no tooltip will be shown.
+
+*tooltip-format*: ++
+	typeof: string ++
+	default: {title} ++
+	The format, how information in the tooltip should be displayed.
+
+*active-first*: ++
+	typeof: bool ++
+	default: false ++
+	If set to true, always reorder the tasks in the taskbar so that the currently active one is first. Otherwise don't reorder.
+
+*on-click*: ++
+	typeof: string ++
+	The action which should be triggered when clicking on the application button with the left mouse button.
+
+*on-click-middle*: ++
+	typeof: string ++
+	The action which should be triggered when clicking on the application button with the middle mouse button.
+
+*on-click-right*: ++
+	typeof: string ++
+	The action which should be triggered when clicking on the application button with the right mouse button.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+# FORMAT REPLACEMENTS
+
+*{icon}*: The icon of the application.
+
+*{title}*: The title of the application.
+
+*{app_id}*: The app_id (== application name) of the application.
+
+*{state}*: The state (minimized, maximized, active, fullscreen) of the application.
+
+*{short_state}*: The state (minimize == m, maximized == M, active == A, fullscreen == F) represented as one character of the application.
+
+# CLICK ACTIONS
+
+*activate*: Bring the application into foreground.
+*minimize*: Minimize the application.
+*maximize*: Maximize the application.
+*fullscreen*: Set the application to fullscreen.
+*close*: Close the application.
+
+# EXAMPLES
+
+```
+"wlr/taskbar": {
+	"format": "{icon}",
+	"icon-size": 14,
+	"icon-theme": "Numix-Circle",
+	"tooltip-format": "{title}",
+	"on-click": "activate",
+	"on-click-middle": "close"
+}
+```
+
+# Style
+
+- *#taskbar*
+- *#taskbar button*
+- *#taskbar button.maximized*
+- *#taskbar button.minimized*
+- *#taskbar button.active*
+- *#taskbar button.fullscreen*

man/waybar.5.scd

@@ -0,0 +1,205 @@
+waybar(5)
+
+# NAME
+
+waybar - configuration file
+
+# DESCRIPTION
+
+The configuration uses the JSON file format and is named *config*.
+
+Valid locations for this file are:
+
+- *$XDG_CONFIG_HOME/waybar/config*
+- *~/.config/waybar/config*
+- *~/waybar/config*
+- */etc/xdg/waybar/config*
+
+A good starting point is the default configuration found at https://github.com/Alexays/Waybar/blob/master/resources/config
+Also a minimal example configuration can be found on the at the bottom of this man page.
+
+# BAR CONFIGURATION
+
+*layer* ++
+	typeof: string ++
+	default: bottom ++
+	Decide if the bar is displayed in front (*top*) of the windows or behind (*bottom*)
+	them.
+
+*output* ++
+	typeof: string|array ++
+	Specifies on which screen this bar will be displayed. Exclamation mark(*!*) can be used to exclude specific output.
+
+*position* ++
+	typeof: string ++
+	default: top ++
+	Bar position, can be *top*, *bottom*, *left*, *right*.
+
+*height* ++
+	typeof: integer ++
+	Height to be used by the bar if possible. Leave blank for a dynamic value.
+
+*width* ++
+	typeof: integer ++
+	Width to be used by the bar if possible. Leave blank for a dynamic value.
+
+*modules-left* ++
+	typeof: array ++
+	Modules that will be displayed on the left.
+
+*modules-center* ++
+	typeof: array ++
+	Modules that will be displayed in the center.
+
+*modules-right* ++
+	typeof: array
+	Modules that will be displayed on the right.
+
+*margin* ++
+	typeof: string ++
+	Margins value using the CSS format without units.
+
+*margin-<top\|left\|bottom\|right>* ++
+	typeof: integer ++
+	Margins value without units.
+
+*name* ++
+	typeof: string ++
+	Optional name added as a CSS class, for styling multiple waybars.
+
+*gtk-layer-shell* ++
+	typeof: bool ++
+	default: true ++
+	Option to disable the use of gtk-layer-shell for popups.
+	Only functional if compiled with gtk-layer-shell support.
+
+# MODULE FORMAT
+
+You can use PangoMarkupFormat (See https://developer.gnome.org/pango/stable/PangoMarkupFormat.html#PangoMarkupFormat).
+
+e.g.
+
+```
+"format": "<span style=\"italic\">{}</span>"
+```
+# MULTIPLE INSTANCES OF A MODULE
+
+If you want to have a second instance of a module, you can suffix it by a '#' and a custom name.
+For example if you want a second battery module, you can add *"battery#bat2"* to your modules.
+To configure the newly added module, you then also add a module configuration with the same name.
+
+This could then look something like this *(this is an incomplete example)*:
+
+```
+"modules-right": ["battery", "battery#bat2"],
+"battery": {
+	"bat": "BAT1"
+},
+"battery#bat2": {
+	"bat": "BAT2"
+}
+```
+
+# MINIMAL CONFIGURATION
+
+A minimal *config* file could look like this:
+
+```
+{
+	"layer": "top",
+	"modules-left": ["sway/workspaces", "sway/mode"],
+	"modules-center": ["sway/window"],
+	"modules-right": ["battery", "clock"],
+	"sway/window": {
+		"max-length": 50
+	},
+	"battery": {
+		"format": "{capacity}% {icon}",
+		"format-icons": ["", "", "", "", ""]
+	},
+	"clock": {
+		"format-alt": "{:%a, %d. %b  %H:%M}"
+	}
+}
+```
+
+# MULTI OUTPUT CONFIGURATION
+
+## Limit a configuration to some outputs
+
+```
+{
+	"layer": "top",
+	"output": "eDP-1",
+	"modules-left": ["sway/workspaces", "sway/mode"],
+	...
+
+}
+
+```
+
+```
+{
+	"layer": "top",
+	"output": ["eDP-1", "VGA"],
+	"modules-left": ["sway/workspaces", "sway/mode"],
+	...
+}
+
+```
+
+## Configuration of multiple outputs
+
+Don't specify an output to create multiple bars on the same screen.
+
+```
+[{
+	"layer": "top",
+	"output": "eDP-1",
+	"modules-left": ["sway/workspaces", "sway/mode"],
+	...
+}, {
+	"layer": "top",
+	"output": "VGA",
+	"modules-right": ["clock"],
+	...
+}]
+
+```
+
+## Rotating modules
+
+When positioning Waybar on the left or right side of the screen, sometimes it's useful to be able to rotate the contents of a module so the text runs vertically. This can be done using the "rotate" property of the module. Example:
+
+```
+{
+	"clock": {
+		"rotate": 90
+	}
+}
+```
+
+Valid options for the "rotate" property are: 0, 90, 180 and 270.
+
+# SUPPORTED MODULES
+
+- *waybar-backlight(5)*
+- *waybar-battery(5)*
+- *waybar-bluetooth(5)*
+- *waybar-clock(5)*
+- *waybar-cpu(5)*
+- *waybar-custom(5)*
+- *waybar-disk(5)*
+- *waybar-idle-inhibitor(5)*
+- *waybar-memory(5)*
+- *waybar-mpd(5)*
+- *waybar-network(5)*
+- *waybar-pulseaudio(5)*
+- *waybar-river-tags(5)*
+- *waybar-states(5)*
+- *waybar-sway-mode(5)*
+- *waybar-sway-window(5)*
+- *waybar-sway-workspaces(5)*
+- *waybar-wlr-taskbar(5)*
+- *waybar-temperature(5)*
+- *waybar-tray(5)*

meson.build

@@ -1,6 +1,6 @@
 project(
     'waybar', 'cpp', 'c',
-    version: '0.5.0',
+    version: '0.9.4',
     license: 'MIT',
     default_options : [
         'cpp_std=c++17',
@@ -9,77 +9,166 @@ project(
     ],
 )
 
+compiler = meson.get_compiler('cpp')
+
 cpp_args = []
 cpp_link_args = []
 
-if false # libc++
+if get_option('libcxx')
     cpp_args += ['-stdlib=libc++']
     cpp_link_args += ['-stdlib=libc++', '-lc++abi']
+endif
 
+if compiler.has_link_argument('-lc++fs')
     cpp_link_args += ['-lc++fs']
-else
+elif compiler.has_link_argument('-lc++experimental')
+    cpp_link_args += ['-lc++experimental']
+elif compiler.has_link_argument('-lstdc++fs')
     cpp_link_args += ['-lstdc++fs']
 endif
 
-compiler = meson.get_compiler('cpp')
-git = find_program('git', required: false)
+git = find_program('git', native: true, required: false)
 
 if not git.found()
     add_project_arguments('-DVERSION="@0@"'.format(meson.project_version()), language: 'cpp')
 else
-    git_commit_hash = run_command([git.path(), 'describe', '--always', '--tags']).stdout().strip()
-    git_branch = run_command([git.path(), 'rev-parse', '--abbrev-ref', 'HEAD']).stdout().strip()
-    version = '"@0@ (" __DATE__ ", branch \'@1@\')"'.format(git_commit_hash, git_branch)
-    add_project_arguments('-DVERSION=@0@'.format(version), language: 'cpp')
+    git_path = run_command([git.path(), 'rev-parse', '--show-toplevel']).stdout().strip()
+    if meson.source_root() == git_path
+        git_commit_hash = run_command([git.path(), 'describe', '--always', '--tags']).stdout().strip()
+        git_branch = run_command([git.path(), 'rev-parse', '--abbrev-ref', 'HEAD']).stdout().strip()
+        version = '"@0@ (branch \'@1@\')"'.format(git_commit_hash, git_branch)
+        add_project_arguments('-DVERSION=@0@'.format(version), language: 'cpp')
+    else
+        add_project_arguments('-DVERSION="@0@"'.format(meson.project_version()), language: 'cpp')
+    endif
 endif
 
 if not compiler.has_header('filesystem')
-    add_project_arguments('-DFILESYSTEM_EXPERIMENTAL', language: 'cpp')
+    if compiler.has_header('experimental/filesystem')
+        add_project_arguments('-DFILESYSTEM_EXPERIMENTAL', language: 'cpp')
+    else
+        add_project_arguments('-DNO_FILESYSTEM', language: 'cpp')
+        warning('No filesystem header found, some modules may not work')
+    endif
+endif
+
+code = '''
+#include <langinfo.h>
+#include <locale.h>
+int main(int argc, char** argv) {
+    locale_t locale = newlocale(LC_ALL, "en_US.UTF-8", nullptr);
+    char* str;
+    str = nl_langinfo_l(_NL_TIME_WEEK_1STDAY, locale);
+    str = nl_langinfo_l(_NL_TIME_FIRST_WEEKDAY, locale);
+    freelocale(locale);
+    return 0;
+}
+'''
+if compiler.links(code, name : 'nl_langinfo with _NL_TIME_WEEK_1STDAY, _NL_TIME_FIRST_WEEKDAY')
+    add_project_arguments('-DHAVE_LANGINFO_1STDAY', language: 'cpp')
 endif
 
 add_global_arguments(cpp_args, language : 'cpp')
 add_global_link_arguments(cpp_link_args, language : 'cpp')
 
+is_linux = host_machine.system() == 'linux'
+is_dragonfly = host_machine.system() == 'dragonfly'
+is_freebsd = host_machine.system() == 'freebsd'
+is_netbsd = host_machine.system() == 'netbsd'
+is_openbsd = host_machine.system() == 'openbsd'
+
 thread_dep = dependency('threads')
-libinput = dependency('libinput')
-fmt = dependency('fmt', version : ['>=5.2.1'], fallback : ['fmt', 'fmt_dep'])
+fmt = dependency('fmt', version : ['>=5.3.0'], fallback : ['fmt', 'fmt_dep'])
+spdlog = dependency('spdlog', version : ['>=1.3.1'], fallback : ['spdlog', 'spdlog_dep'])
 wayland_client = dependency('wayland-client')
 wayland_cursor = dependency('wayland-cursor')
 wayland_protos = dependency('wayland-protocols')
-wlroots = dependency('wlroots', fallback: ['wlroots', 'wlroots'])
-gtkmm = dependency('gtkmm-3.0')
+gtkmm = dependency('gtkmm-3.0', version : ['>=3.22.0'])
 dbusmenu_gtk = dependency('dbusmenu-gtk3-0.4', required: get_option('dbusmenu-gtk'))
 giounix = dependency('gio-unix-2.0', required: get_option('dbusmenu-gtk'))
 jsoncpp = dependency('jsoncpp')
 sigcpp = dependency('sigc++-2.0')
+libepoll = dependency('epoll-shim', required: false)
 libnl = dependency('libnl-3.0', required: get_option('libnl'))
 libnlgen = dependency('libnl-genl-3.0', required: get_option('libnl'))
 libpulse = dependency('libpulse', required: get_option('pulseaudio'))
 libudev = dependency('libudev', required: get_option('libudev'))
+libmpdclient = dependency('libmpdclient', required: get_option('mpd'))
+gtk_layer_shell = dependency('gtk-layer-shell-0',
+        required: get_option('gtk-layer-shell'),
+        fallback : ['gtk-layer-shell', 'gtk_layer_shell_dep'])
+systemd = dependency('systemd', required: get_option('systemd'))
+tz_dep = dependency('date', default_options : [ 'use_system_tzdb=true' ], modules : [ 'date::date', 'date::date-tz' ], fallback: [ 'date', 'tz_dep' ])
+
+prefix = get_option('prefix')
+sysconfdir = get_option('sysconfdir')
+conf_data = configuration_data()
+conf_data.set('prefix', prefix)
+
+add_project_arguments('-DSYSCONFDIR="/@0@"'.format(join_paths(prefix, sysconfdir)), language : 'cpp')
+
+if systemd.found()
+  user_units_dir = systemd.get_pkgconfig_variable('systemduserunitdir')
+
+  configure_file(
+    configuration: conf_data,
+    input: './resources/waybar.service.in',
+    output: '@BASENAME@',
+    install_dir: user_units_dir
+  )
+endif
 
 src_files = files(
     'src/factory.cpp',
+    'src/AModule.cpp',
     'src/ALabel.cpp',
-    'src/modules/memory.cpp',
-    'src/modules/battery.cpp',
     'src/modules/clock.cpp',
     'src/modules/custom.cpp',
-    'src/modules/cpu.cpp',
-	'src/modules/idle_inhibitor.cpp',
+    'src/modules/disk.cpp',
+    'src/modules/idle_inhibitor.cpp',
     'src/modules/temperature.cpp',
     'src/main.cpp',
     'src/bar.cpp',
-    'src/client.cpp'
+    'src/client.cpp',
 )
 
-if find_program('sway', required : false).found()
-    add_project_arguments('-DHAVE_SWAY', language: 'cpp')
-    src_files += [
-        'src/modules/sway/ipc/client.cpp',
-        'src/modules/sway/mode.cpp',
-        'src/modules/sway/window.cpp',
-        'src/modules/sway/workspaces.cpp'
-    ]
+if is_linux
+    add_project_arguments('-DHAVE_CPU_LINUX', language: 'cpp')
+    add_project_arguments('-DHAVE_MEMORY_LINUX', language: 'cpp')
+    src_files += files(
+        'src/modules/battery.cpp',
+        'src/modules/cpu/common.cpp',
+        'src/modules/cpu/linux.cpp',
+        'src/modules/memory/common.cpp',
+        'src/modules/memory/linux.cpp',
+    )
+elif is_dragonfly or is_freebsd or is_netbsd or is_openbsd
+    add_project_arguments('-DHAVE_CPU_BSD', language: 'cpp')
+    add_project_arguments('-DHAVE_MEMORY_BSD', language: 'cpp')
+    src_files += files(
+        'src/modules/cpu/bsd.cpp',
+        'src/modules/cpu/common.cpp',
+        'src/modules/memory/bsd.cpp',
+        'src/modules/memory/common.cpp',
+    )
+endif
+
+add_project_arguments('-DHAVE_SWAY', language: 'cpp')
+src_files += [
+    'src/modules/sway/ipc/client.cpp',
+    'src/modules/sway/mode.cpp',
+    'src/modules/sway/window.cpp',
+    'src/modules/sway/workspaces.cpp'
+]
+
+if true
+    add_project_arguments('-DHAVE_WLR', language: 'cpp')
+    src_files += 'src/modules/wlr/taskbar.cpp'
+endif
+
+if true
+    add_project_arguments('-DHAVE_RIVER', language: 'cpp')
+    src_files += 'src/modules/river/tags.cpp'
 endif
 
 if libnl.found() and libnlgen.found()
@@ -102,11 +191,30 @@ if dbusmenu_gtk.found()
     )
 endif
 
-if libudev.found()
+if libudev.found() and (is_linux or libepoll.found())
     add_project_arguments('-DHAVE_LIBUDEV', language: 'cpp')
     src_files += 'src/modules/backlight.cpp'
 endif
 
+if libmpdclient.found()
+    add_project_arguments('-DHAVE_LIBMPDCLIENT', language: 'cpp')
+    src_files += 'src/modules/mpd.cpp'
+endif
+
+if gtk_layer_shell.found()
+    add_project_arguments('-DHAVE_GTK_LAYER_SHELL', language: 'cpp')
+endif
+
+if get_option('rfkill').enabled()
+    if is_linux
+        add_project_arguments('-DWANT_RFKILL', language: 'cpp')
+        src_files += files(
+            'src/modules/bluetooth.cpp',
+            'src/util/rfkill.cpp'
+        )
+    endif
+endif
+
 subdir('protocol')
 
 executable(
@@ -114,13 +222,12 @@ executable(
     src_files,
     dependencies: [
         thread_dep,
-        wlroots,
         client_protos,
         wayland_client,
         fmt,
+        spdlog,
         sigcpp,
         jsoncpp,
-        libinput,
         wayland_cursor,
         gtkmm,
         dbusmenu_gtk,
@@ -128,7 +235,11 @@ executable(
         libnl,
         libnlgen,
         libpulse,
-        libudev
+        libudev,
+        libepoll,
+        libmpdclient,
+        gtk_layer_shell,
+        tz_dep
     ],
     include_directories: [include_directories('include')],
     install: true,
@@ -137,9 +248,57 @@ executable(
 install_data(
     './resources/config',
     './resources/style.css',
-    install_dir: join_paths(get_option('out'), 'etc/xdg/waybar')
+    install_dir: sysconfdir + '/xdg/waybar'
 )
 
+scdoc = dependency('scdoc', version: '>=1.9.2', native: true, required: get_option('man-pages'))
+
+if scdoc.found()
+    scdoc_prog = find_program(scdoc.get_pkgconfig_variable('scdoc'), native: true)
+    sh = find_program('sh', native: true)
+    mandir = get_option('mandir')
+    man_files = [
+        'waybar.5.scd',
+        'waybar-backlight.5.scd',
+        'waybar-battery.5.scd',
+        'waybar-clock.5.scd',
+        'waybar-cpu.5.scd',
+        'waybar-custom.5.scd',
+        'waybar-disk.5.scd',
+        'waybar-idle-inhibitor.5.scd',
+        'waybar-memory.5.scd',
+        'waybar-mpd.5.scd',
+        'waybar-network.5.scd',
+        'waybar-pulseaudio.5.scd',
+        'waybar-river-tags.5.scd',
+        'waybar-sway-mode.5.scd',
+        'waybar-sway-window.5.scd',
+        'waybar-sway-workspaces.5.scd',
+        'waybar-temperature.5.scd',
+        'waybar-tray.5.scd',
+        'waybar-states.5.scd',
+        'waybar-wlr-taskbar.5.scd',
+        'waybar-bluetooth.5.scd',
+    ]
+
+    foreach filename : man_files
+        topic = filename.split('.')[-3].split('/')[-1]
+        section = filename.split('.')[-2]
+        output = '@0@.@1@'.format(topic, section)
+
+        custom_target(
+            output,
+            input: 'man/@0@'.format(filename),
+            output: output,
+            command: [
+                sh, '-c', '@0@ < @INPUT@ > @1@'.format(scdoc_prog.path(), output)
+            ],
+            install: true,
+            install_dir: '@0@/man@1@'.format(mandir, section)
+        )
+    endforeach
+endif
+
 clangtidy = find_program('clang-tidy', required: false)
 
 if clangtidy.found()

meson_options.txt

@@ -1,5 +1,10 @@
+option('libcxx', type : 'boolean', value : false, description : 'Build with Clang\'s libc++ instead of libstdc++ on Linux.')
 option('libnl', type: 'feature', value: 'auto', description: 'Enable libnl support for network related features')
 option('libudev', type: 'feature', value: 'auto', description: 'Enable libudev support for udev related features')
 option('pulseaudio', type: 'feature', value: 'auto', description: 'Enable support for pulseaudio')
+option('systemd', type: 'feature', value: 'auto', description: 'Install systemd user service unit')
 option('dbusmenu-gtk', type: 'feature', value: 'auto', description: 'Enable support for tray')
-option('out', type: 'string', value : '/', description: 'output prefix directory')
+option('man-pages', type: 'feature', value: 'auto', description: 'Generate and install man pages')
+option('mpd', type: 'feature', value: 'auto', description: 'Enable support for the Music Player Daemon')
+option('gtk-layer-shell', type: 'feature', value: 'auto', description: 'Use gtk-layer-shell library for popups support')
+option('rfkill', type: 'feature', value: 'auto', description: 'Enable support for RFKILL')

protocol/dbus-status-notifier-item.xml

@@ -31,7 +31,9 @@
     <property name='Id' type='s' access='read'/>
     <property name='Title' type='s' access='read'/>
     <property name='Status' type='s' access='read'/>
+    <!-- See discussion on pull #536
     <property name='WindowId' type='u' access='read'/>
+    -->
     <property name='IconThemePath' type='s' access='read'/>
     <property name='IconName' type='s' access='read'/>
     <property name='IconPixmap' type='a(iiay)' access='read'/>
@@ -44,4 +46,4 @@
     <property name='Menu' type='o' access='read'/>
     <property name='ItemIsMenu' type='b' access='read'/>
   </interface>
-</node>
+</node>

protocol/meson.build

@@ -26,6 +26,8 @@ client_protocols = [
 	[wl_protocol_dir, 'unstable/xdg-output/xdg-output-unstable-v1.xml'],
 	[wl_protocol_dir, 'unstable/idle-inhibit/idle-inhibit-unstable-v1.xml'],
 	['wlr-layer-shell-unstable-v1.xml'],
+	['wlr-foreign-toplevel-management-unstable-v1.xml'],
+	['river-status-unstable-v1.xml'],
 ]
 
 client_protos_src = []

protocol/river-status-unstable-v1.xml

@@ -0,0 +1,116 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="river_status_unstable_v1">
+  <copyright>
+    Copyright 2020 Isaac Freund
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted, provided that the above
+    copyright notice and this permission notice appear in all copies.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+    WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+    MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+    ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+  </copyright>
+
+  <interface name="zriver_status_manager_v1" version="1">
+    <description summary="manage river status objects">
+      A global factory for objects that receive status information specific
+      to river. It could be used to implement, for example, a status bar.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the river_status_manager object">
+        This request indicates that the client will not use the
+        river_status_manager object any more. Objects that have been created
+        through this instance are not affected.
+      </description>
+    </request>
+
+    <request name="get_river_output_status">
+      <description summary="create an output status object">
+        This creates a new river_output_status object for the given wl_output.
+      </description>
+      <arg name="id" type="new_id" interface="zriver_output_status_v1"/>
+      <arg name="output" type="object" interface="wl_output"/>
+    </request>
+
+    <request name="get_river_seat_status">
+      <description summary="create a seat status object">
+        This creates a new river_seat_status object for the given wl_seat.
+      </description>
+      <arg name="id" type="new_id" interface="zriver_seat_status_v1"/>
+      <arg name="seat" type="object" interface="wl_seat"/>
+    </request>
+  </interface>
+
+  <interface name="zriver_output_status_v1" version="1">
+    <description summary="track output tags and focus">
+      This interface allows clients to receive information about the current
+      windowing state of an output.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the river_output_status object">
+        This request indicates that the client will not use the
+        river_output_status object any more.
+      </description>
+    </request>
+
+    <event name="focused_tags">
+      <description summary="focused tags of the output">
+        Sent once binding the interface and again whenever the tag focus of
+        the output changes.
+      </description>
+      <arg name="tags" type="uint" summary="32-bit bitfield"/>
+    </event>
+
+    <event name="view_tags">
+      <description summary="tag state of an output's views">
+        Sent once on binding the interface and again whenever the tag state
+        of the output changes.
+      </description>
+      <arg name="tags" type="array" summary="array of 32-bit bitfields"/>
+    </event>
+  </interface>
+
+  <interface name="zriver_seat_status_v1" version="1">
+    <description summary="track seat focus">
+      This interface allows clients to receive information about the current
+      focus of a seat.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the river_seat_status object">
+        This request indicates that the client will not use the
+        river_seat_status object any more.
+      </description>
+    </request>
+
+    <event name="focused_output">
+      <description summary="the seat focused an output">
+        Sent on binding the interface and again whenever an output gains focus.
+      </description>
+      <arg name="output" type="object" interface="wl_output"/>
+    </event>
+
+    <event name="unfocused_output">
+      <description summary="the seat unfocused an output">
+        Sent whenever an output loses focus.
+      </description>
+      <arg name="output" type="object" interface="wl_output"/>
+    </event>
+
+    <event name="focused_view">
+      <description summary="information on the focused view">
+        Sent once on binding the interface and again whenever the focused
+        view or a property thereof changes. The title may be an empty string
+        if no view is focused or the focused view did not set a title.
+      </description>
+      <arg name="title" type="string" summary="title of the focused view"/>
+    </event>
+  </interface>
+</protocol>

protocol/wlr-foreign-toplevel-management-unstable-v1.xml

@@ -0,0 +1,259 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="wlr_foreign_toplevel_management_unstable_v1">
+  <copyright>
+    Copyright © 2018 Ilia Bozhinov
+
+    Permission to use, copy, modify, distribute, and sell this
+    software and its documentation for any purpose is hereby granted
+    without fee, provided that the above copyright notice appear in
+    all copies and that both that copyright notice and this permission
+    notice appear in supporting documentation, and that the name of
+    the copyright holders not be used in advertising or publicity
+    pertaining to distribution of the software without specific,
+    written prior permission.  The copyright holders make no
+    representations about the suitability of this software for any
+    purpose.  It is provided "as is" without express or implied
+    warranty.
+
+    THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+    SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+    FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+    ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+    THIS SOFTWARE.
+  </copyright>
+
+  <interface name="zwlr_foreign_toplevel_manager_v1" version="2">
+    <description summary="list and control opened apps">
+      The purpose of this protocol is to enable the creation of taskbars
+      and docks by providing them with a list of opened applications and
+      letting them request certain actions on them, like maximizing, etc.
+
+      After a client binds the zwlr_foreign_toplevel_manager_v1, each opened
+      toplevel window will be sent via the toplevel event
+    </description>
+
+    <event name="toplevel">
+      <description summary="a toplevel has been created">
+        This event is emitted whenever a new toplevel window is created. It
+        is emitted for all toplevels, regardless of the app that has created
+        them.
+
+        All initial details of the toplevel(title, app_id, states, etc.) will
+        be sent immediately after this event via the corresponding events in
+        zwlr_foreign_toplevel_handle_v1.
+      </description>
+      <arg name="toplevel" type="new_id" interface="zwlr_foreign_toplevel_handle_v1"/>
+    </event>
+
+    <request name="stop">
+      <description summary="stop sending events">
+        Indicates the client no longer wishes to receive events for new toplevels.
+        However the compositor may emit further toplevel_created events, until
+        the finished event is emitted.
+
+        The client must not send any more requests after this one.
+      </description>
+    </request>
+
+    <event name="finished">
+      <description summary="the compositor has finished with the toplevel manager">
+        This event indicates that the compositor is done sending events to the
+        zwlr_foreign_toplevel_manager_v1. The server will destroy the object
+        immediately after sending this request, so it will become invalid and
+        the client should free any resources associated with it.
+      </description>
+    </event>
+  </interface>
+
+  <interface name="zwlr_foreign_toplevel_handle_v1" version="2">
+    <description summary="an opened toplevel">
+      A zwlr_foreign_toplevel_handle_v1 object represents an opened toplevel
+      window. Each app may have multiple opened toplevels.
+
+      Each toplevel has a list of outputs it is visible on, conveyed to the
+      client with the output_enter and output_leave events.
+    </description>
+
+    <event name="title">
+      <description summary="title change">
+        This event is emitted whenever the title of the toplevel changes.
+      </description>
+      <arg name="title" type="string"/>
+    </event>
+
+    <event name="app_id">
+      <description summary="app-id change">
+        This event is emitted whenever the app-id of the toplevel changes.
+      </description>
+      <arg name="app_id" type="string"/>
+    </event>
+
+    <event name="output_enter">
+      <description summary="toplevel entered an output">
+        This event is emitted whenever the toplevel becomes visible on
+        the given output. A toplevel may be visible on multiple outputs.
+      </description>
+      <arg name="output" type="object" interface="wl_output"/>
+    </event>
+
+    <event name="output_leave">
+      <description summary="toplevel left an output">
+        This event is emitted whenever the toplevel stops being visible on
+        the given output. It is guaranteed that an entered-output event
+        with the same output has been emitted before this event.
+      </description>
+      <arg name="output" type="object" interface="wl_output"/>
+    </event>
+
+    <request name="set_maximized">
+      <description summary="requests that the toplevel be maximized">
+        Requests that the toplevel be maximized. If the maximized state actually
+        changes, this will be indicated by the state event.
+      </description>
+    </request>
+
+    <request name="unset_maximized">
+      <description summary="requests that the toplevel be unmaximized">
+        Requests that the toplevel be unmaximized. If the maximized state actually
+        changes, this will be indicated by the state event.
+      </description>
+    </request>
+
+    <request name="set_minimized">
+      <description summary="requests that the toplevel be minimized">
+        Requests that the toplevel be minimized. If the minimized state actually
+        changes, this will be indicated by the state event.
+      </description>
+    </request>
+
+    <request name="unset_minimized">
+      <description summary="requests that the toplevel be unminimized">
+        Requests that the toplevel be unminimized. If the minimized state actually
+        changes, this will be indicated by the state event.
+      </description>
+    </request>
+
+    <request name="activate">
+      <description summary="activate the toplevel">
+        Request that this toplevel be activated on the given seat.
+        There is no guarantee the toplevel will be actually activated.
+      </description>
+      <arg name="seat" type="object" interface="wl_seat"/>
+    </request>
+
+    <enum name="state">
+      <description summary="types of states on the toplevel">
+        The different states that a toplevel can have. These have the same meaning
+        as the states with the same names defined in xdg-toplevel
+      </description>
+
+      <entry name="maximized"  value="0" summary="the toplevel is maximized"/>
+      <entry name="minimized"  value="1" summary="the toplevel is minimized"/>
+      <entry name="activated"  value="2" summary="the toplevel is active"/>
+      <entry name="fullscreen" value="3" summary="the toplevel is fullscreen" since="2"/>
+    </enum>
+
+    <event name="state">
+      <description summary="the toplevel state changed">
+        This event is emitted immediately after the zlw_foreign_toplevel_handle_v1
+        is created and each time the toplevel state changes, either because of a
+        compositor action or because of a request in this protocol.
+      </description>
+
+      <arg name="state" type="array"/>
+    </event>
+
+    <event name="done">
+      <description summary="all information about the toplevel has been sent">
+        This event is sent after all changes in the toplevel state have been
+        sent.
+
+        This allows changes to the zwlr_foreign_toplevel_handle_v1 properties
+        to be seen as atomic, even if they happen via multiple events.
+      </description>
+    </event>
+
+    <request name="close">
+      <description summary="request that the toplevel be closed">
+        Send a request to the toplevel to close itself. The compositor would
+        typically use a shell-specific method to carry out this request, for
+        example by sending the xdg_toplevel.close event. However, this gives
+        no guarantees the toplevel will actually be destroyed. If and when
+        this happens, the zwlr_foreign_toplevel_handle_v1.closed event will
+        be emitted.
+      </description>
+    </request>
+
+    <request name="set_rectangle">
+      <description summary="the rectangle which represents the toplevel">
+        The rectangle of the surface specified in this request corresponds to
+        the place where the app using this protocol represents the given toplevel.
+        It can be used by the compositor as a hint for some operations, e.g
+        minimizing. The client is however not required to set this, in which
+        case the compositor is free to decide some default value.
+
+        If the client specifies more than one rectangle, only the last one is
+        considered.
+
+        The dimensions are given in surface-local coordinates.
+        Setting width=height=0 removes the already-set rectangle.
+      </description>
+
+      <arg name="surface" type="object" interface="wl_surface"/>
+      <arg name="x" type="int"/>
+      <arg name="y" type="int"/>
+      <arg name="width" type="int"/>
+      <arg name="height" type="int"/>
+    </request>
+
+    <enum name="error">
+      <entry name="invalid_rectangle" value="0"
+        summary="the provided rectangle is invalid"/>
+    </enum>
+
+    <event name="closed">
+      <description summary="this toplevel has been destroyed">
+        This event means the toplevel has been destroyed. It is guaranteed there
+        won't be any more events for this zwlr_foreign_toplevel_handle_v1. The
+        toplevel itself becomes inert so any requests will be ignored except the
+        destroy request.
+      </description>
+    </event>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the zwlr_foreign_toplevel_handle_v1 object">
+        Destroys the zwlr_foreign_toplevel_handle_v1 object.
+
+        This request should be called either when the client does not want to
+        use the toplevel anymore or after the closed event to finalize the
+        destruction of the object.
+      </description>
+    </request>
+
+    <!-- Version 2 additions -->
+
+    <request name="set_fullscreen" since="2">
+      <description summary="request that the toplevel be fullscreened">
+        Requests that the toplevel be fullscreened on the given output. If the
+        fullscreen state and/or the outputs the toplevel is visible on actually
+        change, this will be indicated by the state and output_enter/leave
+        events.
+
+        The output parameter is only a hint to the compositor. Also, if output
+        is NULL, the compositor should decide which output the toplevel will be
+        fullscreened on, if at all.
+      </description>
+      <arg name="output" type="object" interface="wl_output" allow-null="true"/>
+    </request>
+
+    <request name="unset_fullscreen" since="2">
+      <description summary="request that the toplevel be unfullscreened">
+        Requests that the toplevel be unfullscreened. If the fullscreen state
+        actually changes, this will be indicated by the state event.
+      </description>
+    </request>
+  </interface>
+</protocol>

protocol/wlr-layer-shell-unstable-v1.xml

@@ -25,7 +25,7 @@
     THIS SOFTWARE.
   </copyright>
 
-  <interface name="zwlr_layer_shell_v1" version="1">
+  <interface name="zwlr_layer_shell_v1" version="3">
     <description summary="create surfaces that are layers of the desktop">
       Clients can use this interface to assign the surface_layer role to
       wl_surfaces. Such surfaces are assigned to a "layer" of the output and
@@ -82,17 +82,27 @@
       <entry name="top" value="2"/>
       <entry name="overlay" value="3"/>
     </enum>
+
+    <!-- Version 3 additions -->
+
+    <request name="destroy" type="destructor" since="3">
+      <description summary="destroy the layer_shell object">
+        This request indicates that the client will not use the layer_shell
+        object any more. Objects that have been created through this instance
+        are not affected.
+      </description>
+    </request>
   </interface>
 
-  <interface name="zwlr_layer_surface_v1" version="1">
+  <interface name="zwlr_layer_surface_v1" version="3">
     <description summary="layer metadata interface">
       An interface that may be implemented by a wl_surface, for surfaces that
       are designed to be rendered as a layer of a stacked desktop-like
       environment.
 
-      Layer surface state (size, anchor, exclusive zone, margin, interactivity)
-      is double-buffered, and will be applied at the time wl_surface.commit of
-      the corresponding wl_surface is called.
+      Layer surface state (layer, size, anchor, exclusive zone,
+      margin, interactivity) is double-buffered, and will be applied at the
+      time wl_surface.commit of the corresponding wl_surface is called.
     </description>
 
     <request name="set_size">
@@ -115,7 +125,7 @@
     <request name="set_anchor">
       <description summary="configures the anchor point of the surface">
         Requests that the compositor anchor the surface to the specified edges
-        and corners. If two orthoginal edges are specified (e.g. 'top' and
+        and corners. If two orthogonal edges are specified (e.g. 'top' and
         'left'), then the anchor point will be the intersection of the edges
         (e.g. the top left corner of the output); otherwise the anchor point
         will be centered on that edge, or in the center if none is specified.
@@ -127,20 +137,25 @@
 
     <request name="set_exclusive_zone">
       <description summary="configures the exclusive geometry of this surface">
-        Requests that the compositor avoids occluding an area of the surface
-        with other surfaces. The compositor's use of this information is
+        Requests that the compositor avoids occluding an area with other
+        surfaces. The compositor's use of this information is
         implementation-dependent - do not assume that this region will not
         actually be occluded.
 
-        A positive value is only meaningful if the surface is anchored to an
-        edge, rather than a corner. The zone is the number of surface-local
-        coordinates from the edge that are considered exclusive.
+        A positive value is only meaningful if the surface is anchored to one
+        edge or an edge and both perpendicular edges. If the surface is not
+        anchored, anchored to only two perpendicular edges (a corner), anchored
+        to only two parallel edges or anchored to all edges, a positive value
+        will be treated the same as zero.
+
+        A positive zone is the distance from the edge in surface-local
+        coordinates to consider exclusive.
 
         Surfaces that do not wish to have an exclusive zone may instead specify
         how they should interact with surfaces that do. If set to zero, the
         surface indicates that it would like to be moved to avoid occluding
-        surfaces with a positive excluzive zone. If set to -1, the surface
-        indicates that it would not like to be moved to accomodate for other
+        surfaces with a positive exclusive zone. If set to -1, the surface
+        indicates that it would not like to be moved to accommodate for other
         surfaces, and the compositor should extend it all the way to the edges
         it is anchored to.
 
@@ -281,5 +296,16 @@
       <entry name="left" value="4" summary="the left edge of the anchor rectangle"/>
       <entry name="right" value="8" summary="the right edge of the anchor rectangle"/>
     </enum>
+
+    <!-- Version 2 additions -->
+
+    <request name="set_layer" since="2">
+      <description summary="change the layer of the surface">
+        Change the layer that the surface is rendered on.
+
+        Layer is double-buffered, see wl_surface.commit.
+      </description>
+      <arg name="layer" type="uint" enum="zwlr_layer_shell_v1.layer" summary="layer to move this surface to"/>
+    </request>
   </interface>
 </protocol>

resources/config

@@ -1,12 +1,12 @@
 {
-    "layer": "top", // Waybar at top layer
-    // "position": "bottom", // Waybar at the bottom of your screen
-    // "height": 30, // Waybar height
+    // "layer": "top", // Waybar at top layer
+    // "position": "bottom", // Waybar position (top|bottom|left|right)
+    "height": 30, // Waybar height (to be removed for auto height)
     // "width": 1280, // Waybar width
     // Choose the order of the modules
-    "modules-left": ["sway/workspaces", "sway/mode", "custom/spotify"],
+    "modules-left": ["sway/workspaces", "sway/mode", "custom/media"],
     "modules-center": ["sway/window"],
-    "modules-right": ["idle_inhibitor", "pulseaudio", "network", "cpu", "memory", "temperature", "backlight", "battery", "battery#bat2", "clock", "tray"],
+    "modules-right": ["mpd", "idle_inhibitor", "pulseaudio", "network", "cpu", "memory", "temperature", "backlight", "battery", "battery#bat2", "clock", "tray"],
     // Modules configuration
     // "sway/workspaces": {
     //     "disable-scroll": true,
@@ -26,6 +26,32 @@
     "sway/mode": {
         "format": "<span style=\"italic\">{}</span>"
     },
+    "mpd": {
+        "format": "{stateIcon} {consumeIcon}{randomIcon}{repeatIcon}{singleIcon}{artist} - {album} - {title} ({elapsedTime:%M:%S}/{totalTime:%M:%S}) ⸨{songPosition}|{queueLength}⸩ ",
+        "format-disconnected": "Disconnected ",
+        "format-stopped": "{consumeIcon}{randomIcon}{repeatIcon}{singleIcon}Stopped ",
+        "unknown-tag": "N/A",
+        "interval": 2,
+        "consume-icons": {
+            "on": " "
+        },
+        "random-icons": {
+            "off": "<span color=\"#f53c3c\"></span> ",
+            "on": " "
+        },
+        "repeat-icons": {
+            "on": " "
+        },
+        "single-icons": {
+            "on": "1 "
+        },
+        "state-icons": {
+            "paused": "",
+            "playing": ""
+        },
+        "tooltip-format": "MPD (connected)",
+        "tooltip-format-disconnected": "MPD (disconnected)"
+    },
     "idle_inhibitor": {
         "format": "{icon}",
         "format-icons": {
@@ -38,11 +64,13 @@
         "spacing": 10
     },
     "clock": {
-        "tooltip-format": "{:%Y-%m-%d | %H:%M}",
+        // "timezone": "America/New_York",
+        "tooltip-format": "<big>{:%Y %B}</big>\n<tt><small>{calendar}</small></tt>",
         "format-alt": "{:%Y-%m-%d}"
     },
     "cpu": {
-        "format": "{usage}% "
+        "format": "{usage}% ",
+        "tooltip": false
     },
     "memory": {
         "format": "{}% "
@@ -51,8 +79,9 @@
         // "thermal-zone": 2,
         // "hwmon-path": "/sys/class/hwmon/hwmon2/temp1_input",
         "critical-threshold": 80,
-        // "format-critical": "{temperatureC}°C ",
-        "format": "{temperatureC}°C "
+        // "format-critical": "{temperatureC}°C {icon}",
+        "format": "{temperatureC}°C {icon}",
+        "format-icons": ["", "", ""]
     },
     "backlight": {
         // "device": "acpi_video1",
@@ -66,6 +95,9 @@
             "critical": 15
         },
         "format": "{capacity}% {icon}",
+        "format-charging": "{capacity}% ",
+        "format-plugged": "{capacity}% ",
+        "format-alt": "{time} {icon}",
         // "format-good": "", // An empty format will hide the module
         // "format-full": "",
         "format-icons": ["", "", "", "", ""]
@@ -74,30 +106,42 @@
         "bat": "BAT2"
     },
     "network": {
-        // "interface": "wlp2s0", // (Optional) To force the use of this interface
+        // "interface": "wlp2*", // (Optional) To force the use of this interface
         "format-wifi": "{essid} ({signalStrength}%) ",
-        "format-ethernet": "{ifname}: {ipaddr}/{cidr} ",
-        "format-disconnected": "Disconnected ⚠"
+        "format-ethernet": "{ifname}: {ipaddr}/{cidr} ",
+        "format-linked": "{ifname} (No IP) ",
+        "format-disconnected": "Disconnected ⚠",
+        "format-alt": "{ifname}: {ipaddr}/{cidr}"
     },
     "pulseaudio": {
-        //"scroll-step": 1,
-        "format": "{volume}% {icon}",
-        "format-bluetooth": "{volume}% {icon}",
-        "format-muted": "",
+        // "scroll-step": 1, // %, can be a float
+        "format": "{volume}% {icon} {format_source}",
+        "format-bluetooth": "{volume}% {icon} {format_source}",
+        "format-bluetooth-muted": " {icon} {format_source}",
+        "format-muted": " {format_source}",
+        "format-source": "{volume}% ",
+        "format-source-muted": "",
         "format-icons": {
-            "headphones": "",
-            "handsfree": "",
+            "headphone": "",
+            "hands-free": "",
             "headset": "",
             "phone": "",
             "portable": "",
             "car": "",
-            "default": ["", ""]
+            "default": ["", "", ""]
         },
         "on-click": "pavucontrol"
     },
-    "custom/spotify": {
-        "format": " {}",
+    "custom/media": {
+        "format": "{icon} {}",
+        "return-type": "json",
         "max-length": 40,
+        "format-icons": {
+            "spotify": "",
+            "default": "🎜"
+        },
+        "escape": true,
         "exec": "$HOME/.config/waybar/mediaplayer.py 2> /dev/null" // Script in resources folder
+        // "exec": "$HOME/.config/waybar/mediaplayer.py --player spotify 2> /dev/null" // Filter player based on name
     }
 }

resources/custom_modules/mediaplayer.py

@@ -1,19 +1,34 @@
 #!/usr/bin/env python3
+import argparse
+import logging
 import sys
 import signal
 import gi
+import json
 gi.require_version('Playerctl', '2.0')
 from gi.repository import Playerctl, GLib
 
-manager = Playerctl.PlayerManager()
-loop = GLib.MainLoop()
+logger = logging.getLogger(__name__)
+
+
+def write_output(text, player):
+    logger.info('Writing output')
+
+    output = {'text': text,
+              'class': 'custom-' + player.props.player_name,
+              'alt': player.props.player_name}
+
+    sys.stdout.write(json.dumps(output) + '\n')
+    sys.stdout.flush()
 
 
 def on_play(player, status, manager):
+    logger.info('Received new playback status')
     on_metadata(player, player.props.metadata, manager)
 
 
 def on_metadata(player, metadata, manager):
+    logger.info('Received new metadata')
     track_info = ''
 
     if player.props.player_name == 'spotify' and \
@@ -24,27 +39,28 @@ def on_metadata(player, metadata, manager):
         track_info = '{artist} - {title}'.format(artist=player.get_artist(),
                                                  title=player.get_title())
     else:
-        sys.stdout.write('\n')
-        sys.stdout.flush()
-        return
+        track_info = player.get_title()
 
-    if player.props.status == 'Playing':
-        sys.stdout.write(track_info + '\n')
+    if player.props.status != 'Playing' and track_info:
+        track_info = ' ' + track_info
+    write_output(track_info, player)
+
+
+def on_player_appeared(manager, player, selected_player=None):
+    if player is not None and (selected_player is None or player.name == selected_player):
+        init_player(manager, player)
     else:
-        sys.stdout.write(' ' + track_info + '\n')
-    sys.stdout.flush()
-
-
-def on_name_appeared(manager, name):
-    init_player(name)
+        logger.debug("New player appeared, but it's not the selected player, skipping")
 
 
 def on_player_vanished(manager, player):
-    sys.stdout.write("\n")
+    logger.info('Player has vanished')
+    sys.stdout.write('\n')
     sys.stdout.flush()
 
 
-def init_player(name):
+def init_player(manager, name):
+    logger.debug('Initialize player: {player}'.format(player=name.name))
     player = Playerctl.Player.new_from_name(name)
     player.connect('playback-status', on_play, manager)
     player.connect('metadata', on_metadata, manager)
@@ -53,19 +69,59 @@ def init_player(name):
 
 
 def signal_handler(sig, frame):
-    sys.stdout.write("\n")
+    logger.debug('Received signal to stop, exiting')
+    sys.stdout.write('\n')
     sys.stdout.flush()
-    loop.quit()
+    # loop.quit()
     sys.exit(0)
 
 
-manager.connect('name-appeared', on_name_appeared)
-manager.connect('player-vanished', on_player_vanished)
+def parse_arguments():
+    parser = argparse.ArgumentParser()
 
-signal.signal(signal.SIGINT, signal_handler)
-signal.signal(signal.SIGTERM, signal_handler)
+    # Increase verbosity with every occurence of -v
+    parser.add_argument('-v', '--verbose', action='count', default=0)
 
-for player in manager.props.player_names:
-    init_player(player)
+    # Define for which player we're listening
+    parser.add_argument('--player')
 
-loop.run()
+    return parser.parse_args()
+
+
+def main():
+    arguments = parse_arguments()
+
+    # Initialize logging
+    logging.basicConfig(stream=sys.stderr, level=logging.DEBUG,
+                        format='%(name)s %(levelname)s %(message)s')
+
+    # Logging is set by default to WARN and higher.
+    # With every occurrence of -v it's lowered by one
+    logger.setLevel(max((3 - arguments.verbose) * 10, 0))
+
+    # Log the sent command line arguments
+    logger.debug('Arguments received {}'.format(vars(arguments)))
+
+    manager = Playerctl.PlayerManager()
+    loop = GLib.MainLoop()
+
+    manager.connect('name-appeared', lambda *args: on_player_appeared(*args, arguments.player))
+    manager.connect('player-vanished', on_player_vanished)
+
+    signal.signal(signal.SIGINT, signal_handler)
+    signal.signal(signal.SIGTERM, signal_handler)
+
+    for player in manager.props.player_names:
+        if arguments.player is not None and arguments.player != player.name:
+            logger.debug('{player} is not the filtered player, skipping it'
+                         .format(player=player.name)
+                         )
+            continue
+
+        init_player(manager, player)
+
+    loop.run()
+
+
+if __name__ == '__main__':
+    main()

resources/style.css

@@ -1,38 +1,86 @@
 * {
     border: none;
     border-radius: 0;
+    /* `otf-font-awesome` is required to be installed for icons */
     font-family: Roboto, Helvetica, Arial, sans-serif;
     font-size: 13px;
     min-height: 0;
 }
 
 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-color;
+    transition-duration: .5s;
+}
+
+window#waybar.hidden {
+    opacity: 0.2;
+}
+
+/*
+window#waybar.empty {
+    background-color: transparent;
+}
+window#waybar.solo {
+    background-color: #FFFFFF;
+}
+*/
+
+window#waybar.termite {
+    background-color: #3F3F3F;
+}
+
+window#waybar.chromium {
+    background-color: #000000;
+    border: none;
 }
 
-/* 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;
+/* https://github.com/Alexays/Waybar/wiki/FAQ#the-workspace-buttons-have-a-strange-hover-effect */
+#workspaces button:hover {
+    background: rgba(0, 0, 0, 0.2);
+    box-shadow: inherit;
     border-bottom: 3px solid #ffffff;
 }
 
+#workspaces button.focused {
+    background-color: #64727D;
+    border-bottom: 3px solid #ffffff;
+}
+
+#workspaces button.urgent {
+    background-color: #eb4d4b;
+}
+
 #mode {
-    background: #64727D;
+    background-color: #64727D;
     border-bottom: 3px solid #ffffff;
 }
 
-#clock, #battery, #cpu, #memory, #temperature, #backlight, #network, #pulseaudio, #custom-spotify, #tray, #mode, #idle_inhibitor {
+#clock,
+#battery,
+#cpu,
+#memory,
+#temperature,
+#backlight,
+#network,
+#pulseaudio,
+#custom-media,
+#tray,
+#mode,
+#idle_inhibitor,
+#mpd {
     padding: 0 10px;
-    margin: 0 5px;
+    margin: 0 4px;
+    color: #ffffff;
 }
 
 #clock {
@@ -57,7 +105,7 @@ window#waybar {
 }
 
 #battery.critical:not(.charging) {
-    background: #f53c3c;
+    background-color: #f53c3c;
     color: #ffffff;
     animation-name: blink;
     animation-duration: 0.5s;
@@ -66,48 +114,61 @@ window#waybar {
     animation-direction: alternate;
 }
 
+label:focus {
+    background-color: #000000;
+}
+
 #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-spotify {
-    background: #66cc99;
+#custom-media {
+    background-color: #66cc99;
     color: #2a5c45;
+    min-width: 100px;
+}
+
+#custom-media.custom-spotify {
+    background-color: #66cc99;
+}
+
+#custom-media.custom-vlc {
+    background-color: #ffa000;
 }
 
 #temperature {
-    background: #f0932b;
+    background-color: #f0932b;
 }
 
 #temperature.critical {
-    background: #eb4d4b;
+    background-color: #eb4d4b;
 }
 
 #tray {
@@ -122,3 +183,20 @@ window#waybar {
     background-color: #ecf0f1;
     color: #2d3436;
 }
+
+#mpd {
+    background-color: #66cc99;
+    color: #2a5c45;
+}
+
+#mpd.disconnected {
+    background-color: #f53c3c;
+}
+
+#mpd.stopped {
+    background-color: #90b1b1;
+}
+
+#mpd.paused {
+    background-color: #51a37a;
+}

resources/waybar.service.in

@@ -0,0 +1,11 @@
+[Unit]
+Description=Highly customizable Wayland bar for Sway and Wlroots based compositors.
+Documentation=https://github.com/Alexays/Waybar/wiki/
+PartOf=graphical-session.target
+After=graphical-session.target
+
+[Service]
+ExecStart=@prefix@/bin/waybar
+
+[Install]
+WantedBy=graphical-session.target

src/ALabel.cpp

@@ -1,103 +1,43 @@
 #include "ALabel.hpp"
+#include <fmt/format.h>
 #include <util/command.hpp>
 
-#include <iostream>
+namespace waybar {
 
-waybar::ALabel::ALabel(const Json::Value& config, const std::string format, uint16_t interval)
-  : config_(config),
-    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_)
-{
+ALabel::ALabel(const Json::Value& config, const std::string& name, const std::string& id,
+               const std::string& format, uint16_t interval, bool ellipsize, bool enable_click,
+               bool enable_scroll)
+    : AModule(config, name, id, config["format-alt"].isString() || enable_click, enable_scroll),
+      format_(config_["format"].isString() ? config_["format"].asString() : format),
+      interval_(config_["interval"] == "once"
+                    ? std::chrono::seconds(100000000)
+                    : std::chrono::seconds(
+                          config_["interval"].isUInt() ? config_["interval"].asUInt() : interval)),
+      default_format_(format_) {
+  label_.set_name(name);
+  if (!id.empty()) {
+    label_.get_style_context()->add_class(id);
+  }
   event_box_.add(label_);
-	if (config_["max-length"].isUInt()) {
+  if (config_["max-length"].isUInt()) {
     label_.set_max_width_chars(config_["max-length"].asUInt());
     label_.set_ellipsize(Pango::EllipsizeMode::ELLIPSIZE_END);
-  }
-  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));
+    label_.set_single_line_mode(true);
+  } else if (ellipsize && label_.get_max_width_chars() == -1) {
+    label_.set_ellipsize(Pango::EllipsizeMode::ELLIPSIZE_END);
+    label_.set_single_line_mode(true);
   }
 
-  // configure events' user commands
-  if (config_["on-click"].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));
+  if (config_["rotate"].isUInt()) {
+    label_.set_angle(config["rotate"].asUInt());
   }
 }
 
-auto waybar::ALabel::update() -> void {
-  // Nothing here
+auto ALabel::update() -> void {
+  AModule::update();
 }
 
-bool waybar::ALabel::handleToggle(GdkEventButton* const& e) {
-  if (config_["on-click"].isString() && e->button == 1) {
-    waybar::util::command::forkExec(config_["on-click"].asString());
-  } else if (config_["on-click-middle"].isString() && e->button == 2) {
-    waybar::util::command::forkExec(config_["on-click-middle"].asString());
-  } else if (config_["on-click-right"].isString() && e->button == 3) {
-    waybar::util::command::forkExec(config_["on-click-right"].asString());
-  } else if (config_["on-click-forward"].isString() && e->button == 8) {
-    waybar::util::command::forkExec(config_["on-click-backward"].asString());
-  } else if (config_["on-click-backward"].isString() && e->button == 9) {
-    waybar::util::command::forkExec(config_["on-click-forward"].asString());
-
-
-  }
-  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()) {
-    waybar::util::command::forkExec(config_["on-scroll-up"].asString());
-  } else if (config_["on-scroll-down"].isString()) {
-    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)
-{
+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())) {
@@ -108,7 +48,7 @@ std::string waybar::ALabel::getIcon(uint16_t percentage, const std::string& alt)
   }
   if (format_icons.isArray()) {
     auto size = format_icons.size();
-    auto idx = std::clamp(percentage / (100 / size), 0U, size - 1);
+    auto idx = std::clamp(percentage / ((max == 0 ? 100 : max) / size), 0U, size - 1);
     format_icons = format_icons[idx];
   }
   if (format_icons.isString()) {
@@ -117,9 +57,68 @@ std::string waybar::ALabel::getIcon(uint16_t percentage, const std::string& alt)
   return "";
 }
 
-bool waybar::ALabel::tooltipEnabled()
-{
-  return config_["tooltip"].isBool() ? config_["tooltip"].asBool() : true;
+std::string ALabel::getIcon(uint16_t percentage, std::vector<std::string>& alts, uint16_t max) {
+  auto format_icons = config_["format-icons"];
+  if (format_icons.isObject()) {
+    for (const auto& alt : alts) {
+      if (!alt.empty() && (format_icons[alt].isString() || format_icons[alt].isArray())) {
+        format_icons = format_icons[alt];
+        break;
+      } else {
+        format_icons = format_icons["default"];
+      }
+    }
+  }
+  if (format_icons.isArray()) {
+    auto size = format_icons.size();
+    auto idx = std::clamp(percentage / ((max == 0 ? 100 : max) / size), 0U, size - 1);
+    format_icons = format_icons[idx];
+  }
+  if (format_icons.isString()) {
+    return format_icons.asString();
+  }
+  return "";
 }
 
-waybar::ALabel::operator Gtk::Widget&() { return event_box_; }
+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 "";
+  }
+  // Get current state
+  std::vector<std::pair<std::string, uint8_t>> states;
+  if (config_["states"].isObject()) {
+    for (auto it = config_["states"].begin(); it != config_["states"].end(); ++it) {
+      if (it->isUInt() && it.key().isString()) {
+        states.emplace_back(it.key().asString(), it->asUInt());
+      }
+    }
+  }
+  // Sort states
+  std::sort(states.begin(), states.end(), [&lesser](auto& a, auto& b) {
+    return lesser ? a.second < b.second : a.second > b.second;
+  });
+  std::string valid_state;
+  for (auto const& state : states) {
+    if ((lesser ? value <= state.second : value >= state.second) && valid_state.empty()) {
+      label_.get_style_context()->add_class(state.first);
+      valid_state = state.first;
+    } else {
+      label_.get_style_context()->remove_class(state.first);
+    }
+  }
+  return valid_state;
+}
+
+}  // namespace waybar

src/AModule.cpp

@@ -0,0 +1,123 @@
+#include "AModule.hpp"
+#include <fmt/format.h>
+#include <util/command.hpp>
+
+namespace waybar {
+
+AModule::AModule(const Json::Value& config, const std::string& name, const std::string& id,
+                 bool enable_click, bool enable_scroll)
+    : name_(std::move(name)), config_(std::move(config)) {
+  // 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) {
+      killpg(pid, SIGTERM);
+    }
+  }
+}
+
+
+auto AModule::update() -> void {
+  // Run user-provided update handler if configured
+  if (config_["on-update"].isString()) {
+    pid_.push_back(util::command::forkExec(config_["on-update"].asString()));
+  }
+}
+
+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(format));
+  }
+  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

src/bar.cpp

@@ -1,282 +1,412 @@
+#ifdef HAVE_GTK_LAYER_SHELL
+#include <gtk-layer-shell.h>
+#endif
+
 #include "bar.hpp"
 #include "client.hpp"
 #include "factory.hpp"
-#include "util/json.hpp"
+#include <spdlog/spdlog.h>
 
-waybar::Bar::Bar(const Client& client,
-  std::unique_ptr<struct wl_output *> &&p_output, uint32_t p_wl_name)
-  : client(client), window{Gtk::WindowType::WINDOW_TOPLEVEL},
-    surface(nullptr), layer_surface(nullptr),
-    output(std::move(p_output)), wl_name(p_wl_name),
-    left_(Gtk::ORIENTATION_HORIZONTAL, 0), center_(Gtk::ORIENTATION_HORIZONTAL, 0),
-    right_(Gtk::ORIENTATION_HORIZONTAL, 0), box_(Gtk::ORIENTATION_HORIZONTAL, 0)
-{
-  static const struct zxdg_output_v1_listener xdgOutputListener = {
-    .logical_position = handleLogicalPosition,
-    .logical_size = handleLogicalSize,
-    .done = handleDone,
-    .name = handleName,
-    .description = handleDescription,
-  };
-  xdg_output_ =
-    zxdg_output_manager_v1_get_xdg_output(client.xdg_output_manager, *output);
-	zxdg_output_v1_add_listener(xdg_output_, &xdgOutputListener, this);
+waybar::Bar::Bar(struct waybar_output* w_output, const Json::Value& w_config)
+    : output(w_output),
+      config(w_config),
+      surface(nullptr),
+      window{Gtk::WindowType::WINDOW_TOPLEVEL},
+      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),
+      box_(Gtk::ORIENTATION_HORIZONTAL, 0) {
   window.set_title("waybar");
   window.set_name("waybar");
   window.set_decorated(false);
-  window.set_resizable(false);
-  setupConfig();
-  setupCss();
+  window.get_style_context()->add_class(output->name);
+  window.get_style_context()->add_class(config["name"].asString());
+  window.get_style_context()->add_class(config["position"].asString());
 
-  auto wrap = reinterpret_cast<GtkWidget*>(window.gobj());
-  gtk_widget_realize(wrap);
-  GdkWindow *gdk_window = gtk_widget_get_window(wrap);
-  gdk_wayland_window_set_use_custom_surface(gdk_window);
-  surface = gdk_wayland_window_get_wl_surface(gdk_window);
+  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_;
+
+  if (config["position"] == "bottom") {
+    anchor_ = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
+  } else if (config["position"] == "left") {
+    anchor_ = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT;
+  } else if (config["position"] == "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;
+    left_ = Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0);
+    center_ = Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0);
+    right_ = Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0);
+    box_ = Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0);
+    vertical = true;
+  }
+
+  if (config["margin-top"].isInt() || config["margin-right"].isInt() ||
+      config["margin-bottom"].isInt() || config["margin-left"].isInt()) {
+    margins_ = {
+        config["margin-top"].isInt() ? config["margin-top"].asInt() : 0,
+        config["margin-right"].isInt() ? config["margin-right"].asInt() : 0,
+        config["margin-bottom"].isInt() ? config["margin-bottom"].asInt() : 0,
+        config["margin-left"].isInt() ? config["margin-left"].asInt() : 0,
+    };
+  } else if (config["margin"].isString()) {
+    std::istringstream       iss(config["margin"].asString());
+    std::vector<std::string> margins{std::istream_iterator<std::string>(iss), {}};
+    try {
+      if (margins.size() == 1) {
+        auto gaps = std::stoi(margins[0], nullptr, 10);
+        margins_ = {.top = gaps, .right = gaps, .bottom = gaps, .left = gaps};
+      }
+      if (margins.size() == 2) {
+        auto vertical_margins = std::stoi(margins[0], nullptr, 10);
+        auto horizontal_margins = std::stoi(margins[1], nullptr, 10);
+        margins_ = {.top = vertical_margins,
+                    .right = horizontal_margins,
+                    .bottom = vertical_margins,
+                    .left = horizontal_margins};
+      }
+      if (margins.size() == 3) {
+        auto horizontal_margins = std::stoi(margins[1], nullptr, 10);
+        margins_ = {.top = std::stoi(margins[0], nullptr, 10),
+                    .right = horizontal_margins,
+                    .bottom = std::stoi(margins[2], nullptr, 10),
+                    .left = horizontal_margins};
+      }
+      if (margins.size() == 4) {
+        margins_ = {.top = std::stoi(margins[0], nullptr, 10),
+                    .right = std::stoi(margins[1], nullptr, 10),
+                    .bottom = std::stoi(margins[2], nullptr, 10),
+                    .left = std::stoi(margins[3], nullptr, 10)};
+      }
+    } catch (...) {
+      spdlog::warn("Invalid margins: {}", config["margin"].asString());
+    }
+  } else if (config["margin"].isInt()) {
+    auto gaps = config["margin"].asInt();
+    margins_ = {.top = gaps, .right = gaps, .bottom = gaps, .left = gaps};
+  }
+
+#ifdef HAVE_GTK_LAYER_SHELL
+  use_gls_ = config["gtk-layer-shell"].isBool() ? config["gtk-layer-shell"].asBool() : true;
+  if (use_gls_) {
+    initGtkLayerShell();
+    window.signal_map_event().connect_notify(sigc::mem_fun(*this, &Bar::onMapGLS));
+    window.signal_configure_event().connect_notify(sigc::mem_fun(*this, &Bar::onConfigureGLS));
+  }
+#endif
+
+  if (!use_gls_) {
+    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_);
+  setupWidgets();
+
+  if (!use_gls_ && window.get_realized()) {
+    onRealize();
+  }
+  window.show_all();
 }
 
-void waybar::Bar::initBar()
-{
-  // Converting string to button code rn as to avoid doing it later
-  auto setupAltFormatKeyForModule = [this](const std::string& module_name){
-  	if (config_.isMember(module_name)) {
-      Json::Value& module = config_[module_name];
-      if (module.isMember("format-alt")) {
-        if (module.isMember("format-alt-click")) {
-          Json::Value& click = module["format-alt-click"];
-          if (click.isString()) {
-	        std::string str_click = click.asString();
+#ifdef HAVE_GTK_LAYER_SHELL
+void waybar::Bar::initGtkLayerShell() {
+  auto gtk_window = window.gobj();
+  // this has to be executed before GtkWindow.realize
+  gtk_layer_init_for_window(gtk_window);
+  gtk_layer_set_keyboard_interactivity(gtk_window, FALSE);
+  auto layer = config["layer"] == "top" ? GTK_LAYER_SHELL_LAYER_TOP : GTK_LAYER_SHELL_LAYER_BOTTOM;
+  gtk_layer_set_layer(gtk_window, layer);
+  gtk_layer_set_monitor(gtk_window, output->monitor->gobj());
+  gtk_layer_set_namespace(gtk_window, "waybar");
 
-	        if (str_click == "click-right") {
-		      module["format-alt-click"] = 3u;
-	        } else if (str_click == "click-middle") {
-		      module["format-alt-click"] = 2u;
-	        } else if (str_click == "click-backward") {
-		      module["format-alt-click"] = 8u;
-	        } else if (str_click == "click-forward") {
-		      module["format-alt-click"] = 9u;
-	        } else {
-		      module["format-alt-click"] = 1u; // default click-left
-	        }
-          } else {
-            module["format-alt-click"] = 1u;
-          }
-        } else {
-	      module["format-alt-click"] = 1u;
-        }
+  gtk_layer_set_anchor(
+      gtk_window, GTK_LAYER_SHELL_EDGE_LEFT, anchor_ & ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT);
+  gtk_layer_set_anchor(
+      gtk_window, GTK_LAYER_SHELL_EDGE_RIGHT, anchor_ & ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT);
+  gtk_layer_set_anchor(
+      gtk_window, GTK_LAYER_SHELL_EDGE_TOP, anchor_ & ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP);
+  gtk_layer_set_anchor(
+      gtk_window, GTK_LAYER_SHELL_EDGE_BOTTOM, anchor_ & ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM);
 
-      }
+  gtk_layer_set_margin(gtk_window, GTK_LAYER_SHELL_EDGE_LEFT, margins_.left);
+  gtk_layer_set_margin(gtk_window, GTK_LAYER_SHELL_EDGE_RIGHT, margins_.right);
+  gtk_layer_set_margin(gtk_window, GTK_LAYER_SHELL_EDGE_TOP, margins_.top);
+  gtk_layer_set_margin(gtk_window, GTK_LAYER_SHELL_EDGE_BOTTOM, margins_.bottom);
+
+  if (width_ > 1 && height_ > 1) {
+    /* configure events are not emitted if the bar is using initial size */
+    setExclusiveZone(width_, height_);
+  }
+}
+
+void waybar::Bar::onConfigureGLS(GdkEventConfigure* ev) {
+  /*
+   * GTK wants new size for the window.
+   * Actual resizing is done within the gtk-layer-shell code; the only remaining action is to apply
+   * exclusive zone.
+   * gtk_layer_auto_exclusive_zone_enable() could handle even that, but at the cost of ignoring
+   * margins on unanchored edge.
+   *
+   * Note: forced resizing to a window smaller than required by GTK would not work with
+   * gtk-layer-shell.
+   */
+  if (vertical) {
+    if (width_ > 1 && ev->width > static_cast<int>(width_)) {
+      spdlog::warn(MIN_WIDTH_MSG, width_, ev->width);
     }
-  };
+  } else {
+    if (!vertical && height_ > 1 && ev->height > static_cast<int>(height_)) {
+      spdlog::warn(MIN_HEIGHT_MSG, height_, ev->height);
+    }
+  }
+  width_ = ev->width;
+  height_ = ev->height;
+  spdlog::info(BAR_SIZE_MSG, width_, height_, output->name);
+  setExclusiveZone(width_, height_);
+}
 
-  auto setupAltFormatKeyForModuleList = [this, &setupAltFormatKeyForModule](const char* module_list_name) {
-  	if (config_.isMember(module_list_name)) {
-  		Json::Value& modules = config_[module_list_name];
-	    for (const Json::Value& module_name : modules) {
-		    if (module_name.isString()) {
-			    setupAltFormatKeyForModule(module_name.asString());
-		    }
-	    }
-  	}
-  };
+void waybar::Bar::onMapGLS(GdkEventAny* ev) {
+  /*
+   * Obtain a pointer to the custom layer surface for modules that require it (idle_inhibitor).
+   */
+  auto gdk_window = window.get_window();
+  surface = gdk_wayland_window_get_wl_surface(gdk_window->gobj());
+}
 
-  // Convert to button code for every module that is used.
-  setupAltFormatKeyForModuleList("modules-left");
-  setupAltFormatKeyForModuleList("modules-right");
-  setupAltFormatKeyForModuleList("modules-center");
-  std::size_t layer_top = 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, layer_top, "waybar");
+#endif
+
+void waybar::Bar::onConfigure(GdkEventConfigure* ev) {
+  /*
+   * GTK wants new size for the window.
+   *
+   * Prefer configured size if it's non-default.
+   * If the size is not set and the window is smaller than requested by GTK, request resize from
+   * layer surface.
+   */
+  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_) {
+    setSurfaceSize(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();
+  // owned by output->monitor; no need to destroy
+  auto wl_output = gdk_wayland_monitor_get_wl_output(output->monitor->gobj());
+  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, wl_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_margin(
+      layer_surface_, margins_.top, margins_.right, margins_.bottom, margins_.left);
+  setSurfaceSize(width_, height_);
+  setExclusiveZone(width_, height_);
 
   static const struct zwlr_layer_surface_v1_listener layer_surface_listener = {
-    .configure = layerSurfaceHandleConfigure,
-    .closed = layerSurfaceHandleClosed,
+      .configure = layerSurfaceHandleConfigure,
+      .closed = layerSurfaceHandleClosed,
   };
-  zwlr_layer_surface_v1_add_listener(layer_surface, &layer_surface_listener, this);
-
-  std::size_t anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT
-    | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
-  if (config_["position"] == "bottom") {
-    anchor |= ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
-  } else {
-    anchor |= ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP;
-  }
-
-  auto height = config_["height"].isUInt() ? config_["height"].asUInt() : height_;
-  auto width = config_["width"].isUInt() ? config_["width"].asUInt() : width_;
-  zwlr_layer_surface_v1_set_anchor(layer_surface, anchor);
-  zwlr_layer_surface_v1_set_exclusive_zone(layer_surface, height);
-  zwlr_layer_surface_v1_set_size(layer_surface, width, height);
+  zwlr_layer_surface_v1_add_listener(layer_surface_, &layer_surface_listener, this);
 
   wl_surface_commit(surface);
-
-  setupWidgets();
+  wl_display_roundtrip(client->wl_display);
 }
 
-void waybar::Bar::handleLogicalPosition(void* /*data*/,
-  struct zxdg_output_v1* /*zxdg_output_v1*/, int32_t /*x*/, int32_t /*y*/)
-{
-  // Nothing here
+void waybar::Bar::setExclusiveZone(uint32_t width, uint32_t height) {
+  auto zone = 0;
+  if (visible) {
+    // exclusive zone already includes margin for anchored edge,
+    // only opposite margin should be added
+    if (vertical) {
+      zone += width;
+      zone += (anchor_ & ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT) ? margins_.right : margins_.left;
+    } else {
+      zone += height;
+      zone += (anchor_ & ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP) ? margins_.bottom : margins_.top;
+    }
+  }
+  spdlog::debug("Set exclusive zone {} for output {}", zone, output->name);
+
+#ifdef HAVE_GTK_LAYER_SHELL
+  if (use_gls_) {
+    gtk_layer_set_exclusive_zone(window.gobj(), zone);
+  } else
+#endif
+  {
+    zwlr_layer_surface_v1_set_exclusive_zone(layer_surface_, zone);
+  }
 }
 
-void waybar::Bar::handleLogicalSize(void* /*data*/,
-  struct zxdg_output_v1* /*zxdg_output_v1*/, int32_t /*width*/,
-  int32_t /*height*/)
-{
-  // Nothing here
+void waybar::Bar::setSurfaceSize(uint32_t width, uint32_t height) {
+  /* If the client is anchored to two opposite edges, layer_surface.configure will return
+   * size without margins for the axis.
+   * layer_surface.set_size, however, expects size with margins for the anchored axis.
+   * This is not specified by wlr-layer-shell and based on actual behavior of sway.
+   */
+  if (vertical && height > 1) {
+    height += margins_.top + margins_.bottom;
+  }
+  if (!vertical && width > 1) {
+    width += margins_.right + margins_.left;
+  }
+  spdlog::debug("Set surface size {}x{} for output {}", width, height, output->name);
+  zwlr_layer_surface_v1_set_size(layer_surface_, width, height);
 }
 
-void waybar::Bar::handleDone(void* /*data*/,
-  struct zxdg_output_v1* /*zxdg_output_v1*/)
-{
-  // Nothing here
-}
-
-bool waybar::Bar::isValidOutput(const Json::Value &config)
-{
-  bool found = true;
-  if (config["output"].isArray()) {
-    bool in_array = false;
-    for (auto const &output : config["output"]) {
-      if (output.isString() && output.asString() == output_name) {
-        in_array = true;
-        break;
+// 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)) {
+    Json::Value& module = config[module_name];
+    if (module.isMember("format-alt")) {
+      if (module.isMember("format-alt-click")) {
+        Json::Value& click = module["format-alt-click"];
+        if (click.isString()) {
+          if (click == "click-right") {
+            module["format-alt-click"] = 3U;
+          } else if (click == "click-middle") {
+            module["format-alt-click"] = 2U;
+          } else if (click == "click-backward") {
+            module["format-alt-click"] = 8U;
+          } else if (click == "click-forward") {
+            module["format-alt-click"] = 9U;
+          } else {
+            module["format-alt-click"] = 1U;  // default click-left
+          }
+        } else {
+          module["format-alt-click"] = 1U;
+        }
+      } else {
+        module["format-alt-click"] = 1U;
       }
     }
-    found = in_array;
   }
-  if (config["output"].isString() && config["output"].asString() != output_name) {
-    found = false;
-  }
-  return found;
 }
 
-void waybar::Bar::handleName(void* data, struct zxdg_output_v1* /*xdg_output*/,
-  const char* name)
-{
-	auto o = static_cast<waybar::Bar *>(data);
-  o->output_name = name;
-  bool found = true;
-  if (o->config_.isArray()) {
-    bool in_array = false;
-    for (auto const &config : o->config_) {
-      if (config.isObject() && o->isValidOutput(config)) {
-        in_array = true;
-        o->config_ = config;
-        break;
+void waybar::Bar::setupAltFormatKeyForModuleList(const char* module_list_name) {
+  if (config.isMember(module_list_name)) {
+    Json::Value& modules = config[module_list_name];
+    for (const Json::Value& module_name : modules) {
+      if (module_name.isString()) {
+        setupAltFormatKeyForModule(module_name.asString());
       }
     }
-    found = in_array;
-  } else {
-    found = o->isValidOutput(o->config_);
-  }
-  if (!found) {
-    wl_output_destroy(*o->output);
-    zxdg_output_v1_destroy(o->xdg_output_);
-  } else {
-    o->initBar();
   }
 }
 
-void waybar::Bar::handleDescription(void* /*data*/,
-  struct zxdg_output_v1* /*zxdg_output_v1*/, const char* /*description*/)
-{
-  // Nothing here
-}
-
-void waybar::Bar::handleSignal(int signal)
-{
+void waybar::Bar::handleSignal(int signal) {
   for (auto& module : modules_left_) {
     auto* custom = dynamic_cast<waybar::modules::Custom*>(module.get());
-    if(custom) custom->refresh(signal);
+    if (custom != nullptr) {
+      custom->refresh(signal);
+    }
   }
   for (auto& module : modules_center_) {
     auto* custom = dynamic_cast<waybar::modules::Custom*>(module.get());
-    if(custom) custom->refresh(signal);
+    if (custom != nullptr) {
+      custom->refresh(signal);
+    }
   }
   for (auto& module : modules_right_) {
     auto* custom = dynamic_cast<waybar::modules::Custom*>(module.get());
-    if(custom) custom->refresh(signal);
+    if (custom != nullptr) {
+      custom->refresh(signal);
+    }
   }
 }
 
-void waybar::Bar::layerSurfaceHandleConfigure(void* data,
-  struct zwlr_layer_surface_v1* surface, uint32_t serial, uint32_t width,
-  uint32_t height)
-{
-  auto o = static_cast<waybar::Bar *>(data);
-  zwlr_layer_surface_v1_ack_configure(surface, serial);
+void waybar::Bar::layerSurfaceHandleConfigure(void* data, struct zwlr_layer_surface_v1* surface,
+                                              uint32_t serial, uint32_t width, uint32_t height) {
+  auto o = static_cast<waybar::Bar*>(data);
   if (width != o->width_ || height != o->height_) {
     o->width_ = width;
     o->height_ = height;
     o->window.set_size_request(o->width_, o->height_);
     o->window.resize(o->width_, o->height_);
-
-    int dummy_width, min_height;
-    o->window.get_size(dummy_width, min_height);
-    if (o->height_ < static_cast<uint32_t>(min_height)) {
-      std::cout << fmt::format("Requested height: {} exceeds the minimum \
-height: {} required by the modules", o->height_, min_height) << std::endl;
-      o->height_ = min_height;
-    }
-    std::cout << fmt::format(
-      "Bar configured (width: {}, height: {}) for output: {}",
-      o->width_, o->height_, o->output_name) << std::endl;
-
+    o->setExclusiveZone(width, height);
+    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);
     wl_surface_commit(o->surface);
   }
+  zwlr_layer_surface_v1_ack_configure(surface, serial);
 }
 
-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);
-  wl_output_destroy(*o->output);
-  zxdg_output_v1_destroy(o->xdg_output_);
+void waybar::Bar::layerSurfaceHandleClosed(void* data, struct zwlr_layer_surface_v1* /*surface*/) {
+  auto o = static_cast<waybar::Bar*>(data);
+  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();
 }
 
-auto waybar::Bar::toggle() -> void
-{
+auto waybar::Bar::toggle() -> void {
   visible = !visible;
-  auto zone = visible ? height_ : 0;
-  zwlr_layer_surface_v1_set_exclusive_zone(layer_surface, zone);
-  wl_surface_commit(surface);
-}
-
-auto waybar::Bar::setupConfig() -> void
-{
-  std::ifstream file(client.config_file);
-  if (!file.is_open()) {
-    throw std::runtime_error("Can't open config file");
+  if (!visible) {
+    window.get_style_context()->add_class("hidden");
+    window.set_opacity(0);
+  } else {
+    window.get_style_context()->remove_class("hidden");
+    window.set_opacity(1);
   }
-  std::string str((std::istreambuf_iterator<char>(file)),
-    std::istreambuf_iterator<char>());
-  util::JsonParser parser;
-  config_ = parser.parse(str);
-}
-
-auto waybar::Bar::setupCss() -> 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(client.css_file)) {
-    Glib::RefPtr<Gdk::Screen> screen = window.get_screen();
-    style_context_->add_provider_for_screen(screen, css_provider_,
-      GTK_STYLE_PROVIDER_PRIORITY_USER);
+  setExclusiveZone(width_, height_);
+  if (!use_gls_) {
+    wl_surface_commit(surface);
   }
 }
 
-void waybar::Bar::getModules(const Factory& factory, const std::string& pos)
-{
-  if (config_[pos].isArray()) {
-    for (const auto &name : config_[pos]) {
+void waybar::Bar::getModules(const Factory& factory, const std::string& pos) {
+  if (config[pos].isArray()) {
+    for (const auto& name : config[pos]) {
       try {
         auto module = factory.makeModule(name.asString());
         if (pos == "modules-left") {
@@ -292,36 +422,39 @@ void waybar::Bar::getModules(const Factory& factory, const std::string& pos)
           try {
             module->update();
           } catch (const std::exception& e) {
-            std::cerr << name.asString() + ": " + e.what() << std::endl;
+            spdlog::error("{}: {}", name.asString(), e.what());
           }
         });
       } catch (const std::exception& e) {
-        std::cerr << e.what() << std::endl;
+        spdlog::warn("module {}: {}", name.asString(), e.what());
       }
     }
   }
 }
 
-auto waybar::Bar::setupWidgets() -> void
-{
+auto waybar::Bar::setupWidgets() -> void {
   window.add(box_);
-  box_.pack_start(left_, true, true);
+  box_.pack_start(left_, false, false);
   box_.set_center_widget(center_);
-  box_.pack_end(right_, true, true);
+  box_.pack_end(right_, false, false);
 
-  Factory factory(*this, config_);
+  // Convert to button code for every module that is used.
+  setupAltFormatKeyForModuleList("modules-left");
+  setupAltFormatKeyForModuleList("modules-right");
+  setupAltFormatKeyForModuleList("modules-center");
+
+  Factory factory(*this, config);
   getModules(factory, "modules-left");
   getModules(factory, "modules-center");
   getModules(factory, "modules-right");
   for (auto const& module : modules_left_) {
-    left_.pack_start(*module, false, true, 0);
+    left_.pack_start(*module, false, false);
   }
   for (auto const& module : modules_center_) {
-    center_.pack_start(*module, true, true, 0);
+    center_.pack_start(*module, false, false);
   }
   std::reverse(modules_right_.begin(), modules_right_.end());
   for (auto const& module : modules_right_) {
-    right_.pack_end(*module, false, false, 0);
+    right_.pack_end(*module, false, false);
   }
-  window.show_all();
 }

src/client.cpp

@@ -1,25 +1,20 @@
 #include "client.hpp"
-#include "util/clara.hpp"
+#include <fmt/ostream.h>
+#include <spdlog/spdlog.h>
+#include <fstream>
 #include <iostream>
+#include "util/clara.hpp"
+#include "util/json.hpp"
 
-waybar::Client::Client(int argc, char* argv[])
-  : gtk_main(argc, argv),
-    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());
+waybar::Client *waybar::Client::inst() {
+  static auto c = new Client();
+  return c;
 }
 
-const std::string waybar::Client::getValidPath(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) {
+  for (const std::string &path : paths) {
     if (wordexp(path.c_str(), &p, 0) == 0) {
       if (access(*p.we_wordv, F_OK) == 0) {
         std::string result = *p.we_wordv;
@@ -33,101 +28,218 @@ const std::string waybar::Client::getValidPath(std::vector<std::string> paths)
   return std::string();
 }
 
-void waybar::Client::handleGlobal(void *data, struct wl_registry *registry,
-  uint32_t name, const char *interface, uint32_t version)
-{
-  auto o = static_cast<waybar::Client *>(data);
+void waybar::Client::handleGlobal(void *data, struct wl_registry *registry, uint32_t name,
+                                  const char *interface, uint32_t version) {
+  auto client = static_cast<Client *>(data);
   if (strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) {
-    o->layer_shell = static_cast<struct zwlr_layer_shell_v1 *>(
-      wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface, version));
-  } else if (strcmp(interface, wl_output_interface.name) == 0) {
-    auto output = std::make_unique<struct wl_output *>();
-    *output = static_cast<struct wl_output *>(wl_registry_bind(registry, name,
-      &wl_output_interface, version));
-    if (o->xdg_output_manager != nullptr) {
-      o->bars.emplace_back(std::make_unique<Bar>(*o, std::move(output), name));
-    }
-  } else if (strcmp(interface, wl_seat_interface.name) == 0) {
-    o->seat = static_cast<struct wl_seat *>(wl_registry_bind(registry, name,
-      &wl_seat_interface, version));
-  } else if (strcmp(interface, zxdg_output_manager_v1_interface.name) == 0
-    && version >= ZXDG_OUTPUT_V1_NAME_SINCE_VERSION) {
-      o->xdg_output_manager = static_cast<struct zxdg_output_manager_v1 *>(
-        wl_registry_bind(registry, name,
-        &zxdg_output_manager_v1_interface, ZXDG_OUTPUT_V1_NAME_SINCE_VERSION));
+    client->layer_shell = static_cast<struct zwlr_layer_shell_v1 *>(
+        wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface, version));
+  } else if (strcmp(interface, zxdg_output_manager_v1_interface.name) == 0 &&
+             version >= ZXDG_OUTPUT_V1_NAME_SINCE_VERSION) {
+    client->xdg_output_manager = static_cast<struct zxdg_output_manager_v1 *>(wl_registry_bind(
+        registry, name, &zxdg_output_manager_v1_interface, ZXDG_OUTPUT_V1_NAME_SINCE_VERSION));
   } else if (strcmp(interface, zwp_idle_inhibit_manager_v1_interface.name) == 0) {
-    o->idle_inhibit_manager = static_cast<struct zwp_idle_inhibit_manager_v1 *>(
-        wl_registry_bind(registry, name,
-        &zwp_idle_inhibit_manager_v1_interface, 1));
+    client->idle_inhibit_manager = static_cast<struct zwp_idle_inhibit_manager_v1 *>(
+        wl_registry_bind(registry, name, &zwp_idle_inhibit_manager_v1_interface, 1));
   }
 }
 
-void waybar::Client::handleGlobalRemove(void* data,
-  struct wl_registry* /*registry*/, uint32_t name)
-{
-  auto o = static_cast<waybar::Client *>(data);
-  for (auto it = o->bars.begin(); it != o->bars.end(); ++it) {
-    if ((*it)->wl_name == name) {
-      auto output_name = (*it)->output_name;
-      o->bars.erase(it);
-      std::cout << "Bar removed from output: " + output_name << std::endl;
-      break;
+void waybar::Client::handleGlobalRemove(void *   data, struct wl_registry * /*registry*/,
+                                        uint32_t name) {
+  // Nothing here
+}
+
+void waybar::Client::handleOutput(struct waybar_output &output) {
+  static const struct zxdg_output_v1_listener xdgOutputListener = {
+      .logical_position = [](void *, struct zxdg_output_v1 *, int32_t, int32_t) {},
+      .logical_size = [](void *, struct zxdg_output_v1 *, int32_t, int32_t) {},
+      .done = [](void *, struct zxdg_output_v1 *) {},
+      .name = &handleOutputName,
+      .description = [](void *, struct zxdg_output_v1 *, const char *) {},
+  };
+  // owned by output->monitor; no need to destroy
+  auto wl_output = gdk_wayland_monitor_get_wl_output(output.monitor->gobj());
+  output.xdg_output.reset(zxdg_output_manager_v1_get_xdg_output(xdg_output_manager, wl_output));
+  zxdg_output_v1_add_listener(output.xdg_output.get(), &xdgOutputListener, &output);
+}
+
+bool waybar::Client::isValidOutput(const Json::Value &config, struct waybar_output &output) {
+  if (config["output"].isArray()) {
+    for (auto const &output_conf : config["output"]) {
+      if (output_conf.isString() && output_conf.asString() == output.name) {
+        return true;
+      }
+    }
+    return false;
+  } else if (config["output"].isString()) {
+    auto config_output_name = config["output"].asString();
+    if (!config_output_name.empty()) {
+      if (config_output_name.substr(0, 1) == "!") {
+          return config_output_name.substr(1) != output.name;
+      }
+      return config_output_name == output.name;
     }
   }
+
+  return true;
 }
 
-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",
-  }) : 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;
+struct waybar::waybar_output &waybar::Client::getOutput(void *addr) {
+  auto it = std::find_if(
+      outputs_.begin(), outputs_.end(), [&addr](const auto &output) { return &output == addr; });
+  if (it == outputs_.end()) {
+    throw std::runtime_error("Unable to find valid output");
+  }
+  return *it;
+}
+
+std::vector<Json::Value> waybar::Client::getOutputConfigs(struct waybar_output &output) {
+  std::vector<Json::Value> configs;
+  if (config_.isArray()) {
+    for (auto const &config : config_) {
+      if (config.isObject() && isValidOutput(config, output)) {
+        configs.push_back(config);
+      }
+    }
+  } else if (isValidOutput(config_, output)) {
+    configs.push_back(config_);
+  }
+  return configs;
+}
+
+void waybar::Client::handleOutputName(void *      data, struct zxdg_output_v1 * /*xdg_output*/,
+                                      const char *name) {
+  auto client = waybar::Client::inst();
+  try {
+    auto &output = client->getOutput(data);
+    output.name = name;
+    spdlog::debug("Output detected: {} ({} {})",
+                  name,
+                  output.monitor->get_manufacturer(),
+                  output.monitor->get_model());
+    auto configs = client->getOutputConfigs(output);
+    if (configs.empty()) {
+      output.xdg_output.reset();
+    } else {
+      wl_display_roundtrip(client->wl_display);
+      for (const auto &config : configs) {
+        client->bars.emplace_back(std::make_unique<Bar>(&output, config));
+        Glib::RefPtr<Gdk::Screen> screen = client->bars.back()->window.get_screen();
+        client->style_context_->add_provider_for_screen(
+            screen, client->css_provider_, GTK_STYLE_PROVIDER_PRIORITY_USER);
+      }
+    }
+  } catch (const std::exception &e) {
+    std::cerr << e.what() << std::endl;
+  }
+}
+
+void waybar::Client::handleMonitorAdded(Glib::RefPtr<Gdk::Monitor> monitor) {
+  auto &output = outputs_.emplace_back();
+  output.monitor = monitor;
+  handleOutput(output);
+}
+
+void waybar::Client::handleMonitorRemoved(Glib::RefPtr<Gdk::Monitor> monitor) {
+  spdlog::debug("Output removed: {} {}", monitor->get_manufacturer(), monitor->get_model());
+  for (auto it = bars.begin(); it != bars.end();) {
+    if ((*it)->output->monitor == monitor) {
+      auto output_name = (*it)->output->name;
+      (*it)->window.hide();
+      gtk_app->remove_window((*it)->window);
+      it = bars.erase(it);
+      spdlog::info("Bar removed from output: {}", output_name);
+    } else {
+      ++it;
+    }
+  }
+  outputs_.remove_if([&monitor](const auto &output) { return output.monitor == monitor; });
+}
+
+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",
+                                          SYSCONFDIR "/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",
+                                      SYSCONFDIR "/xdg/waybar/style.css",
+                                      "./resources/style.css",
+                                  })
+                                : style;
   if (css_file.empty() || config_file.empty()) {
     throw std::runtime_error("Missing required resources files");
   }
-  std::cout << "Resources files: " + config_file + ", " + css_file << std::endl;
+  spdlog::info("Resources files: {}, {}", config_file, css_file);
+  return {config_file, css_file};
 }
 
-void waybar::Client::bindInterfaces()
-{
+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");
+  }
+  std::string      str((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
+  util::JsonParser parser;
+  config_ = parser.parse(str);
+}
+
+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)) {
+    throw std::runtime_error("Can't open style file");
+  }
+}
+
+void waybar::Client::bindInterfaces() {
   registry = wl_display_get_registry(wl_display);
   static const struct wl_registry_listener registry_listener = {
-    .global = handleGlobal,
-    .global_remove = handleGlobalRemove,
+      .global = handleGlobal,
+      .global_remove = handleGlobalRemove,
   };
   wl_registry_add_listener(registry, &registry_listener, this);
   wl_display_roundtrip(wl_display);
-  if (!layer_shell || !seat || !xdg_output_manager) {
+  if (layer_shell == nullptr || xdg_output_manager == nullptr) {
     throw std::runtime_error("Failed to acquire required resources.");
   }
-  wl_display_roundtrip(wl_display);
+  // add existing outputs and subscribe to updates
+  for (auto i = 0; i < gdk_display->get_n_monitors(); ++i) {
+    auto monitor = gdk_display->get_monitor(i);
+    handleMonitorAdded(monitor);
+  }
+  gdk_display->signal_monitor_added().connect(sigc::mem_fun(*this, &Client::handleMonitorAdded));
+  gdk_display->signal_monitor_removed().connect(
+      sigc::mem_fun(*this, &Client::handleMonitorRemoved));
 }
 
-int waybar::Client::main(int argc, char* argv[])
-{
-  bool show_help = false;
-  bool show_version = false;
+int waybar::Client::main(int argc, char *argv[]) {
+  bool        show_help = false;
+  bool        show_version = false;
   std::string config;
   std::string style;
   std::string bar_id;
-  auto cli = clara::detail::Help(show_help)
-    | clara::detail::Opt(show_version)["-v"]["--version"]("Show version")
-    | clara::detail::Opt(config, "config")["-c"]["--config"]("Config path")
-    | clara::detail::Opt(style, "style")["-s"]["--style"]("Style path")
-    | clara::detail::Opt(bar_id, "id")["-b"]["--bar"]("Bar id");
+  std::string log_level;
+  auto        cli = clara::detail::Help(show_help) |
+             clara::detail::Opt(show_version)["-v"]["--version"]("Show version") |
+             clara::detail::Opt(config, "config")["-c"]["--config"]("Config path") |
+             clara::detail::Opt(style, "style")["-s"]["--style"]("Style path") |
+             clara::detail::Opt(
+                 log_level,
+                 "trace|debug|info|warning|error|critical|off")["-l"]["--log-level"]("Log level") |
+             clara::detail::Opt(bar_id, "id")["-b"]["--bar"]("Bar id");
   auto res = cli.parse(clara::detail::Args(argc, argv));
   if (!res) {
-    std::cerr << "Error in command line: " << res.errorMessage() << std::endl;
+    spdlog::error("Error in command line: {}", res.errorMessage());
     return 1;
   }
   if (show_help) {
@@ -138,15 +250,29 @@ int waybar::Client::main(int argc, char* argv[])
     std::cout << "Waybar v" << VERSION << std::endl;
     return 0;
   }
-  setupConfigs(config, style);
+  if (!log_level.empty()) {
+    spdlog::set_level(spdlog::level::from_str(log_level));
+  }
+  gtk_app = Gtk::Application::create(argc, argv, "fr.arouillard.waybar", Gio::APPLICATION_HANDLES_COMMAND_LINE);
+  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_main.run();
+  gtk_app->hold();
+  gtk_app->run();
   bars.clear();
   zxdg_output_manager_v1_destroy(xdg_output_manager);
   zwlr_layer_shell_v1_destroy(layer_shell);
   zwp_idle_inhibit_manager_v1_destroy(idle_inhibit_manager);
   wl_registry_destroy(registry);
-  wl_seat_destroy(seat);
   wl_display_disconnect(wl_display);
   return 0;
 }

src/factory.cpp

@@ -1,21 +1,20 @@
 #include "factory.hpp"
 
-waybar::Factory::Factory(const Bar& bar, const Json::Value& config)
-  : bar_(bar), config_(config)
-{}
+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 hash_pos = name.find('#');
     auto ref = name.substr(0, hash_pos);
     auto id = hash_pos != std::string::npos ? name.substr(hash_pos + 1) : "";
+#if defined(__linux__) && !defined(NO_FILESYSTEM)
     if (ref == "battery") {
       return new waybar::modules::Battery(id, config_[name]);
     }
-    #ifdef HAVE_SWAY
+#endif
+#ifdef HAVE_SWAY
     if (ref == "sway/mode") {
-      return new waybar::modules::sway::Mode(id, bar_, config_[name]);
+      return new waybar::modules::sway::Mode(id, config_[name]);
     }
     if (ref == "sway/workspaces") {
       return new waybar::modules::sway::Workspaces(id, bar_, config_[name]);
@@ -23,44 +22,73 @@ waybar::IModule* waybar::Factory::makeModule(const std::string &name) const
     if (ref == "sway/window") {
       return new waybar::modules::sway::Window(id, bar_, config_[name]);
     }
-    #endif
+#endif
+#ifdef HAVE_WLR
+    if (ref == "wlr/taskbar") {
+      return new waybar::modules::wlr::Taskbar(id, bar_, config_[name]);
+    }
+#endif
+#ifdef HAVE_RIVER
+    if (ref == "river/tags") {
+      return new waybar::modules::river::Tags(id, bar_, config_[name]);
+    }
+#endif
     if (ref == "idle_inhibitor") {
       return new waybar::modules::IdleInhibitor(id, bar_, config_[name]);
     }
+#if defined(HAVE_MEMORY_LINUX) || defined(HAVE_MEMORY_BSD)
     if (ref == "memory") {
       return new waybar::modules::Memory(id, config_[name]);
     }
+#endif
+#if defined(HAVE_CPU_LINUX) || defined(HAVE_CPU_BSD)
     if (ref == "cpu") {
       return new waybar::modules::Cpu(id, config_[name]);
     }
+#endif
     if (ref == "clock") {
       return new waybar::modules::Clock(id, config_[name]);
     }
-    #ifdef HAVE_DBUSMENU
-    if (ref == "tray") {
-      return new waybar::modules::SNI::Tray(id, config_[name]);
+    if (ref == "disk") {
+      return new waybar::modules::Disk(id, config_[name]);
     }
-    #endif
-    #ifdef HAVE_LIBNL
+#ifdef HAVE_DBUSMENU
+    if (ref == "tray") {
+      return new waybar::modules::SNI::Tray(id, bar_, config_[name]);
+    }
+#endif
+#ifdef HAVE_LIBNL
     if (ref == "network") {
       return new waybar::modules::Network(id, config_[name]);
     }
-    #endif
-    #ifdef HAVE_LIBUDEV
+#endif
+#ifdef HAVE_LIBUDEV
     if (ref == "backlight") {
       return new waybar::modules::Backlight(id, config_[name]);
     }
-    #endif
-    #ifdef HAVE_LIBPULSE
+#endif
+#ifdef HAVE_LIBPULSE
     if (ref == "pulseaudio") {
       return new waybar::modules::Pulseaudio(id, config_[name]);
     }
-    #endif
+#endif
+#ifdef HAVE_LIBMPDCLIENT
+    if (ref == "mpd") {
+      return new waybar::modules::MPD(id, config_[name]);
+    }
+#endif
     if (ref == "temperature") {
       return new waybar::modules::Temperature(id, config_[name]);
     }
+#if defined(__linux__)
+#  ifdef WANT_RFKILL
+    if (ref == "bluetooth") {
+      return new waybar::modules::Bluetooth(id, config_[name]);
+    }
+#  endif
+#endif
     if (ref.compare(0, 7, "custom/") == 0 && ref.size() > 7) {
-      return new waybar::modules::Custom(ref.substr(7), 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());

src/main.cpp

@@ -1,38 +1,98 @@
-#include "client.hpp"
 #include <csignal>
-#include <iostream>
+#include <list>
+#include <mutex>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <spdlog/spdlog.h>
+#include "client.hpp"
 
-namespace waybar {
+std::mutex reap_mtx;
+std::list<pid_t> reap;
 
-static Client* client;
+void* signalThread(void* args) {
+  int err, signum;
+  sigset_t mask;
+  sigemptyset(&mask);
+  sigaddset(&mask, SIGCHLD);
 
-} // namespace waybar
+  while (true) {
+    err = sigwait(&mask, &signum);
+    if (err != 0) {
+      spdlog::error("sigwait failed: {}", strerror(errno));
+      continue;
+    }
 
-int main(int argc, char* argv[])
-{
+    switch (signum) {
+      case SIGCHLD:
+        spdlog::debug("Received SIGCHLD in signalThread");
+        if (!reap.empty()) {
+          reap_mtx.lock();
+          for (auto it = reap.begin(); it != reap.end(); ++it) {
+            if (waitpid(*it, nullptr, WNOHANG) == *it) {
+              spdlog::debug("Reaped child with PID: {}", *it);
+              it = reap.erase(it);
+            }
+          }
+          reap_mtx.unlock();
+        }
+        break;
+      default:
+        spdlog::debug("Received signal with number {}, but not handling",
+                      signum);
+        break;
+    }
+  }
+}
+
+void startSignalThread(void) {
+  int err;
+  sigset_t mask;
+  sigemptyset(&mask);
+  sigaddset(&mask, SIGCHLD);
+
+  // Block SIGCHLD so it can be handled by the signal thread
+  // Any threads created by this one (the main thread) should not
+  // modify their signal mask to unblock SIGCHLD
+  err = pthread_sigmask(SIG_BLOCK, &mask, nullptr);
+  if (err != 0) {
+    spdlog::error("pthread_sigmask failed in startSignalThread: {}", strerror(err));
+    exit(1);
+  }
+
+  pthread_t thread_id;
+  err = pthread_create(&thread_id, nullptr, signalThread, nullptr);
+  if (err != 0) {
+    spdlog::error("pthread_create failed in startSignalThread: {}", strerror(err));
+    exit(1);
+  }
+}
+
+int main(int argc, char* argv[]) {
   try {
-    waybar::Client c(argc, argv);
-    waybar::client = &c;
-    std::signal(SIGUSR1, [] (int /*signal*/) {
-      for (auto& bar : waybar::client->bars) {
+    auto client = waybar::Client::inst();
+    std::signal(SIGUSR1, [](int /*signal*/) {
+      for (auto& bar : waybar::Client::inst()->bars) {
         bar->toggle();
       }
     });
 
     for (int sig = SIGRTMIN + 1; sig <= SIGRTMAX; ++sig) {
-      std::signal(sig, [] (int sig/*signal*/) {
-        for (auto& bar : waybar::client->bars) {
+      std::signal(sig, [](int sig) {
+        for (auto& bar : waybar::Client::inst()->bars) {
           bar->handleSignal(sig);
         }
       });
     }
+    startSignalThread();
 
-    return c.main(argc, argv);
+    auto ret = client->main(argc, argv);
+    delete client;
+    return ret;
   } catch (const std::exception& e) {
-    std::cerr << e.what() << std::endl;
+    spdlog::error("{}", e.what());
     return 1;
   } catch (const Glib::Exception& e) {
-    std::cerr << e.what().c_str() << std::endl;
+    spdlog::error("{}", static_cast<std::string>(e.what()));
     return 1;
   }
 }

src/modules/backlight.cpp

@@ -1,19 +1,17 @@
 #include "modules/backlight.hpp"
 
+#include <fmt/format.h>
+#include <libudev.h>
+#include <sys/epoll.h>
+#include <unistd.h>
+
 #include <algorithm>
 #include <chrono>
 #include <memory>
 
-#include <libudev.h>
-
-#include <sys/epoll.h>
-#include <unistd.h>
-
-#include <fmt/format.h>
-
 namespace {
 class FileDescriptor {
-public:
+ public:
   explicit FileDescriptor(int fd) : fd_(fd) {}
   FileDescriptor(const FileDescriptor &other) = delete;
   FileDescriptor(FileDescriptor &&other) noexcept = delete;
@@ -28,7 +26,7 @@ public:
   }
   int get() const { return fd_; }
 
-private:
+ private:
   int fd_;
 };
 
@@ -60,9 +58,7 @@ void check_neq(int rc, int bad_rc, const char *message = "neq, rc was: ") {
   }
 }
 
-void check0(int rc, const char *message = "rc wasn't 0") {
-  check_eq(rc, 0, message);
-}
+void check0(int rc, const char *message = "rc wasn't 0") { check_eq(rc, 0, message); }
 
 void check_gte(int rc, int gte, const char *message = "rc was: ") {
   if (rc < gte) {
@@ -75,41 +71,30 @@ void check_nn(const void *ptr, const char *message = "ptr was null") {
     throw std::runtime_error(message);
   }
 }
-} // namespace
+}  // namespace
 
-waybar::modules::Backlight::BacklightDev::BacklightDev(std::string name,
-                                                       int actual, int max)
+waybar::modules::Backlight::BacklightDev::BacklightDev(std::string name, int actual, int max)
     : name_(std::move(name)), actual_(actual), max_(max) {}
 
-std::string_view waybar::modules::Backlight::BacklightDev::name() const {
-  return name_;
-}
+std::string_view waybar::modules::Backlight::BacklightDev::name() const { return name_; }
 
-int waybar::modules::Backlight::BacklightDev::get_actual() const {
-  return actual_;
-}
+int waybar::modules::Backlight::BacklightDev::get_actual() const { return actual_; }
 
-void waybar::modules::Backlight::BacklightDev::set_actual(int actual) {
-  actual_ = actual;
-}
+void waybar::modules::Backlight::BacklightDev::set_actual(int actual) { actual_ = actual; }
 
 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),
-      preferred_device_(
-          config["device"].isString() ? config["device"].asString() : "") {
-  label_.set_name("backlight");
-
+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() : "") {
   // Get initial state
   {
     std::unique_ptr<udev, UdevDeleter> udev_check{udev_new()};
     check_nn(udev_check.get(), "Udev check new failed");
-    enumerate_devices(devices_.begin(), devices_.end(),
-                      std::back_inserter(devices_), udev_check.get());
+    enumerate_devices(
+        devices_.begin(), devices_.end(), std::back_inserter(devices_), udev_check.get());
     if (devices_.empty()) {
       throw std::runtime_error("No backlight found");
     }
@@ -123,28 +108,26 @@ waybar::modules::Backlight::Backlight(const std::string &name,
     std::unique_ptr<udev_monitor, UdevMonitorDeleter> mon{
         udev_monitor_new_from_netlink(udev.get(), "udev")};
     check_nn(mon.get(), "udev monitor new failed");
-    check_gte(udev_monitor_filter_add_match_subsystem_devtype(
-                  mon.get(), "backlight", nullptr),
-              0, "udev failed to add monitor filter: ");
+    check_gte(udev_monitor_filter_add_match_subsystem_devtype(mon.get(), "backlight", nullptr),
+              0,
+              "udev failed to add monitor filter: ");
     udev_monitor_enable_receiving(mon.get());
 
     auto udev_fd = udev_monitor_get_fd(mon.get());
 
-    auto epoll_fd = FileDescriptor{epoll_create1(0)};
+    auto epoll_fd = FileDescriptor{epoll_create1(EPOLL_CLOEXEC)};
     check_neq(epoll_fd.get(), -1, "epoll init failed: ");
-    epoll_event ctl_event;
+    epoll_event ctl_event{};
     ctl_event.events = EPOLLIN;
     ctl_event.data.fd = udev_fd;
 
-    check0(
-        epoll_ctl(epoll_fd.get(), EPOLL_CTL_ADD, ctl_event.data.fd, &ctl_event),
-        "epoll_ctl failed: {}");
+    check0(epoll_ctl(epoll_fd.get(), EPOLL_CTL_ADD, ctl_event.data.fd, &ctl_event),
+           "epoll_ctl failed: {}");
     epoll_event events[EPOLL_MAX_EVENTS];
 
     while (udev_thread_.isRunning()) {
-      const int event_count =
-          epoll_wait(epoll_fd.get(), events, EPOLL_MAX_EVENTS,
-                     std::chrono::milliseconds{interval_}.count());
+      const int event_count = epoll_wait(
+          epoll_fd.get(), events, EPOLL_MAX_EVENTS, std::chrono::milliseconds{interval_}.count());
       if (!udev_thread_.isRunning()) {
         break;
       }
@@ -156,17 +139,14 @@ waybar::modules::Backlight::Backlight(const std::string &name,
       for (int i = 0; i < event_count; ++i) {
         const auto &event = events[i];
         check_eq(event.data.fd, udev_fd, "unexpected udev fd");
-        std::unique_ptr<udev_device, UdevDeviceDeleter> dev{
-            udev_monitor_receive_device(mon.get())};
+        std::unique_ptr<udev_device, UdevDeviceDeleter> dev{udev_monitor_receive_device(mon.get())};
         check_nn(dev.get(), "epoll dev was null");
-        upsert_device(devices.begin(), devices.end(),
-                      std::back_inserter(devices), dev.get());
+        upsert_device(devices.begin(), devices.end(), std::back_inserter(devices), dev.get());
       }
 
       // Refresh state if timed out
       if (event_count == 0) {
-        enumerate_devices(devices.begin(), devices.end(),
-                          std::back_inserter(devices), udev.get());
+        enumerate_devices(devices.begin(), devices.end(), std::back_inserter(devices), udev.get());
       }
       {
         std::scoped_lock<std::mutex> lock(udev_thread_mutex_);
@@ -186,19 +166,17 @@ auto waybar::modules::Backlight::update() -> void {
     devices = devices_;
   }
 
-  const auto best =
-      best_device(devices.cbegin(), devices.cend(), preferred_device_);
+  const auto best = best_device(devices.cbegin(), devices.cend(), preferred_device_);
   if (best != nullptr) {
     if (previous_best_.has_value() && previous_best_.value() == *best &&
         !previous_format_.empty() && previous_format_ == format_) {
       return;
     }
 
-    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))));
+    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);
   } else {
     if (!previous_best_.has_value()) {
       return;
@@ -207,36 +185,35 @@ auto waybar::modules::Backlight::update() -> void {
   }
   previous_best_ = best == nullptr ? std::nullopt : std::optional{*best};
   previous_format_ = format_;
+  // Call parent update
+  ALabel::update();
 }
 
 template <class ForwardIt>
-const waybar::modules::Backlight::BacklightDev *
-waybar::modules::Backlight::best_device(ForwardIt first, ForwardIt last,
-                                        std::string_view preferred_device) {
-  const auto found =
-      std::find_if(first, last, [preferred_device](const auto &dev) {
-        return dev.name() == preferred_device;
-      });
+const waybar::modules::Backlight::BacklightDev *waybar::modules::Backlight::best_device(
+    ForwardIt first, ForwardIt last, std::string_view preferred_device) {
+  const auto found = std::find_if(
+      first, last, [preferred_device](const auto &dev) { return dev.name() == preferred_device; });
   if (found != last) {
     return &(*found);
   }
 
-  const auto max =
-      std::max_element(first, last, [](const auto &l, const auto &r) {
-        return l.get_max() < r.get_max();
-      });
+  const auto max = std::max_element(
+      first, last, [](const auto &l, const auto &r) { return l.get_max() < r.get_max(); });
 
   return max == last ? nullptr : &(*max);
 }
 
 template <class ForwardIt, class Inserter>
-void waybar::modules::Backlight::upsert_device(ForwardIt first, ForwardIt last,
-                                               Inserter inserter,
+void waybar::modules::Backlight::upsert_device(ForwardIt first, ForwardIt last, Inserter inserter,
                                                udev_device *dev) {
   const char *name = udev_device_get_sysname(dev);
   check_nn(name);
 
-  const char *actual = udev_device_get_sysattr_value(dev, "actual_brightness");
+  const char *actual_brightness_attr =
+      strncmp(name, "amdgpu_bl", 9) == 0 ? "brightness" : "actual_brightness";
+
+  const char *actual = udev_device_get_sysattr_value(dev, actual_brightness_attr);
   check_nn(actual);
   const int actual_int = std::stoi(actual);
 
@@ -244,9 +221,8 @@ void waybar::modules::Backlight::upsert_device(ForwardIt first, ForwardIt last,
   check_nn(max);
   const int max_int = std::stoi(max);
 
-  auto found = std::find_if(first, last, [name](const auto &device) {
-    return device.name() == name;
-  });
+  auto found =
+      std::find_if(first, last, [name](const auto &device) { return device.name() == name; });
   if (found != last) {
     found->set_actual(actual_int);
     found->set_max(max_int);
@@ -257,21 +233,16 @@ void waybar::modules::Backlight::upsert_device(ForwardIt first, ForwardIt last,
 }
 
 template <class ForwardIt, class Inserter>
-void waybar::modules::Backlight::enumerate_devices(ForwardIt first,
-                                                   ForwardIt last,
-                                                   Inserter inserter,
-                                                   udev *udev) {
-  std::unique_ptr<udev_enumerate, UdevEnumerateDeleter> enumerate{
-      udev_enumerate_new(udev)};
+void waybar::modules::Backlight::enumerate_devices(ForwardIt first, ForwardIt last,
+                                                   Inserter inserter, udev *udev) {
+  std::unique_ptr<udev_enumerate, UdevEnumerateDeleter> enumerate{udev_enumerate_new(udev)};
   udev_enumerate_add_match_subsystem(enumerate.get(), "backlight");
   udev_enumerate_scan_devices(enumerate.get());
-  udev_list_entry *enum_devices =
-      udev_enumerate_get_list_entry(enumerate.get());
+  udev_list_entry *enum_devices = udev_enumerate_get_list_entry(enumerate.get());
   udev_list_entry *dev_list_entry;
   udev_list_entry_foreach(dev_list_entry, enum_devices) {
-    const char *path = udev_list_entry_get_name(dev_list_entry);
-    std::unique_ptr<udev_device, UdevDeviceDeleter> dev{
-        udev_device_new_from_syspath(udev, path)};
+    const char *                                    path = udev_list_entry_get_name(dev_list_entry);
+    std::unique_ptr<udev_device, UdevDeviceDeleter> dev{udev_device_new_from_syspath(udev, path)};
     check_nn(dev.get(), "dev new failed");
     upsert_device(first, last, inserter, dev.get());
   }

src/modules/battery.cpp

@@ -1,12 +1,9 @@
 #include "modules/battery.hpp"
 
+#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) {
@@ -21,23 +18,21 @@ waybar::modules::Battery::Battery(const std::string& id, const Json::Value& conf
   worker();
 }
 
-waybar::modules::Battery::~Battery()
-{
+waybar::modules::Battery::~Battery() {
   for (auto wd : wds_) {
     inotify_rm_watch(fd_, wd);
   }
   close(fd_);
 }
 
-void waybar::modules::Battery::worker()
-{
+void waybar::modules::Battery::worker() {
   thread_timer_ = [this] {
     dp.emit();
     thread_timer_.sleep_for(interval_);
   };
   thread_ = [this] {
     struct inotify_event event = {0};
-    int nbytes = read(fd_, &event, sizeof(event));
+    int                  nbytes = read(fd_, &event, sizeof(event));
     if (nbytes != sizeof(event) || event.mask & IN_IGNORED) {
       thread_.stop();
       return;
@@ -48,27 +43,31 @@ void waybar::modules::Battery::worker()
   };
 }
 
-void waybar::modules::Battery::getBatteries()
-{
+void waybar::modules::Battery::getBatteries() {
   try {
-    for (auto const& node : fs::directory_iterator(data_dir_)) {
+    for (auto& node : fs::directory_iterator(data_dir_)) {
       if (!fs::is_directory(node)) {
         continue;
       }
       auto dir_name = node.path().filename();
       auto bat_defined = config_["bat"].isString();
-      if (((bat_defined && dir_name == config_["bat"].asString())
-        || !bat_defined) && fs::exists(node / "capacity")
-        && fs::exists(node / "uevent") && fs::exists(node / "status")) {
-          batteries_.push_back(node);
+      if (((bat_defined && dir_name == config_["bat"].asString()) || !bat_defined) &&
+          fs::exists(node.path() / "capacity") && fs::exists(node.path() / "uevent") &&
+          fs::exists(node.path() / "status") && fs::exists(node.path() / "type")) {
+            std::string type;
+            std::ifstream(node.path() / "type") >> type;
+
+            if (!type.compare("Battery")){
+              batteries_.push_back(node.path());
+            }
       }
       auto adap_defined = config_["adapter"].isString();
-      if (((adap_defined && dir_name == config_["adapter"].asString())
-        || !adap_defined) && fs::exists(node / "online")) {
-          adapter_ = node;
+      if (((adap_defined && dir_name == config_["adapter"].asString()) || !adap_defined) &&
+          fs::exists(node.path() / "online")) {
+        adapter_ = node.path();
       }
     }
-  } catch (fs::filesystem_error &e) {
+  } catch (fs::filesystem_error& e) {
     throw std::runtime_error(e.what());
   }
   if (batteries_.empty()) {
@@ -79,82 +78,116 @@ void waybar::modules::Battery::getBatteries()
   }
 }
 
-const std::tuple<uint8_t, std::string> waybar::modules::Battery::getInfos() const
-{
+const std::tuple<uint8_t, float, std::string> waybar::modules::Battery::getInfos() const {
   try {
-    uint16_t total = 0;
+    uint16_t    total = 0;
+    uint32_t    total_power = 0;   // μW
+    uint32_t    total_energy = 0;  // μWh
+    uint32_t    total_energy_full = 0;
     std::string status = "Unknown";
     for (auto const& bat : batteries_) {
-      uint16_t capacity;
+      uint16_t    capacity;
+      uint32_t    power_now;
+      uint32_t    energy_full;
+      uint32_t    energy_now;
       std::string _status;
       std::ifstream(bat / "capacity") >> capacity;
       std::ifstream(bat / "status") >> _status;
+      auto rate_path = fs::exists(bat / "current_now") ? "current_now" : "power_now";
+      std::ifstream(bat / rate_path) >> power_now;
+      auto now_path = fs::exists(bat / "charge_now") ? "charge_now" : "energy_now";
+      std::ifstream(bat / now_path) >> energy_now;
+      auto full_path = fs::exists(bat / "charge_full") ? "charge_full" : "energy_full";
+      std::ifstream(bat / full_path) >> energy_full;
       if (_status != "Unknown") {
         status = _status;
       }
       total += capacity;
+      total_power += power_now;
+      total_energy += energy_now;
+      total_energy_full += energy_full;
+    }
+    if (!adapter_.empty() && status == "Discharging") {
+      bool online;
+      std::ifstream(adapter_ / "online") >> online;
+      if (online) {
+        status = "Plugged";
+      }
+    }
+    float time_remaining = 0;
+    if (status == "Discharging" && total_power != 0) {
+      time_remaining = (float)total_energy / total_power;
+    } else if (status == "Charging" && total_power != 0) {
+      time_remaining = -(float)(total_energy_full - total_energy) / total_power;
     }
     uint16_t capacity = total / batteries_.size();
-    return {capacity, status};
+    // Handle full-at
+    if (config_["full-at"].isUInt()) {
+      auto full_at = config_["full-at"].asUInt();
+      if (full_at < 100) {
+        capacity = 100.f * capacity / full_at;
+        if (capacity > full_at) {
+          capacity = full_at;
+        }
+      }
+    }
+    return {capacity, time_remaining, status};
   } catch (const std::exception& e) {
-    std::cerr << e.what() << std::endl;
-    return {0, "Unknown"};
+    spdlog::error("Battery: {}", e.what());
+    return {0, 0, "Unknown"};
   }
 }
 
-const std::string waybar::modules::Battery::getAdapterStatus(uint8_t capacity) const
-{
+const std::string waybar::modules::Battery::getAdapterStatus(uint8_t capacity) const {
   if (!adapter_.empty()) {
     bool online;
     std::ifstream(adapter_ / "online") >> online;
     if (capacity == 100) {
       return "Full";
     }
-    return online ? "Charging" : "Discharging";
+    if (online) {
+      return "Plugged";
+    }
+    return "Discharging";
   }
   return "Unknown";
 }
 
-const std::string waybar::modules::Battery::getState(uint8_t capacity) const
-{
-  // Get current state
-  std::vector<std::pair<std::string, uint8_t>> states;
-  if (config_["states"].isObject()) {
-    for (auto it = config_["states"].begin(); it != config_["states"].end(); ++it) {
-      if (it->isUInt() && it.key().isString()) {
-        states.push_back({it.key().asString(), it->asUInt()});
-      }
-    }
+const std::string waybar::modules::Battery::formatTimeRemaining(float hoursRemaining) {
+  hoursRemaining = std::fabs(hoursRemaining);
+  uint16_t full_hours = static_cast<uint16_t>(hoursRemaining);
+  uint16_t minutes = static_cast<uint16_t>(60 * (hoursRemaining - full_hours));
+  auto     format = std::string("{H} h {M} min");
+  if (config_["format-time"].isString()) {
+    format = config_["format-time"].asString();
   }
-  // Sort states
-  std::sort(states.begin(), states.end(), [](auto &a, auto &b) {
-    return a.second < b.second;
-  });
-  std::string valid_state;
-  for (auto const& state : states) {
-    if (capacity <= state.second && valid_state.empty()) {
-      label_.get_style_context()->add_class(state.first);
-      valid_state = state.first;
-    } else {
-      label_.get_style_context()->remove_class(state.first);
-    }
-  }
-  return valid_state;
+  return fmt::format(format, fmt::arg("H", full_hours), fmt::arg("M", minutes));
 }
 
-auto waybar::modules::Battery::update() -> void
-{
-  auto [capacity, status] = getInfos();
+auto waybar::modules::Battery::update() -> void {
+  auto [capacity, time_remaining, status] = getInfos();
   if (status == "Unknown") {
     status = getAdapterStatus(capacity);
   }
   if (tooltipEnabled()) {
-    label_.set_tooltip_text(status);
+    std::string tooltip_text;
+    if (time_remaining != 0) {
+      std::string time_to = std::string("Time to ") + ((time_remaining > 0) ? "empty" : "full");
+      tooltip_text = time_to + ": " + formatTimeRemaining(time_remaining);
+    } else {
+      tooltip_text = status;
+    }
+    label_.set_tooltip_text(tooltip_text);
   }
-  std::transform(status.begin(), status.end(), status.begin(), ::tolower);
+  // Transform to lowercase  and replace space with dash
+  std::transform(status.begin(), status.end(), status.begin(), [](char ch) {
+    return ch == ' ' ? '-' : std::tolower(ch);
+  });
   auto format = format_;
-  auto state = getState(capacity);
-  label_.get_style_context()->remove_class(old_status_);
+  auto state = getState(capacity, true);
+  if (!old_status_.empty()) {
+    label_.get_style_context()->remove_class(old_status_);
+  }
   label_.get_style_context()->add_class(status);
   old_status_ = status;
   if (!state.empty() && config_["format-" + status + "-" + state].isString()) {
@@ -168,7 +201,12 @@ auto waybar::modules::Battery::update() -> void
     event_box_.hide();
   } else {
     event_box_.show();
-    label_.set_markup(fmt::format(format, fmt::arg("capacity", capacity),
-      fmt::arg("icon", getIcon(capacity))));
+    auto icons = std::vector<std::string>{status + "-" + state, status, state};
+    label_.set_markup(fmt::format(format,
+                                  fmt::arg("capacity", capacity),
+                                  fmt::arg("icon", getIcon(capacity, icons)),
+                                  fmt::arg("time", formatTimeRemaining(time_remaining))));
   }
+  // Call parent update
+  ALabel::update();
 }

src/modules/bluetooth.cpp

@@ -0,0 +1,45 @@
+#include "modules/bluetooth.hpp"
+#include "util/rfkill.hpp"
+#include <linux/rfkill.h>
+#include <time.h>
+
+waybar::modules::Bluetooth::Bluetooth(const std::string& id, const Json::Value& config)
+    : ALabel(config, "bluetooth", id, "{icon}", 10),
+      status_("disabled"),
+      rfkill_{RFKILL_TYPE_BLUETOOTH} {
+  thread_ = [this] {
+    dp.emit();
+    rfkill_.waitForEvent();
+  };
+  intervall_thread_ = [this] {
+    auto now = std::chrono::system_clock::now();
+    auto timeout = std::chrono::floor<std::chrono::seconds>(now + interval_);
+    auto diff = std::chrono::seconds(timeout.time_since_epoch().count() % interval_.count());
+    thread_.sleep_until(timeout - diff);
+    dp.emit();
+  };
+}
+
+auto waybar::modules::Bluetooth::update() -> void {
+  if (rfkill_.getState()) {
+    status_ = "disabled";
+  } else {
+    status_ = "enabled";
+  }
+
+  label_.set_markup(
+      fmt::format(
+        format_,
+        fmt::arg("status", status_),
+        fmt::arg("icon", getIcon(0, status_))));
+
+  if (tooltipEnabled()) {
+    if (config_["tooltip-format"].isString()) {
+      auto tooltip_format = config_["tooltip-format"].asString();
+      auto tooltip_text = fmt::format(tooltip_format, status_);
+      label_.set_tooltip_text(tooltip_text);
+    } else {
+      label_.set_tooltip_text(status_);
+    }
+  }
+}

src/modules/clock.cpp

@@ -1,37 +1,200 @@
 #include "modules/clock.hpp"
 
+#include <time.h>
+#include <spdlog/spdlog.h>
+
+#include <sstream>
+#include <type_traits>
+#ifdef HAVE_LANGINFO_1STDAY
+#include <langinfo.h>
+#include <locale.h>
+#endif
+
+using waybar::modules::waybar_time;
+
 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, false, false, true), fixed_time_zone_(false) {
+  if (config_["timezone"].isString()) {
+    spdlog::warn("As using a timezone, some format args may be missing as the date library havn't got a release since 2018.");
+    time_zone_ = date::locate_zone(config_["timezone"].asString());
+    fixed_time_zone_ = true;
   }
+
+  if (config_["locale"].isString()) {
+    locale_ = std::locale(config_["locale"].asString());
+  } else {
+    locale_ = std::locale("");
+  }
+
   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();
-    if (sub_m > 0) thread_.sleep_until(timeout - std::chrono::seconds(sub_m - 1));
-    else 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);
   };
 }
 
-auto waybar::modules::Clock::update() -> void
-{
-  auto localtime = fmt::localtime(std::time(nullptr));
-  auto text = fmt::format(format_, localtime);
-  label_.set_markup(text);
-  
+auto waybar::modules::Clock::update() -> void {
+  if (!fixed_time_zone_) {
+    // Time zone can change. Be sure to pick that.
+    time_zone_ = date::current_zone();
+  }
+
+  auto        now = std::chrono::system_clock::now();
+  waybar_time wtime = {locale_,
+                       date::make_zoned(time_zone_, date::floor<std::chrono::seconds>(now))};
+
+  std::string text;
+  if (!fixed_time_zone_) {
+    // As date dep is not fully compatible, prefer fmt
+    tzset();
+    auto localtime = fmt::localtime(std::chrono::system_clock::to_time_t(now));
+    text = fmt::format(format_, localtime);
+    label_.set_markup(text);
+  } else {
+    text = fmt::format(format_, wtime);
+    label_.set_markup(text);
+  }
+
   if (tooltipEnabled()) {
     if (config_["tooltip-format"].isString()) {
-      auto tooltip_format = config_["tooltip-format"].asString();
-      auto tooltip_text = fmt::format(tooltip_format, localtime);
-      label_.set_tooltip_text(tooltip_text);
+      const auto calendar = calendar_text(wtime);
+      auto       tooltip_format = config_["tooltip-format"].asString();
+      auto       tooltip_text = fmt::format(tooltip_format, wtime, fmt::arg("calendar", calendar));
+      label_.set_tooltip_markup(tooltip_text);
     } else {
-      label_.set_tooltip_text(text);
+      label_.set_tooltip_markup(text);
     }
   }
+  // Call parent update
+  ALabel::update();
 }
+
+bool waybar::modules::Clock::handleScroll(GdkEventScroll *e) {
+  // defer to user commands if set
+  if (config_["on-scroll-up"].isString() || config_["on-scroll-down"].isString()) {
+    return AModule::handleScroll(e);
+  }
+
+  auto dir = AModule::getScrollDir(e);
+  if (dir != SCROLL_DIR::UP && dir != SCROLL_DIR::DOWN) {
+    return true;
+  }
+  if (!config_["timezones"].isArray() || config_["timezones"].empty()) {
+    return true;
+  }
+  auto nr_zones = config_["timezones"].size();
+  int new_idx = time_zone_idx_ + ((dir == SCROLL_DIR::UP) ? 1 : -1);
+  if (new_idx < 0) {
+    time_zone_idx_ = nr_zones - 1;
+  } else if (new_idx >= nr_zones) {
+    time_zone_idx_ = 0;
+  } else {
+    time_zone_idx_ = new_idx;
+  }
+  auto zone_name = config_["timezones"][time_zone_idx_];
+  if (!zone_name.isString() || zone_name.empty()) {
+    fixed_time_zone_ = false;
+  } else {
+    time_zone_ = date::locate_zone(zone_name.asString());
+    fixed_time_zone_ = true;
+  }
+
+  update();
+  return true;
+}
+
+auto waybar::modules::Clock::calendar_text(const waybar_time& wtime) -> std::string {
+  const auto daypoint = date::floor<date::days>(wtime.ztime.get_local_time());
+  const auto ymd = date::year_month_day(daypoint);
+  if (cached_calendar_ymd_ == ymd) {
+    return cached_calendar_text_;
+  }
+
+  const date::year_month ym(ymd.year(), ymd.month());
+  const auto             curr_day = ymd.day();
+
+  std::stringstream os;
+  const auto        first_dow = first_day_of_week();
+  weekdays_header(first_dow, os);
+
+  // First week prefixed with spaces if needed.
+  auto wd = date::weekday(ym / 1);
+  auto empty_days = (wd - first_dow).count();
+  if (empty_days > 0) {
+    os << std::string(empty_days * 3 - 1, ' ');
+  }
+  auto last_day = (ym / date::literals::last).day();
+  for (auto d = date::day(1); d <= last_day; ++d, ++wd) {
+    if (wd != first_dow) {
+      os << ' ';
+    } else if (unsigned(d) != 1) {
+      os << '\n';
+    }
+    if (d == curr_day) {
+      if (config_["today-format"].isString()) {
+        auto today_format = config_["today-format"].asString();
+        os << fmt::format(today_format, date::format("%e", d));
+      } else {
+        os << "<b><u>" << date::format("%e", d) << "</u></b>";
+      }
+    } else {
+      os << date::format("%e", d);
+    }
+  }
+
+  auto result = os.str();
+  cached_calendar_ymd_ = ymd;
+  cached_calendar_text_ = result;
+  return result;
+}
+
+auto waybar::modules::Clock::weekdays_header(const date::weekday& first_dow, std::ostream& os)
+    -> void {
+  auto wd = first_dow;
+  do {
+    if (wd != first_dow) os << ' ';
+    Glib::ustring wd_ustring(date::format(locale_, "%a", wd));
+    auto          wd_len = wd_ustring.length();
+    if (wd_len > 2) {
+      wd_ustring = wd_ustring.substr(0, 2);
+      wd_len = 2;
+    }
+    const std::string pad(2 - wd_len, ' ');
+    os << pad << wd_ustring;
+  } while (++wd != first_dow);
+  os << "\n";
+}
+
+#ifdef HAVE_LANGINFO_1STDAY
+template <auto fn>
+using deleter_from_fn = std::integral_constant<decltype(fn), fn>;
+
+template <typename T, auto fn>
+using deleting_unique_ptr = std::unique_ptr<T, deleter_from_fn<fn>>;
+#endif
+
+// Computations done similarly to Linux cal utility.
+auto waybar::modules::Clock::first_day_of_week() -> date::weekday {
+#ifdef HAVE_LANGINFO_1STDAY
+  deleting_unique_ptr<std::remove_pointer<locale_t>::type, freelocale> posix_locale{
+      newlocale(LC_ALL, locale_.name().c_str(), nullptr)};
+  if (posix_locale) {
+    const int i = (std::intptr_t)nl_langinfo_l(_NL_TIME_WEEK_1STDAY, posix_locale.get());
+    auto      ymd = date::year(i / 10000) / (i / 100 % 100) / (i % 100);
+    auto      wd = date::weekday(ymd);
+    uint8_t   j = *nl_langinfo_l(_NL_TIME_FIRST_WEEKDAY, posix_locale.get());
+    return wd + date::days(j - 1);
+  }
+#endif
+  return date::Sunday;
+}
+
+template <>
+struct fmt::formatter<waybar_time> : fmt::formatter<std::tm> {
+  template <typename FormatContext>
+  auto format(const waybar_time& t, FormatContext& ctx) {
+    return format_to(ctx.out(), "{}", date::format(t.locale, fmt::to_string(tm_format), t.ztime));
+  }
+};

src/modules/cpu.cpp

@@ -1,90 +0,0 @@
-#include "modules/cpu.hpp"
-
-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);
-  }
-  thread_ = [this] {
-    dp.emit();
-    thread_.sleep_for(interval_);
-  };
-}
-
-auto waybar::modules::Cpu::update() -> void
-{
-  // TODO: as creating dynamic fmt::arg arrays is buggy we have to calc both
-  auto cpu_load = getCpuLoad();
-  auto [cpu_usage, tooltip] = getCpuUsage();
-  if (tooltipEnabled()) {
-    label_.set_tooltip_text(tooltip);
-  }
-  label_.set_markup(fmt::format(format_,
-    fmt::arg("load", cpu_load), fmt::arg("usage", cpu_usage)));
-}
-
-uint16_t waybar::modules::Cpu::getCpuLoad()
-{
-  struct sysinfo info = {0};
-  if (sysinfo(&info) == 0) {
-    float f_load = 1.f / (1u << SI_LOAD_SHIFT);
-    uint16_t load = info.loads[0] * f_load * 100 / get_nprocs();
-    return load;
-  }
-  throw std::runtime_error("Can't get Cpu load");
-}
-
-std::tuple<uint16_t, std::string> waybar::modules::Cpu::getCpuUsage()
-{
-  if (prev_times_.empty()) {
-    prev_times_ = parseCpuinfo();
-    std::this_thread::sleep_for(std::chrono::milliseconds(100));
-  }
-  std::vector<std::tuple<size_t, size_t>> curr_times = parseCpuinfo();
-  std::string tooltip;
-  uint16_t usage = 0;
-  for (size_t i = 0; i < curr_times.size(); ++i) {
-    auto [curr_idle, curr_total] = curr_times[i];
-    auto [prev_idle, prev_total] = prev_times_[i];
-    const float delta_idle = curr_idle - prev_idle;
-    const float delta_total = curr_total - prev_total;
-    uint16_t tmp = 100 * (1 - delta_idle / delta_total);
-    if (i == 0) {
-      usage = tmp;
-      tooltip = fmt::format("Total: {}%", tmp);
-    } else {
-      tooltip = tooltip + fmt::format("\nCore{}: {}%", i - 1, tmp);
-    }
-  }
-  prev_times_ = curr_times;
-  return {usage, tooltip};
-}
-
-std::vector<std::tuple<size_t, size_t>> waybar::modules::Cpu::parseCpuinfo()
-{
-  std::ifstream info(data_dir_);
-  if (!info.is_open()) {
-    throw std::runtime_error("Can't open " + data_dir_);
-  }
-  std::vector< std::tuple<size_t, size_t> > cpuinfo;
-  std::string line;
-  while (getline(info, line)) {    
-    if (line.substr(0,3).compare("cpu") != 0) {
-      break;
-    }
-    std::stringstream sline(line.substr(5));
-    std::vector<size_t> times;
-    for (size_t time; sline >> time; times.push_back(time));
-
-    size_t idle_time = 0;
-    size_t total_time = 0;
-    if (times.size() >= 4) {
-      idle_time = times[3];
-      total_time = std::accumulate(times.begin(), times.end(), 0);
-    }
-    cpuinfo.push_back({idle_time, total_time});
-  }
-  return cpuinfo;
-}

src/modules/cpu/bsd.cpp

@@ -0,0 +1,97 @@
+#include "modules/cpu.hpp"
+
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <cstdlib>            // malloc
+#include <unistd.h>           // sysconf
+
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+#  include <sys/sched.h>
+#else
+#  include <sys/resource.h>
+#endif
+
+#if defined(__NetBSD__)
+typedef uint64_t cp_time_t;
+#else
+typedef long cp_time_t;
+#endif
+#if defined(__NetBSD__) || defined(__OpenBSD__)
+typedef uint64_t pcp_time_t;
+#else
+typedef long pcp_time_t;
+#endif
+
+std::vector<std::tuple<size_t, size_t>> waybar::modules::Cpu::parseCpuinfo() {
+  cp_time_t sum_cp_time[CPUSTATES];
+  size_t sum_sz = sizeof(sum_cp_time);
+  int ncpu = sysconf(_SC_NPROCESSORS_CONF);
+  size_t sz = CPUSTATES * (ncpu + 1) * sizeof(pcp_time_t);
+  pcp_time_t *cp_time = static_cast<pcp_time_t *>(malloc(sz)), *pcp_time = cp_time;
+#if defined(__NetBSD__)
+  int mib[] = {
+    CTL_KERN,
+    KERN_CP_TIME,
+  };
+  if (sysctl(mib, sizeof(mib)/sizeof(mib[0]), sum_cp_time, &sum_sz, NULL, 0)) {
+    throw std::runtime_error("sysctl kern.cp_time failed");
+  }
+  for (int state = 0; state < CPUSTATES; state++) {
+    cp_time[state] = sum_cp_time[state];
+  }
+  pcp_time += CPUSTATES;
+  if (sysctl(mib, sizeof(mib)/sizeof(mib[0]), pcp_time, &sz, NULL, 0)) {
+    throw std::runtime_error("sysctl kern.cp_time failed");
+  }
+#elif defined(__OpenBSD__)
+  {
+    int mib[] = {
+      CTL_KERN,
+      KERN_CPTIME,
+    };
+    if (sysctl(mib, sizeof(mib)/sizeof(mib[0]), sum_cp_time, &sum_sz, NULL, 0)) {
+      throw std::runtime_error("sysctl kern.cp_time failed");
+    }
+  }
+  for (int state = 0; state < CPUSTATES; state++) {
+    cp_time[state] = sum_cp_time[state];
+  }
+  pcp_time = cp_time;
+  sz /= ncpu + 1;
+  {
+    int mib[] = {
+      CTL_KERN,
+      KERN_CPTIME2,
+      0,
+    };
+    for (int cpu = 0; cpu < ncpu; cpu++) {
+      mib[2] = cpu;
+      pcp_time += CPUSTATES;
+      if (sysctl(mib, sizeof(mib)/sizeof(mib[0]), pcp_time, &sz, NULL, 0)) {
+        throw std::runtime_error("sysctl kern.cp_time2 failed");
+      }
+    }
+  }
+#else
+  if (sysctlbyname("kern.cp_time", sum_cp_time, &sum_sz, NULL, 0)) {
+    throw std::runtime_error("sysctl kern.cp_time failed");
+  }
+  for (int state = 0; state < CPUSTATES; state++) {
+    cp_time[state] = sum_cp_time[state];
+  }
+  pcp_time += CPUSTATES;
+  if (sysctlbyname("kern.cp_times", pcp_time, &sz, NULL, 0)) {
+    throw std::runtime_error("sysctl kern.cp_times failed");
+  }
+#endif
+  std::vector<std::tuple<size_t, size_t>> cpuinfo;
+  for (int cpu = 0; cpu < ncpu + 1; cpu++) {
+    pcp_time_t total = 0, *single_cp_time = &cp_time[cpu * CPUSTATES];
+    for (int state = 0; state < CPUSTATES; state++) {
+      total += single_cp_time[state];
+    }
+    cpuinfo.emplace_back(single_cp_time[CP_IDLE], total);
+  }
+  free(cp_time);
+  return cpuinfo;
+}

src/modules/cpu/common.cpp

@@ -0,0 +1,55 @@
+#include "modules/cpu.hpp"
+
+waybar::modules::Cpu::Cpu(const std::string& id, const Json::Value& config)
+    : ALabel(config, "cpu", id, "{usage}%", 10) {
+  thread_ = [this] {
+    dp.emit();
+    thread_.sleep_for(interval_);
+  };
+}
+
+auto waybar::modules::Cpu::update() -> void {
+  // TODO: as creating dynamic fmt::arg arrays is buggy we have to calc both
+  auto cpu_load = getCpuLoad();
+  auto [cpu_usage, tooltip] = getCpuUsage();
+  if (tooltipEnabled()) {
+    label_.set_tooltip_text(tooltip);
+  }
+  label_.set_markup(fmt::format(format_, fmt::arg("load", cpu_load), fmt::arg("usage", cpu_usage)));
+  getState(cpu_usage);
+  // Call parent update
+  ALabel::update();
+}
+
+uint16_t waybar::modules::Cpu::getCpuLoad() {
+  double load[1];
+  if (getloadavg(load, 1) != -1) {
+    return load[0] * 100 / sysconf(_SC_NPROCESSORS_ONLN);
+  }
+  throw std::runtime_error("Can't get Cpu load");
+}
+
+std::tuple<uint16_t, std::string> waybar::modules::Cpu::getCpuUsage() {
+  if (prev_times_.empty()) {
+    prev_times_ = parseCpuinfo();
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+  }
+  std::vector<std::tuple<size_t, size_t>> curr_times = parseCpuinfo();
+  std::string                             tooltip;
+  uint16_t                                usage = 0;
+  for (size_t i = 0; i < curr_times.size(); ++i) {
+    auto [curr_idle, curr_total] = curr_times[i];
+    auto [prev_idle, prev_total] = prev_times_[i];
+    const float delta_idle = curr_idle - prev_idle;
+    const float delta_total = curr_total - prev_total;
+    uint16_t    tmp = 100 * (1 - delta_idle / delta_total);
+    if (i == 0) {
+      usage = tmp;
+      tooltip = fmt::format("Total: {}%", tmp);
+    } else {
+      tooltip = tooltip + fmt::format("\nCore{}: {}%", i - 1, tmp);
+    }
+  }
+  prev_times_ = curr_times;
+  return {usage, tooltip};
+}

src/modules/cpu/linux.cpp

@@ -0,0 +1,29 @@
+#include "modules/cpu.hpp"
+
+std::vector<std::tuple<size_t, size_t>> waybar::modules::Cpu::parseCpuinfo() {
+  const std::string data_dir_ = "/proc/stat";
+  std::ifstream info(data_dir_);
+  if (!info.is_open()) {
+    throw std::runtime_error("Can't open " + data_dir_);
+  }
+  std::vector<std::tuple<size_t, size_t>> cpuinfo;
+  std::string                             line;
+  while (getline(info, line)) {
+    if (line.substr(0, 3).compare("cpu") != 0) {
+      break;
+    }
+    std::stringstream   sline(line.substr(5));
+    std::vector<size_t> times;
+    for (size_t time = 0; sline >> time; times.push_back(time))
+      ;
+
+    size_t idle_time = 0;
+    size_t total_time = 0;
+    if (times.size() >= 4) {
+      idle_time = times[3];
+      total_time = std::accumulate(times.begin(), times.end(), 0);
+    }
+    cpuinfo.emplace_back(idle_time, total_time);
+  }
+  return cpuinfo;
+}

src/modules/custom.cpp

@@ -1,93 +1,118 @@
 #include "modules/custom.hpp"
 
-waybar::modules::Custom::Custom(const std::string& name,
-  const Json::Value& config)
-  : ALabel(config, "{}"), name_(name), fp_(nullptr)
-{
-  label_.set_name("custom-" + name_);
-  if (config_["exec"].isString()) {
-    if (interval_.count() > 0) {
-      delayWorker();
-    } else {
-      continuousWorker();
-    }
-  }
+#include <spdlog/spdlog.h>
+
+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) {
   dp.emit();
-}
-
-waybar::modules::Custom::~Custom()
-{
-  if (fp_) {
-    pclose(fp_);
-    fp_ = nullptr;
+  if (interval_.count() > 0) {
+    delayWorker();
+  } else if (config_["exec"].isString()) {
+    continuousWorker();
   }
 }
 
-void waybar::modules::Custom::delayWorker()
-{
+waybar::modules::Custom::~Custom() {
+  if (pid_ != -1) {
+    killpg(pid_, SIGTERM);
+    pid_ = -1;
+  }
+}
+
+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());
-      if (res.exit_code != 0) {
+      output_ = util::command::execNoRead(config_["exec-if"].asString());
+      if (output_.exit_code != 0) {
         can_update = false;
-        event_box_.hide();
+        dp.emit();
       }
     }
     if (can_update) {
-      output_ = waybar::util::command::exec(config_["exec"].asString());
+      if (config_["exec"].isString()) {
+        output_ = util::command::exec(config_["exec"].asString());
+      }
       dp.emit();
     }
     thread_.sleep_for(interval_);
   };
 }
 
-void waybar::modules::Custom::continuousWorker()
-{
+void waybar::modules::Custom::continuousWorker() {
   auto cmd = config_["exec"].asString();
-  fp_ = popen(cmd.c_str(), "r");
+  pid_ = -1;
+  fp_ = util::command::open(cmd, pid_);
   if (!fp_) {
     throw std::runtime_error("Unable to open " + cmd);
   }
-  thread_ = [this] {
-    char* buff = nullptr;
+  thread_ = [this, cmd] {
+    char*  buff = nullptr;
     size_t len = 0;
     if (getline(&buff, &len, fp_) == -1) {
       int exit_code = 1;
       if (fp_) {
-        exit_code = WEXITSTATUS(pclose(fp_));
+        exit_code = WEXITSTATUS(util::command::close(fp_, pid_));
         fp_ = nullptr;
       }
-      thread_.stop();
       if (exit_code != 0) {
-        output_ = { exit_code, "" };
+        output_ = {exit_code, ""};
         dp.emit();
-        std::cerr << name_ + " just stopped unexpectedly, is it endless?" << std::endl;
+        spdlog::error("{} stopped unexpectedly, is it endless?", name_);
       }
-      return;
-    }
-    std::string output = buff;
+      if (config_["restart-interval"].isUInt()) {
+        pid_ = -1;
+        thread_.sleep_for(std::chrono::seconds(config_["restart-interval"].asUInt()));
+        fp_ = util::command::open(cmd, pid_);
+        if (!fp_) {
+          throw std::runtime_error("Unable to open " + cmd);
+        }
+      } else {
+        thread_.stop();
+        return;
+      }
+    } else {
+      std::string output = buff;
 
-    // Remove last newline
-    if (!output.empty() && output[output.length()-1] == '\n') {
-      output.erase(output.length()-1);
+      // Remove last newline
+      if (!output.empty() && output[output.length() - 1] == '\n') {
+        output.erase(output.length() - 1);
+      }
+      output_ = {0, output};
+      dp.emit();
     }
-    output_ = { 0, output };
-    dp.emit();
   };
 }
 
-void waybar::modules::Custom::refresh(int sig /*signal*/)
-{
-  if(sig == SIGRTMIN + config_["signal"].asInt()) {
+void waybar::modules::Custom::refresh(int sig) {
+  if (sig == SIGRTMIN + config_["signal"].asInt()) {
     thread_.wake_up();
   }
 }
 
-auto waybar::modules::Custom::update() -> void
-{
+void waybar::modules::Custom::handleEvent() {
+  if (!config_["exec-on-event"].isBool() || config_["exec-on-event"].asBool()) {
+    thread_.wake_up();
+  }
+}
+
+bool waybar::modules::Custom::handleScroll(GdkEventScroll* e) {
+  auto ret = ALabel::handleScroll(e);
+  handleEvent();
+  return ret;
+}
+
+bool waybar::modules::Custom::handleToggle(GdkEventButton* const& e) {
+  auto ret = ALabel::handleToggle(e);
+  handleEvent();
+  return ret;
+}
+
+auto waybar::modules::Custom::update() -> void {
   // Hide label if output is empty
-  if (config_["exec"].isString() && (output_.out.empty() || output_.exit_code != 0)) {
+  if ((config_["exec"].isString() || config_["exec-if"].isString()) &&
+      (output_.out.empty() || output_.exit_code != 0)) {
     event_box_.hide();
   } else {
     if (config_["return-type"].asString() == "json") {
@@ -95,39 +120,40 @@ auto waybar::modules::Custom::update() -> void
     } else {
       parseOutputRaw();
     }
-
-    auto str = fmt::format(format_, text_,
-      fmt::arg("alt", alt_),
-      fmt::arg("icon", getIcon(percentage_)),
-      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 (class_ != "") {
-      if (prevclass_ != "") {
-        label_.get_style_context()->remove_class(prevclass_);
-      }
-      label_.get_style_context()->add_class(class_);
-      prevclass_ = class_;
+    auto str = fmt::format(format_,
+                           text_,
+                           fmt::arg("alt", alt_),
+                           fmt::arg("icon", getIcon(percentage_, alt_)),
+                           fmt::arg("percentage", percentage_));
+    if (str.empty()) {
+      event_box_.hide();
     } else {
-      label_.get_style_context()->remove_class(prevclass_);
-      prevclass_ = "";
+      label_.set_markup(str);
+      if (tooltipEnabled()) {
+        if (text_ == tooltip_) {
+          label_.set_tooltip_markup(str);
+        } else {
+          label_.set_tooltip_markup(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();
     }
-
-    event_box_.show();
   }
+  // Call parent update
+  ALabel::update();
 }
 
-void waybar::modules::Custom::parseOutputRaw()
-{
+void waybar::modules::Custom::parseOutputRaw() {
   std::istringstream output(output_.out);
-  std::string line;
-  int i = 0;
+  std::string        line;
+  int                i = 0;
   while (getline(output, line)) {
     if (i == 0) {
       if (config_["escape"].isBool() && config_["escape"].asBool()) {
@@ -136,11 +162,11 @@ void waybar::modules::Custom::parseOutputRaw()
         text_ = line;
       }
       tooltip_ = line;
-      class_ = "";
+      class_.clear();
     } else if (i == 1) {
       tooltip_ = line;
     } else if (i == 2) {
-      class_ = line;
+      class_.push_back(line);
     } else {
       break;
     }
@@ -148,10 +174,10 @@ void waybar::modules::Custom::parseOutputRaw()
   }
 }
 
-void waybar::modules::Custom::parseOutputJson()
-{
+void waybar::modules::Custom::parseOutputJson() {
   std::istringstream output(output_.out);
-  std::string line;
+  std::string        line;
+  class_.clear();
   while (getline(output, line)) {
     auto parsed = parser_.parse(line);
     if (config_["escape"].isBool() && config_["escape"].asBool()) {
@@ -165,7 +191,13 @@ void waybar::modules::Custom::parseOutputJson()
       alt_ = parsed["alt"].asString();
     }
     tooltip_ = parsed["tooltip"].asString();
-    class_ = parsed["class"].asString();
+    if (parsed["class"].isString()) {
+      class_.push_back(parsed["class"].asString());
+    } else if (parsed["class"].isArray()) {
+      for (auto const& c : parsed["class"]) {
+        class_.push_back(c.asString());
+      }
+    }
     if (!parsed["percentage"].asString().empty() && parsed["percentage"].isUInt()) {
       percentage_ = parsed["percentage"].asUInt();
     } else {

src/modules/disk.cpp

@@ -0,0 +1,78 @@
+#include "modules/disk.hpp"
+
+using namespace waybar::util;
+
+waybar::modules::Disk::Disk(const std::string& id, const Json::Value& config)
+    : ALabel(config, "disk", id, "{}%", 30)
+    , path_("/")
+{
+  thread_ = [this] {
+    dp.emit();
+    thread_.sleep_for(interval_);
+  };
+  if (config["path"].isString()) {
+    path_ = config["path"].asString();
+  }
+}
+
+auto waybar::modules::Disk::update() -> void {
+  struct statvfs /* {
+      unsigned long  f_bsize;    // filesystem block size
+      unsigned long  f_frsize;   // fragment size
+      fsblkcnt_t     f_blocks;   // size of fs in f_frsize units
+      fsblkcnt_t     f_bfree;    // # free blocks
+      fsblkcnt_t     f_bavail;   // # free blocks for unprivileged users
+      fsfilcnt_t     f_files;    // # inodes
+      fsfilcnt_t     f_ffree;    // # free inodes
+      fsfilcnt_t     f_favail;   // # free inodes for unprivileged users
+      unsigned long  f_fsid;     // filesystem ID
+      unsigned long  f_flag;     // mount flags
+      unsigned long  f_namemax;  // maximum filename length
+  }; */ stats;
+  int err = statvfs(path_.c_str(), &stats);
+
+  /* Conky options
+    fs_bar - Bar that shows how much space is used
+    fs_free - Free space on a file system
+    fs_free_perc - Free percentage of space
+    fs_size - File system size
+    fs_used - File system used space
+  */
+
+  if (err != 0) {
+    event_box_.hide();
+    return;
+  }
+
+  auto free = pow_format(stats.f_bavail * stats.f_frsize, "B", true);
+  auto used = pow_format((stats.f_blocks - stats.f_bavail) * stats.f_frsize, "B", true);
+  auto total = pow_format(stats.f_blocks * stats.f_frsize, "B", true);
+
+  label_.set_markup(fmt::format(format_
+      , stats.f_bavail * 100 / stats.f_blocks
+      , fmt::arg("free", free)
+      , fmt::arg("percentage_free", stats.f_bavail * 100 / stats.f_blocks)
+      , fmt::arg("used", used)
+      , fmt::arg("percentage_used", (stats.f_blocks - stats.f_bavail) * 100 / stats.f_blocks)
+      , fmt::arg("total", total)
+      , fmt::arg("path", path_)
+      ));
+  if (tooltipEnabled()) {
+    std::string tooltip_format = "{used} used out of {total} on {path} ({percentage_used}%)";
+    if (config_["tooltip-format"].isString()) {
+      tooltip_format = config_["tooltip-format"].asString();
+    }
+    label_.set_tooltip_text(fmt::format(tooltip_format
+      , stats.f_bavail * 100 / stats.f_blocks
+      , fmt::arg("free", free)
+      , fmt::arg("percentage_free", stats.f_bavail * 100 / stats.f_blocks)
+      , fmt::arg("used", used)
+      , fmt::arg("percentage_used", (stats.f_blocks - stats.f_bavail) * 100 / stats.f_blocks)
+      , fmt::arg("total", total)
+      , fmt::arg("path", path_)
+      ));
+  }
+  event_box_.show();
+  // Call parent update
+  ALabel::update();
+}

src/modules/idle_inhibitor.cpp

@@ -1,57 +1,55 @@
 #include "modules/idle_inhibitor.hpp"
 #include "util/command.hpp"
 
-waybar::modules::IdleInhibitor::IdleInhibitor(const std::string& id, const Bar& bar, const Json::Value& config)
-  : ALabel(config, "{status}"), bar_(bar), status_("deactivated"), idle_inhibitor_(nullptr)
-{
-  label_.set_name("idle_inhibitor");
-  if (!id.empty()) {
-    label_.get_style_context()->add_class(id);
-  }
+waybar::modules::IdleInhibitor::IdleInhibitor(const std::string& id, const Bar& bar,
+                                              const Json::Value& config)
+    : ALabel(config, "idle_inhibitor", id, "{status}"),
+      bar_(bar),
+      status_("deactivated"),
+      idle_inhibitor_(nullptr),
+      pid_(-1) {
   event_box_.add_events(Gdk::BUTTON_PRESS_MASK);
   event_box_.signal_button_press_event().connect(
       sigc::mem_fun(*this, &IdleInhibitor::handleToggle));
   dp.emit();
 }
 
-waybar::modules::IdleInhibitor::~IdleInhibitor()
-{
-  if(idle_inhibitor_) {
+waybar::modules::IdleInhibitor::~IdleInhibitor() {
+  if (idle_inhibitor_ != nullptr) {
     zwp_idle_inhibitor_v1_destroy(idle_inhibitor_);
     idle_inhibitor_ = nullptr;
   }
+  if (pid_ != -1) {
+    kill(-pid_, 9);
+    pid_ = -1;
+  }
 }
 
-auto waybar::modules::IdleInhibitor::update() -> void
-{
+auto waybar::modules::IdleInhibitor::update() -> void {
   label_.set_markup(
-      fmt::format(format_, fmt::arg("status", status_),
-                  fmt::arg("icon", getIcon(0, status_))));
+      fmt::format(format_, fmt::arg("status", status_), fmt::arg("icon", getIcon(0, status_))));
   label_.get_style_context()->add_class(status_);
-  if(tooltipEnabled()) {
+  if (tooltipEnabled()) {
     label_.set_tooltip_text(status_);
   }
+  // Call parent update
+  ALabel::update();
 }
 
 bool waybar::modules::IdleInhibitor::handleToggle(GdkEventButton* const& e) {
   if (e->button == 1) {
     label_.get_style_context()->remove_class(status_);
-    if (idle_inhibitor_) {
+    if (idle_inhibitor_ != nullptr) {
       zwp_idle_inhibitor_v1_destroy(idle_inhibitor_);
       idle_inhibitor_ = nullptr;
       status_ = "deactivated";
     } else {
       idle_inhibitor_ = zwp_idle_inhibit_manager_v1_create_inhibitor(
-          bar_.client.idle_inhibit_manager, bar_.surface);
+          waybar::Client::inst()->idle_inhibit_manager, bar_.surface);
       status_ = "activated";
     }
-    if (config_["on-click"].isString() && e->button == 1) {
-      waybar::util::command::forkExec(config_["on-click"].asString());
-    }
-  } else {
-    ALabel::handleToggle(e);
+    click_param = status_;
   }
-
-  dp.emit();
+  ALabel::handleToggle(e);
   return true;
 }

src/modules/memory.cpp

@@ -1,65 +0,0 @@
-#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);
-  }
-  thread_ = [this] {
-    dp.emit();
-    thread_.sleep_for(interval_);
-  };
-}
-
-auto waybar::modules::Memory::update() -> void
-{
-  parseMeminfo();
-  if (memtotal_ > 0 && memfree_ >= 0) {
-    int used_ram_percentage = 100 * (memtotal_ - memfree_) / memtotal_;
-    label_.set_markup(fmt::format(format_, used_ram_percentage));
-    auto used_ram_gigabytes = (memtotal_ - memfree_) / std::pow(1024, 2);
-    if (tooltipEnabled()) {
-      label_.set_tooltip_text(fmt::format("{:.{}f}Gb used", used_ram_gigabytes, 1));
-    }
-    event_box_.show();
-  } else {
-    event_box_.hide();
-  }
-}
-
-void waybar::modules::Memory::parseMeminfo()
-{
-  long memfree = -1, membuffer = -1, memcache = -1, memavail = -1;
-  std::ifstream info(data_dir_);
-  if (!info.is_open()) {
-    throw std::runtime_error("Can't open " + data_dir_);
-  }
-  std::string line;
-  while (getline(info, line)) {
-    auto posDelim = line.find(":");
-    if (posDelim == std::string::npos) {
-      continue;
-    }
-    std::string name = line.substr(0, posDelim);
-    long value = std::stol(line.substr(posDelim + 1));
-
-    if (name.compare("MemTotal") == 0) {
-      memtotal_ = value;
-    } else if (name.compare("MemAvailable") == 0) {
-      memavail = value;
-    } else if (name.compare("MemFree") == 0) {
-      memfree = value;
-    } else if (name.compare("Buffers") == 0) {
-      membuffer = value;
-    } else if (name.compare("Cached") == 0) {
-      memcache = value;
-    }
-    if (memtotal_ > 0 &&
-      (memavail >= 0 || (memfree > -1  && membuffer > -1 && memcache > -1))) {
-      break;
-    }
-  }
-  memfree_ = memavail >= 0 ? memavail : memfree + membuffer + memcache;
-}

src/modules/memory/bsd.cpp

@@ -0,0 +1,89 @@
+#include "modules/memory.hpp"
+
+#include <sys/types.h>
+#include <sys/sysctl.h>
+#include <unistd.h>           // getpagesize
+
+#if defined(__DragonFly__)
+#  include <sys/vmmeter.h>    // struct vmstats
+#elif defined(__NetBSD__)
+#  include <uvm/uvm_extern.h> // struct uvmexp_sysctl
+#elif defined(__OpenBSD__)
+#  include <uvm/uvmexp.h>     // struct uvmexp
+#endif
+
+static uint64_t get_total_memory() {
+#if defined(HW_MEMSIZE) || defined(HW_PHYSMEM64)
+  uint64_t physmem;
+#else
+  u_long physmem;
+#endif
+  int mib[] = {
+    CTL_HW,
+#if defined(HW_MEMSIZE)
+    HW_MEMSIZE,
+#elif defined(HW_PHYSMEM64)
+    HW_PHYSMEM64,
+#else
+    HW_PHYSMEM,
+#endif
+  };
+  u_int miblen = sizeof(mib) / sizeof(mib[0]);
+  size_t sz = sizeof(physmem);
+  if (sysctl(mib, miblen, &physmem, &sz, NULL, 0)) {
+    throw std::runtime_error("sysctl hw.physmem failed");
+  }
+  return physmem;
+}
+
+static uint64_t get_free_memory() {
+#if defined(__DragonFly__)
+  struct vmstats vms;
+  size_t sz = sizeof(vms);
+  if (sysctlbyname("vm.vmstats", &vms, &sz, NULL, 0)) {
+    throw std::runtime_error("sysctl vm.vmstats failed");
+  }
+  return static_cast<uint64_t>
+    (vms.v_free_count + vms.v_inactive_count + vms.v_cache_count)
+    * getpagesize();
+#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
+  u_int v_free_count = 0, v_inactive_count = 0, v_cache_count = 0;
+  size_t sz = sizeof(u_int);
+  sysctlbyname("vm.stats.vm.v_free_count",
+               &v_free_count, &sz, NULL, 0);
+  sysctlbyname("vm.stats.vm.v_inactive_count",
+               &v_inactive_count, &sz, NULL, 0);
+  sysctlbyname("vm.stats.vm.v_cache_count",
+               &v_cache_count, &sz, NULL, 0);
+  return static_cast<uint64_t>
+    (v_free_count + v_inactive_count + v_cache_count)
+    * getpagesize();
+#elif defined(__NetBSD__) || defined(__OpenBSD__)
+#ifdef VM_UVMEXP2
+#  undef VM_UVMEXP
+#  define VM_UVMEXP VM_UVMEXP2
+#  define uvmexp uvmexp_sysctl
+#else
+#  define filepages vnodepages
+#  define execpages vtextpages
+#endif
+  int mib[] = {
+    CTL_VM,
+    VM_UVMEXP,
+  };
+  u_int miblen = sizeof(mib) / sizeof(mib[0]);
+  struct uvmexp uvmexp;
+  size_t sz = sizeof(uvmexp);
+  if (sysctl(mib, miblen, &uvmexp, &sz, NULL, 0)) {
+    throw std::runtime_error("sysctl vm.uvmexp failed");
+  }
+  return static_cast<uint64_t>
+    (uvmexp.free + uvmexp.inactive + uvmexp.filepages + uvmexp.execpages)
+    * uvmexp.pagesize;
+#endif
+}
+
+void waybar::modules::Memory::parseMeminfo() {
+  meminfo_["MemTotal"] = get_total_memory() / 1024;
+  meminfo_["MemAvailable"] = get_free_memory() / 1024;
+}

src/modules/memory/common.cpp

@@ -0,0 +1,57 @@
+#include "modules/memory.hpp"
+
+waybar::modules::Memory::Memory(const std::string& id, const Json::Value& config)
+    : ALabel(config, "memory", id, "{}%", 30) {
+  thread_ = [this] {
+    dp.emit();
+    thread_.sleep_for(interval_);
+  };
+}
+
+auto waybar::modules::Memory::update() -> void {
+  parseMeminfo();
+
+  unsigned long memtotal = meminfo_["MemTotal"];
+  unsigned long memfree;
+  if (meminfo_.count("MemAvailable")) {
+    // New kernels (3.4+) have an accurate available memory field.
+    memfree = meminfo_["MemAvailable"];
+  } else {
+    // Old kernel; give a best-effort approximation of available memory.
+    memfree = meminfo_["MemFree"] + meminfo_["Buffers"] + meminfo_["Cached"] +
+              meminfo_["SReclaimable"] - meminfo_["Shmem"];
+  }
+
+  if (memtotal > 0 && memfree >= 0) {
+    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,
+                                  fmt::arg("total", total_ram_gigabytes),
+                                  fmt::arg("percentage", used_ram_percentage),
+                                  fmt::arg("used", used_ram_gigabytes),
+                                  fmt::arg("avail", available_ram_gigabytes)));
+    if (tooltipEnabled()) {
+      if (config_["tooltip-format"].isString()) {
+        auto tooltip_format = config_["tooltip-format"].asString();
+        label_.set_tooltip_text(fmt::format(tooltip_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)));
+      } else {
+        label_.set_tooltip_text(fmt::format("{:.{}f}GiB used", used_ram_gigabytes, 1));
+      }
+    }
+    event_box_.show();
+  } else {
+    event_box_.hide();
+  }
+  // Call parent update
+  ALabel::update();
+}

src/modules/memory/linux.cpp

@@ -0,0 +1,20 @@
+#include "modules/memory.hpp"
+
+void waybar::modules::Memory::parseMeminfo() {
+  const std::string data_dir_ = "/proc/meminfo";
+  std::ifstream info(data_dir_);
+  if (!info.is_open()) {
+    throw std::runtime_error("Can't open " + data_dir_);
+  }
+  std::string line;
+  while (getline(info, line)) {
+    auto posDelim = line.find(':');
+    if (posDelim == std::string::npos) {
+      continue;
+    }
+
+    std::string name = line.substr(0, posDelim);
+    int64_t     value = std::stol(line.substr(posDelim + 1));
+    meminfo_[name] = value;
+  }
+}

src/modules/mpd.cpp

@@ -0,0 +1,369 @@
+#include "modules/mpd.hpp"
+
+#include <fmt/chrono.h>
+#include <spdlog/spdlog.h>
+
+waybar::modules::MPD::MPD(const std::string& id, const Json::Value& config)
+    : 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),
+      timeout_(config_["timeout"].isUInt() ? config_["timeout"].asUInt() * 1'000 : 30'000),
+      connection_(nullptr, &mpd_connection_free),
+      alternate_connection_(nullptr, &mpd_connection_free),
+      status_(nullptr, &mpd_status_free),
+      song_(nullptr, &mpd_song_free) {
+  if (!config_["port"].isNull() && !config_["port"].isUInt()) {
+    spdlog::warn("{}: `port` configuration should be an unsigned int", module_name_);
+  }
+
+  if (!config_["timeout"].isNull() && !config_["timeout"].isUInt()) {
+    spdlog::warn("{}: `timeout` configuration should be an unsigned int", module_name_);
+  }
+
+  if (!config["server"].isNull()) {
+    if (!config_["server"].isString()) {
+      spdlog::warn("{}:`server` configuration should be a string", module_name_);
+    }
+    server_ = config["server"].asCString();
+  }
+
+  event_listener().detach();
+
+  event_box_.add_events(Gdk::BUTTON_PRESS_MASK);
+  event_box_.signal_button_press_event().connect(sigc::mem_fun(*this, &MPD::handlePlayPause));
+}
+
+auto waybar::modules::MPD::update() -> void {
+  std::lock_guard guard(connection_lock_);
+  tryConnect();
+
+  if (connection_ != nullptr) {
+    try {
+      bool wasPlaying = playing();
+      if(!wasPlaying) {
+        // Wait until the periodic_updater has stopped
+        std::lock_guard periodic_guard(periodic_lock_);
+      }
+      fetchState();
+      if (!wasPlaying && playing()) {
+        periodic_updater().detach();
+      }
+    } catch (const std::exception& e) {
+      spdlog::error("{}: {}", module_name_, e.what());
+      state_ = MPD_STATE_UNKNOWN;
+    }
+  }
+
+  setLabel();
+
+  // Call parent update
+  ALabel::update();
+}
+
+std::thread waybar::modules::MPD::event_listener() {
+  return std::thread([this] {
+    while (true) {
+      try {
+        if (connection_ == nullptr) {
+          // Retry periodically if no connection
+          dp.emit();
+          std::this_thread::sleep_for(interval_);
+        } else {
+          waitForEvent();
+          dp.emit();
+        }
+      } catch (const std::exception& e) {
+        if (strcmp(e.what(), "Connection to MPD closed") == 0) {
+          spdlog::debug("{}: {}", module_name_, e.what());
+        } else {
+          spdlog::warn("{}: {}", module_name_, e.what());
+        }
+      }
+    }
+  });
+}
+
+std::thread waybar::modules::MPD::periodic_updater() {
+  return std::thread([this] {
+    std::lock_guard guard(periodic_lock_);
+    while (connection_ != nullptr && playing()) {
+      dp.emit();
+      std::this_thread::sleep_for(std::chrono::seconds(1));
+    }
+  });
+}
+
+std::string waybar::modules::MPD::getTag(mpd_tag_type type, unsigned idx) {
+  std::string result =
+      config_["unknown-tag"].isString() ? config_["unknown-tag"].asString() : "N/A";
+  const char* tag = mpd_song_get_tag(song_.get(), type, idx);
+
+  // mpd_song_get_tag can return NULL, so make sure it's valid before setting
+  if (tag) result = tag;
+
+  return result;
+}
+
+void waybar::modules::MPD::setLabel() {
+  if (connection_ == nullptr) {
+    label_.get_style_context()->add_class("disconnected");
+    label_.get_style_context()->remove_class("stopped");
+    label_.get_style_context()->remove_class("playing");
+    label_.get_style_context()->remove_class("paused");
+
+    auto format = config_["format-disconnected"].isString()
+                      ? config_["format-disconnected"].asString()
+                      : "disconnected";
+    label_.set_markup(format);
+
+    if (tooltipEnabled()) {
+      std::string tooltip_format;
+      tooltip_format = config_["tooltip-format-disconnected"].isString()
+                           ? config_["tooltip-format-disconnected"].asString()
+                           : "MPD (disconnected)";
+      // Nothing to format
+      label_.set_tooltip_text(tooltip_format);
+    }
+    return;
+  } else {
+    label_.get_style_context()->remove_class("disconnected");
+  }
+
+  auto format = format_;
+
+  std::string          artist, album_artist, album, title, date;
+  int song_pos, queue_length;
+  std::chrono::seconds elapsedTime, totalTime;
+
+  std::string stateIcon = "";
+  if (stopped()) {
+    format =
+        config_["format-stopped"].isString() ? config_["format-stopped"].asString() : "stopped";
+    label_.get_style_context()->add_class("stopped");
+    label_.get_style_context()->remove_class("playing");
+    label_.get_style_context()->remove_class("paused");
+  } else {
+    label_.get_style_context()->remove_class("stopped");
+    if (playing()) {
+      label_.get_style_context()->add_class("playing");
+      label_.get_style_context()->remove_class("paused");
+    } else if (paused()) {
+      format =
+        config_["format-paused"].isString() ? config_["format-paused"].asString() : config_["format"].asString();
+      label_.get_style_context()->add_class("paused");
+      label_.get_style_context()->remove_class("playing");
+    }
+
+    stateIcon = getStateIcon();
+
+    artist = getTag(MPD_TAG_ARTIST);
+    album_artist = getTag(MPD_TAG_ALBUM_ARTIST);
+    album = getTag(MPD_TAG_ALBUM);
+    title = getTag(MPD_TAG_TITLE);
+    date = getTag(MPD_TAG_DATE);
+    song_pos = mpd_status_get_song_pos(status_.get());
+    queue_length = mpd_status_get_queue_length(status_.get());
+    elapsedTime = std::chrono::seconds(mpd_status_get_elapsed_time(status_.get()));
+    totalTime = std::chrono::seconds(mpd_status_get_total_time(status_.get()));
+  }
+
+  bool        consumeActivated = mpd_status_get_consume(status_.get());
+  std::string consumeIcon = getOptionIcon("consume", consumeActivated);
+  bool        randomActivated = mpd_status_get_random(status_.get());
+  std::string randomIcon = getOptionIcon("random", randomActivated);
+  bool        repeatActivated = mpd_status_get_repeat(status_.get());
+  std::string repeatIcon = getOptionIcon("repeat", repeatActivated);
+  bool        singleActivated = mpd_status_get_single(status_.get());
+  std::string singleIcon = getOptionIcon("single", singleActivated);
+
+  // TODO: format can fail
+  label_.set_markup(
+      fmt::format(format,
+                  fmt::arg("artist", Glib::Markup::escape_text(artist).raw()),
+                  fmt::arg("albumArtist", Glib::Markup::escape_text(album_artist).raw()),
+                  fmt::arg("album", Glib::Markup::escape_text(album).raw()),
+                  fmt::arg("title", Glib::Markup::escape_text(title).raw()),
+                  fmt::arg("date", Glib::Markup::escape_text(date).raw()),
+                  fmt::arg("elapsedTime", elapsedTime),
+                  fmt::arg("totalTime", totalTime),
+                  fmt::arg("songPosition", song_pos),
+                  fmt::arg("queueLength", queue_length),
+                  fmt::arg("stateIcon", stateIcon),
+                  fmt::arg("consumeIcon", consumeIcon),
+                  fmt::arg("randomIcon", randomIcon),
+                  fmt::arg("repeatIcon", repeatIcon),
+                  fmt::arg("singleIcon", singleIcon)));
+
+  if (tooltipEnabled()) {
+    std::string tooltip_format;
+    tooltip_format = config_["tooltip-format"].isString() ? config_["tooltip-format"].asString()
+                                                          : "MPD (connected)";
+    auto tooltip_text = fmt::format(tooltip_format,
+                                    fmt::arg("artist", artist),
+                                    fmt::arg("albumArtist", album_artist),
+                                    fmt::arg("album", album),
+                                    fmt::arg("title", title),
+                                    fmt::arg("date", date),
+                                    fmt::arg("songPosition", song_pos),
+                                    fmt::arg("queueLength", queue_length),
+                                    fmt::arg("stateIcon", stateIcon),
+                                    fmt::arg("consumeIcon", consumeIcon),
+                                    fmt::arg("randomIcon", randomIcon),
+                                    fmt::arg("repeatIcon", repeatIcon),
+                                    fmt::arg("singleIcon", singleIcon));
+    label_.set_tooltip_text(tooltip_text);
+  }
+}
+
+std::string waybar::modules::MPD::getStateIcon() {
+  if (!config_["state-icons"].isObject()) {
+    return "";
+  }
+
+  if (connection_ == nullptr) {
+    spdlog::warn("{}: Trying to fetch state icon while disconnected", module_name_);
+    return "";
+  }
+
+  if (stopped()) {
+    spdlog::warn("{}: Trying to fetch state icon while stopped", module_name_);
+    return "";
+  }
+
+  if (playing()) {
+    return config_["state-icons"]["playing"].asString();
+  } else {
+    return config_["state-icons"]["paused"].asString();
+  }
+}
+
+std::string waybar::modules::MPD::getOptionIcon(std::string optionName, bool activated) {
+  if (!config_[optionName + "-icons"].isObject()) {
+    return "";
+  }
+
+  if (connection_ == nullptr) {
+    spdlog::warn("{}: Trying to fetch option icon while disconnected", module_name_);
+    return "";
+  }
+
+  if (activated) {
+    return config_[optionName + "-icons"]["on"].asString();
+  } else {
+    return config_[optionName + "-icons"]["off"].asString();
+  }
+}
+
+void waybar::modules::MPD::tryConnect() {
+  if (connection_ != nullptr) {
+    return;
+  }
+
+  connection_ =
+      unique_connection(mpd_connection_new(server_, port_, timeout_), &mpd_connection_free);
+
+  alternate_connection_ =
+      unique_connection(mpd_connection_new(server_, port_, timeout_), &mpd_connection_free);
+
+  if (connection_ == nullptr || alternate_connection_ == nullptr) {
+    spdlog::error("{}: Failed to connect to MPD", module_name_);
+    connection_.reset();
+    alternate_connection_.reset();
+    return;
+  }
+
+  try {
+    checkErrors(connection_.get());
+    spdlog::debug("{}: Connected to MPD", module_name_);
+  } catch (std::runtime_error& e) {
+    spdlog::error("{}: Failed to connect to MPD: {}", module_name_, e.what());
+    connection_.reset();
+    alternate_connection_.reset();
+  }
+}
+
+void waybar::modules::MPD::checkErrors(mpd_connection* conn) {
+  switch (mpd_connection_get_error(conn)) {
+    case MPD_ERROR_SUCCESS:
+      mpd_connection_clear_error(conn);
+      return;
+    case MPD_ERROR_TIMEOUT:
+    case MPD_ERROR_CLOSED:
+      mpd_connection_clear_error(conn);
+      connection_.reset();
+      alternate_connection_.reset();
+      state_ = MPD_STATE_UNKNOWN;
+      throw std::runtime_error("Connection to MPD closed");
+    default:
+      if (conn) {
+        auto error_message = mpd_connection_get_error_message(conn);
+        mpd_connection_clear_error(conn);
+        throw std::runtime_error(std::string(error_message));
+      }
+      throw std::runtime_error("Invalid connection");
+  }
+}
+
+void waybar::modules::MPD::fetchState() {
+  auto conn = connection_.get();
+  status_ = unique_status(mpd_run_status(conn), &mpd_status_free);
+  checkErrors(conn);
+  state_ = mpd_status_get_state(status_.get());
+  checkErrors(conn);
+
+  song_ = unique_song(mpd_run_current_song(conn), &mpd_song_free);
+  checkErrors(conn);
+}
+
+void waybar::modules::MPD::waitForEvent() {
+  auto conn = alternate_connection_.get();
+  // Wait for a player (play/pause), option (random, shuffle, etc.), or playlist
+  // change
+  if (!mpd_send_idle_mask(
+          conn, static_cast<mpd_idle>(MPD_IDLE_PLAYER | MPD_IDLE_OPTIONS | MPD_IDLE_QUEUE))) {
+    checkErrors(conn);
+    return;
+  }
+  // alternate_idle_ = true;
+
+  // See issue #277:
+  // https://github.com/Alexays/Waybar/issues/277
+  mpd_recv_idle(conn, /* disable_timeout = */ false);
+  // See issue #281:
+  // https://github.com/Alexays/Waybar/issues/281
+  std::lock_guard guard(connection_lock_);
+
+  checkErrors(conn);
+  mpd_response_finish(conn);
+
+  checkErrors(conn);
+}
+
+bool waybar::modules::MPD::handlePlayPause(GdkEventButton* const& e) {
+  if (e->type == GDK_2BUTTON_PRESS || e->type == GDK_3BUTTON_PRESS || connection_ == nullptr) {
+    return false;
+  }
+
+  if (e->button == 1) {
+    std::lock_guard guard(connection_lock_);
+    if (stopped()) {
+      mpd_run_play(connection_.get());
+    } else {
+      mpd_run_toggle_pause(connection_.get());
+    }
+  } else if (e->button == 3) {
+    std::lock_guard guard(connection_lock_);
+    mpd_run_stop(connection_.get());
+  }
+
+  return true;
+}
+
+bool waybar::modules::MPD::stopped() {
+  return connection_ == nullptr || state_ == MPD_STATE_UNKNOWN || state_ == MPD_STATE_STOP || status_ == nullptr;
+}
+
+bool waybar::modules::MPD::playing() { return connection_ != nullptr && state_ == MPD_STATE_PLAY; }
+
+bool waybar::modules::MPD::paused() { return connection_ != nullptr && state_ == MPD_STATE_PAUSE; }