chore: v0.9.3

chore: update subprojects for date, gtk-layer-shell

.github/FUNDING.yml

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

.travis.yml

@@ -1,4 +1,4 @@
-sudo: false
+language: cpp
 
 services:
     - docker
@@ -11,6 +11,7 @@ env:
     - distro: archlinux
     - distro: fedora
     - distro: alpine
+    - distro: opensuse
 
 before_install:
     - docker pull alexays/waybar:${distro}
@@ -21,3 +22,15 @@ script:
     - echo ADD . /root >> Dockerfile
     - docker build -t waybar .
     - 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

@@ -2,4 +2,4 @@
 
 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 libnl3-dev pulseaudio-dev libmpdclient-dev scdoc
+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

@@ -3,4 +3,4 @@
 FROM archlinux/base:latest
 
 RUN pacman -Syu --noconfirm && \
-    pacman -S git meson base-devel libinput wayland wayland-protocols pixman libxkbcommon mesa gtkmm3 jsoncpp scdoc --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

@@ -3,5 +3,5 @@
 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 scdoc && \
+    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

@@ -1,7 +1,7 @@
 # vim: ft=Dockerfile
 
-FROM fedora:30
+FROM fedora:32
 
-RUN dnf install sway meson git libinput-devel wayland-devel wayland-protocols-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 && \
+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

@@ -4,4 +4,4 @@ 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 scdoc
+    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

@@ -11,6 +11,7 @@
 - Local time
 - Battery
 - Network
+- Bluetooth
 - Pulseaudio
 - Disk
 - Memory
@@ -43,23 +44,51 @@ $ 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]
 ```
 
-On Ubuntu 19.10 you can install all the relevant dependencies using this command:
+**Build dependencies**
 
 ```
-sudo apt install libgtkmm-3.0-dev libjsoncpp-dev libinput-dev libsigc++-2.0-dev libpulse-dev libnl-3-dev libdbusmenu-gtk3-dev libnl-genl-3-dev libfmt-dev clang-tidy scdoc libmpdclient-dev
+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
 ```
 
 

include/ALabel.hpp

@@ -14,6 +14,7 @@ class ALabel : public AModule {
   virtual ~ALabel() = default;
   virtual auto        update() -> void;
   virtual std::string getIcon(uint16_t, const std::string &alt = "", uint16_t max = 0);
+  virtual std::string getIcon(uint16_t, std::vector<std::string> &alts, uint16_t max = 0);
 
  protected:
   Gtk::Label                 label_;

include/AModule.hpp

@@ -4,14 +4,15 @@
 #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);
+  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 &();
@@ -24,6 +25,7 @@ class AModule : public IModule {
   SCROLL_DIR getScrollDir(GdkEventScroll *e);
   bool       tooltipEnabled();
 
+  const std::string  name_;
   const Json::Value &config_;
   Gtk::EventBox      event_box_;
 

include/bar.hpp

@@ -34,10 +34,10 @@ class Bar {
 
   struct waybar_output *output;
   Json::Value           config;
-  Gtk::Window           window;
   struct wl_surface *   surface;
   bool                  visible = true;
   bool                  vertical = false;
+  Gtk::Window           window;
 
  private:
   static constexpr const char *MIN_HEIGHT_MSG =

include/client.hpp

@@ -30,12 +30,12 @@ class Client {
                                                               const std::string &style) const;
   void                                             bindInterfaces();
   const std::string getValidPath(const std::vector<std::string> &paths) const;
-  void              handleOutput(std::unique_ptr<struct waybar_output> &output);
-  bool isValidOutput(const Json::Value &config, std::unique_ptr<struct waybar_output> &output);
+  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;
-  std::unique_ptr<struct waybar_output> &getOutput(void *);
-  std::vector<Json::Value> getOutputConfigs(std::unique_ptr<struct waybar_output> &output);
+  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);
@@ -44,10 +44,10 @@ class Client {
   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::vector<std::unique_ptr<struct waybar_output>> outputs_;
+  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

@@ -7,14 +7,24 @@
 #include "modules/sway/window.hpp"
 #include "modules/sway/workspaces.hpp"
 #endif
-#ifndef NO_FILESYSTEM
+#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"
+#if defined(HAVE_MEMORY_LINUX) || defined(HAVE_MEMORY_BSD)
 #include "modules/memory.hpp"
+#endif
 #include "modules/disk.hpp"
-#if defined(HAVE_DBUSMENU) && !defined(NO_FILESYSTEM)
+#ifdef HAVE_DBUSMENU
 #include "modules/sni/tray.hpp"
 #endif
 #ifdef HAVE_LIBNL
@@ -32,6 +42,9 @@
 #include "bar.hpp"
 #include "modules/custom.hpp"
 #include "modules/temperature.hpp"
+#if defined(__linux__)
+#include "modules/bluetooth.hpp"
+#endif
 
 namespace waybar {
 

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

@@ -6,11 +6,17 @@
 #else
 #include <fmt/chrono.h>
 #endif
+#include <date/tz.h>
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 
 namespace waybar::modules {
 
+struct waybar_time {
+  std::locale locale;
+  date::zoned_seconds ztime;
+};
+
 class Clock : public ALabel {
  public:
   Clock(const std::string&, const Json::Value&);
@@ -19,6 +25,15 @@ class Clock : public ALabel {
 
  private:
   util::SleeperThread thread_;
+  std::locale locale_;
+  const date::time_zone* time_zone_;
+  bool fixed_time_zone_;
+  date::year_month_day cached_calendar_ymd_;
+  std::string cached_calendar_text_;
+
+  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,7 +1,7 @@
 #pragma once
 
 #include <fmt/format.h>
-#include <sys/sysinfo.h>
+#include <unistd.h>
 #include <cstdint>
 #include <fstream>
 #include <numeric>
@@ -20,7 +20,6 @@ class Cpu : public ALabel {
   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();

include/modules/memory.hpp

@@ -2,6 +2,7 @@
 
 #include <fmt/format.h>
 #include <fstream>
+#include <unordered_map>
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 
@@ -14,11 +15,9 @@ class Memory : public ALabel {
   auto update() -> void;
 
  private:
-  static inline const std::string data_dir_ = "/proc/meminfo";
   void                            parseMeminfo();
 
-  unsigned long memtotal_;
-  unsigned long memfree_;
+  std::unordered_map<std::string, unsigned long> meminfo_;
 
   util::SleeperThread thread_;
 };

include/modules/mpd.hpp

@@ -36,6 +36,7 @@ class MPD : public ALabel {
 
   bool stopped();
   bool playing();
+  bool paused();
 
   const std::string module_name_;
 

include/modules/network.hpp

@@ -11,6 +11,7 @@
 #include <sys/epoll.h>
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
+#include "util/rfkill.hpp"
 
 namespace waybar::modules {
 
@@ -51,8 +52,6 @@ class Network : public ALabel {
   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_;
 
@@ -71,6 +70,9 @@ class Network : public ALabel {
 
   util::SleeperThread thread_;
   util::SleeperThread thread_timer_;
+  util::SleeperThread thread_rfkill_;
+
+  util::Rfkill rfkill_;
 };
 
 }  // namespace waybar::modules

include/modules/pulseaudio.hpp

@@ -4,6 +4,7 @@
 #include <pulse/pulseaudio.h>
 #include <pulse/volume.h>
 #include <algorithm>
+#include <array>
 #include "ALabel.hpp"
 
 namespace waybar::modules {
@@ -34,14 +35,17 @@ class Pulseaudio : public ALabel {
   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/item.hpp

@@ -10,11 +10,6 @@
 #include <json/json.h>
 #include <libdbusmenu-gtk/dbusmenu-gtk.h>
 #include <sigc++/trackable.h>
-#ifdef FILESYSTEM_EXPERIMENTAL
-#include <experimental/filesystem>
-#else
-#include <filesystem>
-#endif
 
 namespace waybar::modules::SNI {
 

include/modules/sni/tray.hpp

@@ -21,7 +21,7 @@ class Tray : public AModule {
 
   static inline std::size_t nb_hosts_ = 0;
   Gtk::Box                  box_;
-  SNI::Watcher              watcher_;
+  SNI::Watcher::singleton   watcher_;
   SNI::Host                 host_;
 };
 

include/modules/sni/watcher.hpp

@@ -7,10 +7,24 @@
 namespace waybar::modules::SNI {
 
 class Watcher {
+ private:
+  Watcher();
+
  public:
-  Watcher(std::size_t id);
   ~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;
 
@@ -34,7 +48,6 @@ class Watcher {
   void updateRegisteredItems(SnWatcher *obj);
 
   uint32_t   bus_name_id_;
-  uint32_t   watcher_id_;
   GSList *   hosts_ = nullptr;
   GSList *   items_ = nullptr;
   SnWatcher *watcher_ = nullptr;

include/modules/sway/ipc/client.hpp

@@ -8,6 +8,7 @@
 #include <memory>
 #include <mutex>
 #include "ipc.hpp"
+#include "util/sleeper_thread.hpp"
 
 namespace waybar::modules::sway {
 
@@ -28,6 +29,7 @@ class Ipc {
   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";
@@ -38,9 +40,10 @@ class Ipc {
   struct ipc_response send(int fd, uint32_t type, const std::string &payload = "");
   struct ipc_response recv(int fd);
 
-  int        fd_;
-  int        fd_event_;
-  std::mutex mutex_;
+  int                 fd_;
+  int                 fd_event_;
+  std::mutex          mutex_;
+  util::SleeperThread thread_;
 };
 
 }  // namespace waybar::modules::sway

include/modules/sway/mode.hpp

@@ -6,7 +6,6 @@
 #include "client.hpp"
 #include "modules/sway/ipc/client.hpp"
 #include "util/json.hpp"
-#include "util/sleeper_thread.hpp"
 
 namespace waybar::modules::sway {
 
@@ -18,14 +17,11 @@ class Mode : public ALabel, public sigc::trackable {
 
  private:
   void onEvent(const struct Ipc::ipc_response&);
-  void worker();
 
   std::string      mode_;
   util::JsonParser parser_;
   std::mutex       mutex_;
-
-  util::SleeperThread thread_;
-  Ipc                 ipc_;
+  Ipc              ipc_;
 };
 
 }  // namespace waybar::modules::sway

include/modules/sway/window.hpp

@@ -7,7 +7,6 @@
 #include "client.hpp"
 #include "modules/sway/ipc/client.hpp"
 #include "util/json.hpp"
-#include "util/sleeper_thread.hpp"
 
 namespace waybar::modules::sway {
 
@@ -20,7 +19,6 @@ class Window : public ALabel, public sigc::trackable {
  private:
   void                                                   onEvent(const struct Ipc::ipc_response&);
   void                                                   onCmd(const struct Ipc::ipc_response&);
-  void                                                   worker();
   std::tuple<std::size_t, int, std::string, std::string> getFocusedNode(const Json::Value& nodes,
                                                                         std::string&       output);
   void                                                   getTree();
@@ -33,9 +31,7 @@ class Window : public ALabel, public sigc::trackable {
   std::size_t      app_nb_;
   util::JsonParser parser_;
   std::mutex       mutex_;
-
-  util::SleeperThread thread_;
-  Ipc                 ipc_;
+  Ipc              ipc_;
 };
 
 }  // namespace waybar::modules::sway

include/modules/sway/workspaces.hpp

@@ -1,14 +1,15 @@
 #pragma once
 
+#include <unordered_map>
 #include <fmt/format.h>
 #include <gtkmm/button.h>
 #include <gtkmm/label.h>
+#include <unordered_map>
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "client.hpp"
 #include "modules/sway/ipc/client.hpp"
 #include "util/json.hpp"
-#include "util/sleeper_thread.hpp"
 
 namespace waybar::modules::sway {
 
@@ -19,9 +20,12 @@ class Workspaces : public AModule, public sigc::trackable {
   auto update() -> void;
 
  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&);
-  void              worker();
   bool              filterButtons();
   Gtk::Button&      addButton(const Json::Value&);
   void              onButtonReady(const Json::Value&, Gtk::Button&);
@@ -38,9 +42,7 @@ class Workspaces : public AModule, public sigc::trackable {
   util::JsonParser                             parser_;
   std::unordered_map<std::string, Gtk::Button> buttons_;
   std::mutex                                   mutex_;
-
-  util::SleeperThread thread_;
-  Ipc                 ipc_;
+  Ipc                                          ipc_;
 };
 
 }  // namespace waybar::modules::sway

include/modules/temperature.hpp

@@ -14,8 +14,8 @@ class Temperature : public ALabel {
   auto update() -> void;
 
  private:
-  std::tuple<uint16_t, uint16_t> getTemperature();
-  bool                           isCritical(uint16_t);
+  float               getTemperature();
+  bool                isCritical(uint16_t);
 
   std::string         file_path_;
   util::SleeperThread thread_;

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,9 +1,12 @@
 #pragma once
 
 #include <giomm.h>
+#include <spdlog/spdlog.h>
 #include <sys/wait.h>
 #include <unistd.h>
 
+#include <array>
+
 namespace waybar::util::command {
 
 struct res {
@@ -28,20 +31,28 @@ inline std::string read(FILE* fp) {
 }
 
 inline int close(FILE* fp, pid_t pid) {
-  int stat;
+  int stat = -1;
 
   fclose(fp);
-  while (waitpid(pid, &stat, 0) == -1) {
-    if (errno != EINTR) {
-      stat = 0;
+  do {
+    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 {
       break;
     }
-  }
-
+  } while (!WIFEXITED(stat) && !WIFSIGNALED(stat));
   return stat;
 }
 
-inline FILE* open(const std::string cmd, int& pid) {
+inline FILE* open(const std::string& cmd, int& pid) {
   if (cmd == "") return nullptr;
   int fd[2];
   pipe(fd);
@@ -49,7 +60,7 @@ inline FILE* open(const std::string cmd, int& pid) {
   pid_t child_pid = fork();
 
   if (child_pid < 0) {
-    printf("Unable to exec cmd %s, error %s", cmd.c_str(), strerror(errno));
+    spdlog::error("Unable to exec cmd {}, error {}", cmd.c_str(), strerror(errno));
     return nullptr;
   }
 
@@ -57,7 +68,7 @@ inline FILE* open(const std::string cmd, int& pid) {
     ::close(fd[0]);
     dup2(fd[1], 1);
     setpgid(child_pid, child_pid);
-    execl("/bin/sh", "sh", "-c", cmd.c_str(), (char*)0);
+    execlp("/bin/sh", "sh", "-c", cmd.c_str(), (char*)0);
     exit(0);
   } else {
     ::close(fd[1]);
@@ -66,7 +77,7 @@ inline FILE* open(const std::string cmd, int& pid) {
   return fdopen(fd[0], "r");
 }
 
-inline struct res exec(std::string cmd) {
+inline struct res exec(const std::string& cmd) {
   int  pid;
   auto fp = command::open(cmd, pid);
   if (!fp) return {-1, ""};
@@ -75,23 +86,32 @@ inline struct res exec(std::string cmd) {
   return {WEXITSTATUS(stat), output};
 }
 
-inline int32_t forkExec(std::string cmd) {
+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;
 
   int32_t pid = fork();
 
   if (pid < 0) {
-    printf("Unable to exec cmd %s, error %s", cmd.c_str(), strerror(errno));
+    spdlog::error("Unable to exec cmd {}, error {}", cmd.c_str(), strerror(errno));
     return pid;
   }
 
   // Child executes the command
   if (!pid) {
     setpgid(pid, pid);
+    signal(SIGCHLD, SIG_DFL);
     execl("/bin/sh", "sh", "-c", cmd.c_str(), (char*)0);
     exit(0);
   } else {
-    signal(SIGCHLD,SIG_IGN);
+    signal(SIGCHLD, SIG_IGN);
   }
 
   return pid;

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

@@ -59,6 +59,11 @@ class SleeperThread {
       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() {

man/waybar-backlight.5.scd

@@ -10,45 +10,53 @@ The *backlight* module displays the current backlight level.
 
 # CONFIGURATION
 
-*interval* ++
+*interval*: ++
 	typeof: integer ++
 	default: 2 ++
 	The interval in which information gets polled.
 
-*format* ++
+*format*: ++
 	typeof: string ++
 	default: {percent}% ++
 	The format, how information should be displayed. On {} data gets inserted.
 
-*max-length* ++
+*max-length*: ++
 	typeof: integer ++
 	The maximum length in characters the module should display.
 
-*rotate* ++
+*rotate*: ++
 	typeof: integer ++
 	Positive value to rotate the text label.
 
-*states* ++
+*states*: ++
 	typeof: array ++
 	A number of backlight states which get activated on certain brightness levels.
 
-*on-click* ++
+*on-click*: ++
 	typeof: string ++
 	Command to execute when the module is clicked.
 
-*on-click-right* ++
+*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-scroll-up* ++
+*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* ++
+*on-scroll-down*: ++
 	typeof: string
 	Command to execute when performing a scroll down on the module.
 
-*smooth-scrolling-threshold* ++
+*smooth-scrolling-threshold*: ++
 	typeof: double
 	Threshold to be used when scrolling.
 

man/waybar-battery.5.scd

@@ -10,67 +10,79 @@ The *battery* module displays the current capacity and state (eg. charging) of y
 
 # CONFIGURATION
 
-*bat* ++
+*bat*: ++
 	typeof: string ++
 	The battery to monitor, as in /sys/class/power_supply/ instead of auto detect.
 
-*adapter* ++
+*adapter*: ++
 	typeof: string ++
 	The adapter to monitor, as in /sys/class/power_supply/ instead of auto detect.
 
-*interval* ++
+*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* ++
+*states*: ++
 	typeof: array ++
 	A number of battery states which get activated on certain capacity levels. See *waybar-states(5)*.
 
-*format* ++
+*format*: ++
 	typeof: string ++
 	default: {capacity}% ++
 	The format, how the time should be displayed.
 
-*format-time* ++
+*format-time*: ++
 	typeof: string ++
 	default: {H} h {M} min ++
 	The format, how the time should be displayed.
 
-*format-icons*
-	typeof: array/object
+*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* ++
+*max-length*: ++
 	typeof: integer++
 	The maximum length in character the module should display.
 
-*rotate* ++
+*rotate*: ++
 	typeof: integer++
 	Positive value to rotate the text label.
 
-*on-click* ++
+*on-click*: ++
 	typeof: string ++
 	Command to execute when clicked on the module.
 
-*on-click-right* ++
+*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* ++
+*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* ++
+*on-scroll-down*: ++
 	typeof: string ++
 	Command to execute when scrolling down on the module.
 
-*smooth-scrolling-threshold* ++
+*smooth-scrolling-threshold*: ++
 	typeof: double ++
 	Threshold to be used when scrolling.
 
-*tooltip* ++
+*tooltip*: ++
 	typeof: bool ++
 	default: true ++
 	Option to disable tooltip on hover.

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

@@ -18,7 +18,18 @@ The *clock* module displays the current date and time.
 *format*: ++
 	typeof: string ++
 	default: {:%H:%M} ++
-	The format, how the date and time should be displayed.
+	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.
+
+*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.
 
 *max-length*: ++
 	typeof: integer ++
@@ -32,10 +43,18 @@ The *clock* module displays the current date and time.
 	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.
@@ -50,6 +69,10 @@ The *clock* module displays the current date and time.
 
 View all valid format options in *strftime(3)*.
 
+# FORMAT REPLACEMENTS
+
+*{calendar}*: Current month calendar
+
 # EXAMPLES
 
 ```

man/waybar-cpu.5.scd

@@ -36,10 +36,18 @@ The *cpu* module displays the current cpu utilization.
 	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.

man/waybar-custom.5.scd

@@ -33,6 +33,12 @@ Addressed by *custom/<name>*
 	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.
@@ -59,10 +65,18 @@ Addressed by *custom/<name>*
 	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.

man/waybar-disk.5.scd

@@ -39,10 +39,18 @@ Addressed by *disk*
 	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.

man/waybar-idle-inhibitor.5.scd

@@ -31,10 +31,18 @@ screensaving, also known as "presentation mode".
 	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.

man/waybar-memory.5.scd

@@ -38,10 +38,18 @@ Addressed by *memory*
 	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.

man/waybar-mpd.5.scd

@@ -13,110 +13,122 @@ The *mpd* module displays information about a running "Music Player Daemon" inst
 Addressed by *mpd*
 
 *server*: ++
-    typeof: string ++
-    The network address or Unix socket path of the MPD server. If empty, connect to the default host.
+	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.
+	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
+	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
+	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`
+	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 or paused
+	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.
+	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.
+	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.
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
 
 *tooltip-format*: ++
-    typeof: string ++
-    default: "MPD (connected)" ++
-    Tooltip information displayed when connected to MPD.
+	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.
+	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.
+	typeof: integer ++
+	Positive value to rotate the text label.
 
 *max-length*: ++
-    typeof: integer ++
-    The maximum length in character the module should display.
+	typeof: integer ++
+	The maximum length in character the module should display.
 
 *on-click*: ++
-    typeof: string ++
-    Command to execute when clicked on the module.
+	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.
+	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.
+	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.
+	typeof: string ++
+	Command to execute when scrolling down on the module.
 
 *smooth-scrolling-threshold*: ++
-    typeof: double ++
-    Threshold to be used when scrolling.
+	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": "..." }*)
+	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": "..." }*)
+	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": "..." }*)
+	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": "..." }*)
+	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": "..." }*)
+	typeof: object ++
+	default: {} ++
+	Icon to show depending on the "single" option (*{ "on": "...", "off": "..." }*)
 
 # FORMAT REPLACEMENTS
 

man/waybar-network.5.scd

@@ -21,6 +21,11 @@ Addressed by *network*
 	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}* ++
@@ -28,7 +33,7 @@ Addressed by *network*
 
 *format-ethernet*: ++
 	typeof: string ++
-	This format is used when a ethernet interface is displayed.
+	This format is used when an ethernet interface is displayed.
 
 *format-wifi*: ++
 	typeof: string ++
@@ -42,6 +47,15 @@ Addressed by *network*
 	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.
@@ -54,10 +68,18 @@ Addressed by *network*
 	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.
@@ -81,7 +103,7 @@ Addressed by *network*
 
 *tooltip-format-ethernet*: ++
 	typeof: string ++
-	This format is used when a ethernet interface is displayed.
+	This format is used when an ethernet interface is displayed.
 
 *tooltip-format-wifi*: ++
 	typeof: string ++
@@ -91,6 +113,10 @@ Addressed by *network*
 	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.
@@ -117,6 +143,8 @@ Addressed by *network*
 
 *{bandwidthDownOctets}*: Instant down speed in octets/seconds.
 
+*{icon}*: Icon, as defined in *format-icons*.
+
 # EXAMPLES
 
 ```
@@ -126,6 +154,7 @@ Addressed by *network*
 	"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} ",
@@ -138,6 +167,7 @@ Addressed by *network*
 
 - *#network*
 - *#network.disconnected*
+- *#network.disabled*
 - *#network.linked*
 - *#network.ethernet*
 - *#network.wifi*

man/waybar-pulseaudio.5.scd

@@ -59,10 +59,18 @@ Additionally you can control the volume by scrolling *up* or *down* while the cu
 	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.
@@ -96,16 +104,17 @@ 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)
-- *headphones*
+- *headphone*
 - *speaker*
 - *hdmi*
 - *headset*
-- *handsfree*
+- *hands-free*
 - *portable*
 - *car*
 - *hifi*
 - *phone*
 
+
 # EXAMPLES
 
 ```

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-sway-mode.5.scd

@@ -29,10 +29,18 @@ Addressed by *sway/mode*
 	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.

man/waybar-sway-window.5.scd

@@ -29,10 +29,18 @@ Addressed by *sway/window*
 	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.

man/waybar-sway-workspaces.5.scd

@@ -19,7 +19,7 @@ Addressed by *sway/workspaces*
 
 *format*: ++
     typeof: string ++
-    default: {name} ++
+    default: {value} ++
     The format, how information should be displayed.
 
 *format-icons*: ++
@@ -60,9 +60,19 @@ Addressed by *sway/workspaces*
     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
 
-*{name}*: Name of the workspace, as defined by sway.
+*{value}*: Name of the workspace, as defined by sway.
+
+*{name}*: Number stripped from workspace value.
 
 *{icon}*: Icon, as defined in *format-icons*.
 
@@ -75,6 +85,7 @@ 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
 
@@ -100,6 +111,7 @@ n.b.: the list of outputs can be obtained from command line using *swaymsg -t ge
 "sway/workspaces": {
     "disable-scroll": true,
     "all-outputs": true,
+    "numeric-first": false,
     "format": "{name}: {icon}",
     "format-icons": {
         "1": "",
@@ -121,3 +133,4 @@ n.b.: the list of outputs can be obtained from command line using *swaymsg -t ge
 - *#workspaces button.focused*
 - *#workspaces button.urgent*
 - *#workspaces button.persistent*
+- *#workspaces button.current_output*

man/waybar-temperature.5.scd

@@ -13,74 +13,92 @@ The *temperature* module displays the current temperature from a thermal zone.
 Addressed by *temperature*
 
 *thermal-zone*: ++
-    typeof: integer ++
-    The thermal zone, as in */sys/class/thermal/*.
+	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/*.
+	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 (Celcius).
+	typeof: integer ++
+	The threshold before it is considered critical (Celsius).
 
 *interval*: ++
-    typeof: integer ++
-    default: 10 ++
-    The interval in which the information gets polled.
+	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
+	typeof: string ++
+	The format to use when temperature is considered critical
 
 *format*: ++
-    typeof: string  ++
-    default: {temperatureC}°C ++
-    The format (Celcius/Farenheit) in which the temperature should be displayed.
+	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 (Celcius) and *critical-threshold* if available, the corresponding icon gets selected. The order is *low* to *high*.
+	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.
+	typeof: integer ++
+	Positive value to rotate the text label.
 
 *max-length*: ++
-    typeof: integer ++
-    The maximum length in characters the module should display.
+	typeof: integer ++
+	The maximum length in characters the module should display.
 
 *on-click*: ++
-    typeof: string ++
-    Command to execute when you clicked on the module.
+	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.
+	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.
+	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.
+	typeof: string ++
+	Command to execute when scrolling down on the module.
 
 *smooth-scrolling-threshold*: ++
-    typeof: double ++
-    Threshold to be used when scrolling.
+	typeof: double ++
+	Threshold to be used when scrolling.
 
 *tooltip*: ++
-    typeof: bool ++
-    default: true ++
-    Option to disable tooltip on hover.
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
 
 # FORMAT REPLACEMENTS
 
-*{temperatureC}*: Temperature in Celcius.
+*{temperatureC}*: Temperature in Celsius.
 
 *{temperatureF}*: Temperature in Fahrenheit.
 
+*{temperatureK}*: Temperature in Kelvin.
+
 # EXAMPLES
 
 ```

man/waybar-tray.5.scd

@@ -20,6 +20,10 @@ Addressed by *tray*
     typeof: integer ++
     Defines the spacing between the tray icons.
 
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
 # EXAMPLES
 
 ```

man/waybar-wlr-taskbar.5.scd

@@ -0,0 +1,106 @@
+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.
+
+*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

@@ -15,7 +15,7 @@ Valid locations for this file are:
 - *~/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.
+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
@@ -23,11 +23,12 @@ Also a minimal example configuration can be found on the at the bottom of this m
 *layer* ++
 	typeof: string ++
 	default: bottom ++
-	Decide if the bar is displayed in front of the windows or behind them.
+	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.
+	Specifies on which screen this bar will be displayed. Exclamation mark(*!*) can be used to exclude specific output.
 
 *position* ++
 	typeof: string ++
@@ -66,6 +67,12 @@ Also a minimal example configuration can be found on the at the bottom of this m
 	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).
@@ -178,16 +185,21 @@ Valid options for the "rotate" property are: 0, 90, 180 and 270.
 
 - *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-mdp(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.9.0',
+    version: '0.9.3',
     license: 'MIT',
     default_options : [
         'cpp_std=c++17',
@@ -9,28 +9,38 @@ project(
     ],
 )
 
+compiler = meson.get_compiler('cpp')
+
 cpp_args = []
 cpp_link_args = []
 
 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')
@@ -42,11 +52,32 @@ if not compiler.has_header('filesystem')
     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.3.0'], fallback : ['fmt', 'fmt_dep'])
 spdlog = dependency('spdlog', version : ['>=1.3.1'], fallback : ['spdlog', 'spdlog_dep'])
 wayland_client = dependency('wayland-client')
@@ -57,6 +88,7 @@ dbusmenu_gtk = dependency('dbusmenu-gtk3-0.4', required: get_option('dbusmenu-gt
 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'))
@@ -66,11 +98,15 @@ 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')
 
@@ -86,27 +122,55 @@ 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/disk.cpp',
     'src/modules/idle_inhibitor.cpp',
     'src/modules/temperature.cpp',
     'src/main.cpp',
     'src/bar.cpp',
-    'src/client.cpp'
+    'src/client.cpp',
 )
 
-if true # 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/bluetooth.cpp',
+        'src/modules/cpu/common.cpp',
+        'src/modules/cpu/linux.cpp',
+        'src/modules/memory/common.cpp',
+        'src/modules/memory/linux.cpp',
+        'src/util/rfkill.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()
@@ -129,7 +193,7 @@ 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
@@ -156,7 +220,6 @@ executable(
         spdlog,
         sigcpp,
         jsoncpp,
-        libinput,
         wayland_cursor,
         gtkmm,
         dbusmenu_gtk,
@@ -165,8 +228,10 @@ executable(
         libnlgen,
         libpulse,
         libudev,
+        libepoll,
         libmpdclient,
-        gtk_layer_shell
+        gtk_layer_shell,
+        tz_dep
     ],
     include_directories: [include_directories('include')],
     install: true,
@@ -175,7 +240,7 @@ 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'))
@@ -197,12 +262,15 @@ if scdoc.found()
         '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

meson_options.txt

@@ -6,5 +6,4 @@ option('systemd', type: 'feature', value: 'auto', description: 'Install systemd
 option('dbusmenu-gtk', type: 'feature', value: 'auto', description: 'Enable support for tray')
 option('man-pages', type: 'feature', value: 'auto', description: 'Generate and install man pages')
 option('mpd', type: 'feature', value: 'auto', description: 'Enable support for the Music Player Daemon')
-option('out', type: 'string', value : '/', description: 'output prefix directory')
 option('gtk-layer-shell', type: 'feature', value: 'auto', description: 'Use gtk-layer-shell library for popups support')

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'/>

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,5 +1,5 @@
 {
-    "layer": "top", // Waybar at top layer
+    // "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
@@ -64,7 +64,8 @@
         "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": {
@@ -121,8 +122,8 @@
         "format-source": "{volume}% ",
         "format-source-muted": "",
         "format-icons": {
-            "headphones": "",
-            "handsfree": "",
+            "headphone": "",
+            "hands-free": "",
             "headset": "",
             "phone": "",
             "portable": "",

resources/custom_modules/mediaplayer.py

@@ -38,6 +38,8 @@ def on_metadata(player, metadata, manager):
     elif player.get_artist() != '' and player.get_title() != '':
         track_info = '{artist} - {title}'.format(artist=player.get_artist(),
                                                  title=player.get_title())
+    else:
+        track_info = player.get_title()
 
     if player.props.status != 'Playing' and track_info:
         track_info = ' ' + track_info
@@ -77,7 +79,7 @@ def signal_handler(sig, frame):
 def parse_arguments():
     parser = argparse.ArgumentParser()
 
-    # Increase verbosity with every occurance of -v
+    # Increase verbosity with every occurence of -v
     parser.add_argument('-v', '--verbose', action='count', default=0)
 
     # Define for which player we're listening
@@ -123,4 +125,3 @@ def main():
 
 if __name__ == '__main__':
     main()
-

resources/waybar.service.in

@@ -2,6 +2,7 @@
 Description=Highly customizable Wayland bar for Sway and Wlroots based compositors.
 Documentation=https://github.com/Alexays/Waybar/wiki/
 PartOf=wayland-session.target
+After=wayland-session.target
 
 [Service]
 Type=dbus

src/ALabel.cpp

@@ -31,7 +31,7 @@ ALabel::ALabel(const Json::Value& config, const std::string& name, const std::st
 }
 
 auto ALabel::update() -> void {
-  // Nothing here
+  AModule::update();
 }
 
 std::string ALabel::getIcon(uint16_t percentage, const std::string& alt, uint16_t max) {
@@ -54,6 +54,29 @@ std::string ALabel::getIcon(uint16_t percentage, const std::string& alt, uint16_
   return "";
 }
 
+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 "";
+}
+
 bool waybar::ALabel::handleToggle(GdkEventButton* const& e) {
   if (config_["format-alt-click"].isUInt() && e->button == config_["format-alt-click"].asUInt()) {
     alt_ = !alt_;

src/AModule.cpp

@@ -6,7 +6,7 @@ namespace waybar {
 
 AModule::AModule(const Json::Value& config, const std::string& name, const std::string& id,
                  bool enable_click, bool enable_scroll)
-    : config_(std::move(config)) {
+    : 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() ||
@@ -23,13 +23,17 @@ AModule::AModule(const Json::Value& config, const std::string& name, const std::
 AModule::~AModule() {
   for (const auto& pid : pid_) {
     if (pid != -1) {
-      kill(-pid, 9);
+      killpg(pid, SIGTERM);
     }
   }
 }
 
+
 auto AModule::update() -> void {
-  // Nothing here
+  // 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) {

src/bar.cpp

@@ -10,8 +10,8 @@
 waybar::Bar::Bar(struct waybar_output* w_output, const Json::Value& w_config)
     : output(w_output),
       config(w_config),
-      window{Gtk::WindowType::WINDOW_TOPLEVEL},
       surface(nullptr),
+      window{Gtk::WindowType::WINDOW_TOPLEVEL},
       layer_surface_(nullptr),
       anchor_(ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP),
       left_(Gtk::ORIENTATION_HORIZONTAL, 0),
@@ -121,7 +121,7 @@ void waybar::Bar::onConfigure(GdkEventConfigure* ev) {
   auto tmp_width = width_;
   if (ev->height > static_cast<int>(height_)) {
     // Default minimal value
-    if (height_ != 1) {
+    if (height_ > 1) {
       spdlog::warn(MIN_HEIGHT_MSG, height_, ev->height);
     }
     if (config["height"].isUInt()) {
@@ -132,7 +132,7 @@ void waybar::Bar::onConfigure(GdkEventConfigure* ev) {
   }
   if (ev->width > static_cast<int>(width_)) {
     // Default minimal value
-    if (width_ != 1) {
+    if (width_ > 1) {
       spdlog::warn(MIN_WIDTH_MSG, width_, ev->width);
     }
     if (config["width"].isUInt()) {
@@ -175,6 +175,11 @@ void waybar::Bar::initGtkLayerShell() {
   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_);
+  }
 }
 #endif
 

src/client.cpp

@@ -49,7 +49,7 @@ void waybar::Client::handleGlobalRemove(void *   data, struct wl_registry * /*re
   // Nothing here
 }
 
-void waybar::Client::handleOutput(std::unique_ptr<struct waybar_output> &output) {
+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) {},
@@ -58,42 +58,42 @@ void waybar::Client::handleOutput(std::unique_ptr<struct waybar_output> &output)
       .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.get());
+  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,
-                                   std::unique_ptr<struct waybar_output> &output) {
-  bool found = true;
+bool waybar::Client::isValidOutput(const Json::Value &config, struct waybar_output &output) {
   if (config["output"].isArray()) {
-    bool in_array = false;
     for (auto const &output_conf : config["output"]) {
-      if (output_conf.isString() && output_conf.asString() == output->name) {
-        in_array = true;
-        break;
+      if (output_conf.isString() && output_conf.asString() == output.name) {
+        return true;
       }
     }
-    found = in_array;
+    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;
+    }
   }
-  if (config["output"].isString() && config["output"].asString() != output->name) {
-    found = false;
-  }
-  return found;
+
+  return true;
 }
 
-std::unique_ptr<struct waybar::waybar_output> &waybar::Client::getOutput(void *addr) {
-  auto it = std::find_if(outputs_.begin(), outputs_.end(), [&addr](const auto &output) {
-    return output.get() == addr;
-  });
+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(
-    std::unique_ptr<struct waybar_output> &output) {
+std::vector<Json::Value> waybar::Client::getOutputConfigs(struct waybar_output &output) {
   std::vector<Json::Value> configs;
   if (config_.isArray()) {
     for (auto const &config : config_) {
@@ -112,18 +112,18 @@ void waybar::Client::handleOutputName(void *      data, struct zxdg_output_v1 *
   auto client = waybar::Client::inst();
   try {
     auto &output = client->getOutput(data);
-    output->name = name;
+    output.name = name;
     spdlog::debug("Output detected: {} ({} {})",
                   name,
-                  output->monitor->get_manufacturer(),
-                  output->monitor->get_model());
+                  output.monitor->get_manufacturer(),
+                  output.monitor->get_model());
     auto configs = client->getOutputConfigs(output);
     if (configs.empty()) {
-      output->xdg_output.reset();
+      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.get(), config));
+        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);
@@ -135,7 +135,8 @@ void waybar::Client::handleOutputName(void *      data, struct zxdg_output_v1 *
 }
 
 void waybar::Client::handleMonitorAdded(Glib::RefPtr<Gdk::Monitor> monitor) {
-  auto &output = outputs_.emplace_back(new struct waybar_output({monitor}));
+  auto &output = outputs_.emplace_back();
+  output.monitor = monitor;
   handleOutput(output);
 }
 
@@ -144,16 +145,15 @@ void waybar::Client::handleMonitorRemoved(Glib::RefPtr<Gdk::Monitor> monitor) {
   for (auto it = bars.begin(); it != bars.end();) {
     if ((*it)->output->monitor == monitor) {
       auto output_name = (*it)->output->name;
-      (*it)->window.close();
+      (*it)->window.hide();
+      gtk_app->remove_window((*it)->window);
       it = bars.erase(it);
       spdlog::info("Bar removed from output: {}", output_name);
     } else {
       ++it;
     }
   }
-  std::remove_if(outputs_.begin(), outputs_.end(), [&monitor](const auto &output) {
-    return output->monitor == monitor;
-  });
+  outputs_.remove_if([&monitor](const auto &output) { return output.monitor == monitor; });
 }
 
 std::tuple<const std::string, const std::string> waybar::Client::getConfigs(
@@ -162,7 +162,7 @@ std::tuple<const std::string, const std::string> waybar::Client::getConfigs(
                                           "$XDG_CONFIG_HOME/waybar/config",
                                           "$HOME/.config/waybar/config",
                                           "$HOME/waybar/config",
-                                          "/etc/xdg/waybar/config",
+                                          SYSCONFDIR "/xdg/waybar/config",
                                           "./resources/config",
                                       })
                                     : config;
@@ -170,7 +170,7 @@ std::tuple<const std::string, const std::string> waybar::Client::getConfigs(
                                       "$XDG_CONFIG_HOME/waybar/style.css",
                                       "$HOME/.config/waybar/style.css",
                                       "$HOME/waybar/style.css",
-                                      "/etc/xdg/waybar/style.css",
+                                      SYSCONFDIR "/xdg/waybar/style.css",
                                       "./resources/style.css",
                                   })
                                 : style;
@@ -253,7 +253,7 @@ int waybar::Client::main(int argc, char *argv[]) {
   if (!log_level.empty()) {
     spdlog::set_level(spdlog::level::from_str(log_level));
   }
-  gtk_app = Gtk::Application::create(argc, argv, "fr.arouillard.waybar");
+  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");

src/factory.cpp

@@ -7,7 +7,7 @@ waybar::AModule* waybar::Factory::makeModule(const std::string& name) const {
     auto hash_pos = name.find('#');
     auto ref = name.substr(0, hash_pos);
     auto id = hash_pos != std::string::npos ? name.substr(hash_pos + 1) : "";
-#ifndef NO_FILESYSTEM
+#if defined(__linux__) && !defined(NO_FILESYSTEM)
     if (ref == "battery") {
       return new waybar::modules::Battery(id, config_[name]);
     }
@@ -22,23 +22,37 @@ waybar::AModule* waybar::Factory::makeModule(const std::string& name) const {
     if (ref == "sway/window") {
       return new waybar::modules::sway::Window(id, bar_, config_[name]);
     }
+#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]);
     }
     if (ref == "disk") {
       return new waybar::modules::Disk(id, config_[name]);
     }
-#if defined(HAVE_DBUSMENU) && !defined(NO_FILESYSTEM)
+#ifdef HAVE_DBUSMENU
     if (ref == "tray") {
       return new waybar::modules::SNI::Tray(id, bar_, config_[name]);
     }
@@ -66,6 +80,11 @@ waybar::AModule* waybar::Factory::makeModule(const std::string& name) const {
     if (ref == "temperature") {
       return new waybar::modules::Temperature(id, config_[name]);
     }
+#if defined(__linux__)
+    if (ref == "bluetooth") {
+      return new waybar::modules::Bluetooth(id, config_[name]);
+    }
+#endif
     if (ref.compare(0, 7, "custom/") == 0 && ref.size() > 7) {
       return new waybar::modules::Custom(ref.substr(7), id, config_[name]);
     }

src/modules/backlight.cpp

@@ -1,16 +1,14 @@
 #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:
@@ -187,6 +185,8 @@ 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>
@@ -211,7 +211,7 @@ void waybar::modules::Backlight::upsert_device(ForwardIt first, ForwardIt last,
   check_nn(name);
 
   const char *actual_brightness_attr =
-      strcmp(name, "amdgpu_bl0") == 0 ? "brightness" : "actual_brightness";
+      strncmp(name, "amdgpu_bl", 9) == 0 ? "brightness" : "actual_brightness";
 
   const char *actual = udev_device_get_sysattr_value(dev, actual_brightness_attr);
   check_nn(actual);

src/modules/battery.cpp

@@ -1,4 +1,5 @@
 #include "modules/battery.hpp"
+
 #include <spdlog/spdlog.h>
 
 waybar::modules::Battery::Battery(const std::string& id, const Json::Value& config)
@@ -52,8 +53,13 @@ void waybar::modules::Battery::getBatteries() {
       auto bat_defined = config_["bat"].isString();
       if (((bat_defined && dir_name == config_["bat"].asString()) || !bat_defined) &&
           fs::exists(node.path() / "capacity") && fs::exists(node.path() / "uevent") &&
-          fs::exists(node.path() / "status")) {
-        batteries_.push_back(node.path());
+          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) &&
@@ -115,6 +121,16 @@ const std::tuple<uint8_t, float, std::string> waybar::modules::Battery::getInfos
       time_remaining = -(float)(total_energy_full - total_energy) / total_power;
     }
     uint16_t capacity = total / batteries_.size();
+    // 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) {
     spdlog::error("Battery: {}", e.what());
@@ -141,7 +157,7 @@ const std::string waybar::modules::Battery::formatTimeRemaining(float hoursRemai
   hoursRemaining = std::fabs(hoursRemaining);
   uint16_t full_hours = static_cast<uint16_t>(hoursRemaining);
   uint16_t minutes = static_cast<uint16_t>(60 * (hoursRemaining - full_hours));
-  auto format = std::string("{H} h {M} min");
+  auto     format = std::string("{H} h {M} min");
   if (config_["format-time"].isString()) {
     format = config_["format-time"].asString();
   }
@@ -163,7 +179,10 @@ auto waybar::modules::Battery::update() -> void {
     }
     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, true);
   if (!old_status_.empty()) {
@@ -182,9 +201,12 @@ auto waybar::modules::Battery::update() -> void {
     event_box_.hide();
   } else {
     event_box_.show();
+    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, state)),
+                                  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,8 +1,31 @@
 #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, "clock", id, "{:%H:%M}", 60) {
+    : ALabel(config, "clock", id, "{:%H:%M}", 60), 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();
@@ -13,19 +36,126 @@ waybar::modules::Clock::Clock(const std::string& id, const Json::Value& config)
 }
 
 auto waybar::modules::Clock::update() -> void {
-  tzset(); // Update timezone information
-  auto now = std::chrono::system_clock::now();
-  auto localtime = fmt::localtime(std::chrono::system_clock::to_time_t(now));
-  auto text = fmt::format(format_, localtime);
-  label_.set_markup(text);
+  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();
 }
+
+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) {
+      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/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

@@ -1,5 +1,4 @@
 #include "modules/cpu.hpp"
-#include <numeric>
 
 waybar::modules::Cpu::Cpu(const std::string& id, const Json::Value& config)
     : ALabel(config, "cpu", id, "{usage}%", 10) {
@@ -18,14 +17,14 @@ auto waybar::modules::Cpu::update() -> void {
   }
   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() {
-  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;
+  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");
 }
@@ -54,30 +53,3 @@ std::tuple<uint16_t, std::string> waybar::modules::Cpu::getCpuUsage() {
   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 = 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/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,22 +1,21 @@
 #include "modules/custom.hpp"
+
 #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) {
-  if (config_["exec"].isString()) {
-    if (interval_.count() > 0) {
-      delayWorker();
-    } else {
-      continuousWorker();
-    }
-  }
   dp.emit();
+  if (interval_.count() > 0) {
+    delayWorker();
+  } else if (config_["exec"].isString()) {
+    continuousWorker();
+  }
 }
 
 waybar::modules::Custom::~Custom() {
   if (pid_ != -1) {
-    kill(-pid_, 9);
+    killpg(pid_, SIGTERM);
     pid_ = -1;
   }
 }
@@ -25,14 +24,16 @@ void waybar::modules::Custom::delayWorker() {
   thread_ = [this] {
     bool can_update = true;
     if (config_["exec-if"].isString()) {
-      auto res = 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_ = util::command::exec(config_["exec"].asString());
+      if (config_["exec"].isString()) {
+        output_ = util::command::exec(config_["exec"].asString());
+      }
       dp.emit();
     }
     thread_.sleep_for(interval_);
@@ -46,31 +47,45 @@ void waybar::modules::Custom::continuousWorker() {
   if (!fp_) {
     throw std::runtime_error("Unable to open " + cmd);
   }
-  thread_ = [&] {
+  thread_ = [this, cmd] {
     char*  buff = nullptr;
     size_t len = 0;
+    bool   restart = false;
     if (getline(&buff, &len, fp_) == -1) {
       int exit_code = 1;
       if (fp_) {
         exit_code = WEXITSTATUS(util::command::close(fp_, pid_));
         fp_ = nullptr;
       }
-      thread_.stop();
       if (exit_code != 0) {
         output_ = {exit_code, ""};
         dp.emit();
         spdlog::error("{} stopped unexpectedly, is it endless?", name_);
       }
-      return;
-    }
-    std::string output = buff;
+      if (config_["restart-interval"].isUInt()) {
+        restart = true;
+        pid_ = -1;
+        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();
+    }
+    if (restart) {
+      thread_.sleep_for(std::chrono::seconds(config_["restart-interval"].asUInt()));
     }
-    output_ = {0, output};
-    dp.emit();
   };
 }
 
@@ -94,7 +109,8 @@ bool waybar::modules::Custom::handleToggle(GdkEventButton* const& e) {
 
 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") {
@@ -113,9 +129,9 @@ auto waybar::modules::Custom::update() -> void {
       label_.set_markup(str);
       if (tooltipEnabled()) {
         if (text_ == tooltip_) {
-          label_.set_tooltip_text(str);
+          label_.set_tooltip_markup(str);
         } else {
-          label_.set_tooltip_text(tooltip_);
+          label_.set_tooltip_markup(tooltip_);
         }
       }
       auto classes = label_.get_style_context()->list_classes();
@@ -128,6 +144,8 @@ auto waybar::modules::Custom::update() -> void {
       event_box_.show();
     }
   }
+  // Call parent update
+  ALabel::update();
 }
 
 void waybar::modules::Custom::parseOutputRaw() {

src/modules/disk.cpp

@@ -44,9 +44,9 @@ auto waybar::modules::Disk::update() -> void {
     return;
   }
 
-  auto free = pow_format(stats.f_bavail * stats.f_bsize, "B", true);
-  auto used = pow_format((stats.f_blocks - stats.f_bavail) * stats.f_bsize, "B", true);
-  auto total = pow_format(stats.f_blocks * stats.f_bsize, "B", true);
+  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
@@ -73,4 +73,6 @@ auto waybar::modules::Disk::update() -> void {
       ));
   }
   event_box_.show();
+  // Call parent update
+  ALabel::update();
 }

src/modules/idle_inhibitor.cpp

@@ -32,6 +32,8 @@ auto waybar::modules::IdleInhibitor::update() -> void {
   if (tooltipEnabled()) {
     label_.set_tooltip_text(status_);
   }
+  // Call parent update
+  ALabel::update();
 }
 
 bool waybar::modules::IdleInhibitor::handleToggle(GdkEventButton* const& e) {

src/modules/memory.cpp

@@ -1,66 +0,0 @@
-#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();
-  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()) {
-      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() {
-  int64_t       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);
-    int64_t     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,47 @@
+#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()) {
+      label_.set_tooltip_text(fmt::format("{:.{}f}Gb 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

@@ -56,21 +56,26 @@ auto waybar::modules::MPD::update() -> void {
   }
 
   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) {
+    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());
       }
     }
@@ -140,7 +145,9 @@ void waybar::modules::MPD::setLabel() {
     if (playing()) {
       label_.get_style_context()->add_class("playing");
       label_.get_style_context()->remove_class("paused");
-    } else {
+    } 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");
     }
@@ -259,7 +266,7 @@ void waybar::modules::MPD::tryConnect() {
 
   try {
     checkErrors(connection_.get());
-    spdlog::info("{}: Connected to MPD", module_name_);
+    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();
@@ -280,9 +287,12 @@ void waybar::modules::MPD::checkErrors(mpd_connection* conn) {
       state_ = MPD_STATE_UNKNOWN;
       throw std::runtime_error("Connection to MPD closed");
     default:
-      auto error_message = mpd_connection_get_error_message(conn);
-      mpd_connection_clear_error(conn);
-      throw std::runtime_error(std::string(error_message));
+      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");
   }
 }
 
@@ -342,7 +352,9 @@ bool waybar::modules::MPD::handlePlayPause(GdkEventButton* const& e) {
 }
 
 bool waybar::modules::MPD::stopped() {
-  return connection_ == nullptr || state_ == MPD_STATE_UNKNOWN || state_ == MPD_STATE_STOP;
+  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; }

src/modules/network.cpp

@@ -2,8 +2,9 @@
 #include <spdlog/spdlog.h>
 #include <sys/eventfd.h>
 #include <fstream>
+#include <cassert>
 #include "util/format.hpp"
-
+#include "util/rfkill.hpp"
 
 namespace {
 
@@ -80,12 +81,11 @@ waybar::modules::Network::Network(const std::string &id, const Json::Value &conf
     : ALabel(config, "network", id, "{ifname}", 60),
       ifid_(-1),
       family_(config["family"] == "ipv6" ? AF_INET6 : AF_INET),
-      efd_(-1),
-      ev_fd_(-1),
       cidr_(-1),
       signal_strength_dbm_(0),
       signal_strength_(0),
-      frequency_(0) {
+      frequency_(0),
+      rfkill_{RFKILL_TYPE_WLAN} {
   auto down_octets = read_netstat(BANDWIDTH_CATEGORY, BANDWIDTH_DOWN_TOTAL_KEY);
   auto up_octets = read_netstat(BANDWIDTH_CATEGORY, BANDWIDTH_UP_TOTAL_KEY);
   if (down_octets) {
@@ -115,14 +115,6 @@ waybar::modules::Network::Network(const std::string &id, const Json::Value &conf
 }
 
 waybar::modules::Network::~Network() {
-  if (ev_fd_ > -1) {
-    eventfd_write(ev_fd_, 1);
-    std::this_thread::sleep_for(std::chrono::milliseconds(150));
-    close(ev_fd_);
-  }
-  if (efd_ > -1) {
-    close(efd_);
-  }
   if (ev_sock_ != nullptr) {
     nl_socket_drop_membership(ev_sock_, RTNLGRP_LINK);
     if (family_ == AF_INET) {
@@ -154,30 +146,6 @@ void waybar::modules::Network::createEventSocket() {
   } else {
     nl_socket_add_membership(ev_sock_, RTNLGRP_IPV6_IFADDR);
   }
-  efd_ = epoll_create1(EPOLL_CLOEXEC);
-  if (efd_ < 0) {
-    throw std::runtime_error("Can't create epoll");
-  }
-  {
-    ev_fd_ = eventfd(0, EFD_NONBLOCK);
-    struct epoll_event event;
-    memset(&event, 0, sizeof(event));
-    event.events = EPOLLIN | EPOLLET;
-    event.data.fd = ev_fd_;
-    if (epoll_ctl(efd_, EPOLL_CTL_ADD, ev_fd_, &event) == -1) {
-      throw std::runtime_error("Can't add epoll event");
-    }
-  }
-  {
-    auto               fd = nl_socket_get_fd(ev_sock_);
-    struct epoll_event event;
-    memset(&event, 0, sizeof(event));
-    event.events = EPOLLIN | EPOLLET | EPOLLRDHUP;
-    event.data.fd = fd;
-    if (epoll_ctl(efd_, EPOLL_CTL_ADD, fd, &event) == -1) {
-      throw std::runtime_error("Can't add epoll event");
-    }
-  }
 }
 
 void waybar::modules::Network::createInfoSocket() {
@@ -190,11 +158,12 @@ void waybar::modules::Network::createInfoSocket() {
   }
   nl80211_id_ = genl_ctrl_resolve(sock_, "nl80211");
   if (nl80211_id_ < 0) {
-    throw std::runtime_error("Can't resolve nl80211 interface");
+    spdlog::warn("Can't resolve nl80211 interface");
   }
 }
 
 void waybar::modules::Network::worker() {
+  // update via here not working
   thread_timer_ = [this] {
     {
       std::lock_guard<std::mutex> lock(mutex_);
@@ -205,23 +174,24 @@ void waybar::modules::Network::worker() {
     }
     thread_timer_.sleep_for(interval_);
   };
-  thread_ = [this] {
-    std::array<struct epoll_event, EPOLL_MAX> events{};
-
-    int ec = epoll_wait(efd_, events.data(), EPOLL_MAX, -1);
-    if (ec > 0) {
-      for (auto i = 0; i < ec; i++) {
-        if (events[i].data.fd != nl_socket_get_fd(ev_sock_) || nl_recvmsgs_default(ev_sock_) < 0) {
-          thread_.stop();
-          break;
-        }
+  thread_rfkill_ = [this] {
+    rfkill_.waitForEvent();
+    {
+      std::lock_guard<std::mutex> lock(mutex_);
+      if (ifid_ > 0) {
+        getInfo();
+        dp.emit();
       }
     }
   };
 }
 
 const std::string waybar::modules::Network::getNetworkState() const {
-  if (ifid_ == -1) return "disconnected";
+  if (ifid_ == -1) {
+    if (rfkill_.getState())
+      return "disabled";
+    return "disconnected";
+  }
   if (ipaddr_.empty()) return "linked";
   if (essid_.empty()) return "ethernet";
   return "wifi";
@@ -278,8 +248,13 @@ auto waybar::modules::Network::update() -> void {
       fmt::arg("bandwidthUpBits", pow_format(bandwidth_up * 8ull / interval_.count(), "b/s")),
       fmt::arg("bandwidthDownOctets", pow_format(bandwidth_down / interval_.count(), "o/s")),
       fmt::arg("bandwidthUpOctets", pow_format(bandwidth_up / interval_.count(), "o/s")));
-  if (text != label_.get_label()) {
+  if (text.compare(label_.get_label()) != 0) {
     label_.set_markup(text);
+    if (text.empty()) {
+      event_box_.hide();
+    } else {
+      event_box_.show();
+    }
   }
   if (tooltipEnabled()) {
     if (tooltip_format.empty() && config_["tooltip-format"].isString()) {
@@ -309,6 +284,9 @@ auto waybar::modules::Network::update() -> void {
       label_.set_tooltip_text(text);
     }
   }
+
+  // Call parent update
+  ALabel::update();
 }
 
 // Based on https://gist.github.com/Yawning/c70d804d4b8ae78cc698
@@ -434,7 +412,6 @@ out:
 }
 
 void waybar::modules::Network::getInterfaceAddress() {
-  unsigned int    cidrRaw;
   struct ifaddrs *ifaddr, *ifa;
   cidr_ = 0;
   int success = getifaddrs(&ifaddr);
@@ -446,18 +423,34 @@ void waybar::modules::Network::getInterfaceAddress() {
     if (ifa->ifa_addr != nullptr && ifa->ifa_addr->sa_family == family_ &&
         ifa->ifa_name == ifname_) {
       char ipaddr[INET6_ADDRSTRLEN];
-      ipaddr_ = inet_ntop(family_,
-                          &reinterpret_cast<struct sockaddr_in *>(ifa->ifa_addr)->sin_addr,
-                          ipaddr,
-                          INET6_ADDRSTRLEN);
       char netmask[INET6_ADDRSTRLEN];
-      auto net_addr = reinterpret_cast<struct sockaddr_in *>(ifa->ifa_netmask);
-      netmask_ = inet_ntop(family_, &net_addr->sin_addr, netmask, INET6_ADDRSTRLEN);
-      cidrRaw = net_addr->sin_addr.s_addr;
       unsigned int cidr = 0;
-      while (cidrRaw) {
-        cidr += cidrRaw & 1;
-        cidrRaw >>= 1;
+      if (family_ == AF_INET) {
+        ipaddr_ = inet_ntop(AF_INET,
+                            &reinterpret_cast<struct sockaddr_in *>(ifa->ifa_addr)->sin_addr,
+                            ipaddr,
+                            INET_ADDRSTRLEN);
+        auto net_addr = reinterpret_cast<struct sockaddr_in *>(ifa->ifa_netmask);
+        netmask_ = inet_ntop(AF_INET, &net_addr->sin_addr, netmask, INET_ADDRSTRLEN);
+        unsigned int cidrRaw = net_addr->sin_addr.s_addr;
+        while (cidrRaw) {
+          cidr += cidrRaw & 1;
+          cidrRaw >>= 1;
+        }
+      } else {
+        ipaddr_ = inet_ntop(AF_INET6,
+                            &reinterpret_cast<struct sockaddr_in6 *>(ifa->ifa_addr)->sin6_addr,
+                            ipaddr,
+                            INET6_ADDRSTRLEN);
+        auto net_addr = reinterpret_cast<struct sockaddr_in6 *>(ifa->ifa_netmask);
+        netmask_ = inet_ntop(AF_INET6, &net_addr->sin6_addr, netmask, INET6_ADDRSTRLEN);
+        for (size_t i = 0; i < sizeof(net_addr->sin6_addr.s6_addr); ++i) {
+          unsigned char cidrRaw = net_addr->sin6_addr.s6_addr[i];
+          while (cidrRaw) {
+            cidr += cidrRaw & 1;
+            cidrRaw >>= 1;
+          }
+        }
       }
       cidr_ = cidr;
       break;

src/modules/pulseaudio.cpp

@@ -21,7 +21,7 @@ waybar::modules::Pulseaudio::Pulseaudio(const std::string &id, const Json::Value
   if (context_ == nullptr) {
     throw std::runtime_error("pa_context_new() failed.");
   }
-  if (pa_context_connect(context_, nullptr, PA_CONTEXT_NOAUTOSPAWN, nullptr) < 0) {
+  if (pa_context_connect(context_, nullptr, PA_CONTEXT_NOFAIL, nullptr) < 0) {
     auto err =
         fmt::format("pa_context_connect() failed: {}", pa_strerror(pa_context_errno(context_)));
     throw std::runtime_error(err);
@@ -52,7 +52,8 @@ void waybar::modules::Pulseaudio::contextStateCb(pa_context *c, void *data) {
       pa_context_set_subscribe_callback(c, subscribeCb, data);
       pa_context_subscribe(
           c,
-          static_cast<enum pa_subscription_mask>(static_cast<int>(PA_SUBSCRIPTION_MASK_SINK) |
+          static_cast<enum pa_subscription_mask>(static_cast<int>(PA_SUBSCRIPTION_MASK_SERVER) |
+                                                 static_cast<int>(PA_SUBSCRIPTION_MASK_SINK) |
                                                  static_cast<int>(PA_SUBSCRIPTION_MASK_SOURCE)),
           nullptr,
           nullptr);
@@ -109,7 +110,9 @@ void waybar::modules::Pulseaudio::subscribeCb(pa_context *                 conte
   if (operation != PA_SUBSCRIPTION_EVENT_CHANGE) {
     return;
   }
-  if (facility == PA_SUBSCRIPTION_EVENT_SINK) {
+  if (facility == PA_SUBSCRIPTION_EVENT_SERVER) {
+    pa_context_get_server_info(context, serverInfoCb, data);
+  } else if (facility == PA_SUBSCRIPTION_EVENT_SINK) {
     pa_context_get_sink_info_by_index(context, idx, sinkInfoCb, data);
   } else if (facility == PA_SUBSCRIPTION_EVENT_SOURCE) {
     pa_context_get_source_info_by_index(context, idx, sourceInfoCb, data);
@@ -131,15 +134,15 @@ void waybar::modules::Pulseaudio::volumeModifyCb(pa_context *c, int success, voi
  */
 void waybar::modules::Pulseaudio::sourceInfoCb(pa_context * /*context*/, const pa_source_info *i,
                                                int /*eol*/, void *data) {
-  if (i != nullptr) {
-    auto self = static_cast<waybar::modules::Pulseaudio *>(data);
+  auto pa = static_cast<waybar::modules::Pulseaudio *>(data);
+  if (i != nullptr && pa->default_source_name_ == i->name) {
     auto source_volume = static_cast<float>(pa_cvolume_avg(&(i->volume))) / float{PA_VOLUME_NORM};
-    self->source_volume_ = std::round(source_volume * 100.0F);
-    self->source_idx_ = i->index;
-    self->source_muted_ = i->mute != 0;
-    self->source_desc_ = i->description;
-    self->source_port_name_ = i->active_port != nullptr ? i->active_port->name : "Unknown";
-    self->dp.emit();
+    pa->source_volume_ = std::round(source_volume * 100.0F);
+    pa->source_idx_ = i->index;
+    pa->source_muted_ = i->mute != 0;
+    pa->source_desc_ = i->description;
+    pa->source_port_name_ = i->active_port != nullptr ? i->active_port->name : "Unknown";
+    pa->dp.emit();
   }
 }
 
@@ -147,9 +150,9 @@ void waybar::modules::Pulseaudio::sourceInfoCb(pa_context * /*context*/, const p
  * Called when the requested sink information is ready.
  */
 void waybar::modules::Pulseaudio::sinkInfoCb(pa_context * /*context*/, const pa_sink_info *i,
-                                             int /*eol*/, void *                           data) {
-  if (i != nullptr) {
-    auto pa = static_cast<waybar::modules::Pulseaudio *>(data);
+                                             int /*eol*/, void *data) {
+  auto pa = static_cast<waybar::modules::Pulseaudio *>(data);
+  if (i != nullptr && pa->default_sink_name_ == i->name) {
     pa->pa_volume_ = i->volume;
     float volume = static_cast<float>(pa_cvolume_avg(&(pa->pa_volume_))) / float{PA_VOLUME_NORM};
     pa->sink_idx_ = i->index;
@@ -158,6 +161,9 @@ void waybar::modules::Pulseaudio::sinkInfoCb(pa_context * /*context*/, const pa_
     pa->desc_ = i->description;
     pa->monitor_ = i->monitor_source_name;
     pa->port_name_ = i->active_port != nullptr ? i->active_port->name : "Unknown";
+    if (auto ff = pa_proplist_gets(i->proplist, PA_PROP_DEVICE_FORM_FACTOR)) {
+      pa->form_factor_ = ff;
+    }
     pa->dp.emit();
   }
 }
@@ -168,16 +174,20 @@ void waybar::modules::Pulseaudio::sinkInfoCb(pa_context * /*context*/, const pa_
  */
 void waybar::modules::Pulseaudio::serverInfoCb(pa_context *context, const pa_server_info *i,
                                                void *data) {
+  auto pa = static_cast<waybar::modules::Pulseaudio *>(data);
+  pa->default_sink_name_ = i->default_sink_name;
+  pa->default_source_name_ = i->default_source_name;
+
   pa_context_get_sink_info_by_name(context, i->default_sink_name, sinkInfoCb, data);
   pa_context_get_source_info_by_name(context, i->default_source_name, sourceInfoCb, data);
 }
 
 static const std::array<std::string, 9> ports = {
-    "headphones",
+    "headphone",
     "speaker",
     "hdmi",
     "headset",
-    "handsfree",
+    "hands-free",
     "portable",
     "car",
     "hifi",
@@ -185,7 +195,7 @@ static const std::array<std::string, 9> ports = {
 };
 
 const std::string waybar::modules::Pulseaudio::getPortIcon() const {
-  std::string nameLC = port_name_;
+  std::string nameLC = port_name_ + form_factor_;
   std::transform(nameLC.begin(), nameLC.end(), nameLC.begin(), ::tolower);
   for (auto const &port : ports) {
     if (nameLC.find(port) != std::string::npos) {
@@ -197,21 +207,27 @@ const std::string waybar::modules::Pulseaudio::getPortIcon() const {
 
 auto waybar::modules::Pulseaudio::update() -> void {
   auto format = format_;
-  std::string format_name = "format";
-  if (monitor_.find("a2dp_sink") != std::string::npos) {
-    format_name = format_name + "-bluetooth";
-    label_.get_style_context()->add_class("bluetooth");
-  } else {
-    label_.get_style_context()->remove_class("bluetooth");
+  if (!alt_) {
+    std::string format_name = "format";
+    if (monitor_.find("a2dp_sink") != std::string::npos) {
+      format_name = format_name + "-bluetooth";
+      label_.get_style_context()->add_class("bluetooth");
+    } else {
+      label_.get_style_context()->remove_class("bluetooth");
+    }
+    if (muted_) {
+      // Check muted bluetooth format exist, otherwise fallback to default muted format
+      if (format_name != "format" && !config_[format_name + "-muted"].isString()) {
+        format_name = "format";
+      }
+      format_name = format_name + "-muted";
+      label_.get_style_context()->add_class("muted");
+    } else {
+      label_.get_style_context()->remove_class("muted");
+    }
+    format =
+      config_[format_name].isString() ? config_[format_name].asString() : format;
   }
-  if (muted_ ) {
-    format_name = format_name + "-muted";
-    label_.get_style_context()->add_class("muted");
-  } else {
-    label_.get_style_context()->remove_class("muted");
-  }
-  format = 
-    config_[format_name].isString() ? config_[format_name].asString() : format;
   // TODO: find a better way to split source/sink
   std::string format_source = "{volume}%";
   if (source_muted_ && config_["format-source-muted"].isString()) {
@@ -229,4 +245,7 @@ auto waybar::modules::Pulseaudio::update() -> void {
   if (tooltipEnabled()) {
     label_.set_tooltip_text(desc_);
   }
+
+  // Call parent update
+  ALabel::update();
 }

src/modules/river/tags.cpp

@@ -0,0 +1,118 @@
+#include <gtkmm/button.h>
+#include <gtkmm/label.h>
+#include <spdlog/spdlog.h>
+#include <wayland-client.h>
+
+#include "client.hpp"
+#include "modules/river/tags.hpp"
+#include "river-status-unstable-v1-client-protocol.h"
+#include "xdg-output-unstable-v1-client-protocol.h"
+
+namespace waybar::modules::river {
+
+static void listen_focused_tags(void *data, struct zriver_output_status_v1 *zriver_output_status_v1,
+                                uint32_t tags) {
+  static_cast<Tags *>(data)->handle_focused_tags(tags);
+}
+
+static void listen_view_tags(void *data, struct zriver_output_status_v1 *zriver_output_status_v1,
+                             struct wl_array *tags) {
+  static_cast<Tags *>(data)->handle_view_tags(tags);
+}
+
+static const zriver_output_status_v1_listener output_status_listener_impl{
+    .focused_tags = listen_focused_tags,
+    .view_tags = listen_view_tags,
+};
+
+static void handle_global(void *data, struct wl_registry *registry, uint32_t name,
+                          const char *interface, uint32_t version) {
+  if (std::strcmp(interface, zriver_status_manager_v1_interface.name) == 0) {
+    static_cast<Tags *>(data)->status_manager_ = static_cast<struct zriver_status_manager_v1 *>(
+        wl_registry_bind(registry, name, &zriver_status_manager_v1_interface, version));
+  }
+}
+
+static void handle_global_remove(void *data, struct wl_registry *registry, uint32_t name) {
+  /* Ignore event */
+}
+
+static const wl_registry_listener registry_listener_impl = {.global = handle_global,
+                                                            .global_remove = handle_global_remove};
+
+Tags::Tags(const std::string &id, const waybar::Bar &bar, const Json::Value &config)
+    : waybar::AModule(config, "tags", id, false, false),
+      status_manager_{nullptr},
+      bar_(bar),
+      box_{bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0},
+      output_status_{nullptr} {
+  struct wl_display * display = Client::inst()->wl_display;
+  struct wl_registry *registry = wl_display_get_registry(display);
+  wl_registry_add_listener(registry, &registry_listener_impl, this);
+  wl_display_roundtrip(display);
+
+  if (!status_manager_) {
+    spdlog::error("river_status_manager_v1 not advertised");
+    return;
+  }
+
+  box_.set_name("tags");
+  if (!id.empty()) {
+    box_.get_style_context()->add_class(id);
+  }
+  event_box_.add(box_);
+
+  // Default to 9 tags
+  const uint32_t num_tags = config["num-tags"].isUInt() ? config_["num-tags"].asUInt() : 9;
+  for (uint32_t tag = 1; tag <= num_tags; ++tag) {
+    Gtk::Button &button = buttons_.emplace_back(std::to_string(tag));
+    button.set_relief(Gtk::RELIEF_NONE);
+    box_.pack_start(button, false, false, 0);
+    button.show();
+  }
+
+  struct wl_output *output = gdk_wayland_monitor_get_wl_output(bar_.output->monitor->gobj());
+  output_status_ = zriver_status_manager_v1_get_river_output_status(status_manager_, output);
+  zriver_output_status_v1_add_listener(output_status_, &output_status_listener_impl, this);
+
+  zriver_status_manager_v1_destroy(status_manager_);
+}
+
+Tags::~Tags() {
+  if (output_status_) {
+    zriver_output_status_v1_destroy(output_status_);
+  }
+}
+
+void Tags::handle_focused_tags(uint32_t tags) {
+  uint32_t i = 0;
+  for (auto &button : buttons_) {
+    if ((1 << i) & tags) {
+      button.get_style_context()->add_class("focused");
+    } else {
+      button.get_style_context()->remove_class("focused");
+    }
+    ++i;
+  }
+}
+
+void Tags::handle_view_tags(struct wl_array *view_tags) {
+  // First clear all occupied state
+  for (auto &button : buttons_) {
+    button.get_style_context()->remove_class("occupied");
+  }
+
+  // Set tags with a view to occupied
+  uint32_t *start = static_cast<uint32_t *>(view_tags->data);
+  for (uint32_t *tags = start; tags < start + view_tags->size / sizeof(uint32_t); ++tags) {
+    uint32_t i = 0;
+    for (auto &button : buttons_) {
+      if (*tags & (1 << i)) {
+        button.get_style_context()->add_class("occupied");
+      }
+      ++i;
+    }
+  }
+}
+
+} /* namespace waybar::modules::river */

src/modules/sni/item.cpp

@@ -1,6 +1,7 @@
 #include "modules/sni/item.hpp"
 #include <glibmm/main.h>
 #include <spdlog/spdlog.h>
+#include <fstream>
 
 template <>
 struct fmt::formatter<Glib::ustring> : formatter<std::string> {
@@ -256,16 +257,17 @@ void Item::updateImage() {
   if (!icon_name.empty()) {
     try {
       // Try to find icons specified by path and filename
-#ifdef FILESYSTEM_EXPERIMENTAL
-      if (std::experimental::filesystem::exists(icon_name)) {
-#else
-      if (std::filesystem::exists(icon_name)) {
-#endif
+      std::ifstream temp(icon_name);
+      if (temp.is_open()) {
         auto pixbuf = Gdk::Pixbuf::create_from_file(icon_name);
         if (pixbuf->gobj() != nullptr) {
           // An icon specified by path and filename may be the wrong size for
           // the tray
-          pixbuf = pixbuf->scale_simple(icon_size, icon_size, Gdk::InterpType::INTERP_BILINEAR);
+          // Keep the aspect ratio and scale to make the height equal to icon_size
+          // If people have non square icons, assume they want it to grow in width not height
+          int width = icon_size * pixbuf->get_width() / pixbuf->get_height();
+
+          pixbuf = pixbuf->scale_simple(width, icon_size, Gdk::InterpType::INTERP_BILINEAR);
           image.set(pixbuf);
         }
       } else {

src/modules/sni/tray.cpp

@@ -6,7 +6,7 @@ namespace waybar::modules::SNI {
 Tray::Tray(const std::string& id, const Bar& bar, const Json::Value& config)
     : AModule(config, "tray", id),
       box_(bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0),
-      watcher_(nb_hosts_),
+      watcher_(SNI::Watcher::getInstance()),
       host_(nb_hosts_, config, std::bind(&Tray::onAdd, this, std::placeholders::_1),
             std::bind(&Tray::onRemove, this, std::placeholders::_1)) {
   spdlog::warn(
@@ -40,6 +40,8 @@ auto Tray::update() -> void {
   } else {
     box_.show_all();
   }
+  // Call parent update
+  AModule::update();
 }
 
 }  // namespace waybar::modules::SNI

src/modules/sni/watcher.cpp

@@ -3,14 +3,13 @@
 
 using namespace waybar::modules::SNI;
 
-Watcher::Watcher(std::size_t id)
+Watcher::Watcher()
     : bus_name_id_(Gio::DBus::own_name(Gio::DBus::BusType::BUS_TYPE_SESSION,
                                        "org.kde.StatusNotifierWatcher",
                                        sigc::mem_fun(*this, &Watcher::busAcquired),
                                        Gio::DBus::SlotNameAcquired(), Gio::DBus::SlotNameLost(),
                                        Gio::DBus::BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT |
                                            Gio::DBus::BUS_NAME_OWNER_FLAGS_REPLACE)),
-      watcher_id_(id),
       watcher_(sn_watcher_skeleton_new()) {}
 
 Watcher::~Watcher() {
@@ -23,6 +22,7 @@ Watcher::~Watcher() {
     g_slist_free_full(items_, gfWatchFree);
     items_ = nullptr;
   }
+  Gio::DBus::unown_name(bus_name_id_);
   auto iface = G_DBUS_INTERFACE_SKELETON(watcher_);
   g_dbus_interface_skeleton_unexport(iface);
 }
@@ -34,7 +34,7 @@ void Watcher::busAcquired(const Glib::RefPtr<Gio::DBus::Connection>& conn, Glib:
   if (error != nullptr) {
     // Don't print an error when a watcher is already present
     if (error->code != 2) {
-      spdlog::error("Watcher {}: {}", watcher_id_, error->message);
+      spdlog::error("Watcher: {}", error->message);
     }
     g_error_free(error);
     return;

src/modules/sway/ipc/client.cpp

@@ -10,19 +10,23 @@ Ipc::Ipc() {
 }
 
 Ipc::~Ipc() {
-  // To fail the IPC header
-  write(fd_, "close-sway-ipc", 14);
-  write(fd_event_, "close-sway-ipc", 14);
+  thread_.stop();
+
   if (fd_ > 0) {
+    // To fail the IPC header
+    write(fd_, "close-sway-ipc", 14);
     close(fd_);
     fd_ = -1;
   }
   if (fd_event_ > 0) {
+    write(fd_event_, "close-sway-ipc", 14);
     close(fd_event_);
     fd_event_ = -1;
   }
 }
 
+void Ipc::setWorker(std::function<void()>&& func) { thread_ = func; }
+
 const std::string Ipc::getSocketPath() const {
   const char* env = getenv("SWAYSOCK");
   if (env != nullptr) {

src/modules/sway/mode.cpp

@@ -8,7 +8,13 @@ Mode::Mode(const std::string& id, const Json::Value& config)
   ipc_.subscribe(R"(["mode"])");
   ipc_.signal_event.connect(sigc::mem_fun(*this, &Mode::onEvent));
   // Launch worker
-  worker();
+  ipc_.setWorker([this] {
+    try {
+      ipc_.handleEvent();
+    } catch (const std::exception& e) {
+      spdlog::error("Mode: {}", e.what());
+    }
+  });
   dp.emit();
 }
 
@@ -31,16 +37,6 @@ void Mode::onEvent(const struct Ipc::ipc_response& res) {
   }
 }
 
-void Mode::worker() {
-  thread_ = [this] {
-    try {
-      ipc_.handleEvent();
-    } catch (const std::exception& e) {
-      spdlog::error("Mode: {}", e.what());
-    }
-  };
-}
-
 auto Mode::update() -> void {
   if (mode_.empty()) {
     event_box_.hide();
@@ -51,6 +47,8 @@ auto Mode::update() -> void {
     }
     event_box_.show();
   }
+  // Call parent update
+  ALabel::update();
 }
 
 }  // namespace waybar::modules::sway

src/modules/sway/window.cpp

@@ -11,7 +11,13 @@ Window::Window(const std::string& id, const Bar& bar, const Json::Value& config)
   // Get Initial focused window
   getTree();
   // Launch worker
-  worker();
+  ipc_.setWorker([this] {
+    try {
+      ipc_.handleEvent();
+    } catch (const std::exception& e) {
+      spdlog::error("Window: {}", e.what());
+    }
+  });
 }
 
 void Window::onEvent(const struct Ipc::ipc_response& res) { getTree(); }
@@ -28,16 +34,6 @@ void Window::onCmd(const struct Ipc::ipc_response& res) {
   }
 }
 
-void Window::worker() {
-  thread_ = [this] {
-    try {
-      ipc_.handleEvent();
-    } catch (const std::exception& e) {
-      spdlog::error("Window: {}", e.what());
-    }
-  };
-}
-
 auto Window::update() -> void {
   if (!old_app_id_.empty()) {
     bar_.window.get_style_context()->remove_class(old_app_id_);
@@ -64,6 +60,8 @@ auto Window::update() -> void {
   if (tooltipEnabled()) {
     label_.set_tooltip_text(window_);
   }
+  // Call parent update
+  ALabel::update();
 }
 
 std::tuple<std::size_t, int, std::string, std::string> Window::getFocusedNode(

src/modules/sway/workspaces.cpp

@@ -1,8 +1,28 @@
 #include "modules/sway/workspaces.hpp"
+
 #include <spdlog/spdlog.h>
 
+#include <cctype>
+#include <string>
+
 namespace waybar::modules::sway {
 
+// Helper function to to assign a number to a workspace, just like sway. In fact
+// this is taken quite verbatim from `sway/ipc-json.c`.
+int Workspaces::convertWorkspaceNameToNum(std::string name) {
+  if (isdigit(name[0])) {
+    errno = 0;
+    char *    endptr = NULL;
+    long long parsed_num = strtoll(name.c_str(), &endptr, 10);
+    if (errno != 0 || parsed_num > INT32_MAX || parsed_num < 0 || endptr == name.c_str()) {
+      return -1;
+    } else {
+      return (int)parsed_num;
+    }
+  }
+  return -1;
+}
+
 Workspaces::Workspaces(const std::string &id, const Bar &bar, const Json::Value &config)
     : AModule(config, "workspaces", id, false, !config["disable-scroll"].asBool()),
       bar_(bar),
@@ -22,7 +42,13 @@ Workspaces::Workspaces(const std::string &id, const Bar &bar, const Json::Value
     window.signal_scroll_event().connect(sigc::mem_fun(*this, &Workspaces::handleScroll));
   }
   // Launch worker
-  worker();
+  ipc_.setWorker([this] {
+    try {
+      ipc_.handleEvent();
+    } catch (const std::exception &e) {
+      spdlog::error("Workspaces: {}", e.what());
+    }
+  });
 }
 
 void Workspaces::onEvent(const struct Ipc::ipc_response &res) {
@@ -84,16 +110,54 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
               workspaces_.emplace_back(std::move(v));
             }
           }
-
-          std::sort(workspaces_.begin(),
-                    workspaces_.end(),
-                    [](const Json::Value &lhs, const Json::Value &rhs) {
-                      if (lhs["name"].isInt() && rhs["name"].isInt()) {
-                        return lhs["name"].asInt() < rhs["name"].asInt();
-                      }
-                      return lhs["name"].asString() < rhs["name"].asString();
-                    });
         }
+
+        // config option to sort numeric workspace names before others
+        bool config_numeric_first = config_["numeric-first"].asBool();
+
+        std::sort(workspaces_.begin(),
+                  workspaces_.end(),
+                  [config_numeric_first](const Json::Value &lhs, const Json::Value &rhs) {
+                    // the "num" property (integer type):
+                    // The workspace number or -1 for workspaces that do
+                    // not start with a number.
+                    // We could rely on sway providing this property:
+                    //
+                    //     auto l = lhs["num"].asInt();
+                    //     auto r = rhs["num"].asInt();
+                    //
+                    // We cannot rely on the "num" property as provided by sway
+                    // via IPC, because persistent workspace might not exist in
+                    // sway's view. However, we need this property also for
+                    // not-yet created persistent workspace. As such, we simply
+                    // duplicate sway's logic of assigning the "num" property
+                    // into waybar (see convertWorkspaceNameToNum). This way the
+                    // sorting should work out even when we include workspaces
+                    // that do not currently exist.
+                    auto lname = lhs["name"].asString();
+                    auto rname = rhs["name"].asString();
+                    int  l = convertWorkspaceNameToNum(lname);
+                    int  r = convertWorkspaceNameToNum(rname);
+
+                    if (l == r) {
+                      // in case both integers are the same, lexicographical
+                      // sort. This also covers the case when both don't have a
+                      // number (i.e., l == r == -1).
+                      return lname < rname;
+                    }
+
+                    // one of the workspaces doesn't begin with a number, so
+                    // num is -1.
+                    if (l < 0 || r < 0) {
+                      if (config_numeric_first) {
+                        return r < 0;
+                      }
+                      return l < 0;
+                    }
+
+                    // both workspaces have a "num" so let's just compare those
+                    return l < r;
+                  });
       }
       dp.emit();
     } catch (const std::exception &e) {
@@ -102,16 +166,6 @@ void Workspaces::onCmd(const struct Ipc::ipc_response &res) {
   }
 }
 
-void Workspaces::worker() {
-  thread_ = [this] {
-    try {
-      ipc_.handleEvent();
-    } catch (const std::exception &e) {
-      spdlog::error("Workspaces: {}", e.what());
-    }
-  };
-}
-
 bool Workspaces::filterButtons() {
   bool needReorder = false;
   for (auto it = buttons_.begin(); it != buttons_.end();) {
@@ -158,15 +212,25 @@ auto Workspaces::update() -> void {
     } else {
       button.get_style_context()->remove_class("persistent");
     }
+    if ((*it)["output"].isString()) {
+      if (((*it)["output"].asString()) == bar_.output->name) {
+        button.get_style_context()->add_class("current_output");
+      } else {
+        button.get_style_context()->remove_class("current_output");
+      }
+    } else {
+      button.get_style_context()->remove_class("current_output");
+    }
     if (needReorder) {
       box_.reorder_child(button, it - workspaces_.begin());
     }
-    std::string output = getIcon((*it)["name"].asString(), *it);
+    std::string output = (*it)["name"].asString();
     if (config_["format"].isString()) {
       auto format = config_["format"].asString();
       output = fmt::format(format,
-                           fmt::arg("icon", output),
-                           fmt::arg("name", trimWorkspaceName((*it)["name"].asString())),
+                           fmt::arg("icon", getIcon(output, *it)),
+                           fmt::arg("value", output),
+                           fmt::arg("name", trimWorkspaceName(output)),
                            fmt::arg("index", (*it)["num"].asString()));
     }
     if (!config_["disable-markup"].asBool()) {
@@ -176,6 +240,8 @@ auto Workspaces::update() -> void {
     }
     onButtonReady(*it, button);
   }
+  // Call parent update
+  AModule::update();
 }
 
 Gtk::Button &Workspaces::addButton(const Json::Value &node) {
@@ -188,12 +254,12 @@ Gtk::Button &Workspaces::addButton(const Json::Value &node) {
       if (node["target_output"].isString()) {
         ipc_.sendCmd(
             IPC_COMMAND,
-            fmt::format("workspace \"{}\"; move workspace to output \"{}\"; workspace \"{}\"",
+            fmt::format(workspace_switch_cmd_ + "; move workspace to output \"{}\"; " + workspace_switch_cmd_,
                         node["name"].asString(),
                         node["target_output"].asString(),
                         node["name"].asString()));
       } else {
-        ipc_.sendCmd(IPC_COMMAND, fmt::format("workspace \"{}\"", node["name"].asString()));
+        ipc_.sendCmd(IPC_COMMAND, fmt::format(workspace_switch_cmd_, node["name"].asString()));
       }
     } catch (const std::exception &e) {
       spdlog::error("Workspaces: {}", e.what());
@@ -209,6 +275,9 @@ std::string Workspaces::getIcon(const std::string &name, const Json::Value &node
       if (config_["format-icons"][key].isString() && node[key].asBool()) {
         return config_["format-icons"][key].asString();
       }
+    } else if (config_["format_icons"]["persistent"].isString() &&
+               node["target_output"].isString()) {
+      return config_["format-icons"]["persistent"].asString();
     } else if (config_["format-icons"][key].isString()) {
       return config_["format-icons"][key].asString();
     }
@@ -242,7 +311,7 @@ bool Workspaces::handleScroll(GdkEventScroll *e) {
     }
   }
   try {
-    ipc_.sendCmd(IPC_COMMAND, fmt::format("workspace \"{}\"", name));
+    ipc_.sendCmd(IPC_COMMAND, fmt::format(workspace_switch_cmd_, name));
   } catch (const std::exception &e) {
     spdlog::error("Workspaces: {}", e.what());
   }

src/modules/temperature.cpp

@@ -1,9 +1,12 @@
 #include "modules/temperature.hpp"
+#include <filesystem>
 
 waybar::modules::Temperature::Temperature(const std::string& id, const Json::Value& config)
     : ALabel(config, "temperature", id, "{temperatureC}°C", 10) {
   if (config_["hwmon-path"].isString()) {
     file_path_ = config_["hwmon-path"].asString();
+  } else if (config_["hwmon-path-abs"].isString() && config_["input-filename"].isString()) {
+    file_path_ = (*std::filesystem::directory_iterator(config_["hwmon-path-abs"].asString())).path().string() + "/" + config_["input-filename"].asString();
   } else {
     auto zone = config_["thermal-zone"].isInt() ? config_["thermal-zone"].asInt() : 0;
     file_path_ = fmt::format("/sys/class/thermal/thermal_zone{}/temp", zone);
@@ -19,7 +22,10 @@ waybar::modules::Temperature::Temperature(const std::string& id, const Json::Val
 }
 
 auto waybar::modules::Temperature::update() -> void {
-  auto [temperature_c, temperature_f] = getTemperature();
+  auto temperature = getTemperature();
+  uint16_t temperature_c = std::round(temperature);
+  uint16_t temperature_f = std::round(temperature * 1.8 + 32);
+  uint16_t temperature_k = std::round(temperature + 273.15);
   auto critical = isCritical(temperature_c);
   auto format = format_;
   if (critical) {
@@ -32,10 +38,13 @@ auto waybar::modules::Temperature::update() -> void {
   label_.set_markup(fmt::format(format,
                                 fmt::arg("temperatureC", temperature_c),
                                 fmt::arg("temperatureF", temperature_f),
+                                fmt::arg("temperatureK", temperature_k),
                                 fmt::arg("icon", getIcon(temperature_c, "", max_temp))));
+  // Call parent update
+  ALabel::update();
 }
 
-std::tuple<uint16_t, uint16_t> waybar::modules::Temperature::getTemperature() {
+float waybar::modules::Temperature::getTemperature() {
   std::ifstream temp(file_path_);
   if (!temp.is_open()) {
     throw std::runtime_error("Can't open " + file_path_);
@@ -46,9 +55,7 @@ std::tuple<uint16_t, uint16_t> waybar::modules::Temperature::getTemperature() {
   }
   temp.close();
   auto                           temperature_c = std::strtol(line.c_str(), nullptr, 10) / 1000.0;
-  auto                           temperature_f = temperature_c * 1.8 + 32;
-  std::tuple<uint16_t, uint16_t> temperatures(std::round(temperature_c), std::round(temperature_f));
-  return temperatures;
+  return temperature_c;
 }
 
 bool waybar::modules::Temperature::isCritical(uint16_t temperature_c) {

src/modules/wlr/taskbar.cpp

@@ -0,0 +1,722 @@
+#include "modules/wlr/taskbar.hpp"
+
+#include "glibmm/refptr.h"
+#include "util/format.hpp"
+
+#include <algorithm>
+#include <cctype>
+#include <cstdlib>
+#include <cstring>
+#include <memory>
+#include <sstream>
+
+#include <gdkmm/monitor.h>
+
+#include <gtkmm/icontheme.h>
+
+#include <giomm/desktopappinfo.h>
+
+#include <spdlog/spdlog.h>
+
+
+namespace waybar::modules::wlr {
+
+/* String manipulation methods */
+const std::string WHITESPACE = " \n\r\t\f\v";
+
+static std::string ltrim(const std::string& s)
+{
+	size_t start = s.find_first_not_of(WHITESPACE);
+	return (start == std::string::npos) ? "" : s.substr(start);
+}
+
+static std::string rtrim(const std::string& s)
+{
+	size_t end = s.find_last_not_of(WHITESPACE);
+	return (end == std::string::npos) ? "" : s.substr(0, end + 1);
+}
+
+static std::string trim(const std::string& s)
+{
+	return rtrim(ltrim(s));
+}
+
+
+/* Icon loading functions */
+static std::vector<std::string> search_prefix()
+{
+    std::vector<std::string> prefixes = {""};
+
+    auto xdg_data_dirs = std::getenv("XDG_DATA_DIRS");
+    if (!xdg_data_dirs) {
+        prefixes.push_back("/usr/share/");
+        prefixes.push_back("/usr/local/share/");
+    } else {
+        std::string xdg_data_dirs_str(xdg_data_dirs);
+        size_t start = 0, end = 0;
+
+        do {
+            end = xdg_data_dirs_str.find(':', start);
+            auto p = xdg_data_dirs_str.substr(start, end-start);
+            prefixes.push_back(trim(p) + "/");
+
+            start = end == std::string::npos ? end : end + 1;
+        } while(end != std::string::npos);
+    }
+
+    for (auto& p : prefixes)
+        spdlog::debug("Using 'desktop' search path prefix: {}", p);
+
+    return prefixes;
+}
+
+/* Method 1 - get the correct icon name from the desktop file */
+static std::string get_from_desktop_app_info(const std::string &app_id)
+{
+    static std::vector<std::string> prefixes = search_prefix();
+
+    std::vector<std::string> app_folders = {
+        "",
+        "applications/",
+        "applications/kde/",
+        "applications/org.kde."
+    };
+
+    std::vector<std::string> suffixes = {
+        "",
+        ".desktop"
+    };
+
+    Glib::RefPtr<Gio::DesktopAppInfo> app_info;
+
+    for (auto& prefix : prefixes)
+        for (auto& folder : app_folders)
+            for (auto& suffix : suffixes)
+                if (!app_info)
+                    app_info = Gio::DesktopAppInfo::create_from_filename(prefix + folder + app_id + suffix);
+
+    if (app_info)
+        return app_info->get_icon()->to_string();
+
+    return "";
+}
+
+/* Method 2 - use the app_id and check whether there is an icon with this name in the icon theme */
+static std::string get_from_icon_theme(Glib::RefPtr<Gtk::IconTheme> icon_theme,
+        const std::string &app_id) {
+
+    if (icon_theme->lookup_icon(app_id, 24))
+        return app_id;
+
+    return "";
+}
+
+static bool image_load_icon(Gtk::Image& image, Glib::RefPtr<Gtk::IconTheme> icon_theme,
+        const std::string &app_id_list, int size)
+{
+    std::string app_id;
+    std::istringstream stream(app_id_list);
+    bool found = false;
+
+    /* Wayfire sends a list of app-id's in space separated format, other compositors
+     * send a single app-id, but in any case this works fine */
+    while (stream >> app_id)
+    {
+        auto lower_app_id = app_id;
+        std::transform(lower_app_id.begin(), lower_app_id.end(), lower_app_id.begin(),
+                [](char c){ return std::tolower(c); });
+
+        std::string icon_name = get_from_icon_theme(icon_theme, app_id);
+
+        if (icon_name.empty())
+            icon_name = get_from_icon_theme(icon_theme, lower_app_id);
+        if (icon_name.empty())
+            icon_name = get_from_desktop_app_info(app_id);
+        if (icon_name.empty())
+            icon_name = get_from_desktop_app_info(lower_app_id);
+
+        if (icon_name.empty())
+            continue;
+
+        auto pixbuf = icon_theme->load_icon(icon_name, size, Gtk::ICON_LOOKUP_FORCE_SIZE);
+        if (pixbuf) {
+            image.set(pixbuf);
+            found = true;
+            break;
+        }
+    }
+
+    return found;
+}
+
+/* Task class implementation */
+uint32_t Task::global_id = 0;
+
+static void tl_handle_title(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle,
+        const char *title)
+{
+    return static_cast<Task*>(data)->handle_title(title);
+}
+
+static void tl_handle_app_id(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle,
+        const char *app_id)
+{
+    return static_cast<Task*>(data)->handle_app_id(app_id);
+}
+
+static void tl_handle_output_enter(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle,
+        struct wl_output *output)
+{
+    return static_cast<Task*>(data)->handle_output_enter(output);
+}
+
+static void tl_handle_output_leave(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle,
+        struct wl_output *output)
+{
+    return static_cast<Task*>(data)->handle_output_leave(output);
+}
+
+static void tl_handle_state(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle,
+        struct wl_array *state)
+{
+    return static_cast<Task*>(data)->handle_state(state);
+}
+
+static void tl_handle_done(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle)
+{
+    return static_cast<Task*>(data)->handle_done();
+}
+
+static void tl_handle_closed(void *data, struct zwlr_foreign_toplevel_handle_v1 *handle)
+{
+    return static_cast<Task*>(data)->handle_closed();
+}
+
+static const struct zwlr_foreign_toplevel_handle_v1_listener toplevel_handle_impl = {
+    .title = tl_handle_title,
+    .app_id = tl_handle_app_id,
+    .output_enter = tl_handle_output_enter,
+    .output_leave = tl_handle_output_leave,
+    .state = tl_handle_state,
+    .done = tl_handle_done,
+    .closed = tl_handle_closed,
+};
+
+Task::Task(const waybar::Bar &bar, const Json::Value &config, Taskbar *tbar,
+        struct zwlr_foreign_toplevel_handle_v1 *tl_handle, struct wl_seat *seat) :
+    bar_{bar}, config_{config}, tbar_{tbar}, handle_{tl_handle}, seat_{seat},
+    id_{global_id++},
+    content_{bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0},
+    button_visible_{false}
+{
+    zwlr_foreign_toplevel_handle_v1_add_listener(handle_, &toplevel_handle_impl, this);
+
+    button_.set_relief(Gtk::RELIEF_NONE);
+
+    content_.add(text_before_);
+    content_.add(icon_);
+    content_.add(text_after_);
+
+    content_.show();
+    button_.add(content_);
+
+    with_icon_ = false;
+    format_before_.clear();
+    format_after_.clear();
+
+    if (config_["format"].isString()) {
+        /* The user defined a format string, use it */
+        auto format = config_["format"].asString();
+
+        auto icon_pos = format.find("{icon}");
+        if (icon_pos == 0) {
+            with_icon_ = true;
+            format_after_ = trim(format.substr(6));
+        } else if (icon_pos == std::string::npos) {
+            format_before_ = format;
+        } else {
+            with_icon_ = true;
+            format_before_ = trim(format.substr(0, icon_pos));
+            format_after_ = trim(format.substr(icon_pos + 6));
+        }
+    } else {
+        /* The default is to only show the icon */
+        with_icon_ = true;
+    }
+
+    /* Strip spaces at the beginning and end of the format strings */
+    format_tooltip_.clear();
+    if (!config_["tooltip"].isBool() || config_["tooltip"].asBool()) {
+        if (config_["tooltip-format"].isString())
+            format_tooltip_ = config_["tooltip-format"].asString();
+        else
+            format_tooltip_ = "{title}";
+    }
+
+    /* Handle click events if configured */
+    if (config_["on-click"].isString() || config_["on-click-middle"].isString()
+            || config_["on-click-right"].isString()) {
+        button_.add_events(Gdk::BUTTON_PRESS_MASK);
+        button_.signal_button_press_event().connect(
+                sigc::mem_fun(*this, &Task::handle_clicked), false);
+    }
+}
+
+Task::~Task()
+{
+    if (handle_) {
+        zwlr_foreign_toplevel_handle_v1_destroy(handle_);
+        handle_ = nullptr;
+    }
+    if (button_visible_) {
+        tbar_->remove_button(button_);
+        button_visible_ = false;
+    }
+}
+
+std::string Task::repr() const
+{
+    std::stringstream ss;
+    ss << "Task (" << id_ << ") " << title_ << " [" << app_id_ << "] <"
+       << (active() ? "A" : "a")
+       << (maximized() ? "M" : "m")
+       << (minimized() ? "I" : "i")
+       << (fullscreen() ? "F" : "f")
+       << ">";
+
+    return ss.str();
+}
+
+std::string Task::state_string(bool shortened) const
+{
+    std::stringstream ss;
+    if (shortened)
+        ss << (minimized() ? "m" : "") << (maximized() ? "M" : "")
+           << (active() ? "A" : "") << (fullscreen() ? "F" : "");
+    else
+        ss << (minimized() ? "minimized " : "") << (maximized() ? "maximized " : "")
+           << (active() ? "active " : "") << (fullscreen() ? "fullscreen " : "");
+
+    std::string res = ss.str();
+    if (shortened || res.empty())
+        return res;
+    else
+        return res.substr(0, res.size() - 1);
+}
+
+void Task::handle_title(const char *title)
+{
+    title_ = title;
+}
+
+void Task::handle_app_id(const char *app_id)
+{
+    app_id_ = app_id;
+
+    if (!with_icon_)
+        return;
+
+    int icon_size = config_["icon-size"].isInt() ? config_["icon-size"].asInt() : 16;
+    bool found = false;
+    for (auto& icon_theme : tbar_->icon_themes()) {
+        if (image_load_icon(icon_, icon_theme, app_id_, icon_size)) {
+            found = true;
+            break;
+        }
+    }
+
+    if (found)
+        icon_.show();
+    else
+        spdlog::debug("Couldn't find icon for {}", app_id_);
+}
+
+void Task::handle_output_enter(struct wl_output *output)
+{
+    spdlog::debug("{} entered output {}", repr(), (void*)output);
+
+    if (!button_visible_ && (tbar_->all_outputs() || tbar_->show_output(output))) {
+        /* The task entered the output of the current bar make the button visible */
+        tbar_->add_button(button_);
+        button_.show();
+        button_visible_ = true;
+        spdlog::debug("{} now visible on {}", repr(), bar_.output->name);
+    }
+}
+
+void Task::handle_output_leave(struct wl_output *output)
+{
+    spdlog::debug("{} left output {}", repr(), (void*)output);
+
+    if (button_visible_ && !tbar_->all_outputs() && tbar_->show_output(output)) {
+        /* The task left the output of the current bar, make the button invisible */
+        tbar_->remove_button(button_);
+        button_.hide();
+        button_visible_ = false;
+        spdlog::debug("{} now invisible on {}", repr(), bar_.output->name);
+    }
+}
+
+void Task::handle_state(struct wl_array *state)
+{
+    state_ = 0;
+    for (uint32_t* entry = static_cast<uint32_t*>(state->data);
+         entry < static_cast<uint32_t*>(state->data) + state->size;
+         entry++) {
+        if (*entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_MAXIMIZED)
+            state_ |= MAXIMIZED;
+        if (*entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_MINIMIZED)
+            state_ |= MINIMIZED;
+        if (*entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_ACTIVATED)
+            state_ |= ACTIVE;
+        if (*entry == ZWLR_FOREIGN_TOPLEVEL_HANDLE_V1_STATE_FULLSCREEN)
+            state_ |= FULLSCREEN;
+    }
+}
+
+void Task::handle_done()
+{
+    spdlog::debug("{} changed", repr());
+
+    if (state_ & MAXIMIZED) {
+        button_.get_style_context()->add_class("maximized");
+    } else if (!(state_ & MAXIMIZED)) {
+        button_.get_style_context()->remove_class("maximized");
+    }
+
+    if (state_ & MINIMIZED) {
+        button_.get_style_context()->add_class("minimized");
+    } else if (!(state_ & MINIMIZED)) {
+        button_.get_style_context()->remove_class("minimized");
+    }
+
+    if (state_ & ACTIVE) {
+        button_.get_style_context()->add_class("active");
+    } else if (!(state_ & ACTIVE)) {
+        button_.get_style_context()->remove_class("active");
+    }
+
+    if (state_ & FULLSCREEN) {
+        button_.get_style_context()->add_class("fullscreen");
+    } else if (!(state_ & FULLSCREEN)) {
+        button_.get_style_context()->remove_class("fullscreen");
+    }
+
+    if (config_["active-first"].isBool() && config_["active-first"].asBool() && active())
+        tbar_->move_button(button_, 0);
+
+    tbar_->dp.emit();
+}
+
+void Task::handle_closed()
+{
+    spdlog::debug("{} closed", repr());
+    zwlr_foreign_toplevel_handle_v1_destroy(handle_);
+    handle_ = nullptr;
+    if (button_visible_) {
+        tbar_->remove_button(button_);
+        button_visible_ = false;
+    }
+    tbar_->remove_task(id_);
+}
+
+bool Task::handle_clicked(GdkEventButton *bt)
+{
+    std::string action;
+    if (config_["on-click"].isString() && bt->button == 1)
+        action = config_["on-click"].asString();
+    else if (config_["on-click-middle"].isString() && bt->button == 2)
+        action = config_["on-click-middle"].asString();
+    else if (config_["on-click-right"].isString() && bt->button == 3)
+        action = config_["on-click-right"].asString();
+
+    if (action.empty())
+        return true;
+    else if (action == "activate")
+        activate();
+    else if (action == "minimize")
+        minimize(!minimized());
+    else if (action == "maximize")
+        maximize(!maximized());
+    else if (action == "fullscreen")
+        fullscreen(!fullscreen());
+    else if (action == "close")
+        close();
+    else
+        spdlog::warn("Unknown action {}", action);
+
+    return true;
+}
+
+bool Task::operator==(const Task &o) const
+{
+    return o.id_ == id_;
+}
+
+bool Task::operator!=(const Task &o) const
+{
+    return o.id_ != id_;
+}
+
+void Task::update()
+{
+    if (!format_before_.empty()) {
+        text_before_.set_label(
+                fmt::format(format_before_,
+                    fmt::arg("title", title_),
+                    fmt::arg("app_id", app_id_),
+                    fmt::arg("state", state_string()),
+                    fmt::arg("short_state", state_string(true))
+                )
+        );
+        text_before_.show();
+    }
+    if (!format_after_.empty()) {
+        text_after_.set_label(
+                fmt::format(format_after_,
+                    fmt::arg("title", title_),
+                    fmt::arg("app_id", app_id_),
+                    fmt::arg("state", state_string()),
+                    fmt::arg("short_state", state_string(true))
+                )
+        );
+        text_after_.show();
+    }
+
+    if (!format_tooltip_.empty()) {
+        button_.set_tooltip_markup(
+                fmt::format(format_tooltip_,
+                    fmt::arg("title", title_),
+                    fmt::arg("app_id", app_id_),
+                    fmt::arg("state", state_string()),
+                    fmt::arg("short_state", state_string(true))
+                )
+        );
+    }
+}
+
+void Task::maximize(bool set)
+{
+    if (set)
+        zwlr_foreign_toplevel_handle_v1_set_maximized(handle_);
+    else
+        zwlr_foreign_toplevel_handle_v1_unset_maximized(handle_);
+}
+
+void Task::minimize(bool set)
+{
+    if (set)
+        zwlr_foreign_toplevel_handle_v1_set_minimized(handle_);
+    else
+        zwlr_foreign_toplevel_handle_v1_unset_minimized(handle_);
+}
+
+void Task::activate()
+{
+    zwlr_foreign_toplevel_handle_v1_activate(handle_, seat_);
+}
+
+void Task::fullscreen(bool set)
+{
+    if (set)
+        zwlr_foreign_toplevel_handle_v1_set_fullscreen(handle_, nullptr);
+    else
+        zwlr_foreign_toplevel_handle_v1_unset_fullscreen(handle_);
+}
+
+void Task::close()
+{
+    zwlr_foreign_toplevel_handle_v1_close(handle_);
+}
+
+
+/* Taskbar class implementation */
+static void handle_global(void *data, struct wl_registry *registry, uint32_t name,
+        const char *interface, uint32_t version)
+{
+    if (std::strcmp(interface, zwlr_foreign_toplevel_manager_v1_interface.name) == 0) {
+        static_cast<Taskbar*>(data)->register_manager(registry, name, version);
+    } else if (std::strcmp(interface, wl_seat_interface.name) == 0) {
+        static_cast<Taskbar*>(data)->register_seat(registry, name, version);
+    }
+}
+
+static void handle_global_remove(void *data, struct wl_registry *registry, uint32_t name)
+{
+    /* Nothing to do here */
+}
+
+static const wl_registry_listener registry_listener_impl = {
+    .global = handle_global,
+    .global_remove = handle_global_remove
+};
+
+Taskbar::Taskbar(const std::string &id, const waybar::Bar &bar, const Json::Value &config) 
+    : waybar::AModule(config, "taskbar", id, false, false),
+      bar_(bar),
+      box_{bar.vertical ? Gtk::ORIENTATION_VERTICAL : Gtk::ORIENTATION_HORIZONTAL, 0},
+      manager_{nullptr}, seat_{nullptr}
+{
+    box_.set_name("taskbar");
+    if (!id.empty()) {
+        box_.get_style_context()->add_class(id);
+    }
+    event_box_.add(box_);
+
+    struct wl_display *display = Client::inst()->wl_display;
+    struct wl_registry *registry = wl_display_get_registry(display);
+
+    wl_registry_add_listener(registry, &registry_listener_impl, this);
+    wl_display_roundtrip(display);
+
+    if (!manager_) {
+        spdlog::error("Failed to register as toplevel manager");
+        return;
+    }
+    if (!seat_) {
+        spdlog::error("Failed to get wayland seat");
+        return;
+    }
+
+    /* Get the configured icon theme if specified */
+    if (config_["icon-theme"].isArray()) {
+        for (auto& c : config_["icon-theme"]) {
+            auto it_name = c.asString();
+
+            auto it = Gtk::IconTheme::create();
+            it->set_custom_theme(it_name);
+            spdlog::debug("Use custom icon theme: {}", it_name);
+
+            icon_themes_.push_back(it);
+        }
+    } else if (config_["icon-theme"].isString()) {
+        auto it_name = config_["icon-theme"].asString();
+
+        auto it = Gtk::IconTheme::create();
+        it->set_custom_theme(it_name);
+        spdlog::debug("Use custom icon theme: {}", it_name);
+
+        icon_themes_.push_back(it);
+    }
+    icon_themes_.push_back(Gtk::IconTheme::get_default());
+}
+
+Taskbar::~Taskbar()
+{
+    if (manager_) {
+        zwlr_foreign_toplevel_manager_v1_destroy(manager_);
+        manager_ = nullptr;
+    }
+}
+
+void Taskbar::update()
+{
+    for (auto& t : tasks_) {
+        t->update();
+    }
+
+    AModule::update();
+}
+
+static void tm_handle_toplevel(void *data, struct zwlr_foreign_toplevel_manager_v1 *manager,
+        struct zwlr_foreign_toplevel_handle_v1 *tl_handle)
+{
+    return static_cast<Taskbar*>(data)->handle_toplevel_create(tl_handle);
+}
+
+static void tm_handle_finished(void *data, struct zwlr_foreign_toplevel_manager_v1 *manager)
+{
+    return static_cast<Taskbar*>(data)->handle_finished();
+}
+
+static const struct zwlr_foreign_toplevel_manager_v1_listener toplevel_manager_impl = {
+    .toplevel = tm_handle_toplevel,
+    .finished = tm_handle_finished,
+};
+
+void Taskbar::register_manager(struct wl_registry *registry, uint32_t name, uint32_t version)
+{
+    if (manager_) {
+        spdlog::warn("Register foreign toplevel manager again although already existing!");
+        return;
+    }
+    if (version != 2) {
+        spdlog::warn("Using different foreign toplevel manager protocol version: {}", version);
+    }
+
+    manager_ = static_cast<struct zwlr_foreign_toplevel_manager_v1 *>(wl_registry_bind(registry, name,
+            &zwlr_foreign_toplevel_manager_v1_interface, version));
+
+    if (manager_)
+        zwlr_foreign_toplevel_manager_v1_add_listener(manager_, &toplevel_manager_impl, this);
+    else
+        spdlog::debug("Failed to register manager");
+}
+
+void Taskbar::register_seat(struct wl_registry *registry, uint32_t name, uint32_t version)
+{
+    if (seat_) {
+        spdlog::warn("Register seat again although already existing!");
+        return;
+    }
+
+    seat_ = static_cast<wl_seat*>(wl_registry_bind(registry, name, &wl_seat_interface, version));
+}
+
+void Taskbar::handle_toplevel_create(struct zwlr_foreign_toplevel_handle_v1 *tl_handle)
+{
+    tasks_.push_back(std::make_unique<Task>(bar_, config_, this, tl_handle, seat_));
+}
+
+void Taskbar::handle_finished()
+{
+    zwlr_foreign_toplevel_manager_v1_destroy(manager_);
+    manager_ = nullptr;
+}
+
+void Taskbar::add_button(Gtk::Button &bt)
+{
+    box_.pack_start(bt, false, false);
+}
+
+void Taskbar::move_button(Gtk::Button &bt, int pos)
+{
+    box_.reorder_child(bt, pos);
+}
+
+void Taskbar::remove_button(Gtk::Button &bt)
+{
+    box_.remove(bt);
+}
+
+void Taskbar::remove_task(uint32_t id)
+{
+    auto it = std::find_if(std::begin(tasks_), std::end(tasks_),
+            [id](const TaskPtr &p) { return p->id() == id; });
+
+    if (it == std::end(tasks_)) {
+        spdlog::warn("Can't find task with id {}", id);
+        return;
+    }
+
+    tasks_.erase(it);
+}
+
+bool Taskbar::show_output(struct wl_output *output) const
+{
+    return output == gdk_wayland_monitor_get_wl_output(bar_.output->monitor->gobj());
+}
+
+bool Taskbar::all_outputs() const
+{
+    static bool result = config_["all_outputs"].isBool() ? config_["all_outputs"].asBool() : false;
+
+    return result;
+}
+
+std::vector<Glib::RefPtr<Gtk::IconTheme>> Taskbar::icon_themes() const
+{
+    return icon_themes_;
+}
+
+} /* namespace waybar::modules::wlr */

src/util/rfkill.cpp

@@ -0,0 +1,78 @@
+/* https://git.kernel.org/pub/scm/linux/kernel/git/jberg/rfkill.git/
+ *
+ * Copyright 2009 Johannes Berg <johannes@sipsolutions.net>
+ * Copyright 2009 Marcel Holtmann <marcel@holtmann.org>
+ * Copyright 2009 Tim Gardner <tim.gardner@canonical.com>
+ *
+ * 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. */
+
+#include "util/rfkill.hpp"
+
+#include <fcntl.h>
+#include <linux/rfkill.h>
+#include <stdlib.h>
+#include <sys/poll.h>
+#include <unistd.h>
+
+#include <cerrno>
+#include <cstring>
+#include <stdexcept>
+
+waybar::util::Rfkill::Rfkill(const enum rfkill_type rfkill_type) : rfkill_type_(rfkill_type) {}
+
+void waybar::util::Rfkill::waitForEvent() {
+  struct rfkill_event event;
+  struct pollfd       p;
+  ssize_t             len;
+  int                 fd, n;
+
+  fd = open("/dev/rfkill", O_RDONLY);
+  if (fd < 0) {
+    throw std::runtime_error("Can't open RFKILL control device");
+    return;
+  }
+
+  memset(&p, 0, sizeof(p));
+  p.fd = fd;
+  p.events = POLLIN | POLLHUP;
+
+  while (1) {
+    n = poll(&p, 1, -1);
+    if (n < 0) {
+      throw std::runtime_error("Failed to poll RFKILL control device");
+      break;
+    }
+
+    if (n == 0) continue;
+
+    len = read(fd, &event, sizeof(event));
+    if (len < 0) {
+      throw std::runtime_error("Reading of RFKILL events failed");
+      break;
+    }
+
+    if (len != RFKILL_EVENT_SIZE_V1) {
+      throw std::runtime_error("Wrong size of RFKILL event");
+      continue;
+    }
+
+    if (event.type == rfkill_type_ && event.op == RFKILL_OP_CHANGE) {
+      state_ = event.soft || event.hard;
+      break;
+    }
+  }
+
+  close(fd);
+}
+
+bool waybar::util::Rfkill::getState() const { return state_; }

subprojects/date.wrap

@@ -0,0 +1,9 @@
+[wrap-file]
+source_url=https://github.com/HowardHinnant/date/archive/v3.0.0.tar.gz
+source_filename=date-3.0.0.tar.gz
+source_hash=87bba2eaf0ebc7ec539e5e62fc317cb80671a337c1fb1b84cb9e4d42c6dbebe3
+directory=date-3.0.0
+
+patch_url = https://github.com/mesonbuild/hinnant-date/releases/download/3.0.0-1/hinnant-date.zip
+patch_filename = hinnant-date-3.0.0-1-wrap.zip
+patch_hash = 6ccaf70732d8bdbd1b6d5fdf3e1b935c23bf269bda12fdfd0e561276f63432fe

subprojects/fmt.wrap

@@ -5,6 +5,6 @@ source_url = https://github.com/fmtlib/fmt/archive/5.3.0.tar.gz
 source_filename = fmt-5.3.0.tar.gz
 source_hash = defa24a9af4c622a7134076602070b45721a43c51598c8456ec6f2c4dbb51c89
 
-patch_url = https://wrapdb.mesonbuild.com/v1/projects/fmt/5.3.0/1/get_zip
+patch_url = https://github.com/mesonbuild/fmt/releases/download/5.3.0-1/fmt.zip
 patch_filename = fmt-5.3.0-1-wrap.zip
 patch_hash = 18f21a3b8833949c35d4ac88a7059577d5fa24b98786e4b1b2d3d81bb811440f

subprojects/gtk-layer-shell.wrap

@@ -1,5 +1,5 @@
 [wrap-file]
-directory = gtk-layer-shell-0.1.0
-source_filename = gtk-layer-shell-0.1.0.tar.gz
-source_hash = f7569e27ae30b1a94c3ad6c955cf56240d6bc272b760d9d266ce2ccdb94a5cf0
-source_url = https://github.com/wmww/gtk-layer-shell/archive/v0.1.0/gtk-layer-shell-0.1.0.tar.gz
+directory = gtk-layer-shell-0.2.0
+source_filename = gtk-layer-shell-0.2.0.tar.gz
+source_hash = 6934376b5296d079fca2c1ba6b222ec91db6bf3667142340ee2bdebfb4b69116
+source_url = https://github.com/wmww/gtk-layer-shell/archive/v0.2.0/gtk-layer-shell-0.2.0.tar.gz