Merge branch 'master' into disk

.github/FUNDING.yml

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

.github/workflows/freebsd.yml

@@ -0,0 +1,27 @@
+name: freebsd
+
+on: [ push, pull_request ]
+
+jobs:
+  clang:
+    # Run actions in a FreeBSD vm on the macos-10.15 runner
+    # https://github.com/actions/runner/issues/385 - for FreeBSD runner support
+    # https://github.com/actions/virtual-environments/issues/4060 - for lack of VirtualBox on MacOS 11 runners
+    runs-on: macos-10.15
+    steps:
+    - uses: actions/checkout@v2
+    - name: Test in FreeBSD VM
+      uses: vmactions/freebsd-vm@v0.1.5 # aka FreeBSD 13.0
+      with:
+        usesh: true
+        prepare: |
+          export CPPFLAGS=-isystem/usr/local/include LDFLAGS=-L/usr/local/lib # sndio
+          sed -i '' 's/quarterly/latest/' /etc/pkg/FreeBSD.conf
+          pkg install -y git #  subprojects/date
+          pkg install -y catch evdev-proto gtk-layer-shell gtkmm30 jsoncpp \
+            libdbusmenu libevdev libfmt libmpdclient libudev-devd meson \
+            pkgconf pulseaudio scdoc sndio spdlog
+        run: |
+          meson build -Dman-pages=enabled
+          ninja -C build
+          meson test -C build --no-rebuild --print-errorlogs --suite waybar

.github/workflows/linux.yml

@@ -0,0 +1,27 @@
+name: linux
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        distro:
+          - alpine
+          - archlinux
+          - debian
+          - fedora
+          - opensuse
+
+    runs-on: ubuntu-latest
+    container:
+      image: alexays/waybar:${{ matrix.distro }}
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: configure
+        run: meson -Dman-pages=enabled build
+      - name: build
+        run: ninja -C build
+      - name: test
+        run: meson test -C build --no-rebuild --print-errorlogs --suite waybar

.travis.yml

@@ -1,37 +0,0 @@
-language: cpp
-
-services:
-    - docker
-
-git:
-    submodules: false
-
-env:
-    - distro: debian
-    - distro: archlinux
-    - distro: fedora
-    - distro: alpine
-    - distro: opensuse
-
-before_install:
-    - docker pull alexays/waybar:${distro}
-    - find . -type f \( -name '*.cpp' -o -name '*.h' \) -print0 | xargs -r0 clang-format -i
-
-script:
-    - echo FROM alexays/waybar:${distro} > Dockerfile
-    - echo ADD . /root >> Dockerfile
-    - docker build -t waybar .
-    - docker run waybar /bin/sh -c "cd /root && meson build -Dman-pages=enabled && ninja -C build"
-
-jobs:
-  include:
-    - os: freebsd
-      compiler: clang
-      env:
-      before_install:
-        - sudo sed -i '' 's/quarterly/latest/' /etc/pkg/FreeBSD.conf
-        - sudo pkg install -y date 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 pugixml-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 sndio-dev scdoc libxkbcommon

Dockerfiles/archlinux

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

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 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 && \
+    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 libxkbcommon-dev libxkbregistry-dev libxkbregistry0 && \
     apt-get clean

Dockerfiles/fedora

@@ -1,7 +1,12 @@
 # vim: ft=Dockerfile
 
-FROM fedora:32
+FROM fedora:latest
 
-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 && \
+RUN dnf install -y @c-development git-core meson scdoc 'pkgconfig(date)' \
-    dnf group install "C Development Tools and Libraries" -y && \
+    'pkgconfig(dbusmenu-gtk3-0.4)' 'pkgconfig(fmt)' 'pkgconfig(gdk-pixbuf-2.0)' \
+    'pkgconfig(gio-unix-2.0)' 'pkgconfig(gtk-layer-shell-0)' 'pkgconfig(gtkmm-3.0)' \
+    'pkgconfig(jsoncpp)' 'pkgconfig(libinput)' 'pkgconfig(libmpdclient)' \
+    'pkgconfig(libnl-3.0)' 'pkgconfig(libnl-genl-3.0)' 'pkgconfig(libpulse)' \
+    'pkgconfig(libudev)' 'pkgconfig(pugixml)' 'pkgconfig(sigc++-2.0)' 'pkgconfig(spdlog)' \
+    'pkgconfig(wayland-client)' 'pkgconfig(wayland-cursor)' 'pkgconfig(wayland-protocols)' 'pkgconfig(xkbregistry)' && \
     dnf clean all -y

Dockerfiles/opensuse

@@ -3,5 +3,7 @@
 FROM opensuse/tumbleweed:latest
 
 RUN zypper -n up && \
+    zypper addrepo https://download.opensuse.org/repositories/X11:Wayland/openSUSE_Tumbleweed/X11:Wayland.repo | echo 'a' && \
+    zypper -n refresh && \
     zypper -n install -t pattern devel_C_C++ && \
-    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
+    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 libxkbregistry-devel scdoc

Makefile

@@ -16,5 +16,8 @@ install: build
 run: build
 	./build/waybar
 
+debug-run: build-debug
+	./build/waybar --log-level debug
+
 clean:
 	rm -rf build

README.md

@@ -1,11 +1,11 @@
-# Waybar [![Travis](https://travis-ci.org/Alexays/Waybar.svg?branch=master)](https://travis-ci.org/Alexays/Waybar) [![Licence](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE) [![Paypal Donate](https://img.shields.io/badge/Donate-Paypal-2244dd.svg)](https://paypal.me/ARouillard)<br>![Waybar](https://raw.githubusercontent.com/alexays/waybar/master/preview-2.png)
+# Waybar [![Licence](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE) [![Paypal Donate](https://img.shields.io/badge/Donate-Paypal-2244dd.svg)](https://paypal.me/ARouillard)<br>![Waybar](https://raw.githubusercontent.com/alexays/waybar/master/preview-2.png)
 
 > Highly customizable Wayland bar for Sway and Wlroots based compositors.<br>
 > Available in Arch [community](https://www.archlinux.org/packages/community/x86_64/waybar/) or
 [AUR](https://aur.archlinux.org/packages/waybar-git/), [openSUSE](https://build.opensuse.org/package/show/X11:Wayland/waybar), and [Alpine Linux](https://pkgs.alpinelinux.org/packages?name=waybar)<br>
 > *Waybar [examples](https://github.com/Alexays/Waybar/wiki/Examples)*
 
-**Current features**
+#### Current features
 - Sway (Workspaces, Binding mode, Focused window name)
 - Tray [#21](https://github.com/Alexays/Waybar/issues/21)
 - Local time
@@ -22,11 +22,21 @@
 - Multiple output configuration
 - And much more customizations
 
-**Configuration and Styling**
+#### Configuration and Styling
 
 [See the wiki for more details](https://github.com/Alexays/Waybar/wiki).
 
-**How to build**
+### Installation
+
+Waybar is available from a number of Linux distributions:
+
+[![Packaging status](https://repology.org/badge/vertical-allrepos/waybar.svg)](https://repology.org/project/waybar/versions)
+
+An Ubuntu PPA with more recent versions is available
+[here](https://launchpad.net/~nschloe/+archive/ubuntu/waybar).
+
+
+#### Building from source
 
 ```bash
 $ git clone https://github.com/Alexays/Waybar
@@ -57,6 +67,8 @@ libnl [Network module]
 libappindicator-gtk3 [Tray module]
 libdbusmenu-gtk3 [Tray module]
 libmpdclient [MPD module]
+libsndio [sndio module]
+libevdev [KeyboardState module]
 ```
 
 **Build dependencies**
@@ -75,6 +87,7 @@ sudo apt install \
   clang-tidy \
   gobject-introspection \
   libdbusmenu-gtk3-dev \
+  libevdev-dev \
   libfmt-dev \
   libgirepository1.0-dev \
   libgtk-3-dev \

include/ALabel.hpp

@@ -10,16 +10,15 @@ namespace waybar {
 class ALabel : public AModule {
  public:
   ALabel(const Json::Value &, const std::string &, const std::string &, const std::string &format,
-         uint16_t interval = 0, bool ellipsize = false);
+         uint16_t interval = 0, bool ellipsize = false, bool enable_click = false, bool enable_scroll = false);
   virtual ~ALabel() = default;
   virtual auto        update() -> void;
   virtual std::string getIcon(uint16_t, const std::string &alt = "", uint16_t max = 0);
-  virtual std::string getIcon(uint16_t, std::vector<std::string> &alts, uint16_t max = 0);
+  virtual std::string getIcon(uint16_t, const std::vector<std::string> &alts, uint16_t max = 0);
 
  protected:
   Gtk::Label                 label_;
   std::string                format_;
-  std::string                click_param;
   const std::chrono::seconds interval_;
   bool                       alt_ = false;
   std::string                default_format_;

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 &,
+  AModule(const Json::Value &, const std::string &, const std::string &, bool enable_click = false,
-          bool enable_click = false, bool enable_scroll = 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

@@ -7,9 +7,8 @@
 #include <gtkmm/main.h>
 #include <gtkmm/window.h>
 #include <json/json.h>
+
 #include "AModule.hpp"
-#include "idle-inhibit-unstable-v1-client-protocol.h"
-#include "wlr-layer-shell-unstable-v1-client-protocol.h"
 #include "xdg-output-unstable-v1-client-protocol.h"
 
 namespace waybar {
@@ -18,65 +17,68 @@ class Factory;
 struct waybar_output {
   Glib::RefPtr<Gdk::Monitor> monitor;
   std::string                name;
+  std::string                identifier;
 
   std::unique_ptr<struct zxdg_output_v1, decltype(&zxdg_output_v1_destroy)> xdg_output = {
       nullptr, &zxdg_output_v1_destroy};
 };
 
+enum class bar_layer : uint8_t {
+  BOTTOM,
+  TOP,
+  OVERLAY,
+};
+
+struct bar_margins {
+  int top = 0;
+  int right = 0;
+  int bottom = 0;
+  int left = 0;
+};
+
+class BarSurface {
+ protected:
+  BarSurface() = default;
+
+ public:
+  virtual void setExclusiveZone(bool enable) = 0;
+  virtual void setLayer(bar_layer layer) = 0;
+  virtual void setMargins(const struct bar_margins &margins) = 0;
+  virtual void setPassThrough(bool enable) = 0;
+  virtual void setPosition(const std::string_view &position) = 0;
+  virtual void setSize(uint32_t width, uint32_t height) = 0;
+  virtual void commit(){};
+
+  virtual ~BarSurface() = default;
+};
+
 class Bar {
  public:
   Bar(struct waybar_output *w_output, const Json::Value &);
   Bar(const Bar &) = delete;
   ~Bar() = default;
 
-  auto toggle() -> void;
+  void setVisible(bool visible);
+  void toggle();
   void handleSignal(int);
 
   struct waybar_output *output;
   Json::Value           config;
-  Gtk::Window           window;
   struct wl_surface *   surface;
+  bool                  exclusive = true;
   bool                  visible = true;
   bool                  vertical = false;
+  Gtk::Window           window;
 
  private:
-  static constexpr const char *MIN_HEIGHT_MSG =
+  void onMap(GdkEventAny *);
-      "Requested height: {} exceeds the minimum height: {} required by the modules";
-  static constexpr const char *MIN_WIDTH_MSG =
-      "Requested width: {} exceeds the minimum width: {} required by the modules";
-  static constexpr const char *BAR_SIZE_MSG =
-      "Bar configured (width: {}, height: {}) for output: {}";
-  static constexpr const char *SIZE_DEFINED =
-      "{} size is defined in the config file so it will stay like that";
-  static void layerSurfaceHandleConfigure(void *, struct zwlr_layer_surface_v1 *, uint32_t,
-                                          uint32_t, uint32_t);
-  static void layerSurfaceHandleClosed(void *, struct zwlr_layer_surface_v1 *);
-
-#ifdef HAVE_GTK_LAYER_SHELL
-  void initGtkLayerShell();
-#endif
-  void onConfigure(GdkEventConfigure *ev);
-  void onRealize();
-  void onMap(GdkEventAny *ev);
-  void setExclusiveZone(uint32_t width, uint32_t height);
-  void setSurfaceSize(uint32_t width, uint32_t height);
   auto setupWidgets() -> void;
   void getModules(const Factory &, const std::string &);
   void setupAltFormatKeyForModule(const std::string &module_name);
   void setupAltFormatKeyForModuleList(const char *module_list_name);
 
-  struct margins {
+  std::unique_ptr<BarSurface>                   surface_impl_;
-    int top = 0;
+  bar_layer                                     layer_;
-    int right = 0;
-    int bottom = 0;
-    int left = 0;
-  } margins_;
-  struct zwlr_layer_surface_v1 *layer_surface_;
-  // use gtk-layer-shell instead of handling layer surfaces directly
-  bool                                          use_gls_ = false;
-  uint32_t                                      width_ = 0;
-  uint32_t                                      height_ = 1;
-  uint8_t                                       anchor_;
   Gtk::Box                                      left_;
   Gtk::Box                                      center_;
   Gtk::Box                                      right_;

include/client.hpp

@@ -3,10 +3,14 @@
 #include <fmt/format.h>
 #include <gdk/gdk.h>
 #include <gdk/gdkwayland.h>
-#include <unistd.h>
 #include <wayland-client.h>
-#include <wordexp.h>
+
 #include "bar.hpp"
+#include "config.hpp"
+
+struct zwlr_layer_shell_v1;
+struct zwp_idle_inhibitor_v1;
+struct zwp_idle_inhibit_manager_v1;
 
 namespace waybar {
 
@@ -14,6 +18,7 @@ class Client {
  public:
   static Client *inst();
   int            main(int argc, char *argv[]);
+  void           reset();
 
   Glib::RefPtr<Gtk::Application>      gtk_app;
   Glib::RefPtr<Gdk::Display>          gdk_display;
@@ -23,28 +28,27 @@ class Client {
   struct zxdg_output_manager_v1 *     xdg_output_manager = nullptr;
   struct zwp_idle_inhibit_manager_v1 *idle_inhibit_manager = nullptr;
   std::vector<std::unique_ptr<Bar>>   bars;
+  Config                              config;
 
  private:
   Client() = default;
-  std::tuple<const std::string, const std::string> getConfigs(const std::string &config,
+  const std::string        getStyle(const std::string &style);
-                                                              const std::string &style) const;
   void                     bindInterfaces();
-  const std::string getValidPath(const std::vector<std::string> &paths) const;
   void                     handleOutput(struct waybar_output &output);
-  bool isValidOutput(const Json::Value &config, struct waybar_output &output);
-  auto setupConfig(const std::string &config_file) -> void;
   auto                     setupCss(const std::string &css_file) -> void;
-  struct waybar_output &getOutput(void *);
+  struct waybar_output &   getOutput(void *);
   std::vector<Json::Value> getOutputConfigs(struct waybar_output &output);
 
   static void handleGlobal(void *data, struct wl_registry *registry, uint32_t name,
                            const char *interface, uint32_t version);
   static void handleGlobalRemove(void *data, struct wl_registry *registry, uint32_t name);
+  static void handleOutputDone(void *, struct zxdg_output_v1 *);
   static void handleOutputName(void *, struct zxdg_output_v1 *, const char *);
+  static void handleOutputDescription(void *, struct zxdg_output_v1 *, const char *);
   void        handleMonitorAdded(Glib::RefPtr<Gdk::Monitor> monitor);
   void        handleMonitorRemoved(Glib::RefPtr<Gdk::Monitor> monitor);
+  void        handleDeferredMonitorRemoval(Glib::RefPtr<Gdk::Monitor> monitor);
 
-  Json::Value                     config_;
   Glib::RefPtr<Gtk::StyleContext> style_context_;
   Glib::RefPtr<Gtk::CssProvider>  css_provider_;
   std::list<struct waybar_output> outputs_;

include/config.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <json/json.h>
+
+#include <optional>
+#include <string>
+
+#ifndef SYSCONFDIR
+#define SYSCONFDIR "/etc"
+#endif
+
+namespace waybar {
+
+class Config {
+ public:
+  static const std::vector<std::string> CONFIG_DIRS;
+
+  /* Try to find any of provided names in the supported set of config directories */
+  static std::optional<std::string> findConfigPath(
+      const std::vector<std::string> &names, const std::vector<std::string> &dirs = CONFIG_DIRS);
+
+  Config() = default;
+
+  void load(const std::string &config);
+
+  Json::Value &getConfig() { return config_; }
+
+  std::vector<Json::Value> getOutputConfigs(const std::string &name, const std::string &identifier);
+
+ private:
+  void setupConfig(Json::Value &dst, const std::string &config_file, int depth);
+  void resolveConfigIncludes(Json::Value &config, int depth);
+  void mergeConfig(Json::Value &a_config_, Json::Value &b_config_);
+
+  std::string config_file_;
+
+  Json::Value config_;
+};
+}  // namespace waybar

include/factory.hpp

@@ -1,11 +1,23 @@
 #pragma once
 
 #include <json/json.h>
+#ifdef HAVE_LIBDATE
 #include "modules/clock.hpp"
+#else
+#include "modules/simpleclock.hpp"
+#endif
 #ifdef HAVE_SWAY
 #include "modules/sway/mode.hpp"
 #include "modules/sway/window.hpp"
 #include "modules/sway/workspaces.hpp"
+#include "modules/sway/language.hpp"
+#endif
+#ifdef HAVE_WLR
+#include "modules/wlr/taskbar.hpp"
+#include "modules/wlr/workspace_manager.hpp"
+#endif
+#ifdef HAVE_RIVER
+#include "modules/river/tags.hpp"
 #endif
 #if defined(__linux__) && !defined(NO_FILESYSTEM)
 #include "modules/battery.hpp"
@@ -27,17 +39,25 @@
 #ifdef HAVE_LIBUDEV
 #include "modules/backlight.hpp"
 #endif
+#ifdef HAVE_LIBEVDEV
+#include "modules/keyboard_state.hpp"
+#endif
 #ifdef HAVE_LIBPULSE
 #include "modules/pulseaudio.hpp"
 #endif
 #ifdef HAVE_LIBMPDCLIENT
-#include "modules/mpd.hpp"
+#include "modules/mpd/mpd.hpp"
+#endif
+#ifdef HAVE_LIBSNDIO
+#include "modules/sndio.hpp"
 #endif
 #include "bar.hpp"
 #include "modules/custom.hpp"
 #include "modules/temperature.hpp"
 #if defined(__linux__)
-#include "modules/bluetooth.hpp"
+#  ifdef WANT_RFKILL
+#    include "modules/bluetooth.hpp"
+#  endif
 #endif
 
 namespace waybar {

include/modules/battery.hpp

@@ -31,19 +31,22 @@ class Battery : public ALabel {
  private:
   static inline const fs::path data_dir_ = "/sys/class/power_supply/";
 
-  void                                          getBatteries();
+  void                                                 refreshBatteries();
   void                                                 worker();
   const std::string                                    getAdapterStatus(uint8_t capacity) const;
-  const std::tuple<uint8_t, float, std::string> getInfos() const;
+  const std::tuple<uint8_t, float, std::string, float> getInfos();
   const std::string                                    formatTimeRemaining(float hoursRemaining);
 
-  std::vector<fs::path> batteries_;
+  int                   global_watch;
+  std::map<fs::path,int> batteries_;
   fs::path              adapter_;
-  int                   fd_;
+  int                   battery_watch_fd_;
-  std::vector<int>      wds_;
+  int                   global_watch_fd_;
+  std::mutex            battery_list_mutex_;
   std::string           old_status_;
 
   util::SleeperThread   thread_;
+  util::SleeperThread   thread_battery_update_;
   util::SleeperThread   thread_timer_;
 };
 

include/modules/bluetooth.hpp

@@ -1,10 +1,6 @@
 #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 {
@@ -16,10 +12,6 @@ class Bluetooth : public ALabel {
   auto update() -> void;
 
  private:
-  std::string           status_;
-  util::SleeperThread 	thread_;
-  util::SleeperThread 	intervall_thread_;
-
   util::Rfkill rfkill_;
 };
 

include/modules/clock.hpp

@@ -28,12 +28,16 @@ class Clock : public ALabel {
   std::locale locale_;
   const date::time_zone* time_zone_;
   bool fixed_time_zone_;
-  date::year_month_day cached_calendar_ymd_;
+  int time_zone_idx_;
+  date::year_month_day cached_calendar_ymd_ = date::January/1/0;
   std::string cached_calendar_text_;
 
+  bool handleScroll(GdkEventScroll* e);
+
   auto calendar_text(const waybar_time& wtime) -> std::string;
   auto weekdays_header(const date::weekday& first_dow, std::ostream& os) -> void;
   auto first_day_of_week() -> date::weekday;
+  bool setTimeZone(Json::Value zone_name);
 };
 
 }  // namespace waybar::modules

include/modules/cpu.hpp

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <fmt/format.h>
-#include <unistd.h>
 #include <cstdint>
 #include <fstream>
 #include <numeric>
@@ -20,9 +19,11 @@ class Cpu : public ALabel {
   auto update() -> void;
 
  private:
-  uint16_t                                getCpuLoad();
+  double                                         getCpuLoad();
-  std::tuple<uint16_t, std::string>       getCpuUsage();
+  std::tuple<std::vector<uint16_t>, std::string> getCpuUsage();
+  std::tuple<float, float, float>                getCpuFrequency();
   std::vector<std::tuple<size_t, size_t>>        parseCpuinfo();
+  std::vector<float>                             parseCpuFrequencies();
 
   std::vector<std::tuple<size_t, size_t>> prev_times_;
 

include/modules/custom.hpp

@@ -22,6 +22,7 @@ class Custom : public ALabel {
   void continuousWorker();
   void parseOutputRaw();
   void parseOutputJson();
+  void handleEvent();
   bool handleScroll(GdkEventScroll* e);
   bool handleToggle(GdkEventButton* const& e);
 

include/modules/idle_inhibitor.hpp

@@ -12,12 +12,13 @@ class IdleInhibitor : public ALabel {
   IdleInhibitor(const std::string&, const waybar::Bar&, const Json::Value&);
   ~IdleInhibitor();
   auto update() -> void;
+  static std::list<waybar::AModule*> modules;
+  static bool                        status;
 
  private:
   bool handleToggle(GdkEventButton* const& e);
 
   const Bar&                    bar_;
-  std::string                   status_;
   struct zwp_idle_inhibitor_v1* idle_inhibitor_;
   int                           pid_;
 };

include/modules/keyboard_state.hpp

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <fmt/format.h>
+#if FMT_VERSION < 60000
+#include <fmt/time.h>
+#else
+#include <fmt/chrono.h>
+#endif
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "util/sleeper_thread.hpp"
+#include <gtkmm/label.h>
+
+extern "C" {
+#include <libevdev/libevdev.h>
+}
+
+namespace waybar::modules {
+
+class KeyboardState : public AModule {
+ public:
+  KeyboardState(const std::string&, const waybar::Bar&, const Json::Value&);
+  ~KeyboardState();
+  auto update() -> void;
+
+ private:
+  static auto openDevice(const std::string&) -> std::pair<int, libevdev*>;
+
+  Gtk::Box    box_;
+  Gtk::Label  numlock_label_;
+  Gtk::Label  capslock_label_;
+  Gtk::Label  scrolllock_label_;
+
+  std::string numlock_format_;
+  std::string capslock_format_;
+  std::string scrolllock_format_;
+  const std::chrono::seconds interval_;
+  std::string icon_locked_;
+  std::string icon_unlocked_;
+
+  int         fd_;
+  libevdev*   dev_;
+
+  util::SleeperThread thread_;
+};
+
+}  // namespace waybar::modules

include/modules/mpd.hpp

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

include/modules/mpd/mpd.hpp

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <mpd/client.h>
+#include <spdlog/spdlog.h>
+
+#include <condition_variable>
+#include <thread>
+
+#include "ALabel.hpp"
+#include "modules/mpd/state.hpp"
+
+namespace waybar::modules {
+
+class MPD : public ALabel {
+  friend class detail::Context;
+
+  // State machine
+  detail::Context context_{this};
+
+  const std::string module_name_;
+
+  // Not using unique_ptr since we don't manage the pointer
+  // (It's either nullptr, or from the config)
+  const char*       server_;
+  const unsigned    port_;
+  const std::string password_;
+
+  unsigned timeout_;
+
+  detail::unique_connection connection_;
+
+  detail::unique_status status_;
+  mpd_state             state_;
+  detail::unique_song   song_;
+
+ public:
+  MPD(const std::string&, const Json::Value&);
+  virtual ~MPD() noexcept = default;
+  auto update() -> void;
+
+ private:
+  std::string getTag(mpd_tag_type type, unsigned idx = 0) const;
+  void        setLabel();
+  std::string getStateIcon() const;
+  std::string getOptionIcon(std::string optionName, bool activated) const;
+
+  // GUI-side methods
+  bool handlePlayPause(GdkEventButton* const&);
+  void emit() { dp.emit(); }
+
+  // MPD-side, Non-GUI methods.
+  void tryConnect();
+  void checkErrors(mpd_connection* conn);
+  void fetchState();
+  void queryMPD();
+
+  inline bool stopped() const { return connection_ && state_ == MPD_STATE_STOP; }
+  inline bool playing() const { return connection_ && state_ == MPD_STATE_PLAY; }
+  inline bool paused() const { return connection_ && state_ == MPD_STATE_PAUSE; }
+};
+
+#if !defined(MPD_NOINLINE)
+#include "modules/mpd/state.inl.hpp"
+#endif
+
+}  // namespace waybar::modules

include/modules/mpd/state.hpp

@@ -0,0 +1,217 @@
+#pragma once
+
+#include <mpd/client.h>
+#include <fmt/format.h>
+#include <spdlog/spdlog.h>
+
+#include <condition_variable>
+#include <thread>
+
+#include "ALabel.hpp"
+
+namespace waybar::modules {
+class MPD;
+}  // namespace waybar::modules
+
+namespace waybar::modules::detail {
+
+using unique_connection = std::unique_ptr<mpd_connection, decltype(&mpd_connection_free)>;
+using unique_status = std::unique_ptr<mpd_status, decltype(&mpd_status_free)>;
+using unique_song = std::unique_ptr<mpd_song, decltype(&mpd_song_free)>;
+
+class Context;
+
+/// This state machine loosely follows a non-hierarchical, statechart
+/// pattern, and includes ENTRY and EXIT actions.
+///
+/// The State class is the base class for all other states. The
+/// entry and exit methods are automatically called when entering
+/// into a new state and exiting from the current state. This
+/// includes initially entering (Disconnected class) and exiting
+/// Waybar.
+///
+/// The following nested "top-level" states are represented:
+/// 1. Idle - await notification of MPD activity.
+/// 2. All Non-Idle states:
+///    1. Playing - An active song is producing audio output.
+///    2. Paused - The current song is paused.
+///    3. Stopped - No song is actively playing.
+/// 3. Disconnected - periodically attempt MPD (re-)connection.
+///
+/// NOTE: Since this statechart is non-hierarchical, the above
+/// states are flattened into a set.
+
+class State {
+ public:
+  virtual ~State() noexcept = default;
+
+  virtual void entry() noexcept { spdlog::debug("mpd: ignore entry action"); }
+  virtual void exit() noexcept { spdlog::debug("mpd: ignore exit action"); }
+
+  virtual void play() { spdlog::debug("mpd: ignore play state transition"); }
+  virtual void stop() { spdlog::debug("mpd: ignore stop state transition"); }
+  virtual void pause() { spdlog::debug("mpd: ignore pause state transition"); }
+
+  /// Request state update the GUI.
+  virtual void update() noexcept { spdlog::debug("mpd: ignoring update method request"); }
+};
+
+class Idle : public State {
+  Context* const   ctx_;
+  sigc::connection idle_connection_;
+
+ public:
+  Idle(Context* const ctx) : ctx_{ctx} {}
+  virtual ~Idle() noexcept { this->exit(); };
+
+  void entry() noexcept override;
+  void exit() noexcept override;
+
+  void play() override;
+  void stop() override;
+  void pause() override;
+  void update() noexcept override;
+
+ private:
+  Idle(const Idle&) = delete;
+  Idle& operator=(const Idle&) = delete;
+
+  bool on_io(Glib::IOCondition const&);
+};
+
+class Playing : public State {
+  Context* const   ctx_;
+  sigc::connection timer_connection_;
+
+ public:
+  Playing(Context* const ctx) : ctx_{ctx} {}
+  virtual ~Playing() noexcept { this->exit(); }
+
+  void entry() noexcept override;
+  void exit() noexcept override;
+
+  void pause() override;
+  void stop() override;
+  void update() noexcept override;
+
+ private:
+  Playing(Playing const&) = delete;
+  Playing& operator=(Playing const&) = delete;
+
+  bool on_timer();
+};
+
+class Paused : public State {
+  Context* const   ctx_;
+  sigc::connection timer_connection_;
+
+ public:
+  Paused(Context* const ctx) : ctx_{ctx} {}
+  virtual ~Paused() noexcept { this->exit(); }
+
+  void entry() noexcept override;
+  void exit() noexcept override;
+
+  void play() override;
+  void stop() override;
+  void update() noexcept override;
+
+ private:
+  Paused(Paused const&) = delete;
+  Paused& operator=(Paused const&) = delete;
+
+  bool on_timer();
+};
+
+class Stopped : public State {
+  Context* const   ctx_;
+  sigc::connection timer_connection_;
+
+ public:
+  Stopped(Context* const ctx) : ctx_{ctx} {}
+  virtual ~Stopped() noexcept { this->exit(); }
+
+  void entry() noexcept override;
+  void exit() noexcept override;
+
+  void play() override;
+  void pause() override;
+  void update() noexcept override;
+
+ private:
+  Stopped(Stopped const&) = delete;
+  Stopped& operator=(Stopped const&) = delete;
+
+  bool on_timer();
+};
+
+class Disconnected : public State {
+  Context* const   ctx_;
+  sigc::connection timer_connection_;
+
+ public:
+  Disconnected(Context* const ctx) : ctx_{ctx} {}
+  virtual ~Disconnected() noexcept { this->exit(); }
+
+  void entry() noexcept override;
+  void exit() noexcept override;
+
+  void update() noexcept override;
+
+ private:
+  Disconnected(Disconnected const&) = delete;
+  Disconnected& operator=(Disconnected const&) = delete;
+
+  void arm_timer(int interval) noexcept;
+  void disarm_timer() noexcept;
+
+  bool on_timer();
+};
+
+class Context {
+  std::unique_ptr<State> state_;
+  waybar::modules::MPD*  mpd_module_;
+
+  friend class State;
+  friend class Playing;
+  friend class Paused;
+  friend class Stopped;
+  friend class Disconnected;
+  friend class Idle;
+
+ protected:
+  void setState(std::unique_ptr<State>&& new_state) noexcept {
+    if (state_.get() != nullptr) {
+      state_->exit();
+    }
+    state_ = std::move(new_state);
+    state_->entry();
+  }
+
+  bool                             is_connected() const;
+  bool                             is_playing() const;
+  bool                             is_paused() const;
+  bool                             is_stopped() const;
+  constexpr std::size_t            interval() const;
+  void                             tryConnect() const;
+  void                             checkErrors(mpd_connection*) const;
+  void                             do_update();
+  void                             queryMPD() const;
+  void                             fetchState() const;
+  constexpr mpd_state              state() const;
+  void                             emit() const;
+  [[nodiscard]] unique_connection& connection();
+
+ public:
+  explicit Context(waybar::modules::MPD* const mpd_module)
+      : state_{std::make_unique<Disconnected>(this)}, mpd_module_{mpd_module} {
+    state_->entry();
+  }
+
+  void play() { state_->play(); }
+  void stop() { state_->stop(); }
+  void pause() { state_->pause(); }
+  void update() noexcept { state_->update(); }
+};
+
+}  // namespace waybar::modules::detail

include/modules/mpd/state.inl.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+namespace detail {
+
+inline bool Context::is_connected() const { return mpd_module_->connection_ != nullptr; }
+inline bool Context::is_playing() const { return mpd_module_->playing(); }
+inline bool Context::is_paused() const { return mpd_module_->paused(); }
+inline bool Context::is_stopped() const { return mpd_module_->stopped(); }
+
+constexpr inline std::size_t Context::interval() const { return mpd_module_->interval_.count(); }
+inline void                  Context::tryConnect() const { mpd_module_->tryConnect(); }
+inline unique_connection&    Context::connection() { return mpd_module_->connection_; }
+constexpr inline mpd_state   Context::state() const { return mpd_module_->state_; }
+
+inline void Context::do_update() {
+  mpd_module_->setLabel();
+}
+
+inline void Context::checkErrors(mpd_connection* conn) const { mpd_module_->checkErrors(conn); }
+inline void Context::queryMPD() const { mpd_module_->queryMPD(); }
+inline void Context::fetchState() const { mpd_module_->fetchState(); }
+inline void Context::emit() const { mpd_module_->emit(); }
+
+}  // namespace detail

include/modules/network.hpp

@@ -2,16 +2,16 @@
 
 #include <arpa/inet.h>
 #include <fmt/format.h>
-#include <ifaddrs.h>
 #include <linux/nl80211.h>
-#include <net/if.h>
 #include <netlink/genl/ctrl.h>
 #include <netlink/genl/genl.h>
 #include <netlink/netlink.h>
 #include <sys/epoll.h>
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
+#ifdef WANT_RFKILL
 #include "util/rfkill.hpp"
+#endif
 
 namespace waybar::modules {
 
@@ -26,26 +26,24 @@ class Network : public ALabel {
   static const uint8_t EPOLL_MAX = 200;
 
   static int handleEvents(struct nl_msg*, void*);
+  static int handleEventsDone(struct nl_msg*, void*);
   static int handleScan(struct nl_msg*, void*);
 
+  void askForStateDump(void);
+
   void              worker();
   void              createInfoSocket();
   void              createEventSocket();
-  int               getExternalInterface(int skip_idx = -1) const;
-  void              getInterfaceAddress();
-  int               netlinkRequest(void*, uint32_t, uint32_t groups = 0) const;
-  int               netlinkResponse(void*, uint32_t, uint32_t groups = 0) const;
   void              parseEssid(struct nlattr**);
   void              parseSignal(struct nlattr**);
   void              parseFreq(struct nlattr**);
   bool              associatedOrJoined(struct nlattr**);
-  bool              checkInterface(struct ifinfomsg* rtif, std::string name);
+  bool              checkInterface(std::string name);
-  int               getPreferredIface(int skip_idx = -1, bool wait = true) const;
   auto              getInfo() -> void;
-  void              checkNewInterface(struct ifinfomsg* rtif);
   const std::string getNetworkState() const;
   void              clearIface();
   bool              wildcardMatch(const std::string& pattern, const std::string& text) const;
+  std::optional<std::pair<unsigned long long, unsigned long long>> readBandwidthUsage();
 
   int                ifid_;
   sa_family_t        family_;
@@ -57,24 +55,32 @@ class Network : public ALabel {
   int                nl80211_id_;
   std::mutex         mutex_;
 
+  bool               want_route_dump_;
+  bool               want_link_dump_;
+  bool               want_addr_dump_;
+  bool               dump_in_progress_;
+
   unsigned long long bandwidth_down_total_;
   unsigned long long bandwidth_up_total_;
 
   std::string state_;
   std::string essid_;
+  bool        carrier_;
   std::string ifname_;
   std::string ipaddr_;
+  std::string gwaddr_;
   std::string netmask_;
   int         cidr_;
   int32_t     signal_strength_dbm_;
   uint8_t     signal_strength_;
   uint32_t    frequency_;
+  uint32_t    route_priority;
 
   util::SleeperThread thread_;
   util::SleeperThread thread_timer_;
-  util::SleeperThread thread_rfkill_;
+#ifdef WANT_RFKILL
-
   util::Rfkill rfkill_;
+#endif
 };
 
 }  // namespace waybar::modules

include/modules/pulseaudio.hpp

@@ -24,7 +24,7 @@ class Pulseaudio : public ALabel {
   static void volumeModifyCb(pa_context*, int, void*);
 
   bool              handleScroll(GdkEventScroll* e);
-  const std::string getPortIcon() const;
+  const std::vector<std::string> getPulseIcon() const;
 
   pa_threaded_mainloop* mainloop_;
   pa_mainloop_api*      mainloop_api_;
@@ -38,7 +38,8 @@ class Pulseaudio : public ALabel {
   std::string form_factor_;
   std::string desc_;
   std::string monitor_;
-  std::string default_sink_name_;
+  std::string current_sink_name_;
+  bool        current_sink_running_;
   // SOURCE
   uint32_t    source_idx_{0};
   uint16_t    source_volume_;

include/modules/river/tags.hpp

@@ -0,0 +1,38 @@
+#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 "river-control-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);
+  void handle_urgent_tags(uint32_t tags);
+
+  void handle_primary_clicked(uint32_t tag);
+  bool handle_button_press(GdkEventButton *event_button, uint32_t tag);
+
+  struct zriver_status_manager_v1 *status_manager_;
+  struct zriver_control_v1 *control_;
+  struct wl_seat *seat_;
+
+ 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/simpleclock.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <fmt/format.h>
+#if FMT_VERSION < 60000
+#include <fmt/time.h>
+#else
+#include <fmt/chrono.h>
+#endif
+#include "ALabel.hpp"
+#include "util/sleeper_thread.hpp"
+
+namespace waybar::modules {
+
+class Clock : public ALabel {
+ public:
+  Clock(const std::string&, const Json::Value&);
+  ~Clock() = default;
+  auto update() -> void;
+
+ private:
+  util::SleeperThread thread_;
+};
+
+}  // namespace waybar::modules

include/modules/sndio.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <sndio.h>
+#include <vector>
+#include "ALabel.hpp"
+#include "util/sleeper_thread.hpp"
+
+namespace waybar::modules {
+
+class Sndio : public ALabel {
+ public:
+  Sndio(const std::string&, const Json::Value&);
+  ~Sndio();
+  auto update() -> void;
+  auto set_desc(struct sioctl_desc *, unsigned int) -> void;
+  auto put_val(unsigned int, unsigned int) -> void;
+  bool handleScroll(GdkEventScroll *);
+  bool handleToggle(GdkEventButton* const&);
+
+ private:
+  auto connect_to_sndio() -> void;
+  util::SleeperThread thread_;
+  struct sioctl_hdl *hdl_;
+  std::vector<struct pollfd> pfds_;
+  unsigned int addr_;
+  unsigned int volume_, old_volume_, maxval_;
+  bool muted_;
+};
+
+}  // namespace waybar::modules

include/modules/sni/host.hpp

@@ -5,13 +5,15 @@
 #include <glibmm/refptr.h>
 #include <json/json.h>
 #include <tuple>
+#include "bar.hpp"
 #include "modules/sni/item.hpp"
 
 namespace waybar::modules::SNI {
 
 class Host {
  public:
-  Host(const std::size_t id, const Json::Value&, const std::function<void(std::unique_ptr<Item>&)>&,
+  Host(const std::size_t id, const Json::Value&, const Bar&,
+       const std::function<void(std::unique_ptr<Item>&)>&,
        const std::function<void(std::unique_ptr<Item>&)>&);
   ~Host();
 
@@ -36,6 +38,7 @@ class Host {
   GCancellable*                                     cancellable_ = nullptr;
   SnWatcher*                                        watcher_ = nullptr;
   const Json::Value&                                config_;
+  const Bar&                                        bar_;
   const std::function<void(std::unique_ptr<Item>&)> on_add_;
   const std::function<void(std::unique_ptr<Item>&)> on_remove_;
 };

include/modules/sni/item.hpp

@@ -11,11 +11,21 @@
 #include <libdbusmenu-gtk/dbusmenu-gtk.h>
 #include <sigc++/trackable.h>
 
+#include <set>
+#include <string_view>
+
+#include "bar.hpp"
+
 namespace waybar::modules::SNI {
 
+struct ToolTip {
+  Glib::ustring icon_name;
+  Glib::ustring text;
+};
+
 class Item : public sigc::trackable {
  public:
-  Item(const std::string&, const std::string&, const Json::Value&);
+  Item(const std::string&, const std::string&, const Json::Value&, const Bar&);
   ~Item() = default;
 
   std::string bus_name;
@@ -27,10 +37,8 @@ class Item : public sigc::trackable {
   Gtk::EventBox event_box;
   std::string   category;
   std::string   id;
-  std::string   status;
 
   std::string                  title;
-  int32_t                      window_id;
   std::string                  icon_name;
   Glib::RefPtr<Gdk::Pixbuf>    icon_pixmap;
   Glib::RefPtr<Gtk::IconTheme> icon_theme;
@@ -39,6 +47,7 @@ class Item : public sigc::trackable {
   std::string                  attention_movie_name;
   std::string                  icon_theme_path;
   std::string                  menu;
+  ToolTip                      tooltip;
   DbusmenuGtkMenu*             dbus_menu = nullptr;
   Gtk::Menu*                   gtk_menu = nullptr;
   /**
@@ -49,8 +58,10 @@ class Item : public sigc::trackable {
   bool item_is_menu = true;
 
  private:
+  void onConfigure(GdkEventConfigure* ev);
   void proxyReady(Glib::RefPtr<Gio::AsyncResult>& result);
   void setProperty(const Glib::ustring& name, Glib::VariantBase& value);
+  void setStatus(const Glib::ustring& value);
   void getUpdatedProperties();
   void processUpdatedProperties(Glib::RefPtr<Gio::AsyncResult>& result);
   void onSignal(const Glib::ustring& sender_name, const Glib::ustring& signal_name,
@@ -58,14 +69,24 @@ class Item : public sigc::trackable {
 
   void                      updateImage();
   Glib::RefPtr<Gdk::Pixbuf> extractPixBuf(GVariant* variant);
+  Glib::RefPtr<Gdk::Pixbuf> getIconPixbuf();
   Glib::RefPtr<Gdk::Pixbuf> getIconByName(const std::string& name, int size);
+  double                    getScaledIconSize();
   static void               onMenuDestroyed(Item* self, GObject* old_menu_pointer);
   void                      makeMenu();
   bool                      handleClick(GdkEventButton* const& /*ev*/);
+  bool                      handleScroll(GdkEventScroll* const&);
+
+  // smooth scrolling threshold
+  gdouble scroll_threshold_ = 0;
+  gdouble distance_scrolled_x_ = 0;
+  gdouble distance_scrolled_y_ = 0;
+  // visibility of items with Status == Passive
+  bool show_passive_ = false;
 
   Glib::RefPtr<Gio::DBus::Proxy> proxy_;
   Glib::RefPtr<Gio::Cancellable> cancellable_;
-  bool                           update_pending_;
+  std::set<std::string_view>     update_pending_;
 };
 
 }  // namespace waybar::modules::SNI

include/modules/sway/ipc/ipc.hpp

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

include/modules/sway/language.hpp

@@ -0,0 +1,69 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <xkbcommon/xkbregistry.h>
+
+#include <map>
+#include <string>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+#include "client.hpp"
+#include "modules/sway/ipc/client.hpp"
+#include "util/json.hpp"
+
+namespace waybar::modules::sway {
+
+class Language : public ALabel, public sigc::trackable {
+ public:
+  Language(const std::string& id, const Json::Value& config);
+  ~Language() = default;
+  auto update() -> void;
+
+ private:
+  enum class DispayedShortFlag {
+	  None = 0,
+	  ShortName = 1,
+	  ShortDescription = 1 << 1
+  };
+
+  struct Layout {
+    std::string full_name;
+    std::string short_name;
+    std::string variant;
+    std::string short_description;
+  };
+
+  class XKBContext {
+   public:
+	   XKBContext();
+	   ~XKBContext();
+	   auto next_layout() -> Layout*;
+   private:
+	rxkb_context* context_ = nullptr;
+	rxkb_layout* xkb_layout_ = nullptr;
+	Layout* layout_ = nullptr;
+	std::map<std::string, rxkb_layout*> base_layouts_by_name_;
+  };
+
+  void onEvent(const struct Ipc::ipc_response&);
+  void onCmd(const struct Ipc::ipc_response&);
+
+  auto set_current_layout(std::string current_layout) -> void;
+  auto init_layouts_map(const std::vector<std::string>& used_layouts) -> void;
+
+  const static std::string XKB_LAYOUT_NAMES_KEY;
+  const static std::string XKB_ACTIVE_LAYOUT_NAME_KEY;
+  
+  Layout                        layout_;
+  std::string tooltip_format_ = "";
+  std::map<std::string, Layout> layouts_map_;
+  bool is_variant_displayed;
+  std::byte displayed_short_flag = static_cast<std::byte>(DispayedShortFlag::None);
+
+  util::JsonParser         parser_;
+  std::mutex               mutex_;
+  Ipc                      ipc_;
+};
+
+}  // namespace waybar::modules::sway

include/modules/sway/window.hpp

@@ -22,6 +22,7 @@ class Window : public ALabel, public sigc::trackable {
   std::tuple<std::size_t, int, std::string, std::string> getFocusedNode(const Json::Value& nodes,
                                                                         std::string&       output);
   void                                                   getTree();
+  std::string                                            rewriteTitle(const std::string& title);
 
   const Bar&       bar_;
   std::string      window_;

include/modules/sway/workspaces.hpp

@@ -20,6 +20,10 @@ class Workspaces : public AModule, public sigc::trackable {
   auto update() -> void;
 
  private:
+  static inline const std::string workspace_switch_cmd_ = "workspace {} \"{}\"";
+
+  static int convertWorkspaceNameToNum(std::string name);
+
   void              onCmd(const struct Ipc::ipc_response&);
   void              onEvent(const struct Ipc::ipc_response&);
   bool              filterButtons();

include/modules/wlr/taskbar.hpp

@@ -0,0 +1,165 @@
+#pragma once
+
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "client.hpp"
+#include "util/json.hpp"
+
+#include <memory>
+#include <string>
+#include <vector>
+#include <unordered_set>
+
+#include <gdk/gdk.h>
+
+#include <glibmm/refptr.h>
+
+#include <gtkmm/box.h>
+#include <gtkmm/button.h>
+#include <gtkmm/image.h>
+#include <gtkmm/label.h>
+#include <gtkmm/icontheme.h>
+
+#include <wayland-client.h>
+#include "wlr-foreign-toplevel-management-unstable-v1-client-protocol.h"
+
+
+namespace waybar::modules::wlr {
+
+class Taskbar;
+
+class Task
+{
+   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_ = false;
+    bool ignored_ = false;
+
+    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_ = 0;
+
+   private:
+    std::string repr() const;
+    std::string state_string(bool = false) const;
+    void hide_if_ignored();
+
+   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_;
+    std::unordered_set<std::string> ignore_list_;
+
+    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;
+    const std::unordered_set<std::string>& ignore_list() const;
+};
+
+} /* namespace waybar::modules::wlr */

include/modules/wlr/workspace_manager.hpp

@@ -0,0 +1,160 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <gtkmm/button.h>
+#include <gtkmm/image.h>
+#include <gtkmm/label.h>
+
+#include <functional>
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "ext-workspace-unstable-v1-client-protocol.h"
+
+namespace waybar::modules::wlr {
+
+class WorkspaceManager;
+class WorkspaceGroup;
+
+class Workspace {
+ public:
+  Workspace(const waybar::Bar &bar, const Json::Value &config, WorkspaceGroup &workspace_group,
+            zext_workspace_handle_v1 *workspace, uint32_t id);
+  ~Workspace();
+  auto update() -> void;
+
+  auto id() const -> uint32_t { return id_; }
+  auto is_active() const -> bool { return state_ & static_cast<uint32_t>(State::ACTIVE); }
+  auto is_urgent() const -> bool { return state_ & static_cast<uint32_t>(State::URGENT); }
+  auto is_hidden() const -> bool { return state_ & static_cast<uint32_t>(State::HIDDEN); }
+  // wlr stuff
+  auto handle_name(const std::string &name) -> void;
+  auto handle_coordinates(const std::vector<uint32_t> &coordinates) -> void;
+  auto handle_state(const std::vector<uint32_t> &state) -> void;
+  auto handle_remove() -> void;
+
+  auto handle_done() -> void;
+  auto handle_clicked(GdkEventButton *bt) -> bool;
+  auto show() -> void;
+  auto hide() -> void;
+  auto get_button_ref() -> Gtk::Button & { return button_; }
+  auto get_name() -> std::string & { return name_; }
+  auto get_coords() -> std::vector<uint32_t> & { return coordinates_; }
+
+  enum class State {
+    ACTIVE = (1 << 0),
+    URGENT = (1 << 1),
+    HIDDEN = (1 << 2),
+  };
+
+ private:
+  auto get_icon() -> std::string;
+
+  const Bar         &bar_;
+  const Json::Value &config_;
+  WorkspaceGroup    &workspace_group_;
+
+  // wlr stuff
+  zext_workspace_handle_v1 *workspace_handle_;
+  uint32_t                  state_ = 0;
+
+  uint32_t                                  id_;
+  std::string                               name_;
+  std::vector<uint32_t>                     coordinates_;
+  static std::map<std::string, std::string> icons_map_;
+  std::string                               format_;
+  bool                                      with_icon_ = false;
+
+  Gtk::Button button_;
+  Gtk::Box    content_;
+  Gtk::Label  label_;
+};
+
+class WorkspaceGroup {
+ public:
+  WorkspaceGroup(const waybar::Bar &bar, Gtk::Box &box, const Json::Value &config,
+                 WorkspaceManager &manager, zext_workspace_group_handle_v1 *workspace_group_handle,
+                 uint32_t id);
+  ~WorkspaceGroup();
+  auto update() -> void;
+
+  auto id() const -> uint32_t { return id_; }
+  auto is_visible() const -> bool;
+  auto remove_workspace(uint32_t id_) -> void;
+  auto active_only() const -> bool;
+  auto creation_delayed() const -> bool;
+  auto workspaces() -> std::vector<std::unique_ptr<Workspace>> & { return workspaces_; }
+
+  auto sort_workspaces() -> void;
+  auto set_need_to_sort() -> void { need_to_sort = true; }
+  auto add_button(Gtk::Button &button) -> void;
+  auto remove_button(Gtk::Button &button) -> void;
+
+  // wlr stuff
+  auto handle_workspace_create(zext_workspace_handle_v1 *workspace_handle) -> void;
+  auto handle_remove() -> void;
+  auto handle_output_enter(wl_output *output) -> void;
+  auto handle_output_leave() -> void;
+  auto handle_done() -> void;
+  auto commit() -> void;
+
+ private:
+  static uint32_t    workspace_global_id;
+  const waybar::Bar &bar_;
+  Gtk::Box          &box_;
+  const Json::Value &config_;
+  WorkspaceManager  &workspace_manager_;
+
+  // wlr stuff
+  zext_workspace_group_handle_v1 *workspace_group_handle_;
+  wl_output                      *output_ = nullptr;
+
+  uint32_t                                id_;
+  std::vector<std::unique_ptr<Workspace>> workspaces_;
+  bool                                    need_to_sort = false;
+};
+
+class WorkspaceManager : public AModule {
+ public:
+  WorkspaceManager(const std::string &id, const waybar::Bar &bar, const Json::Value &config);
+  ~WorkspaceManager() override;
+  auto update() -> void override;
+
+  auto all_outputs() const -> bool { return all_outputs_; }
+  auto active_only() const -> bool { return active_only_; }
+  auto workspace_comparator() const
+      -> std::function<bool(std::unique_ptr<Workspace> &, std::unique_ptr<Workspace> &)>;
+  auto creation_delayed() const -> bool { return creation_delayed_; }
+
+  auto sort_workspaces() -> void;
+  auto remove_workspace_group(uint32_t id_) -> void;
+
+  // wlr stuff
+  auto register_manager(wl_registry *registry, uint32_t name, uint32_t version) -> void;
+  auto handle_workspace_group_create(zext_workspace_group_handle_v1 *workspace_group_handle)
+      -> void;
+  auto handle_done() -> void;
+  auto handle_finished() -> void;
+  auto commit() -> void;
+
+ private:
+  const waybar::Bar                           &bar_;
+  Gtk::Box                                     box_;
+  std::vector<std::unique_ptr<WorkspaceGroup>> groups_;
+
+  // wlr stuff
+  zext_workspace_manager_v1 *workspace_manager_ = nullptr;
+
+  static uint32_t group_global_id;
+
+  bool sort_by_name_ = true;
+  bool sort_by_coordinates_ = true;
+  bool all_outputs_ = false;
+  bool active_only_ = false;
+  bool creation_delayed_ = false;
+};
+
+}  // namespace waybar::modules::wlr

include/modules/wlr/workspace_manager_binding.hpp

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

include/util/command.hpp

@@ -5,8 +5,18 @@
 #include <sys/wait.h>
 #include <unistd.h>
 
+#ifdef __linux__
+#include <sys/prctl.h>
+#endif
+#ifdef __FreeBSD__
+#include <sys/procctl.h>
+#endif
+
 #include <array>
 
+extern std::mutex reap_mtx;
+extern std::list<pid_t> reap;
+
 namespace waybar::util::command {
 
 struct res {
@@ -32,10 +42,11 @@ inline std::string read(FILE* fp) {
 
 inline int close(FILE* fp, pid_t pid) {
   int stat = -1;
+  pid_t ret;
 
   fclose(fp);
   do {
-    waitpid(pid, &stat, WCONTINUED | WUNTRACED);
+    ret = waitpid(pid, &stat, WCONTINUED | WUNTRACED);
 
     if (WIFEXITED(stat)) {
       spdlog::debug("Cmd exited with code {}", WEXITSTATUS(stat));
@@ -45,6 +56,8 @@ inline int close(FILE* fp, pid_t pid) {
       spdlog::debug("Cmd stopped by {}", WSTOPSIG(stat));
     } else if (WIFCONTINUED(stat)) {
       spdlog::debug("Cmd continued");
+    } else if (ret == -1) {
+      spdlog::debug("waitpid failed: {}", strerror(errno));
     } else {
       break;
     }
@@ -65,6 +78,24 @@ inline FILE* open(const std::string& cmd, int& pid) {
   }
 
   if (!child_pid) {
+    int err;
+    sigset_t mask;
+    sigfillset(&mask);
+    // Reset sigmask
+    err = pthread_sigmask(SIG_UNBLOCK, &mask, nullptr);
+    if (err != 0) spdlog::error("pthread_sigmask in open failed: {}", strerror(err));
+    // Kill child if Waybar exits
+    int deathsig = SIGTERM;
+#ifdef __linux__
+    if (prctl(PR_SET_PDEATHSIG, deathsig) != 0) {
+      spdlog::error("prctl(PR_SET_PDEATHSIG) in open failed: {}", strerror(errno));
+    }
+#endif
+#ifdef __FreeBSD__
+    if (procctl(P_PID, 0, PROC_PDEATHSIG_CTL, reinterpret_cast<void*>(&deathsig)) == -1) {
+      spdlog::error("procctl(PROC_PDEATHSIG_CTL) in open failed: {}", strerror(errno));
+    }
+#endif
     ::close(fd[0]);
     dup2(fd[1], 1);
     setpgid(child_pid, child_pid);
@@ -97,7 +128,7 @@ inline struct res execNoRead(const std::string& cmd) {
 inline int32_t forkExec(const std::string& cmd) {
   if (cmd == "") return -1;
 
-  int32_t pid = fork();
+  pid_t pid = fork();
 
   if (pid < 0) {
     spdlog::error("Unable to exec cmd {}, error {}", cmd.c_str(), strerror(errno));
@@ -106,12 +137,20 @@ inline int32_t forkExec(const std::string& cmd) {
 
   // Child executes the command
   if (!pid) {
+    int err;
+    sigset_t mask;
+    sigfillset(&mask);
+    // Reset sigmask
+    err = pthread_sigmask(SIG_UNBLOCK, &mask, nullptr);
+    if (err != 0) spdlog::error("pthread_sigmask in forkExec failed: {}", strerror(err));
     setpgid(pid, pid);
-    signal(SIGCHLD, SIG_DFL);
     execl("/bin/sh", "sh", "-c", cmd.c_str(), (char*)0);
     exit(0);
   } else {
-    signal(SIGCHLD, SIG_IGN);
+    reap_mtx.lock();
+    reap.push_back(pid);
+    reap_mtx.unlock();
+    spdlog::debug("Added child to reap list: {}", pid);
   }
 
   return pid;

include/util/format.hpp

@@ -23,7 +23,7 @@ namespace fmt {
         constexpr auto parse(ParseContext& ctx) -> decltype (ctx.begin()) {
           auto it = ctx.begin(), end = ctx.end();
           if (it != end && *it == ':') ++it;
-          if (*it == '>' || *it == '<' || *it == '=') {
+          if (it && (*it == '>' || *it == '<' || *it == '=')) {
             spec = *it;
             ++it;
           }
@@ -35,7 +35,11 @@ namespace fmt {
             // The rationale for ignoring it is that the only reason to specify
             // an alignment and a with is to get a fixed width bar, and ">" is
             // sufficient in this implementation.
+#if FMT_VERSION < 80000
             width = parse_nonnegative_int(it, end, ctx);
+#else
+            width = detail::parse_nonnegative_int(it, end, -1);
+#endif
           }
           return it;
         }

include/util/rfkill.hpp

@@ -1,19 +1,26 @@
 #pragma once
 
+#include <glibmm/iochannel.h>
 #include <linux/rfkill.h>
+#include <sigc++/signal.h>
+#include <sigc++/trackable.h>
 
 namespace waybar::util {
 
-class Rfkill {
+class Rfkill : public sigc::trackable {
- public:;
+ public:
   Rfkill(enum rfkill_type rfkill_type);
-  ~Rfkill() = default;
+  ~Rfkill();
-  void waitForEvent();
   bool getState() const;
 
+  sigc::signal<void(struct rfkill_event&)> on_update;
+
  private:
   enum rfkill_type rfkill_type_;
-  int state_ = 0;
+  bool             state_ = false;
+  int              fd_ = -1;
+
+  bool on_event(Glib::IOCondition cond);
 };
 
 }  // namespace waybar::util

include/util/sleeper_thread.hpp

@@ -8,6 +8,20 @@
 
 namespace waybar::util {
 
+/**
+ * Defer pthread_cancel until the end of a current scope.
+ *
+ * Required to protect a scope where it's unsafe to raise `__forced_unwind` exception.
+ * An example of these is a call of a method marked as `noexcept`; an attempt to cancel within such
+ * a method may result in a `std::terminate` call.
+ */
+class CancellationGuard {
+  int oldstate;
+public:
+  CancellationGuard() { pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &oldstate); }
+  ~CancellationGuard() { pthread_setcancelstate(oldstate, &oldstate); }
+};
+
 class SleeperThread {
  public:
   SleeperThread() = default;
@@ -34,6 +48,7 @@ class SleeperThread {
 
   auto sleep_for(std::chrono::system_clock::duration dur) {
     std::unique_lock  lk(mutex_);
+    CancellationGuard cancel_lock;
     return condvar_.wait_for(lk, dur, [this] { return signal_ || !do_run_; });
   }
 
@@ -41,6 +56,7 @@ class SleeperThread {
       std::chrono::time_point<std::chrono::system_clock, std::chrono::system_clock::duration>
           time_point) {
     std::unique_lock  lk(mutex_);
+    CancellationGuard cancel_lock;
     return condvar_.wait_until(lk, time_point, [this] { return signal_ || !do_run_; });
   }
 
@@ -59,6 +75,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() {

include/util/string.hpp

@@ -0,0 +1,15 @@
+#include <string>
+
+const std::string WHITESPACE = " \n\r\t\f\v";
+
+std::string ltrim(const std::string s) {
+  size_t begin = s.find_first_not_of(WHITESPACE);
+  return (begin == std::string::npos) ? "" : s.substr(begin);
+}
+
+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);
+}
+
+std::string trim(const std::string& s) { return rtrim(ltrim(s)); }

include/util/ustring_clen.hpp

@@ -0,0 +1,5 @@
+#pragma once
+#include <glibmm/ustring.h>
+
+// calculate column width of ustring
+int ustring_clen(const Glib::ustring &str);

man/waybar-backlight.5.scd

@@ -24,6 +24,14 @@ The *backlight* module displays the current backlight level.
 	typeof: integer ++
 	The maximum length in characters the module should display.
 
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
 *rotate*: ++
 	typeof: integer ++
 	Positive value to rotate the text label.

man/waybar-battery.5.scd

@@ -20,7 +20,12 @@ The *battery* module displays the current capacity and state (eg. charging) of y
 
 *full-at*: ++
 	typeof: integer ++
-	Define the max percentage of the battery, usefull for an old battery, e.g. 96
+	Define the max percentage of the battery, for when you've set the battery to stop charging at a lower level to save it. For example, if you've set the battery to stop at 80% that will become the new 100%.
+
+*design-capacity*: ++
+    typeof: bool ++
+    default: false ++
+    Option to use the battery design capacity instead of it's current maximal capacity.
 
 *interval*: ++
 	typeof: integer ++
@@ -50,6 +55,14 @@ The *battery* module displays the current capacity and state (eg. charging) of y
 	typeof: integer++
 	The maximum length in character the module should display.
 
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
 *rotate*: ++
 	typeof: integer++
 	Positive value to rotate the text label.
@@ -91,6 +104,8 @@ The *battery* module displays the current capacity and state (eg. charging) of y
 
 *{capacity}*: Capacity in percentage
 
+*{power}*: Power in watts
+
 *{icon}*: Icon, as defined in *format-icons*.
 
 *{time}*: Estimate of time until full or empty. Note that this is based on the power draw at the last refresh time, not an average.
@@ -105,7 +120,7 @@ The two arguments are:
 
 # CUSTOM FORMATS
 
-The *battery* module allows to define custom formats based on up to two factors. The best fitting format will be selected.
+The *battery* module allows one to define custom formats based on up to two factors. The best fitting format will be selected.
 
 *format-<state>*: With *states*, a custom format can be set depending on the capacity of your battery.
 

man/waybar-bluetooth.5.scd

@@ -12,11 +12,6 @@ The *bluetooth* module displays information about the status of the device's blu
 
 Addressed by *bluetooth*
 
-*interval*: ++
-	typeof: integer ++
-	default: 60 ++
-	The interval in which the bluetooth state gets updated.
-
 *format*: ++
 	typeof: string  ++
 	default: *{icon}* ++
@@ -35,6 +30,14 @@ Addressed by *bluetooth*
 	typeof: integer ++
 	The maximum length in character the module should display.
 
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
 *on-click*: ++
 	typeof: string ++
 	Command to execute when clicked on the module.
@@ -80,12 +83,11 @@ Addressed by *bluetooth*
 "bluetooth": {
 	"format": "{icon}",
 	"format-alt": "bluetooth: {status}",
-	"interval": 30,
 	"format-icons": {
 		"enabled": "",
 		"disabled": ""
 	},
-	"tooltip-format": "{status}"
+	"tooltip-format": "{}"
 }
 ```
 

man/waybar-clock.5.scd

@@ -24,17 +24,36 @@ The *clock* module displays the current date and time.
 *timezone*: ++
 	typeof: string ++
 	default: inferred local timezone ++
-	The timezone to display the time in, e.g. America/New_York.
+	The timezone to display the time in, e.g. America/New_York. ++
+	This field will be ignored if *timezones* field is set and have at least one value.
+
+*timezones*: ++
+	typeof: list of strings ++
+	A list of timezones to use for time display, changed using the scroll wheel. ++
+	Use "" to represent the system's local timezone.  Using %Z in the format or tooltip format is useful to track which time zone is currently displayed.
 
 *locale*: ++
 	typeof: string ++
 	default: inferred from current locale ++
 	A locale to be used to display the time. Intended to render times in custom timezones with the proper language and format.
 
+*today-format*: ++
+	typeof: string ++
+	default: <b><u>{}</u></b> ++
+	The format of today's date in the calendar.
+
 *max-length*: ++
 	typeof: integer ++
 	The maximum length in character the module should display.
 
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
 *rotate*: ++
 	typeof: integer ++
 	Positive value to rotate the text label.

man/waybar-cpu.5.scd

@@ -20,10 +20,23 @@ The *cpu* module displays the current cpu utilization.
 	default: {usage}% ++
 	The format, how information should be displayed. On {} data gets inserted.
 
+*format-icons*: ++
+	typeof: array/object ++
+	Based on the current usage, the corresponding icon gets selected. ++
+	The order is *low* to *high*. Or by the state if it is an object.
+
 *max-length*: ++
 	typeof: integer ++
 	The maximum length in character the module should display.
 
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
 *rotate*: ++
 	typeof: integer ++
 	Positive value to rotate the text label.
@@ -69,9 +82,23 @@ The *cpu* module displays the current cpu utilization.
 
 *{load}*: Current cpu load.
 
-*{usage}*: Current cpu usage.
+*{usage}*: Current overall cpu usage.
 
-# EXAMPLE
+*{usage*{n}*}*: Current cpu core n usage. Cores are numbered from zero, so first core will be {usage0} and 4th will be {usage3}.
+
+*{avg_frequency}*: Current cpu average frequency (based on all cores) in GHz.
+
+*{max_frequency}*: Current cpu max frequency (based on the core with the highest frequency) in GHz.
+
+*{min_frequency}*: Current cpu min frequency (based on the core with the lowest frequency) in GHz.
+
+*{icon}*: Icon for overall cpu usage.
+
+*{icon*{n}*}*: Icon for cpu core n usage. Use like {icon0}.
+
+# EXAMPLES
+
+Basic configuration:
 
 ```
 "cpu": {
@@ -81,6 +108,16 @@ The *cpu* module displays the current cpu utilization.
 }
 ```
 
+Cpu usage per core rendered as icons:
+
+```
+"cpu": {
+	"interval": 1,
+	"format": "{icon0}{icon1}{icon2}{icon3} {usage:>2}% ",
+	"format-icons": ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"],
+},
+```
+
 # STYLE
 
 - *#cpu*

man/waybar-custom.5.scd

@@ -22,6 +22,12 @@ Addressed by *custom/<name>*
 	The path to a script, which determines if the script in *exec* should be executed.
 	*exec* will be executed if the exit code of *exec-if* equals 0.
 
+*exec-on-event*: ++
+	typeof: bool ++
+	default: true ++
+	If an event command is set (e.g. *on-click* or *on-scroll-up*) then re-execute the script after
+	executing the event command.
+
 *return-type*: ++
 	typeof: string ++
 	See *return-type*
@@ -61,6 +67,14 @@ Addressed by *custom/<name>*
 	typeof: integer ++
 	The maximum length in character the module should display.
 
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
 *on-click*: ++
 	typeof: string ++
 	Command to execute when clicked on the module.

man/waybar-disk.5.scd

@@ -31,10 +31,22 @@ Addressed by *disk*
 	typeof: integer ++
 	Positive value to rotate the text label.
 
+*states*: ++
+	typeof: array ++
+	A number of disk utilization states which get activated on certain percentage thresholds (percentage_used). See *waybar-states(5)*.
+
 *max-length*: ++
 	typeof: integer ++
 	The maximum length in character the module should display.
 
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
 *on-click*: ++
 	typeof: string ++
 	Command to execute when clicked on the module.

man/waybar-idle-inhibitor.5.scd

@@ -27,6 +27,14 @@ screensaving, also known as "presentation mode".
 	typeof: integer ++
 	The maximum length in character the module should display.
 
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
 *on-click*: ++
 	typeof: string ++
 	Command to execute when clicked on the module. A click also toggles the state

man/waybar-keyboard-state.5.scd

@@ -0,0 +1,80 @@
+waybar-keyboard-state(5)
+
+# NAME
+
+waybar - keyboard-state module
+
+# DESCRIPTION
+
+The *keyboard-state* module displays the state of number lock, caps lock, and scroll lock.
+
+# CONFIGURATION
+
+*interval*: ++
+	typeof: integer ++
+	default: 1 ++
+	The interval, in seconds, to poll the keyboard state.
+
+*format*: ++
+	typeof: string|object ++
+	default: {name} {icon} ++
+	The format, how information should be displayed. If a string, the same format is used for all keyboard states. If an object, the fields "numlock", "capslock", and "scrolllock" each specify the format for the corresponding state. Any unspecified states use the default format.
+
+*format-icons*: ++
+	typeof: object ++
+	default: {"locked": "locked", "unlocked": "unlocked"} ++
+	Based on the keyboard state, the corresponding icon gets selected. The same set of icons is used for number, caps, and scroll lock, but the icon is selected from the set independently for each. See *icons*.
+
+*numlock*: ++
+	typeof: bool ++
+	default: false ++
+	Display the number lock state.
+
+*capslock*: ++
+	typeof: bool ++
+	default: false ++
+	Display the caps lock state.
+
+*scrolllock*: ++
+	typeof: bool ++
+	default: false ++
+	Display the scroll lock state.
+
+*device-path*: ++
+	typeof: string ++
+	default: chooses first valid input device ++
+	Which libevdev input device to show the state of. Libevdev devices can be found in /dev/input. The device should support number lock, caps lock, and scroll lock events.
+
+# FORMAT REPLACEMENTS
+
+*{name}*: Caps, Num, or Scroll.
+
+*{icon}*: Icon, as defined in *format-icons*.
+
+# ICONS
+
+The following *format-icons* can be set.
+
+- *locked*: Will be shown when the keyboard state is locked. Default "locked".
+- *unlocked*: Will be shown when the keyboard state is not locked. Default "unlocked"
+
+# EXAMPLE:
+
+```
+"keyboard-state": {
+    "numlock": true,
+    "capslock": true,
+    "format": "{name} {icon}",
+    "format-icons": {
+        "locked": "",
+        "unlocked": ""
+    }
+}
+```
+
+# STYLE
+
+- *#keyboard-state*
+- *#keyboard-state label*
+- *#keyboard-state label.locked*
+

man/waybar-memory.5.scd

@@ -22,6 +22,11 @@ Addressed by *memory*
 	default: {percentage}% ++
 	The format, how information should be displayed.
 
+*format-icons*: ++
+	typeof: array/object ++
+	Based on the current percentage, 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.
@@ -34,6 +39,14 @@ Addressed by *memory*
 	typeof: integer ++
 	The maximum length in character the module should display.
 
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
 *on-click*: ++
 	typeof: string ++
 	Command to execute when clicked on the module.

man/waybar-mpd.5.scd

@@ -20,6 +20,10 @@ Addressed by *mpd*
 	typeof: integer ++
 	The port MPD listens to. If empty, use the default port.
 
+*password*: ++
+	typeof: string ++
+	The password required to connect to the MPD server. If empty, no password is sent to MPD.
+
 *interval*: ++
 	typeof: integer++
 	default: 5 ++
@@ -69,6 +73,22 @@ Addressed by *mpd*
 	default: "MPD (disconnected)" ++
 	Tooltip information displayed when the MPD server can't be reached.
 
+*artist-len*: ++
+    typeof: integer ++
+    Maximum length of the Artist tag.
+
+*album-len*: ++
+    typeof: integer ++
+    Maximum length of the Album tag.
+
+*album-artist-len*: ++
+    typeof: integer ++
+    Maximum length of the Album Artist tag.
+
+*title-len*: ++
+    typeof: integer ++
+    Maximum length of the Title tag.
+
 *rotate*: ++
 	typeof: integer ++
 	Positive value to rotate the text label.
@@ -77,6 +97,14 @@ Addressed by *mpd*
 	typeof: integer ++
 	The maximum length in character the module should display.
 
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
 *on-click*: ++
 	typeof: string ++
 	Command to execute when clicked on the module.
@@ -144,10 +172,16 @@ Addressed by *mpd*
 
 *{date}*: The date of the current song
 
+*{volume}*: The current volume in percent
+
 *{elapsedTime}*: The current position of the current song. To format as a date/time (see example configuration)
 
 *{totalTime}*: The length of the current song. To format as a date/time (see example configuration)
 
+*{songPosition}*: The position of the current song.
+
+*{queueLength}*: The length of the current queue.
+
 *{stateIcon}*: The icon corresponding the playing or paused status of the player (see *state-icons* option)
 
 *{consumeIcon}*: The icon corresponding the "consume" option (see *consume-icons* option)

man/waybar-network.5.scd

@@ -33,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 ++
@@ -64,6 +64,14 @@ Addressed by *network*
 	typeof: integer ++
 	The maximum length in character the module should display.
 
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
 *on-click*: ++
 	typeof: string ++
 	Command to execute when clicked on the module.
@@ -103,7 +111,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 ++
@@ -123,6 +131,8 @@ Addressed by *network*
 
 *{ipaddr}*: The first IP of the interface.
 
+*{gwaddr}*: The default gateway for the interface
+
 *{netmask}*: The subnetmask corresponding to the IP.
 
 *{cidr}*: The subnetmask corresponding to the IP in CIDR notation.

man/waybar-pulseaudio.5.scd

@@ -50,6 +50,14 @@ Additionally you can control the volume by scrolling *up* or *down* while the cu
 	typeof: integer ++
 	The maximum length in character the module should display.
 
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
 *scroll-step*: ++
 	typeof: float ++
 	default: 1.0 ++
@@ -101,6 +109,9 @@ Additionally you can control the volume by scrolling *up* or *down* while the cu
 # ICONS:
 
 The following strings for *format-icons* are supported.
+
+- the device name
+
 If they are found in the current PulseAudio port name, the corresponding icons will be selected.
 
 - *default* (Shown, when no other port is found)
@@ -123,6 +134,7 @@ If they are found in the current PulseAudio port name, the corresponding icons w
 	"format-bluetooth": "{volume}% {icon}",
 	"format-muted": "",
 	"format-icons": {
+		"alsa_output.pci-0000_00_1f.3.analog-stereo": "",
 		"headphones": "",
 		"handsfree": "",
 		"headset": "",

man/waybar-river-tags.5.scd

@@ -0,0 +1,49 @@
+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. Max 32.
+
+*tag-labels*: ++
+    typeof: array ++
+    The label to display for each tag.
+
+*disable-click*: ++
+   typeof: bool ++
+   default: false ++
+   If set to false, you can left click to set focused tag. Right click to toggle tag focus. If set to true this behaviour is disabled.
+
+# EXAMPLE
+
+```
+"river/tags": {
+    "num-tags": 5
+}
+```
+
+# STYLE
+
+- *#tags button*
+- *#tags button.occupied*
+- *#tags button.focused*
+- *#tags button.urgent*
+
+Note that occupied/focused/urgent status may overlap. That is, a tag may be
+both occupied and focused at the same time.
+
+# SEE ALSO
+
+waybar(5), river(1)

man/waybar-sndio.5.scd

@@ -0,0 +1,91 @@
+waybar-sndio(5)
+
+# NAME
+
+waybar - sndio module
+
+# DESCRIPTION
+
+The *sndio* module displays the current volume reported by sndio(7).
+
+Additionally, you can control the volume by scrolling *up* or *down* while the
+cursor is over the module, and clicking on the module toggles mute.
+
+# CONFIGURATION
+
+*format*: ++
+	typeof: string  ++
+	default: {volume}% ++
+	The format for how information should be displayed.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in character the module should display.
+
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
+*scroll-step*: ++
+	typeof: int ++
+	default: 5 ++
+	The speed in which to change the volume when scrolling.
+
+*on-click*: ++
+	typeof: string ++
+	Command to execute when clicked on the module.
+	This replaces the default behaviour of toggling mute.
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when you right clicked on the module.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when scrolling up on the module.
+	This replaces the default behaviour of volume control.
+
+*on-scroll-down*: ++
+	typeof: string ++
+	Command to execute when scrolling down on the module.
+	This replaces the default behaviour of volume control.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
+# FORMAT REPLACEMENTS
+
+*{volume}*: Volume in percentage.
+
+*{raw_value}*: Volume as value reported by sndio.
+
+# EXAMPLES
+
+```
+"sndio": {
+    "format": "{raw_value} 🎜",
+    "scroll-step": 3
+}
+```
+
+# STYLE
+
+- *#sndio*
+- *#sndio.muted*

man/waybar-states.5.scd

@@ -13,7 +13,7 @@ apply a class when the value matches the declared state value.
 	  Each class gets activated when the current capacity is equal or below the configured *<value>*.
 
 	- Also each state can have its own *format*.
-	  Those con be configured via *format-<name>*.
+	  Those can be configured via *format-<name>*.
 	  Or if you want to differentiate a bit more even as *format-<status>-<state>*.
 
 # EXAMPLE

man/waybar-sway-language.5.scd

@@ -0,0 +1,54 @@
+waybar-sway-language(5)
+
+# NAME
+
+waybar - sway language module
+
+# DESCRIPTION
+
+The *language* module displays the current keyboard layout in Sway
+
+# CONFIGURATION
+
+Addressed by *sway/language*
+
+*format*: ++
+	typeof: string ++
+	default: {} ++
+	The format, how layout should be displayed.
+
+*tooltip-format*: ++
+	typeof: string ++
+	default: {} ++
+	The format, how layout should be displayed in tooltip.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
+
+# FORMAT REPLACEMENTS
+
+*{short}*: Short name of layout (e.g. "us"). Equals to {}.
+
+*{shortDescription}*: Short description of layout (e.g. "en").
+
+*{long}*: Long name of layout (e.g. "English (Dvorak)").
+
+*{variant}*: Variant of layout (e.g. "dvorak").
+
+# EXAMPLES
+
+```
+"sway/language": {
+    "format": "{}",
+},
+
+"sway/language": {
+    "format": "{short} {variant}",
+}
+```
+
+# STYLE
+
+- *#language*

man/waybar-sway-mode.5.scd

@@ -25,6 +25,14 @@ Addressed by *sway/mode*
 	typeof: integer ++
 	The maximum length in character the module should display.
 
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
 *on-click*: ++
 	typeof: string ++
 	Command to execute when clicked on the module.

man/waybar-sway-window.5.scd

@@ -25,6 +25,14 @@ Addressed by *sway/window*
 	typeof: integer ++
 	The maximum length in character the module should display.
 
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
 *on-click*: ++
 	typeof: string ++
 	Command to execute when clicked on the module.
@@ -58,12 +66,32 @@ Addressed by *sway/window*
 	default: true ++
 	Option to disable tooltip on hover.
 
+*rewrite*: ++
+	typeof: object ++
+	Rules to rewrite window title. See *rewrite rules*.
+
+# REWRITE RULES
+
+*rewrite* is an object where keys are regular expressions and values are
+rewrite rules if the expression matches. Rules may contain references to
+captures of the expression.
+
+Regular expression and replacement follow ECMA-script rules.
+
+If no expression matches, the title is left unchanged.
+
+Invalid expressions (e.g., mismatched parentheses) are skipped.
+
 # EXAMPLES
 
 ```
 "sway/window": {
     "format": "{}",
-    "max-length": 50
+    "max-length": 50,
+    "rewrite": {
+      "(.*) - Mozilla Firefox": "🌎 $1",
+      "(.*) - zsh": "> [$1]"
+    }
 }
 ```
 

man/waybar-sway-workspaces.5.scd

@@ -31,6 +31,11 @@ Addressed by *sway/workspaces*
     default: false ++
     If set to false, you can scroll to cycle through workspaces. If set to true this behaviour is disabled.
 
+*disable-click*: ++
+    typeof: bool ++
+    default: false ++
+    If set to false, you can click to change workspace. If set to true this behaviour is disabled.
+
 *smooth-scrolling-threshold*: ++
     typeof: double ++
     Threshold to be used when scrolling.
@@ -68,6 +73,10 @@ Addressed by *sway/workspaces*
     typeof: bool ++
     Whether to put workspaces starting with numbers before workspaces that do not start with a number.
 
+*disable-auto-back-and-forth*: ++
+    typeof: bool ++
+    Whether to disable *workspace_auto_back_and_forth* when clicking on workspaces. If this is set to *true*, clicking on a workspace you are already on won't do anything, even if *workspace_auto_back_and_forth* is enabled in the Sway configuration.
+
 # FORMAT REPLACEMENTS
 
 *{value}*: Name of the workspace, as defined by sway.
@@ -134,3 +143,4 @@ n.b.: the list of outputs can be obtained from command line using *swaymsg -t ge
 - *#workspaces button.urgent*
 - *#workspaces button.persistent*
 - *#workspaces button.current_output*
+- *#workspaces button#sway-workspace-${name}*

man/waybar-temperature.5.scd

@@ -50,6 +50,11 @@ Addressed by *temperature*
 	typeof: array ++
 	Based on the current temperature (Celsius) and *critical-threshold* if available, the corresponding icon gets selected. The order is *low* to *high*.
 
+*tooltip-format*: ++
+	typeof: string  ++
+	default: {temperatureC}°C ++
+	The format for the tooltip
+
 *rotate*: ++
 	typeof: integer ++
 	Positive value to rotate the text label.
@@ -58,6 +63,14 @@ Addressed by *temperature*
 	typeof: integer ++
 	The maximum length in characters the module should display.
 
+*min-length*: ++
+    typeof: integer ++
+    The minimum length in characters the module should take up.
+
+*align*: ++
+    typeof: float ++
+    The alignment of the text, where 0 is left-aligned and 1 is right-aligned. If the module is rotated, it will follow the flow of the text.
+
 *on-click*: ++
 	typeof: string ++
 	Command to execute when you clicked on the module.

man/waybar-tray.5.scd

@@ -16,6 +16,15 @@ Addressed by *tray*
     typeof: integer ++
     Defines the size of the tray icons.
 
+*show-passive-items*: ++
+    typeof: bool ++
+    default: false ++
+    Defines visibility of the tray icons with *Passive* status.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
 *spacing*: ++
     typeof: integer ++
     Defines the spacing between the tray icons.
@@ -37,3 +46,6 @@ Addressed by *tray*
 # STYLE
 
 - *#tray*
+- *#tray > .passive*
+- *#tray > .active*
+- *#tray > .needs-attention*

man/waybar-wlr-taskbar.5.scd

@@ -0,0 +1,119 @@
+waybar-wlr-taskbar(5)
+
+# NAME
+
+wlroots - Taskbar module
+
+# DESCRIPTION
+
+The *taskbar* module displays the currently open applications. This module requires
+a compositor that implements the foreign-toplevel-manager interface.
+
+# CONFIGURATION
+
+Addressed by *wlr/taskbar*
+
+*all-outputs*: ++
+	typeof: bool ++
+	default: false ++
+	If set to false applications on the waybar's current output will be shown. Otherwise all applications are shown.
+
+*format*: ++
+	typeof: string ++
+	default: {icon} ++
+	The format, how information should be displayed.
+
+*icon-theme*: ++
+	typeof: array|string ++
+	The names of the icon-themes that should be used to find an icon. The list will be traversed from left to right. If omitted, the system default will be used.
+
+*icon-size*: ++
+	typeof: integer ++
+	default: 16 ++
+	The size of the icon.
+
+*markup*: ++
+	typeof: bool ++
+	default: false ++
+	If set to true, pango markup will be accepted in format and tooltip-format.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	If set to false no tooltip will be shown.
+
+*tooltip-format*: ++
+	typeof: string ++
+	default: {title} ++
+	The format, how information in the tooltip should be displayed.
+
+*active-first*: ++
+	typeof: bool ++
+	default: false ++
+	If set to true, always reorder the tasks in the taskbar so that the currently active one is first. Otherwise don't reorder.
+
+*on-click*: ++
+	typeof: string ++
+	The action which should be triggered when clicking on the application button with the left mouse button.
+
+*on-click-middle*: ++
+	typeof: string ++
+	The action which should be triggered when clicking on the application button with the middle mouse button.
+
+*on-click-right*: ++
+	typeof: string ++
+	The action which should be triggered when clicking on the application button with the right mouse button.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*ignore-list*: ++
+	typeof: array ++
+	List of app_id/titles to be invisible.
+
+# 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*: Toggle application's minimized state.
+*minimize-raise*: Bring the application into foreground or toggle its minimized state.
+*maximize*: Toggle application's maximized state.
+*fullscreen*: Toggle application's fullscreen state.
+*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",
+	"ignore-list": [
+	    "Alacritty"
+	]
+}
+```
+
+# Style
+
+- *#taskbar*
+- *#taskbar button*
+- *#taskbar button.maximized*
+- *#taskbar button.minimized*
+- *#taskbar button.active*
+- *#taskbar button.fullscreen*

man/waybar-wlr-workspaces.5.scd

@@ -0,0 +1,87 @@
+waybar-wlr-workspaces(5)
+
+# NAME
+
+waybar - wlr workspaces module
+
+# DESCRIPTION
+
+The *workspaces* module displays the currently used workspaces in wayland compositor.
+
+# CONFIGURATION
+
+Addressed by *wlr/workspaces*
+
+*format*: ++
+	typeof: string ++
+	default: {name} ++
+	The format, how information should be displayed.
+
+*format-icons*: ++
+	typeof: array ++
+	Based on the workspace name and state, the corresponding icon gets selected. See *icons*.
+
+*sort-by-name*: ++
+	typeof: bool ++
+	default: true ++
+	Should workspaces be sorted by name.
+
+*sort-by-coordinates*: ++
+	typeof: bool ++
+	default: true ++
+	Should workspaces be sorted by coordinates.
+	Note that if both  *sort-by-name* and *sort-by-coordinates* are true sort by name will be first.
+	If both are false - sort by id will be performed.
+
+*all-outputs*: ++
+	typeof: bool ++
+	default: false ++
+	If set to false workspaces group will be shown only in assigned output. Otherwise all workspace groups are shown.
+
+*active-only*: ++
+	typeof: bool ++
+	default: false ++
+	If set to true only active or urgent workspaces will be shown.
+
+# FORMAT REPLACEMENTS
+
+*{name}*: Name of workspace assigned by compositor
+
+*{icon}*: Icon, as defined in *format-icons*.
+
+# CLICK ACTIONS
+
+*activate*: Switch to workspace.
+*close*: Close the workspace.
+
+# ICONS
+
+Additional to workspace name matching, the following *format-icons* can be set.
+
+- *default*: Will be shown, when no string match is found.
+- *focused*: Will be shown, when workspace is focused
+
+# EXAMPLES
+
+```
+"wlr/workspaces": {
+	"format": "{name}: {icon}",
+	"format-icons": {
+		"1": "",
+		"2": "",
+		"3": "",
+		"4": "",
+		"5": "",
+		"focused": "",
+		"default": ""
+	}
+}
+```
+
+# Style
+
+- *#workspaces*
+- *#workspaces button*
+- *#workspaces button.active*
+- *#workspaces button.urgent*
+- *#workspaces button.hidden*

man/waybar.5.scd.in

@@ -14,6 +14,7 @@ Valid locations for this file are:
 - *~/.config/waybar/config*
 - *~/waybar/config*
 - */etc/xdg/waybar/config*
+- *@sysconfdir@/xdg/waybar/config*
 
 A good starting point is the default configuration found at https://github.com/Alexays/Waybar/blob/master/resources/config
 Also a minimal example configuration can be found on the at the bottom of this man page.
@@ -63,16 +64,37 @@ Also a minimal example configuration can be found on the at the bottom of this m
 	typeof: integer ++
 	Margins value without units.
 
+*spacing* ++
+	typeof: integer ++
+	Size of gaps in between of the different modules.
+
 *name* ++
 	typeof: string ++
 	Optional name added as a CSS class, for styling multiple waybars.
 
+*exclusive* ++
+	typeof: bool ++
+	default: *true* unless the layer is set to *overlay* ++
+	Option to request an exclusive zone from the compositor. Disable this to allow drawing application windows underneath or on top of the bar.
+
+*passthrough* ++
+	typeof: bool ++
+	default: *false* unless the layer is set to *overlay* ++
+	Option to pass any pointer events to the window under the bar.
+	Intended to be used with either *top* or *overlay* layers and without exclusive zone.
+
 *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.
 
+*include* ++
+	typeof: string|array ++
+	Paths to additional configuration files.
+	Each file can contain a single object with any of the bar configuration options. In case of duplicate options, the first defined value takes precedence, i.e. including file -> first included file -> etc. Nested includes are permitted, but make sure to avoid circular imports.
+	For a multi-bar config, the include directive affects only current bar configuration object.
+
 # MODULE FORMAT
 
 You can use PangoMarkupFormat (See https://developer.gnome.org/pango/stable/PangoMarkupFormat.html#PangoMarkupFormat).
@@ -185,16 +207,23 @@ 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-keyboard-state(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-wlr-workspaces(5)*
 - *waybar-temperature(5)*
 - *waybar-tray(5)*

meson.build

@@ -1,7 +1,8 @@
 project(
     'waybar', 'cpp', 'c',
-    version: '0.9.2',
+    version: '0.9.8',
     license: 'MIT',
+    meson_version: '>= 0.49.0',
     default_options : [
         'cpp_std=c++17',
         'buildtype=release',
@@ -36,7 +37,7 @@ else
     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@ (" __DATE__ ", branch \'@1@\')"'.format(git_commit_hash, git_branch)
+        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')
@@ -79,7 +80,7 @@ is_openbsd = host_machine.system() == 'openbsd'
 
 thread_dep = dependency('threads')
 fmt = dependency('fmt', version : ['>=5.3.0'], fallback : ['fmt', 'fmt_dep'])
-spdlog = dependency('spdlog', version : ['>=1.3.1'], fallback : ['spdlog', 'spdlog_dep'])
+spdlog = dependency('spdlog', version : ['>=1.8.5'], fallback : ['spdlog', 'spdlog_dep'], default_options : ['external_fmt=true'])
 wayland_client = dependency('wayland-client')
 wayland_cursor = dependency('wayland-cursor')
 wayland_protos = dependency('wayland-protocols')
@@ -93,12 +94,31 @@ libnl = dependency('libnl-3.0', required: get_option('libnl'))
 libnlgen = dependency('libnl-genl-3.0', required: get_option('libnl'))
 libpulse = dependency('libpulse', required: get_option('pulseaudio'))
 libudev = dependency('libudev', required: get_option('libudev'))
+libevdev = dependency('libevdev', required: get_option('libevdev'))
 libmpdclient = dependency('libmpdclient', required: get_option('mpd'))
+xkbregistry = dependency('xkbregistry')
+
+libsndio = compiler.find_library('sndio', required: get_option('sndio'))
+if libsndio.found()
+    if not compiler.has_function('sioctl_open', prefix: '#include <sndio.h>', dependencies: libsndio)
+        if get_option('sndio').enabled()
+            error('libsndio is too old, required >=1.7.0')
+        else
+            warning('libsndio is too old, required >=1.7.0')
+            libsndio = dependency('', required: false)
+        endif
+    endif
+endif
+
 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' ], fallback: [ 'date', 'tz_dep' ])
+tz_dep = dependency('date',
+    required: false,
+    default_options : [ 'use_system_tzdb=true' ],
+    modules : [ 'date::date', 'date::date-tz' ],
+    fallback: [ 'date', 'tz_dep' ])
 
 prefix = get_option('prefix')
 sysconfdir = get_option('sysconfdir')
@@ -122,7 +142,6 @@ src_files = files(
     'src/factory.cpp',
     'src/AModule.cpp',
     'src/ALabel.cpp',
-    'src/modules/clock.cpp',
     'src/modules/custom.cpp',
     'src/modules/disk.cpp',
     'src/modules/idle_inhibitor.cpp',
@@ -130,6 +149,8 @@ src_files = files(
     'src/main.cpp',
     'src/bar.cpp',
     'src/client.cpp',
+    'src/config.cpp',
+    'src/util/ustring_clen.cpp'
 )
 
 if is_linux
@@ -137,12 +158,10 @@ if is_linux
     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')
@@ -155,14 +174,25 @@ elif is_dragonfly or is_freebsd or is_netbsd or is_openbsd
     )
 endif
 
-if true # find_program('sway', required : false).found()
+add_project_arguments('-DHAVE_SWAY', language: 'cpp')
-    add_project_arguments('-DHAVE_SWAY', language: 'cpp')
+src_files += [
-    src_files += [
     'src/modules/sway/ipc/client.cpp',
     'src/modules/sway/mode.cpp',
+    'src/modules/sway/language.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'
+    src_files += 'src/modules/wlr/workspace_manager.cpp'
+    src_files += 'src/modules/wlr/workspace_manager_binding.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()
@@ -190,15 +220,43 @@ if libudev.found() and (is_linux or libepoll.found())
     src_files += 'src/modules/backlight.cpp'
 endif
 
+if libevdev.found() and (is_linux or libepoll.found())
+    add_project_arguments('-DHAVE_LIBEVDEV', language: 'cpp')
+    src_files += 'src/modules/keyboard_state.cpp'
+endif
+
 if libmpdclient.found()
     add_project_arguments('-DHAVE_LIBMPDCLIENT', language: 'cpp')
-    src_files += 'src/modules/mpd.cpp'
+    src_files += 'src/modules/mpd/mpd.cpp'
+    src_files += 'src/modules/mpd/state.cpp'
 endif
 
 if gtk_layer_shell.found()
     add_project_arguments('-DHAVE_GTK_LAYER_SHELL', language: 'cpp')
 endif
 
+if libsndio.found()
+    add_project_arguments('-DHAVE_LIBSNDIO', language: 'cpp')
+    src_files += 'src/modules/sndio.cpp'
+endif
+
+if get_option('rfkill').enabled()
+    if is_linux
+        add_project_arguments('-DWANT_RFKILL', language: 'cpp')
+        src_files += files(
+            'src/modules/bluetooth.cpp',
+            'src/util/rfkill.cpp'
+        )
+    endif
+endif
+
+if tz_dep.found()
+    add_project_arguments('-DHAVE_LIBDATE', language: 'cpp')
+    src_files += 'src/modules/clock.cpp'
+else
+    src_files += 'src/modules/simpleclock.cpp'
+endif
+
 subdir('protocol')
 
 executable(
@@ -222,8 +280,11 @@ executable(
         libudev,
         libepoll,
         libmpdclient,
+        libevdev,
         gtk_layer_shell,
-        tz_dep
+        libsndio,
+        tz_dep,
+				xkbregistry 
     ],
     include_directories: [include_directories('include')],
     install: true,
@@ -240,9 +301,20 @@ scdoc = dependency('scdoc', version: '>=1.9.2', native: true, required: get_opti
 if scdoc.found()
     scdoc_prog = find_program(scdoc.get_pkgconfig_variable('scdoc'), native: true)
     sh = find_program('sh', native: true)
+
+    main_manpage = configure_file(
+        input: 'man/waybar.5.scd.in',
+        output: 'waybar.5.scd',
+        configuration: {
+            'sysconfdir': join_paths(prefix, sysconfdir)
+        }
+    )
+
+    main_manpage_path = join_paths(meson.build_root(), '@0@'.format(main_manpage))
+
     mandir = get_option('mandir')
     man_files = [
-        'waybar.5.scd',
+        main_manpage_path,
         'waybar-backlight.5.scd',
         'waybar-battery.5.scd',
         'waybar-clock.5.scd',
@@ -250,27 +322,37 @@ if scdoc.found()
         'waybar-custom.5.scd',
         'waybar-disk.5.scd',
         'waybar-idle-inhibitor.5.scd',
+        'waybar-keyboard-state.5.scd',
         'waybar-memory.5.scd',
         'waybar-mpd.5.scd',
         'waybar-network.5.scd',
         'waybar-pulseaudio.5.scd',
+        'waybar-river-tags.5.scd',
+        'waybar-sway-language.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-wlr-workspaces.5.scd',
         'waybar-bluetooth.5.scd',
+        'waybar-sndio.5.scd',
     ]
 
-    foreach filename : man_files
+    foreach file : man_files
-        topic = filename.split('.')[-3].split('/')[-1]
+        path = '@0@'.format(file)
-        section = filename.split('.')[-2]
+        basename = path.split('/')[-1]
+
+        topic = basename.split('.')[-3]
+        section = basename.split('.')[-2]
         output = '@0@.@1@'.format(topic, section)
 
         custom_target(
             output,
-            input: 'man/@0@'.format(filename),
+            # drops the 'man' if `path` is an absolute path
+            input: join_paths('man', path),
             output: output,
             command: [
                 sh, '-c', '@0@ < @INPUT@ > @1@'.format(scdoc_prog.path(), output)
@@ -281,6 +363,15 @@ if scdoc.found()
     endforeach
 endif
 
+catch2 = dependency(
+    'catch2',
+    fallback: ['catch2', 'catch2_dep'],
+    required: get_option('tests'),
+)
+if catch2.found()
+    subdir('test')
+endif
+
 clangtidy = find_program('clang-tidy', required: false)
 
 if clangtidy.found()

meson_options.txt

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

protocol/ext-workspace-unstable-v1.xml

@@ -0,0 +1,306 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="ext_workspace_unstable_v1">
+  <copyright>
+    Copyright © 2019 Christopher Billington
+    Copyright © 2020 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="zext_workspace_manager_v1" version="1">
+    <description summary="list and control workspaces">
+      Workspaces, also called virtual desktops, are groups of surfaces. A
+      compositor with a concept of workspaces may only show some such groups of
+      surfaces (those of 'active' workspaces) at a time. 'Activating' a
+      workspace is a request for the compositor to display that workspace's
+      surfaces as normal, whereas the compositor may hide or otherwise
+      de-emphasise surfaces that are associated only with 'inactive' workspaces.
+      Workspaces are grouped by which sets of outputs they correspond to, and
+      may contain surfaces only from those outputs. In this way, it is possible
+      for each output to have its own set of workspaces, or for all outputs (or
+      any other arbitrary grouping) to share workspaces. Compositors may
+      optionally conceptually arrange each group of workspaces in an
+      N-dimensional grid.
+
+      The purpose of this protocol is to enable the creation of taskbars and
+      docks by providing them with a list of workspaces and their properties,
+      and allowing them to activate and deactivate workspaces.
+
+      After a client binds the zext_workspace_manager_v1, each workspace will be
+      sent via the workspace event.
+    </description>
+
+    <event name="workspace_group">
+      <description summary="a workspace group has been created">
+        This event is emitted whenever a new workspace group has been created.
+
+        All initial details of the workspace group (workspaces, outputs) will be
+        sent immediately after this event via the corresponding events in
+        zext_workspace_group_handle_v1.
+      </description>
+      <arg name="workspace_group" type="new_id" interface="zext_workspace_group_handle_v1"/>
+    </event>
+
+    <request name="commit">
+      <description summary="all requests about the workspaces have been sent">
+        The client must send this request after it has finished sending other
+        requests. The compositor must process a series of requests preceding a
+        commit request atomically.
+
+        This allows changes to the workspace properties to be seen as atomic,
+        even if they happen via multiple events, and even if they involve
+        multiple zext_workspace_handle_v1 objects, for example, deactivating one
+        workspace and activating another.
+      </description>
+    </request>
+
+    <event name="done">
+      <description summary="all information about the workspace groups has been sent">
+        This event is sent after all changes in all workspace groups have been
+        sent.
+
+        This allows changes to one or more zext_workspace_group_handle_v1
+        properties to be seen as atomic, even if they happen via multiple
+        events. In particular, an output moving from one workspace group to
+        another sends an output_enter event and an output_leave event to the two
+        zext_workspace_group_handle_v1 objects in question. The compositor sends
+        the done event only after updating the output information in both
+        workspace groups.
+      </description>
+    </event>
+
+    <event name="finished">
+      <description summary="the compositor has finished with the workspace_manager">
+        This event indicates that the compositor is done sending events to the
+        zext_workspace_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>
+
+    <request name="stop">
+      <description summary="stop sending events">
+        Indicates the client no longer wishes to receive events for new
+        workspace groups. However the compositor may emit further workspace
+        events, until the finished event is emitted.
+
+        The client must not send any more requests after this one.
+      </description>
+    </request>
+  </interface>
+
+  <interface name="zext_workspace_group_handle_v1" version="1">
+    <description summary="a workspace group assigned to a set of outputs">
+      A zext_workspace_group_handle_v1 object represents a a workspace group
+      that is assigned a set of outputs and contains a number of workspaces.
+
+      The set of outputs assigned to the workspace group is conveyed to the client via
+      output_enter and output_leave events, and its workspaces are conveyed with
+      workspace events.
+
+      For example, a compositor which has a set of workspaces for each output may
+      advertise a workspace group (and its workspaces) per output, whereas a compositor
+      where a workspace spans all outputs may advertise a single workspace group for all
+      outputs.
+    </description>
+
+    <event name="output_enter">
+      <description summary="output assigned to workspace group">
+        This event is emitted whenever an output is assigned to the workspace
+        group.
+      </description>
+      <arg name="output" type="object" interface="wl_output"/>
+    </event>
+
+    <event name="output_leave">
+      <description summary="output removed from workspace group">
+        This event is emitted whenever an output is removed from the workspace
+        group.
+      </description>
+      <arg name="output" type="object" interface="wl_output"/>
+    </event>
+
+    <event name="workspace">
+      <description summary="workspace added to workspace group">
+        This event is emitted whenever a new workspace has been created.
+
+        All initial details of the workspace (name, coordinates, state) will
+        be sent immediately after this event via the corresponding events in
+        zext_workspace_handle_v1.
+      </description>
+      <arg name="workspace" type="new_id" interface="zext_workspace_handle_v1"/>
+    </event>
+
+    <event name="remove">
+      <description summary="this workspace group has been destroyed">
+        This event means the zext_workspace_group_handle_v1 has been destroyed.
+        It is guaranteed there won't be any more events for this
+        zext_workspace_group_handle_v1. The zext_workspace_group_handle_v1 becomes
+        inert so any requests will be ignored except the destroy request.
+
+        The compositor must remove all workspaces belonging to a workspace group
+        before removing the workspace group.
+      </description>
+    </event>
+
+    <request name="create_workspace">
+      <description summary="create a new workspace">
+        Request that the compositor create a new workspace with the given name.
+
+        There is no guarantee that the compositor will create a new workspace,
+        or that the created workspace will have the provided name.
+      </description>
+      <arg name="workspace" type="string"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the zext_workspace_handle_v1 object">
+        Destroys the zext_workspace_handle_v1 object.
+
+        This request should be called either when the client does not want to
+        use the workspace object any more or after the remove event to finalize
+        the destruction of the object.
+      </description>
+    </request>
+  </interface>
+
+  <interface name="zext_workspace_handle_v1" version="1">
+    <description summary="a workspace handing a group of surfaces">
+      A zext_workspace_handle_v1 object represents a a workspace that handles a
+      group of surfaces.
+
+      Each workspace has a name, conveyed to the client with the name event; a
+      list of states, conveyed to the client with the state event; and
+      optionally a set of coordinates, conveyed to the client with the
+      coordinates event. The client may request that the compositor activate or
+      deactivate the workspace.
+
+      Each workspace can belong to only a single workspace group.
+      Depepending on the compositor policy, there might be workspaces with
+      the same name in different workspace groups, but these workspaces are still
+      separate (e.g. one of them might be active while the other is not).
+    </description>
+
+    <event name="name">
+      <description summary="workspace name changed">
+        This event is emitted immediately after the zext_workspace_handle_v1 is
+        created and whenever the name of the workspace changes.
+      </description>
+      <arg name="name" type="string"/>
+    </event>
+
+    <event name="coordinates">
+      <description summary="workspace coordinates changed">
+        This event is used to organize workspaces into an N-dimensional grid
+        within a workspace group, and if supported, is emitted immediately after
+        the zext_workspace_handle_v1 is created and whenever the coordinates of
+        the workspace change. Compositors may not send this event if they do not
+        conceptually arrange workspaces in this way. If compositors simply
+        number workspaces, without any geometric interpretation, they may send
+        1D coordinates, which clients should not interpret as implying any
+        geometry. Sending an empty array means that the compositor no longer
+        orders the workspace geometrically.
+
+        Coordinates have an arbitrary number of dimensions N with an uint32
+        position along each dimension. By convention if N > 1, the first
+        dimension is X, the second Y, the third Z, and so on. The compositor may
+        chose to utilize these events for a more novel workspace layout
+        convention, however. No guarantee is made about the grid being filled or
+        bounded; there may be a workspace at coordinate 1 and another at
+        coordinate 1000 and none in between. Within a workspace group, however,
+        workspaces must have unique coordinates of equal dimensionality.
+      </description>
+      <arg name="coordinates" type="array"/>
+    </event>
+
+    <event name="state">
+      <description summary="the state of the workspace changed">
+        This event is emitted immediately after the zext_workspace_handle_v1 is
+        created and each time the workspace state changes, either because of a
+        compositor action or because of a request in this protocol.
+      </description>
+      <arg name="state" type="array"/>
+    </event>
+
+    <enum name="state">
+      <description summary="types of states on the workspace">
+        The different states that a workspace can have.
+      </description>
+
+      <entry name="active" value="0" summary="the workspace is active"/>
+      <entry name="urgent" value="1" summary="the workspace requests attention"/>
+      <entry name="hidden" value="2">
+        <description summary="the workspace is not visible">
+          The workspace is not visible in its workspace group, and clients
+          attempting to visualize the compositor workspace state should not
+          display such workspaces.
+        </description>
+      </entry>
+    </enum>
+
+    <event name="remove">
+      <description summary="this workspace has been destroyed">
+        This event means the zext_workspace_handle_v1 has been destroyed. It is
+        guaranteed there won't be any more events for this
+        zext_workspace_handle_v1. The zext_workspace_handle_v1 becomes inert so
+        any requests will be ignored except the destroy request.
+      </description>
+    </event>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the zext_workspace_handle_v1 object">
+        Destroys the zext_workspace_handle_v1 object.
+
+        This request should be called either when the client does not want to
+        use the workspace object any more or after the remove event to finalize
+        the destruction of the object.
+      </description>
+    </request>
+
+    <request name="activate">
+      <description summary="activate the workspace">
+        Request that this workspace be activated.
+
+        There is no guarantee the workspace will be actually activated, and
+        behaviour may be compositor-dependent. For example, activating a
+        workspace may or may not deactivate all other workspaces in the same
+        group.
+      </description>
+    </request>
+
+    <request name="deactivate">
+      <description summary="activate the workspace">
+        Request that this workspace be deactivated.
+
+        There is no guarantee the workspace will be actually deactivated.
+      </description>
+    </request>
+
+    <request name="remove">
+      <description summary="remove the workspace">
+        Request that this workspace be removed.
+
+        There is no guarantee the workspace will be actually removed.
+      </description>
+    </request>
+  </interface>
+</protocol>

protocol/meson.build

@@ -26,6 +26,10 @@ 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'],
+	['ext-workspace-unstable-v1.xml'],
+	['river-status-unstable-v1.xml'],
+	['river-control-unstable-v1.xml'],
 ]
 
 client_protos_src = []

protocol/river-control-unstable-v1.xml

@@ -0,0 +1,85 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="river_control_unstable_v1">
+  <copyright>
+    Copyright 2020 The River Developers
+
+    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_control_v1" version="1">
+    <description summary="run compositor commands">
+      This interface allows clients to run compositor commands and receive a
+      success/failure response with output or a failure message respectively.
+
+      Each command is built up in a series of add_argument requests and
+      executed with a run_command request. The first argument is the command
+      to be run.
+
+      A complete list of commands should be made available in the man page of
+      the compositor.
+    </description>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the river_control object">
+        This request indicates that the client will not use the
+        river_control object any more. Objects that have been created
+        through this instance are not affected.
+      </description>
+    </request>
+
+    <request name="add_argument">
+      <description summary="add an argument to the current command">
+        Arguments are stored by the server in the order they were sent until
+        the run_command request is made.
+      </description>
+      <arg name="argument" type="string" summary="the argument to add"/>
+    </request>
+
+    <request name="run_command">
+      <description summary="run the current command">
+        Execute the command built up using the add_argument request for the
+        given seat.
+      </description>
+      <arg name="seat" type="object" interface="wl_seat"/>
+      <arg name="callback" type="new_id" interface="zriver_command_callback_v1"
+        summary="callback object"/>
+    </request>
+  </interface>
+
+  <interface name="zriver_command_callback_v1" version="1">
+    <description summary="callback object">
+      This object is created by the run_command request. Exactly one of the
+      success or failure events will be sent. This object will be destroyed
+      by the compositor after one of the events is sent.
+    </description>
+
+    <event name="success">
+      <description summary="command successful">
+        Sent when the command has been successfully received and executed by
+        the compositor. Some commands may produce output, in which case the
+        output argument will be a non-empty string.
+      </description>
+      <arg name="output" type="string" summary="the output of the command"/>
+    </event>
+
+    <event name="failure">
+      <description summary="command failed">
+        Sent when the command could not be carried out. This could be due to
+        sending a non-existent command, no command, not enough arguments, too
+        many arguments, invalid arguments, etc.
+      </description>
+      <arg name="failure_message" type="string"
+        summary="a message explaining why failure occurred"/>
+    </event>
+  </interface>
+</protocol>

protocol/river-status-unstable-v1.xml

@@ -0,0 +1,125 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="river_status_unstable_v1">
+  <copyright>
+    Copyright 2020 The River Developers
+
+    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="2">
+    <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="2">
+    <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>
+
+    <event name="urgent_tags" since="2">
+      <description summary="tags of the output with an urgent view">
+        Sent once on binding the interface and again whenever the set of
+        tags with at least one urgent view changes.
+      </description>
+      <arg name="tags" type="uint" summary="32-bit bitfield"/>
+    </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. Note that (un)focused_output events will only be sent
+      if the client has bound the relevant wl_output globals.
+    </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,270 @@
+<?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="3">
+    <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="3">
+    <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>
+
+    <!-- Version 3 additions -->
+
+    <event name="parent" since="3">
+      <description summary="parent change">
+        This event is emitted whenever the parent of the toplevel changes.
+
+        No event is emitted when the parent handle is destroyed by the client.
+      </description>
+      <arg name="parent" type="object" interface="zwlr_foreign_toplevel_handle_v1" allow-null="true"/>
+    </event>
+  </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)
+      Layer surface state (layer, size, anchor, exclusive zone,
-      is double-buffered, and will be applied at the time wl_surface.commit of
+      margin, interactivity) is double-buffered, and will be applied at the
-      the corresponding wl_surface is called.
+      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
+        Requests that the compositor avoids occluding an area with other
-        with other surfaces. The compositor's use of this information is
+        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
+        A positive value is only meaningful if the surface is anchored to one
-        edge, rather than a corner. The zone is the number of surface-local
+        edge or an edge and both perpendicular edges. If the surface is not
-        coordinates from the edge that are considered exclusive.
+        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
+        surfaces with a positive exclusive zone. If set to -1, the surface
-        indicates that it would not like to be moved to accomodate for other
+        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

@@ -3,10 +3,11 @@
     // "position": "bottom", // Waybar position (top|bottom|left|right)
     "height": 30, // Waybar height (to be removed for auto height)
     // "width": 1280, // Waybar width
+    "spacing": 4, // Gaps between modules (4px)
     // Choose the order of the modules
     "modules-left": ["sway/workspaces", "sway/mode", "custom/media"],
     "modules-center": ["sway/window"],
-    "modules-right": ["mpd", "idle_inhibitor", "pulseaudio", "network", "cpu", "memory", "temperature", "backlight", "battery", "battery#bat2", "clock", "tray"],
+    "modules-right": ["mpd", "idle_inhibitor", "pulseaudio", "network", "cpu", "memory", "temperature", "backlight", "keyboard-state", "sway/language", "battery", "battery#bat2", "clock", "tray"],
     // Modules configuration
     // "sway/workspaces": {
     //     "disable-scroll": true,
@@ -23,11 +24,20 @@
     //         "default": ""
     //     }
     // },
+    "keyboard-state": {
+        "numlock": true,
+        "capslock": true,
+        "format": "{name} {icon}",
+        "format-icons": {
+            "locked": "",
+            "unlocked": ""
+        }
+    },
     "sway/mode": {
         "format": "<span style=\"italic\">{}</span>"
     },
     "mpd": {
-        "format": "{stateIcon} {consumeIcon}{randomIcon}{repeatIcon}{singleIcon}{artist} - {album} - {title} ({elapsedTime:%M:%S}/{totalTime:%M:%S}) ",
+        "format": "{stateIcon} {consumeIcon}{randomIcon}{repeatIcon}{singleIcon}{artist} - {album} - {title} ({elapsedTime:%M:%S}/{totalTime:%M:%S}) ⸨{songPosition}|{queueLength}⸩ {volume}% ",
         "format-disconnected": "Disconnected ",
         "format-stopped": "{consumeIcon}{randomIcon}{repeatIcon}{singleIcon}Stopped ",
         "unknown-tag": "N/A",
@@ -108,7 +118,8 @@
     "network": {
         // "interface": "wlp2*", // (Optional) To force the use of this interface
         "format-wifi": "{essid} ({signalStrength}%) ",
-        "format-ethernet": "{ifname}: {ipaddr}/{cidr} ",
+        "format-ethernet": "{ipaddr}/{cidr} ",
+        "tooltip-format": "{ifname} via {gwaddr} ",
         "format-linked": "{ifname} (No IP) ",
         "format-disconnected": "Disconnected ⚠",
         "format-alt": "{ifname}: {ipaddr}/{cidr}"
@@ -145,3 +156,4 @@
         // "exec": "$HOME/.config/waybar/mediaplayer.py --player spotify 2> /dev/null" // Filter player based on name
     }
 }
+

resources/custom_modules/mediaplayer.py

@@ -79,7 +79,7 @@ def signal_handler(sig, frame):
 def parse_arguments():
     parser = argparse.ArgumentParser()
 
-    # Increase verbosity with every occurence of -v
+    # Increase verbosity with every occurrence of -v
     parser.add_argument('-v', '--verbose', action='count', default=0)
 
     # Define for which player we're listening

resources/style.css

@@ -41,19 +41,19 @@ window#waybar.chromium {
     padding: 0 5px;
     background-color: transparent;
     color: #ffffff;
-    border-bottom: 3px solid transparent;
+    /* Use box-shadow instead of border so the text isn't offset */
+    box-shadow: inset 0 -3px transparent;
 }
 
 /* https://github.com/Alexays/Waybar/wiki/FAQ#the-workspace-buttons-have-a-strange-hover-effect */
 #workspaces button:hover {
     background: rgba(0, 0, 0, 0.2);
-    box-shadow: inherit;
+    box-shadow: inset 0 -3px #ffffff;
-    border-bottom: 3px solid #ffffff;
 }
 
 #workspaces button.focused {
     background-color: #64727D;
-    border-bottom: 3px solid #ffffff;
+    box-shadow: inset 0 -3px #ffffff;
 }
 
 #workspaces button.urgent {
@@ -69,6 +69,7 @@ window#waybar.chromium {
 #battery,
 #cpu,
 #memory,
+#disk,
 #temperature,
 #backlight,
 #network,
@@ -79,10 +80,24 @@ window#waybar.chromium {
 #idle_inhibitor,
 #mpd {
     padding: 0 10px;
-    margin: 0 4px;
     color: #ffffff;
 }
 
+#window,
+#workspaces {
+    margin: 0 4px;
+}
+
+/* If workspaces is the leftmost module, omit left margin */
+.modules-left > widget:first-child > #workspaces {
+    margin-left: 0;
+}
+
+/* If workspaces is the rightmost module, omit right margin */
+.modules-right > widget:last-child > #workspaces {
+    margin-right: 0;
+}
+
 #clock {
     background-color: #64727D;
 }
@@ -92,7 +107,7 @@ window#waybar.chromium {
     color: #000000;
 }
 
-#battery.charging {
+#battery.charging, #battery.plugged {
     color: #ffffff;
     background-color: #26A65B;
 }
@@ -127,6 +142,10 @@ label:focus {
     background-color: #9b59b6;
 }
 
+#disk {
+    background-color: #964B00;
+}
+
 #backlight {
     background-color: #90b1b1;
 }
@@ -175,6 +194,15 @@ label:focus {
     background-color: #2980b9;
 }
 
+#tray > .passive {
+    -gtk-icon-effect: dim;
+}
+
+#tray > .needs-attention {
+    -gtk-icon-effect: highlight;
+    background-color: #eb4d4b;
+}
+
 #idle_inhibitor {
     background-color: #2d3436;
 }
@@ -200,3 +228,27 @@ label:focus {
 #mpd.paused {
     background-color: #51a37a;
 }
+
+#language {
+    background: #00b093;
+    color: #740864;
+    padding: 0 5px;
+    margin: 0 5px;
+    min-width: 16px;
+}
+
+#keyboard-state {
+    background: #97e1ad;
+    color: #000000;
+    padding: 0 0px;
+    margin: 0 5px;
+    min-width: 16px;
+}
+
+#keyboard-state > label {
+    padding: 0 5px;
+}
+
+#keyboard-state > label.locked {
+    background: rgba(0, 0, 0, 0.2);
+}

resources/waybar.service.in

@@ -1,13 +1,14 @@
 [Unit]
 Description=Highly customizable Wayland bar for Sway and Wlroots based compositors.
 Documentation=https://github.com/Alexays/Waybar/wiki/
-PartOf=wayland-session.target
+PartOf=graphical-session.target
-After=wayland-session.target
+After=graphical-session.target
+Requisite=graphical-session.target
 
 [Service]
-Type=dbus
-BusName=fr.arouillard.waybar
 ExecStart=@prefix@/bin/waybar
+ExecReload=kill -SIGUSR2 $MAINPID
+Restart=on-failure
 
 [Install]
-WantedBy=wayland-session.target
+WantedBy=graphical-session.target

src/ALabel.cpp

@@ -5,8 +5,9 @@
 namespace waybar {
 
 ALabel::ALabel(const Json::Value& config, const std::string& name, const std::string& id,
-               const std::string& format, uint16_t interval, bool ellipsize)
+               const std::string& format, uint16_t interval, bool ellipsize, bool enable_click,
-    : AModule(config, name, id, config["format-alt"].isString()),
+               bool enable_scroll)
+    : AModule(config, name, id, config["format-alt"].isString() || enable_click, enable_scroll),
       format_(config_["format"].isString() ? config_["format"].asString() : format),
       interval_(config_["interval"] == "once"
                     ? std::chrono::seconds(100000000)
@@ -19,15 +20,36 @@ ALabel::ALabel(const Json::Value& config, const std::string& name, const std::st
   }
   event_box_.add(label_);
   if (config_["max-length"].isUInt()) {
-    label_.set_max_width_chars(config_["max-length"].asUInt());
+    label_.set_max_width_chars(config_["max-length"].asInt());
     label_.set_ellipsize(Pango::EllipsizeMode::ELLIPSIZE_END);
+    label_.set_single_line_mode(true);
   } else if (ellipsize && label_.get_max_width_chars() == -1) {
     label_.set_ellipsize(Pango::EllipsizeMode::ELLIPSIZE_END);
+    label_.set_single_line_mode(true);
   }
 
-  if (config_["rotate"].isUInt()) {
+  if (config_["min-length"].isUInt()) {
-    label_.set_angle(config["rotate"].asUInt());
+    label_.set_width_chars(config_["min-length"].asUInt());
   }
+
+  uint rotate = 0;
+
+  if (config_["rotate"].isUInt()) {
+    rotate = config["rotate"].asUInt();
+    label_.set_angle(rotate);
+  }
+
+  if (config_["align"].isDouble()) {
+    auto align = config_["align"].asFloat();
+    if (rotate == 90 || rotate == 270) {
+      label_.set_yalign(align);
+    } else {
+      label_.set_xalign(align);
+    }
+
+  }
+
+
 }
 
 auto ALabel::update() -> void {
@@ -45,32 +67,36 @@ std::string ALabel::getIcon(uint16_t percentage, const std::string& alt, uint16_
   }
   if (format_icons.isArray()) {
     auto size = format_icons.size();
+    if (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 "";
 }
 
-std::string ALabel::getIcon(uint16_t percentage, std::vector<std::string>& alts, uint16_t max) {
+std::string ALabel::getIcon(uint16_t percentage, const std::vector<std::string>& alts, uint16_t max) {
   auto format_icons = config_["format-icons"];
   if (format_icons.isObject()) {
+    std::string _alt = "default";
     for (const auto& alt : alts) {
       if (!alt.empty() && (format_icons[alt].isString() || format_icons[alt].isArray())) {
-        format_icons = format_icons[alt];
+        _alt = alt;
         break;
-      } else {
-        format_icons = format_icons["default"];
       }
     }
+    format_icons = format_icons[_alt];
   }
   if (format_icons.isArray()) {
     auto size = format_icons.size();
+    if (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();
   }

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,11 +23,12 @@ 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 {
   // Run user-provided update handler if configured
   if (config_["on-update"].isString()) {
@@ -43,9 +44,9 @@ bool AModule::handleToggle(GdkEventButton* const& e) {
     format = config_["on-click-middle"].asString();
   } else if (config_["on-click-right"].isString() && e->button == 3) {
     format = config_["on-click-right"].asString();
-  } else if (config_["on-click-forward"].isString() && e->button == 8) {
+  } else if (config_["on-click-backward"].isString() && e->button == 8) {
     format = config_["on-click-backward"].asString();
-  } else if (config_["on-click-backward"].isString() && e->button == 9) {
+  } else if (config_["on-click-forward"].isString() && e->button == 9) {
     format = config_["on-click-forward"].asString();
   }
   if (!format.empty()) {

src/bar.cpp

@@ -2,18 +2,396 @@
 #include <gtk-layer-shell.h>
 #endif
 
+#include <spdlog/spdlog.h>
+
+#include <type_traits>
+
 #include "bar.hpp"
 #include "client.hpp"
 #include "factory.hpp"
-#include <spdlog/spdlog.h>
+#include "wlr-layer-shell-unstable-v1-client-protocol.h"
+
+namespace waybar {
+static constexpr const char* MIN_HEIGHT_MSG =
+    "Requested height: {} is less than the minimum height: {} required by the modules";
+
+static constexpr const char* MIN_WIDTH_MSG =
+    "Requested width: {} is less than the minimum width: {} required by the modules";
+
+static constexpr const char* BAR_SIZE_MSG = "Bar configured (width: {}, height: {}) for output: {}";
+
+static constexpr const char* SIZE_DEFINED =
+    "{} size is defined in the config file so it will stay like that";
+
+#ifdef HAVE_GTK_LAYER_SHELL
+struct GLSSurfaceImpl : public BarSurface, public sigc::trackable {
+  GLSSurfaceImpl(Gtk::Window& window, struct waybar_output& output) : window_{window} {
+    output_name_ = output.name;
+    // this has to be executed before GtkWindow.realize
+    gtk_layer_init_for_window(window_.gobj());
+    gtk_layer_set_keyboard_interactivity(window.gobj(), FALSE);
+    gtk_layer_set_monitor(window_.gobj(), output.monitor->gobj());
+    gtk_layer_set_namespace(window_.gobj(), "waybar");
+
+    window.signal_map_event().connect_notify(sigc::mem_fun(*this, &GLSSurfaceImpl::onMap));
+    window.signal_configure_event().connect_notify(
+        sigc::mem_fun(*this, &GLSSurfaceImpl::onConfigure));
+  }
+
+  void setExclusiveZone(bool enable) override {
+    if (enable) {
+      gtk_layer_auto_exclusive_zone_enable(window_.gobj());
+    } else {
+      gtk_layer_set_exclusive_zone(window_.gobj(), 0);
+    }
+  }
+
+  void setMargins(const struct bar_margins& margins) override {
+    gtk_layer_set_margin(window_.gobj(), GTK_LAYER_SHELL_EDGE_LEFT, margins.left);
+    gtk_layer_set_margin(window_.gobj(), GTK_LAYER_SHELL_EDGE_RIGHT, margins.right);
+    gtk_layer_set_margin(window_.gobj(), GTK_LAYER_SHELL_EDGE_TOP, margins.top);
+    gtk_layer_set_margin(window_.gobj(), GTK_LAYER_SHELL_EDGE_BOTTOM, margins.bottom);
+  }
+
+  void setLayer(bar_layer value) override {
+    auto layer = GTK_LAYER_SHELL_LAYER_BOTTOM;
+    if (value == bar_layer::TOP) {
+      layer = GTK_LAYER_SHELL_LAYER_TOP;
+    } else if (value == bar_layer::OVERLAY) {
+      layer = GTK_LAYER_SHELL_LAYER_OVERLAY;
+    }
+    gtk_layer_set_layer(window_.gobj(), layer);
+  }
+
+  void setPassThrough(bool enable) override {
+    passthrough_ = enable;
+    auto gdk_window = window_.get_window();
+    if (gdk_window) {
+      Cairo::RefPtr<Cairo::Region> region;
+      if (enable) {
+        region = Cairo::Region::create();
+      }
+      gdk_window->input_shape_combine_region(region, 0, 0);
+    }
+  }
+
+  void setPosition(const std::string_view& position) override {
+    auto unanchored = GTK_LAYER_SHELL_EDGE_BOTTOM;
+    vertical_ = false;
+    if (position == "bottom") {
+      unanchored = GTK_LAYER_SHELL_EDGE_TOP;
+    } else if (position == "left") {
+      unanchored = GTK_LAYER_SHELL_EDGE_RIGHT;
+      vertical_ = true;
+    } else if (position == "right") {
+      vertical_ = true;
+      unanchored = GTK_LAYER_SHELL_EDGE_LEFT;
+    }
+    for (auto edge : {GTK_LAYER_SHELL_EDGE_LEFT,
+                      GTK_LAYER_SHELL_EDGE_RIGHT,
+                      GTK_LAYER_SHELL_EDGE_TOP,
+                      GTK_LAYER_SHELL_EDGE_BOTTOM}) {
+      gtk_layer_set_anchor(window_.gobj(), edge, unanchored != edge);
+    }
+  }
+
+  void setSize(uint32_t width, uint32_t height) override {
+    width_ = width;
+    height_ = height;
+    window_.set_size_request(width_, height_);
+  };
+
+ private:
+  Gtk::Window& window_;
+  std::string  output_name_;
+  uint32_t     width_;
+  uint32_t     height_;
+  bool         passthrough_ = false;
+  bool         vertical_ = false;
+
+  void onMap(GdkEventAny* ev) { setPassThrough(passthrough_); }
+
+  void onConfigure(GdkEventConfigure* ev) {
+    /*
+     * GTK wants new size for the window.
+     * Actual resizing and management of the exclusve zone is handled within the gtk-layer-shell
+     * code. This event handler only updates stored size of the window and prints some warnings.
+     *
+     * Note: forced resizing to a window smaller than required by GTK would not work with
+     * gtk-layer-shell.
+     */
+    if (vertical_) {
+      if (width_ > 1 && ev->width > static_cast<int>(width_)) {
+        spdlog::warn(MIN_WIDTH_MSG, width_, ev->width);
+      }
+    } else {
+      if (height_ > 1 && ev->height > static_cast<int>(height_)) {
+        spdlog::warn(MIN_HEIGHT_MSG, height_, ev->height);
+      }
+    }
+    width_ = ev->width;
+    height_ = ev->height;
+    spdlog::info(BAR_SIZE_MSG, width_, height_, output_name_);
+  }
+};
+#endif
+
+struct RawSurfaceImpl : public BarSurface, public sigc::trackable {
+  RawSurfaceImpl(Gtk::Window& window, struct waybar_output& output) : window_{window} {
+    output_ = gdk_wayland_monitor_get_wl_output(output.monitor->gobj());
+    output_name_ = output.name;
+
+    window.signal_realize().connect_notify(sigc::mem_fun(*this, &RawSurfaceImpl::onRealize));
+    window.signal_map_event().connect_notify(sigc::mem_fun(*this, &RawSurfaceImpl::onMap));
+    window.signal_configure_event().connect_notify(
+        sigc::mem_fun(*this, &RawSurfaceImpl::onConfigure));
+
+    if (window.get_realized()) {
+      onRealize();
+    }
+  }
+
+  void setExclusiveZone(bool enable) override {
+    exclusive_zone_ = enable;
+    if (layer_surface_) {
+      auto zone = 0;
+      if (enable) {
+        // exclusive zone already includes margin for anchored edge,
+        // only opposite margin should be added
+        if ((anchor_ & VERTICAL_ANCHOR) == VERTICAL_ANCHOR) {
+          zone += width_;
+          zone += (anchor_ & ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT) ? margins_.right : margins_.left;
+        } else {
+          zone += height_;
+          zone += (anchor_ & ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP) ? margins_.bottom : margins_.top;
+        }
+      }
+      spdlog::debug("Set exclusive zone {} for output {}", zone, output_name_);
+      zwlr_layer_surface_v1_set_exclusive_zone(layer_surface_.get(), zone);
+    }
+  }
+
+  void setLayer(bar_layer layer) override {
+    layer_ = ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM;
+    if (layer == bar_layer::TOP) {
+      layer_ = ZWLR_LAYER_SHELL_V1_LAYER_TOP;
+    } else if (layer == bar_layer::OVERLAY) {
+      layer_ = ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY;
+    }
+    // updating already mapped window
+    if (layer_surface_) {
+      if (zwlr_layer_surface_v1_get_version(layer_surface_.get()) >=
+          ZWLR_LAYER_SURFACE_V1_SET_LAYER_SINCE_VERSION) {
+        zwlr_layer_surface_v1_set_layer(layer_surface_.get(), layer_);
+      } else {
+        spdlog::warn("Unable to change layer: layer-shell implementation is too old");
+      }
+    }
+  }
+
+  void setMargins(const struct bar_margins& margins) override {
+    margins_ = margins;
+    // updating already mapped window
+    if (layer_surface_) {
+      zwlr_layer_surface_v1_set_margin(
+          layer_surface_.get(), margins_.top, margins_.right, margins_.bottom, margins_.left);
+    }
+  }
+
+  void setPassThrough(bool enable) override {
+    passthrough_ = enable;
+    /* GTK overwrites any region changes applied directly to the wl_surface,
+     * thus the same GTK region API as in the GLS impl has to be used. */
+    auto gdk_window = window_.get_window();
+    if (gdk_window) {
+      Cairo::RefPtr<Cairo::Region> region;
+      if (enable) {
+        region = Cairo::Region::create();
+      }
+      gdk_window->input_shape_combine_region(region, 0, 0);
+    }
+  }
+
+  void setPosition(const std::string_view& position) override {
+    anchor_ = HORIZONTAL_ANCHOR | ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP;
+    if (position == "bottom") {
+      anchor_ = HORIZONTAL_ANCHOR | ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
+    } else if (position == "left") {
+      anchor_ = VERTICAL_ANCHOR | ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT;
+    } else if (position == "right") {
+      anchor_ = VERTICAL_ANCHOR | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
+    }
+
+    // updating already mapped window
+    if (layer_surface_) {
+      zwlr_layer_surface_v1_set_anchor(layer_surface_.get(), anchor_);
+    }
+  }
+
+  void setSize(uint32_t width, uint32_t height) override {
+    configured_width_ = width_ = width;
+    configured_height_ = height_ = height;
+    // layer_shell.configure handler should update exclusive zone if size changes
+    window_.set_size_request(width, height);
+  };
+
+  void commit() override {
+    if (surface_) {
+      wl_surface_commit(surface_);
+    }
+  }
+
+ private:
+  constexpr static uint8_t VERTICAL_ANCHOR =
+      ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
+  constexpr static uint8_t HORIZONTAL_ANCHOR =
+      ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
+
+  template <auto fn>
+  using deleter_fn = std::integral_constant<decltype(fn), fn>;
+  using layer_surface_ptr =
+      std::unique_ptr<zwlr_layer_surface_v1, deleter_fn<zwlr_layer_surface_v1_destroy>>;
+
+  Gtk::Window&       window_;
+  std::string        output_name_;
+  uint32_t           configured_width_ = 0;
+  uint32_t           configured_height_ = 0;
+  uint32_t           width_ = 0;
+  uint32_t           height_ = 0;
+  uint8_t            anchor_ = HORIZONTAL_ANCHOR | ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP;
+  bool               exclusive_zone_ = true;
+  bool               passthrough_ = false;
+  struct bar_margins margins_;
+
+  zwlr_layer_shell_v1_layer layer_ = ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM;
+  struct wl_output*         output_ = nullptr;   // owned by GTK
+  struct wl_surface*        surface_ = nullptr;  // owned by GTK
+  layer_surface_ptr         layer_surface_;
+
+  void onRealize() {
+    auto gdk_window = window_.get_window()->gobj();
+    gdk_wayland_window_set_use_custom_surface(gdk_window);
+  }
+
+  void onMap(GdkEventAny* ev) {
+    static const struct zwlr_layer_surface_v1_listener layer_surface_listener = {
+        .configure = onSurfaceConfigure,
+        .closed = onSurfaceClosed,
+    };
+    auto client = Client::inst();
+    auto gdk_window = window_.get_window()->gobj();
+    surface_ = gdk_wayland_window_get_wl_surface(gdk_window);
+
+    layer_surface_.reset(zwlr_layer_shell_v1_get_layer_surface(
+        client->layer_shell, surface_, output_, layer_, "waybar"));
+
+    zwlr_layer_surface_v1_add_listener(layer_surface_.get(), &layer_surface_listener, this);
+    zwlr_layer_surface_v1_set_keyboard_interactivity(layer_surface_.get(), false);
+    zwlr_layer_surface_v1_set_anchor(layer_surface_.get(), anchor_);
+    zwlr_layer_surface_v1_set_margin(
+        layer_surface_.get(), margins_.top, margins_.right, margins_.bottom, margins_.left);
+
+    setSurfaceSize(width_, height_);
+    setExclusiveZone(exclusive_zone_);
+    setPassThrough(passthrough_);
+
+    commit();
+    wl_display_roundtrip(client->wl_display);
+  }
+
+  void onConfigure(GdkEventConfigure* ev) {
+    /*
+     * GTK wants new size for the window.
+     *
+     * Prefer configured size if it's non-default.
+     * If the size is not set and the window is smaller than requested by GTK, request resize from
+     * layer surface.
+     */
+    auto tmp_height = height_;
+    auto tmp_width = width_;
+    if (ev->height > static_cast<int>(height_)) {
+      // Default minimal value
+      if (height_ > 1) {
+        spdlog::warn(MIN_HEIGHT_MSG, height_, ev->height);
+      }
+      if (configured_height_ > 1) {
+        spdlog::info(SIZE_DEFINED, "Height");
+      } else {
+        tmp_height = ev->height;
+      }
+    }
+    if (ev->width > static_cast<int>(width_)) {
+      // Default minimal value
+      if (width_ > 1) {
+        spdlog::warn(MIN_WIDTH_MSG, width_, ev->width);
+      }
+      if (configured_width_ > 1) {
+        spdlog::info(SIZE_DEFINED, "Width");
+      } else {
+        tmp_width = ev->width;
+      }
+    }
+    if (tmp_width != width_ || tmp_height != height_) {
+      setSurfaceSize(tmp_width, tmp_height);
+      commit();
+    }
+  }
+
+  void setSurfaceSize(uint32_t width, uint32_t height) {
+    /* If the client is anchored to two opposite edges, layer_surface.configure will return
+     * size without margins for the axis.
+     * layer_surface.set_size, however, expects size with margins for the anchored axis.
+     * This is not specified by wlr-layer-shell and based on actual behavior of sway.
+     *
+     * If the size for unanchored axis is not set (0), change request to 1 to avoid automatic
+     * assignment by the compositor.
+     */
+    if ((anchor_ & VERTICAL_ANCHOR) == VERTICAL_ANCHOR) {
+      width = width > 0 ? width : 1;
+      if (height > 1) {
+        height += margins_.top + margins_.bottom;
+      }
+    } else {
+      height = height > 0 ? height : 1;
+      if (width > 1) {
+        width += margins_.right + margins_.left;
+      }
+    }
+    spdlog::debug("Set surface size {}x{} for output {}", width, height, output_name_);
+    zwlr_layer_surface_v1_set_size(layer_surface_.get(), width, height);
+  }
+
+  static void onSurfaceConfigure(void* data, struct zwlr_layer_surface_v1* surface, uint32_t serial,
+                                 uint32_t width, uint32_t height) {
+    auto o = static_cast<RawSurfaceImpl*>(data);
+    if (width != o->width_ || height != o->height_) {
+      o->width_ = width;
+      o->height_ = height;
+      o->window_.set_size_request(o->width_, o->height_);
+      o->window_.resize(o->width_, o->height_);
+      o->setExclusiveZone(o->exclusive_zone_);
+      spdlog::info(BAR_SIZE_MSG,
+                   o->width_ == 1 ? "auto" : std::to_string(o->width_),
+                   o->height_ == 1 ? "auto" : std::to_string(o->height_),
+                   o->output_name_);
+      o->commit();
+    }
+    zwlr_layer_surface_v1_ack_configure(surface, serial);
+  }
+
+  static void onSurfaceClosed(void* data, struct zwlr_layer_surface_v1* /* surface */) {
+    auto o = static_cast<RawSurfaceImpl*>(data);
+    o->layer_surface_.reset();
+  }
+};
+
+};  // namespace waybar
 
 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),
+      layer_{bar_layer::BOTTOM},
-      layer_surface_(nullptr),
-      anchor_(ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP),
       left_(Gtk::ORIENTATION_HORIZONTAL, 0),
       center_(Gtk::ORIENTATION_HORIZONTAL, 0),
       right_(Gtk::ORIENTATION_HORIZONTAL, 0),
@@ -25,26 +403,30 @@ waybar::Bar::Bar(struct waybar_output* w_output, const Json::Value& w_config)
   window.get_style_context()->add_class(config["name"].asString());
   window.get_style_context()->add_class(config["position"].asString());
 
-  if (config["position"] == "right" || config["position"] == "left") {
+  if (config["layer"] == "top") {
-    height_ = 0;
+    layer_ = bar_layer::TOP;
-    width_ = 1;
+  } else if (config["layer"] == "overlay") {
+    layer_ = bar_layer::OVERLAY;
   }
-  height_ = config["height"].isUInt() ? config["height"].asUInt() : height_;
-  width_ = config["width"].isUInt() ? config["width"].asUInt() : width_;
 
-  if (config["position"] == "bottom") {
+  if (config["exclusive"].isBool()) {
-    anchor_ = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
+    exclusive = config["exclusive"].asBool();
-  } else if (config["position"] == "left") {
+  } else if (layer_ == bar_layer::OVERLAY) {
-    anchor_ = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT;
+    // swaybar defaults: overlay mode does not reserve an exclusive zone
-  } else if (config["position"] == "right") {
+    exclusive = false;
-    anchor_ = ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
   }
-  if (anchor_ == ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM ||
+
-      anchor_ == ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP) {
+  bool passthrough = false;
-    anchor_ |= ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
+  if (config["passthrough"].isBool()) {
-  } else if (anchor_ == ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT ||
+    passthrough = config["passthrough"].asBool();
-             anchor_ == ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT) {
+  } else if (layer_ == bar_layer::OVERLAY) {
-    anchor_ |= ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
+    // swaybar defaults: overlay mode does not accept pointer events.
+    passthrough = true;
+  }
+
+  auto position = config["position"].asString();
+
+  if (position == "right" || position == "left") {
     left_ = Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0);
     center_ = Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0);
     right_ = Gtk::Box(Gtk::ORIENTATION_VERTICAL, 0);
@@ -52,6 +434,22 @@ waybar::Bar::Bar(struct waybar_output* w_output, const Json::Value& w_config)
     vertical = true;
   }
 
+  left_.get_style_context()->add_class("modules-left");
+  center_.get_style_context()->add_class("modules-center");
+  right_.get_style_context()->add_class("modules-right");
+
+  if (config["spacing"].isInt()) {
+    int spacing = config["spacing"].asInt();
+    left_.set_spacing(spacing);
+    center_.set_spacing(spacing);
+    right_.set_spacing(spacing);
+  }
+
+  uint32_t height = config["height"].isUInt() ? config["height"].asUInt() : 0;
+  uint32_t width = config["width"].isUInt() ? config["width"].asUInt() : 0;
+
+  struct bar_margins margins_;
+
   if (config["margin-top"].isInt() || config["margin-right"].isInt() ||
       config["margin-bottom"].isInt() || config["margin-left"].isInt()) {
     margins_ = {
@@ -98,170 +496,63 @@ waybar::Bar::Bar(struct waybar_output* w_output, const Json::Value& w_config)
   }
 
 #ifdef HAVE_GTK_LAYER_SHELL
-  use_gls_ = config["gtk-layer-shell"].isBool() ? config["gtk-layer-shell"].asBool() : true;
+  bool use_gls = config["gtk-layer-shell"].isBool() ? config["gtk-layer-shell"].asBool() : true;
-  if (use_gls_) {
+  if (use_gls) {
-    initGtkLayerShell();
+    surface_impl_ = std::make_unique<GLSSurfaceImpl>(window, *output);
-  }
-#endif
-
-  window.signal_realize().connect_notify(sigc::mem_fun(*this, &Bar::onRealize));
-  window.signal_map_event().connect_notify(sigc::mem_fun(*this, &Bar::onMap));
-  window.signal_configure_event().connect_notify(sigc::mem_fun(*this, &Bar::onConfigure));
-  window.set_size_request(width_, height_);
-  setupWidgets();
-
-  if (window.get_realized()) {
-    onRealize();
-  }
-  window.show_all();
-}
-
-void waybar::Bar::onConfigure(GdkEventConfigure* ev) {
-  auto tmp_height = height_;
-  auto tmp_width = width_;
-  if (ev->height > static_cast<int>(height_)) {
-    // Default minimal value
-    if (height_ != 1) {
-      spdlog::warn(MIN_HEIGHT_MSG, height_, ev->height);
-    }
-    if (config["height"].isUInt()) {
-      spdlog::info(SIZE_DEFINED, "Height");
-    } else {
-      tmp_height = ev->height;
-    }
-  }
-  if (ev->width > static_cast<int>(width_)) {
-    // Default minimal value
-    if (width_ != 1) {
-      spdlog::warn(MIN_WIDTH_MSG, width_, ev->width);
-    }
-    if (config["width"].isUInt()) {
-      spdlog::info(SIZE_DEFINED, "Width");
-    } else {
-      tmp_width = ev->width;
-    }
-  }
-  if (use_gls_) {
-    width_ = tmp_width;
-    height_ = tmp_height;
-    spdlog::debug("Set surface size {}x{} for output {}", width_, height_, output->name);
-    setExclusiveZone(tmp_width, tmp_height);
-  } else if (tmp_width != width_ || tmp_height != height_) {
-    setSurfaceSize(tmp_width, tmp_height);
-  }
-}
-
-#ifdef HAVE_GTK_LAYER_SHELL
-void waybar::Bar::initGtkLayerShell() {
-  auto gtk_window = window.gobj();
-  // this has to be executed before GtkWindow.realize
-  gtk_layer_init_for_window(gtk_window);
-  gtk_layer_set_keyboard_interactivity(gtk_window, FALSE);
-  auto layer = config["layer"] == "top" ? GTK_LAYER_SHELL_LAYER_TOP : GTK_LAYER_SHELL_LAYER_BOTTOM;
-  gtk_layer_set_layer(gtk_window, layer);
-  gtk_layer_set_monitor(gtk_window, output->monitor->gobj());
-  gtk_layer_set_namespace(gtk_window, "waybar");
-
-  gtk_layer_set_anchor(
-      gtk_window, GTK_LAYER_SHELL_EDGE_LEFT, anchor_ & ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT);
-  gtk_layer_set_anchor(
-      gtk_window, GTK_LAYER_SHELL_EDGE_RIGHT, anchor_ & ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT);
-  gtk_layer_set_anchor(
-      gtk_window, GTK_LAYER_SHELL_EDGE_TOP, anchor_ & ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP);
-  gtk_layer_set_anchor(
-      gtk_window, GTK_LAYER_SHELL_EDGE_BOTTOM, anchor_ & ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM);
-
-  gtk_layer_set_margin(gtk_window, GTK_LAYER_SHELL_EDGE_LEFT, margins_.left);
-  gtk_layer_set_margin(gtk_window, GTK_LAYER_SHELL_EDGE_RIGHT, margins_.right);
-  gtk_layer_set_margin(gtk_window, GTK_LAYER_SHELL_EDGE_TOP, margins_.top);
-  gtk_layer_set_margin(gtk_window, GTK_LAYER_SHELL_EDGE_BOTTOM, margins_.bottom);
-
-  if (width_ > 1 && height_ > 1) {
-    /* configure events are not emitted if the bar is using initial size */
-    setExclusiveZone(width_, height_);
-  }
-}
-#endif
-
-void waybar::Bar::onRealize() {
-  auto gdk_window = window.get_window()->gobj();
-  gdk_wayland_window_set_use_custom_surface(gdk_window);
-}
-
-void waybar::Bar::onMap(GdkEventAny* ev) {
-  auto gdk_window = window.get_window()->gobj();
-  surface = gdk_wayland_window_get_wl_surface(gdk_window);
-
-  if (use_gls_) {
-    return;
-  }
-
-  auto client = waybar::Client::inst();
-  // owned by output->monitor; no need to destroy
-  auto wl_output = gdk_wayland_monitor_get_wl_output(output->monitor->gobj());
-  auto layer =
-      config["layer"] == "top" ? ZWLR_LAYER_SHELL_V1_LAYER_TOP : ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM;
-  layer_surface_ = zwlr_layer_shell_v1_get_layer_surface(
-      client->layer_shell, surface, wl_output, layer, "waybar");
-
-  zwlr_layer_surface_v1_set_keyboard_interactivity(layer_surface_, false);
-  zwlr_layer_surface_v1_set_anchor(layer_surface_, anchor_);
-  zwlr_layer_surface_v1_set_margin(
-      layer_surface_, margins_.top, margins_.right, margins_.bottom, margins_.left);
-  setSurfaceSize(width_, height_);
-  setExclusiveZone(width_, height_);
-
-  static const struct zwlr_layer_surface_v1_listener layer_surface_listener = {
-      .configure = layerSurfaceHandleConfigure,
-      .closed = layerSurfaceHandleClosed,
-  };
-  zwlr_layer_surface_v1_add_listener(layer_surface_, &layer_surface_listener, this);
-
-  wl_surface_commit(surface);
-  wl_display_roundtrip(client->wl_display);
-}
-
-void waybar::Bar::setExclusiveZone(uint32_t width, uint32_t height) {
-  auto zone = 0;
-  if (visible) {
-    // exclusive zone already includes margin for anchored edge,
-    // only opposite margin should be added
-    if (vertical) {
-      zone += width;
-      zone += (anchor_ & ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT) ? margins_.right : margins_.left;
-    } else {
-      zone += height;
-      zone += (anchor_ & ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP) ? margins_.bottom : margins_.top;
-    }
-  }
-  spdlog::debug("Set exclusive zone {} for output {}", zone, output->name);
-
-#ifdef HAVE_GTK_LAYER_SHELL
-  if (use_gls_) {
-    gtk_layer_set_exclusive_zone(window.gobj(), zone);
   } else
 #endif
   {
-    zwlr_layer_surface_v1_set_exclusive_zone(layer_surface_, zone);
+    surface_impl_ = std::make_unique<RawSurfaceImpl>(window, *output);
+  }
+
+  surface_impl_->setLayer(layer_);
+  surface_impl_->setExclusiveZone(exclusive);
+  surface_impl_->setMargins(margins_);
+  surface_impl_->setPassThrough(passthrough);
+  surface_impl_->setPosition(position);
+  surface_impl_->setSize(width, height);
+
+  window.signal_map_event().connect_notify(sigc::mem_fun(*this, &Bar::onMap));
+
+  setupWidgets();
+  window.show_all();
+
+  if (spdlog::should_log(spdlog::level::debug)) {
+    // Unfortunately, this function isn't in the C++ bindings, so we have to call the C version.
+    char* gtk_tree = gtk_style_context_to_string(
+        window.get_style_context()->gobj(),
+        (GtkStyleContextPrintFlags)(GTK_STYLE_CONTEXT_PRINT_RECURSE |
+                                    GTK_STYLE_CONTEXT_PRINT_SHOW_STYLE));
+    spdlog::debug("GTK widget tree:\n{}", gtk_tree);
+    g_free(gtk_tree);
   }
 }
 
-void waybar::Bar::setSurfaceSize(uint32_t width, uint32_t height) {
+void waybar::Bar::onMap(GdkEventAny*) {
-  /* If the client is anchored to two opposite edges, layer_surface.configure will return
+  /*
-   * size without margins for the axis.
+   * Obtain a pointer to the custom layer surface for modules that require it (idle_inhibitor).
-   * layer_surface.set_size, however, expects size with margins for the anchored axis.
-   * This is not specified by wlr-layer-shell and based on actual behavior of sway.
    */
-  if (vertical && height > 1) {
+  auto gdk_window = window.get_window()->gobj();
-    height += margins_.top + margins_.bottom;
+  surface = gdk_wayland_window_get_wl_surface(gdk_window);
-  }
-  if (!vertical && width > 1) {
-    width += margins_.right + margins_.left;
-  }
-  spdlog::debug("Set surface size {}x{} for output {}", width, height, output->name);
-  zwlr_layer_surface_v1_set_size(layer_surface_, width, height);
 }
 
+void waybar::Bar::setVisible(bool value) {
+  visible = value;
+  if (!visible) {
+    window.get_style_context()->add_class("hidden");
+    window.set_opacity(0);
+    surface_impl_->setLayer(bar_layer::BOTTOM);
+  } else {
+    window.get_style_context()->remove_class("hidden");
+    window.set_opacity(1);
+    surface_impl_->setLayer(layer_);
+  }
+  surface_impl_->setExclusiveZone(exclusive && visible);
+  surface_impl_->commit();
+}
+
+void waybar::Bar::toggle() { setVisible(!visible); }
+
 // Converting string to button code rn as to avoid doing it later
 void waybar::Bar::setupAltFormatKeyForModule(const std::string& module_name) {
   if (config.isMember(module_name)) {
@@ -323,48 +614,6 @@ void waybar::Bar::handleSignal(int signal) {
   }
 }
 
-void waybar::Bar::layerSurfaceHandleConfigure(void* data, struct zwlr_layer_surface_v1* surface,
-                                              uint32_t serial, uint32_t width, uint32_t height) {
-  auto o = static_cast<waybar::Bar*>(data);
-  if (width != o->width_ || height != o->height_) {
-    o->width_ = width;
-    o->height_ = height;
-    o->window.set_size_request(o->width_, o->height_);
-    o->window.resize(o->width_, o->height_);
-    o->setExclusiveZone(width, height);
-    spdlog::info(BAR_SIZE_MSG,
-                 o->width_ == 1 ? "auto" : std::to_string(o->width_),
-                 o->height_ == 1 ? "auto" : std::to_string(o->height_),
-                 o->output->name);
-    wl_surface_commit(o->surface);
-  }
-  zwlr_layer_surface_v1_ack_configure(surface, serial);
-}
-
-void waybar::Bar::layerSurfaceHandleClosed(void* data, struct zwlr_layer_surface_v1* /*surface*/) {
-  auto o = static_cast<waybar::Bar*>(data);
-  if (o->layer_surface_) {
-    zwlr_layer_surface_v1_destroy(o->layer_surface_);
-    o->layer_surface_ = nullptr;
-  }
-  o->modules_left_.clear();
-  o->modules_center_.clear();
-  o->modules_right_.clear();
-}
-
-auto waybar::Bar::toggle() -> void {
-  visible = !visible;
-  if (!visible) {
-    window.get_style_context()->add_class("hidden");
-    window.set_opacity(0);
-  } else {
-    window.get_style_context()->remove_class("hidden");
-    window.set_opacity(1);
-  }
-  setExclusiveZone(width_, height_);
-  wl_surface_commit(surface);
-}
-
 void waybar::Bar::getModules(const Factory& factory, const std::string& pos) {
   if (config[pos].isArray()) {
     for (const auto& name : config[pos]) {

src/client.cpp

@@ -1,37 +1,25 @@
 #include "client.hpp"
+
 #include <fmt/ostream.h>
 #include <spdlog/spdlog.h>
-#include <fstream>
+
 #include <iostream>
+
+#include "idle-inhibit-unstable-v1-client-protocol.h"
 #include "util/clara.hpp"
-#include "util/json.hpp"
+#include "wlr-layer-shell-unstable-v1-client-protocol.h"
 
 waybar::Client *waybar::Client::inst() {
   static auto c = new Client();
   return c;
 }
 
-const std::string waybar::Client::getValidPath(const std::vector<std::string> &paths) const {
-  wordexp_t p;
-
-  for (const std::string &path : paths) {
-    if (wordexp(path.c_str(), &p, 0) == 0) {
-      if (access(*p.we_wordv, F_OK) == 0) {
-        std::string result = *p.we_wordv;
-        wordfree(&p);
-        return result;
-      }
-      wordfree(&p);
-    }
-  }
-
-  return std::string();
-}
-
 void waybar::Client::handleGlobal(void *data, struct wl_registry *registry, uint32_t name,
                                   const char *interface, uint32_t version) {
   auto client = static_cast<Client *>(data);
   if (strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) {
+    // limit version to a highest supported by the client protocol file
+    version = std::min<uint32_t>(version, zwlr_layer_shell_v1_interface.version);
     client->layer_shell = static_cast<struct zwlr_layer_shell_v1 *>(
         wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface, version));
   } else if (strcmp(interface, zxdg_output_manager_v1_interface.name) == 0 &&
@@ -53,9 +41,9 @@ void waybar::Client::handleOutput(struct waybar_output &output) {
   static const struct zxdg_output_v1_listener xdgOutputListener = {
       .logical_position = [](void *, struct zxdg_output_v1 *, int32_t, int32_t) {},
       .logical_size = [](void *, struct zxdg_output_v1 *, int32_t, int32_t) {},
-      .done = [](void *, struct zxdg_output_v1 *) {},
+      .done = &handleOutputDone,
       .name = &handleOutputName,
-      .description = [](void *, struct zxdg_output_v1 *, const char *) {},
+      .description = &handleOutputDescription,
   };
   // owned by output->monitor; no need to destroy
   auto wl_output = gdk_wayland_monitor_get_wl_output(output.monitor->gobj());
@@ -63,27 +51,6 @@ void waybar::Client::handleOutput(struct waybar_output &output) {
   zxdg_output_v1_add_listener(output.xdg_output.get(), &xdgOutputListener, &output);
 }
 
-bool waybar::Client::isValidOutput(const Json::Value &config, struct waybar_output &output) {
-  if (config["output"].isArray()) {
-    for (auto const &output_conf : config["output"]) {
-      if (output_conf.isString() && output_conf.asString() == output.name) {
-        return true;
-      }
-    }
-    return false;
-  } else if (config["output"].isString()) {
-    auto config_output_name = config["output"].asString();
-    if (!config_output_name.empty()) {
-      if (config_output_name.substr(0, 1) == "!") {
-          return config_output_name.substr(1) != output.name;
-      }
-      return config_output_name == output.name;
-    }
-  }
-
-  return true;
-}
-
 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; });
@@ -94,17 +61,36 @@ struct waybar::waybar_output &waybar::Client::getOutput(void *addr) {
 }
 
 std::vector<Json::Value> waybar::Client::getOutputConfigs(struct waybar_output &output) {
-  std::vector<Json::Value> configs;
+  return config.getOutputConfigs(output.name, output.identifier);
-  if (config_.isArray()) {
+}
-    for (auto const &config : config_) {
+
-      if (config.isObject() && isValidOutput(config, output)) {
+void waybar::Client::handleOutputDone(void *data, struct zxdg_output_v1 * /*xdg_output*/) {
-        configs.push_back(config);
+  auto client = waybar::Client::inst();
+  try {
+    auto &output = client->getOutput(data);
+    /**
+     * Multiple .done events may arrive in batch. In this case libwayland would queue
+     * xdg_output.destroy and dispatch all pending events, triggering this callback several times
+     * for the same output. .done events can also arrive after that for a scale or position changes.
+     * We wouldn't want to draw a duplicate bar for each such event either.
+     *
+     * All the properties we care about are immutable so it's safe to delete the xdg_output object
+     * on the first event and use the ptr value to check that the callback was already invoked.
+     */
+    if (output.xdg_output) {
+      output.xdg_output.reset();
+      spdlog::debug("Output detection done: {} ({})", output.name, output.identifier);
+
+      auto configs = client->getOutputConfigs(output);
+      if (!configs.empty()) {
+        for (const auto &config : configs) {
+          client->bars.emplace_back(std::make_unique<Bar>(&output, config));
         }
       }
-  } else if (isValidOutput(config_, output)) {
-    configs.push_back(config_);
     }
-  return configs;
+  } catch (const std::exception &e) {
+    std::cerr << e.what() << std::endl;
+  }
 }
 
 void waybar::Client::handleOutputName(void *      data, struct zxdg_output_v1 * /*xdg_output*/,
@@ -113,22 +99,21 @@ void waybar::Client::handleOutputName(void *      data, struct zxdg_output_v1 *
   try {
     auto &output = client->getOutput(data);
     output.name = name;
-    spdlog::debug("Output detected: {} ({} {})",
+  } catch (const std::exception &e) {
-                  name,
+    std::cerr << e.what() << std::endl;
-                  output.monitor->get_manufacturer(),
-                  output.monitor->get_model());
-    auto configs = client->getOutputConfigs(output);
-    if (configs.empty()) {
-      output.xdg_output.reset();
-    } else {
-      wl_display_roundtrip(client->wl_display);
-      for (const auto &config : configs) {
-        client->bars.emplace_back(std::make_unique<Bar>(&output, config));
-        Glib::RefPtr<Gdk::Screen> screen = client->bars.back()->window.get_screen();
-        client->style_context_->add_provider_for_screen(
-            screen, client->css_provider_, GTK_STYLE_PROVIDER_PRIORITY_USER);
-      }
   }
+}
+
+void waybar::Client::handleOutputDescription(void *data, struct zxdg_output_v1 * /*xdg_output*/,
+                                             const char *description) {
+  auto client = waybar::Client::inst();
+  try {
+    auto &      output = client->getOutput(data);
+    const char *open_paren = strrchr(description, '(');
+
+    // Description format: "identifier (name)"
+    size_t identifier_length = open_paren - description;
+    output.identifier = std::string(description, identifier_length - 1);
   } catch (const std::exception &e) {
     std::cerr << e.what() << std::endl;
   }
@@ -142,10 +127,21 @@ void waybar::Client::handleMonitorAdded(Glib::RefPtr<Gdk::Monitor> monitor) {
 
 void waybar::Client::handleMonitorRemoved(Glib::RefPtr<Gdk::Monitor> monitor) {
   spdlog::debug("Output removed: {} {}", monitor->get_manufacturer(), monitor->get_model());
+  /* This event can be triggered from wl_display_roundtrip called by GTK or our code.
+   * Defer destruction of bars for the output to the next iteration of the event loop to avoid
+   * deleting objects referenced by currently executed code.
+   */
+  Glib::signal_idle().connect_once(
+      sigc::bind(sigc::mem_fun(*this, &Client::handleDeferredMonitorRemoval), monitor),
+      Glib::PRIORITY_HIGH_IDLE);
+}
+
+void waybar::Client::handleDeferredMonitorRemoval(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 {
@@ -155,40 +151,14 @@ void waybar::Client::handleMonitorRemoved(Glib::RefPtr<Gdk::Monitor> monitor) {
   outputs_.remove_if([&monitor](const auto &output) { return output.monitor == monitor; });
 }
 
-std::tuple<const std::string, const std::string> waybar::Client::getConfigs(
+const std::string waybar::Client::getStyle(const std::string &style) {
-    const std::string &config, const std::string &style) const {
+  auto css_file = style.empty() ? Config::findConfigPath({"style.css"}) : style;
-  auto config_file = config.empty() ? getValidPath({
+  if (!css_file) {
-                                          "$XDG_CONFIG_HOME/waybar/config",
+    throw std::runtime_error("Missing required resource files");
-                                          "$HOME/.config/waybar/config",
-                                          "$HOME/waybar/config",
-                                          SYSCONFDIR "/xdg/waybar/config",
-                                          "./resources/config",
-                                      })
-                                    : config;
-  auto css_file = style.empty() ? getValidPath({
-                                      "$XDG_CONFIG_HOME/waybar/style.css",
-                                      "$HOME/.config/waybar/style.css",
-                                      "$HOME/waybar/style.css",
-                                      SYSCONFDIR "/xdg/waybar/style.css",
-                                      "./resources/style.css",
-                                  })
-                                : style;
-  if (css_file.empty() || config_file.empty()) {
-    throw std::runtime_error("Missing required resources files");
   }
-  spdlog::info("Resources files: {}, {}", config_file, css_file);
+  spdlog::info("Using CSS file {}", css_file.value());
-  return {config_file, css_file};
+  return css_file.value();
-}
+};
-
-auto waybar::Client::setupConfig(const std::string &config_file) -> void {
-  std::ifstream file(config_file);
-  if (!file.is_open()) {
-    throw std::runtime_error("Can't open config file");
-  }
-  std::string      str((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
-  util::JsonParser parser;
-  config_ = parser.parse(str);
-}
 
 auto waybar::Client::setupCss(const std::string &css_file) -> void {
   css_provider_ = Gtk::CssProvider::create();
@@ -198,6 +168,9 @@ auto waybar::Client::setupCss(const std::string &css_file) -> void {
   if (!css_provider_->load_from_path(css_file)) {
     throw std::runtime_error("Can't open style file");
   }
+  // there's always only one screen
+  style_context_->add_provider_for_screen(
+      Gdk::Screen::get_default(), css_provider_, GTK_STYLE_PROVIDER_PRIORITY_USER);
 }
 
 void waybar::Client::bindInterfaces() {
@@ -224,14 +197,14 @@ void waybar::Client::bindInterfaces() {
 int waybar::Client::main(int argc, char *argv[]) {
   bool        show_help = false;
   bool        show_version = false;
-  std::string config;
+  std::string config_opt;
-  std::string style;
+  std::string style_opt;
   std::string bar_id;
   std::string log_level;
   auto        cli = clara::detail::Help(show_help) |
              clara::detail::Opt(show_version)["-v"]["--version"]("Show version") |
-             clara::detail::Opt(config, "config")["-c"]["--config"]("Config path") |
+             clara::detail::Opt(config_opt, "config")["-c"]["--config"]("Config path") |
-             clara::detail::Opt(style, "style")["-s"]["--style"]("Style path") |
+             clara::detail::Opt(style_opt, "style")["-s"]["--style"]("Style path") |
              clara::detail::Opt(
                  log_level,
                  "trace|debug|info|warning|error|critical|off")["-l"]["--log-level"]("Log level") |
@@ -252,7 +225,8 @@ int waybar::Client::main(int argc, char *argv[]) {
   if (!log_level.empty()) {
     spdlog::set_level(spdlog::level::from_str(log_level));
   }
-  gtk_app = Gtk::Application::create(argc, argv, "fr.arouillard.waybar", Gio::APPLICATION_HANDLES_COMMAND_LINE);
+  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");
@@ -261,17 +235,16 @@ int waybar::Client::main(int argc, char *argv[]) {
     throw std::runtime_error("Bar need to run under Wayland");
   }
   wl_display = gdk_wayland_display_get_wl_display(gdk_display->gobj());
-  auto [config_file, css_file] = getConfigs(config, style);
+  config.load(config_opt);
-  setupConfig(config_file);
+  auto css_file = getStyle(style_opt);
   setupCss(css_file);
   bindInterfaces();
   gtk_app->hold();
   gtk_app->run();
   bars.clear();
-  zxdg_output_manager_v1_destroy(xdg_output_manager);
-  zwlr_layer_shell_v1_destroy(layer_shell);
-  zwp_idle_inhibit_manager_v1_destroy(idle_inhibit_manager);
-  wl_registry_destroy(registry);
-  wl_display_disconnect(wl_display);
   return 0;
 }
+
+void waybar::Client::reset() {
+  gtk_app->quit();
+}

src/config.cpp

@@ -0,0 +1,153 @@
+#include "config.hpp"
+
+#include <fmt/ostream.h>
+#include <spdlog/spdlog.h>
+#include <unistd.h>
+#include <wordexp.h>
+
+#include <fstream>
+#include <stdexcept>
+
+#include "util/json.hpp"
+
+namespace waybar {
+
+const std::vector<std::string> Config::CONFIG_DIRS = {
+    "$XDG_CONFIG_HOME/waybar/",
+    "$HOME/.config/waybar/",
+    "$HOME/waybar/",
+    "/etc/xdg/waybar/",
+    SYSCONFDIR "/xdg/waybar/",
+    "./resources/",
+};
+
+std::optional<std::string> tryExpandPath(const std::string &path) {
+  wordexp_t p;
+  if (wordexp(path.c_str(), &p, 0) == 0) {
+    if (access(*p.we_wordv, F_OK) == 0) {
+      std::string result = *p.we_wordv;
+      wordfree(&p);
+      return result;
+    }
+    wordfree(&p);
+  }
+  return std::nullopt;
+}
+
+std::optional<std::string> Config::findConfigPath(const std::vector<std::string> &names,
+                                                  const std::vector<std::string> &dirs) {
+  std::vector<std::string> paths;
+  for (const auto &dir : dirs) {
+    for (const auto &name : names) {
+      if (auto res = tryExpandPath(dir + name); res) {
+        return res;
+      }
+    }
+  }
+  return std::nullopt;
+}
+
+void Config::setupConfig(Json::Value &dst, const std::string &config_file, int depth) {
+  if (depth > 100) {
+    throw std::runtime_error("Aborting due to likely recursive include in config files");
+  }
+  std::ifstream file(config_file);
+  if (!file.is_open()) {
+    throw std::runtime_error("Can't open config file");
+  }
+  std::string      str((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
+  util::JsonParser parser;
+  Json::Value      tmp_config = parser.parse(str);
+  if (tmp_config.isArray()) {
+    for (auto &config_part : tmp_config) {
+      resolveConfigIncludes(config_part, depth);
+    }
+  } else {
+    resolveConfigIncludes(tmp_config, depth);
+  }
+  mergeConfig(dst, tmp_config);
+}
+
+void Config::resolveConfigIncludes(Json::Value &config, int depth) {
+  Json::Value includes = config["include"];
+  if (includes.isArray()) {
+    for (const auto &include : includes) {
+      spdlog::info("Including resource file: {}", include.asString());
+      setupConfig(config, tryExpandPath(include.asString()).value_or(""), ++depth);
+    }
+  } else if (includes.isString()) {
+    spdlog::info("Including resource file: {}", includes.asString());
+    setupConfig(config, tryExpandPath(includes.asString()).value_or(""), ++depth);
+  }
+}
+
+void Config::mergeConfig(Json::Value &a_config_, Json::Value &b_config_) {
+  if (!a_config_) {
+    // For the first config
+    a_config_ = b_config_;
+  } else if (a_config_.isObject() && b_config_.isObject()) {
+    for (const auto &key : b_config_.getMemberNames()) {
+      // [] creates key with default value. Use `get` to avoid that.
+      if (a_config_.get(key, Json::Value::nullSingleton()).isObject() &&
+          b_config_[key].isObject()) {
+        mergeConfig(a_config_[key], b_config_[key]);
+      } else if (!a_config_.isMember(key)) {
+        // do not allow overriding value set by top or previously included config
+        a_config_[key] = b_config_[key];
+      } else {
+        spdlog::trace("Option {} is already set; ignoring value {}", key, b_config_[key]);
+      }
+    }
+  } else {
+    spdlog::error("Cannot merge config, conflicting or invalid JSON types");
+  }
+}
+bool isValidOutput(const Json::Value &config, const std::string &name,
+                   const std::string &identifier) {
+  if (config["output"].isArray()) {
+    for (auto const &output_conf : config["output"]) {
+      if (output_conf.isString() &&
+          (output_conf.asString() == name || output_conf.asString() == identifier)) {
+        return true;
+      }
+    }
+    return false;
+  } else if (config["output"].isString()) {
+    auto config_output = config["output"].asString();
+    if (!config_output.empty()) {
+      if (config_output.substr(0, 1) == "!") {
+        return config_output.substr(1) != name && config_output.substr(1) != identifier;
+      }
+      return config_output == name || config_output == identifier;
+    }
+  }
+
+  return true;
+}
+
+void Config::load(const std::string &config) {
+  auto file = config.empty() ? findConfigPath({"config", "config.jsonc"}) : config;
+  if (!file) {
+    throw std::runtime_error("Missing required resource files");
+  }
+  config_file_ = file.value();
+  spdlog::info("Using configuration file {}", config_file_);
+  setupConfig(config_, config_file_, 0);
+}
+
+std::vector<Json::Value> Config::getOutputConfigs(const std::string &name,
+                                                  const std::string &identifier) {
+  std::vector<Json::Value> configs;
+  if (config_.isArray()) {
+    for (auto const &config : config_) {
+      if (config.isObject() && isValidOutput(config, name, identifier)) {
+        configs.push_back(config);
+      }
+    }
+  } else if (isValidOutput(config_, name, identifier)) {
+    configs.push_back(config_);
+  }
+  return configs;
+}
+
+}  // namespace waybar

src/factory.cpp

@@ -22,6 +22,22 @@ waybar::AModule* waybar::Factory::makeModule(const std::string& name) const {
     if (ref == "sway/window") {
       return new waybar::modules::sway::Window(id, bar_, config_[name]);
     }
+    if (ref == "sway/language") {
+        return new waybar::modules::sway::Language(id, config_[name]);
+    }
+#endif
+#ifdef HAVE_WLR
+    if (ref == "wlr/taskbar") {
+      return new waybar::modules::wlr::Taskbar(id, bar_, config_[name]);
+    }
+    if (ref == "wlr/workspaces") {
+      return new waybar::modules::wlr::WorkspaceManager(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]);
@@ -57,6 +73,11 @@ waybar::AModule* waybar::Factory::makeModule(const std::string& name) const {
       return new waybar::modules::Backlight(id, config_[name]);
     }
 #endif
+#ifdef HAVE_LIBEVDEV
+    if (ref == "keyboard-state") {
+      return new waybar::modules::KeyboardState(id, bar_, config_[name]);
+    }
+#endif
 #ifdef HAVE_LIBPULSE
     if (ref == "pulseaudio") {
       return new waybar::modules::Pulseaudio(id, config_[name]);
@@ -66,14 +87,21 @@ waybar::AModule* waybar::Factory::makeModule(const std::string& name) const {
     if (ref == "mpd") {
       return new waybar::modules::MPD(id, config_[name]);
     }
+#endif
+#ifdef HAVE_LIBSNDIO
+    if (ref == "sndio") {
+      return new waybar::modules::Sndio(id, config_[name]);
+    }
 #endif
     if (ref == "temperature") {
       return new waybar::modules::Temperature(id, config_[name]);
     }
 #if defined(__linux__)
+#  ifdef WANT_RFKILL
     if (ref == "bluetooth") {
       return new waybar::modules::Bluetooth(id, config_[name]);
     }
+#  endif
 #endif
     if (ref.compare(0, 7, "custom/") == 0 && ref.size() > 7) {
       return new waybar::modules::Custom(ref.substr(7), id, config_[name]);

src/main.cpp

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

src/modules/backlight.cpp

@@ -173,7 +173,7 @@ auto waybar::modules::Backlight::update() -> void {
       return;
     }
 
-    const auto percent = best->get_max() == 0 ? 100 : best->get_actual() * 100 / best->get_max();
+    const uint8_t percent = best->get_max() == 0 ? 100 : round(best->get_actual() * 100.0f / best->get_max());
     label_.set_markup(fmt::format(
         format_, fmt::arg("percent", std::to_string(percent)), fmt::arg("icon", getIcon(percent))));
     getState(percent);

src/modules/battery.cpp

@@ -4,46 +4,82 @@
 
 waybar::modules::Battery::Battery(const std::string& id, const Json::Value& config)
     : ALabel(config, "battery", id, "{capacity}%", 60) {
-  getBatteries();
+  battery_watch_fd_ = inotify_init1(IN_CLOEXEC);
-  fd_ = inotify_init1(IN_CLOEXEC);
+  if (battery_watch_fd_ == -1) {
-  if (fd_ == -1) {
     throw std::runtime_error("Unable to listen batteries.");
   }
-  for (auto const& bat : batteries_) {
+
-    auto wd = inotify_add_watch(fd_, (bat / "uevent").c_str(), IN_ACCESS);
+  global_watch_fd_ = inotify_init1(IN_CLOEXEC);
-    if (wd != -1) {
+  if (global_watch_fd_ == -1) {
-      wds_.push_back(wd);
+    throw std::runtime_error("Unable to listen batteries.");
   }
+
+  // Watch the directory for any added or removed batteries
+  global_watch = inotify_add_watch(global_watch_fd_, data_dir_.c_str(), IN_CREATE | IN_DELETE);
+  if (global_watch < 0) {
+    throw std::runtime_error("Could not watch for battery plug/unplug");
   }
+
+  refreshBatteries();
   worker();
 }
 
 waybar::modules::Battery::~Battery() {
-  for (auto wd : wds_) {
+  std::lock_guard<std::mutex> guard(battery_list_mutex_);
-    inotify_rm_watch(fd_, wd);
+
+  if (global_watch >= 0) {
+    inotify_rm_watch(global_watch_fd_, global_watch);
   }
-  close(fd_);
+  close(global_watch_fd_);
+
+  for (auto it = batteries_.cbegin(); it != batteries_.cend(); it++) {
+    auto watch_id = (*it).second;
+    if (watch_id >= 0) {
+      inotify_rm_watch(battery_watch_fd_, watch_id);
+    }
+    batteries_.erase(it);
+  }
+  close(battery_watch_fd_);
 }
 
 void waybar::modules::Battery::worker() {
   thread_timer_ = [this] {
+    // Make sure we eventually update the list of batteries even if we miss an
+    // inotify event for some reason
+    refreshBatteries();
     dp.emit();
     thread_timer_.sleep_for(interval_);
   };
   thread_ = [this] {
     struct inotify_event event = {0};
-    int                  nbytes = read(fd_, &event, sizeof(event));
+    int                  nbytes = read(battery_watch_fd_, &event, sizeof(event));
     if (nbytes != sizeof(event) || event.mask & IN_IGNORED) {
       thread_.stop();
       return;
     }
-    // TODO: don't stop timer for now since there is some bugs :?
+    dp.emit();
-    // thread_timer_.stop();
+  };
+  thread_battery_update_ = [this] {
+    struct inotify_event event = {0};
+    int                  nbytes = read(global_watch_fd_, &event, sizeof(event));
+    if (nbytes != sizeof(event) || event.mask & IN_IGNORED) {
+      thread_.stop();
+      return;
+    }
+    refreshBatteries();
     dp.emit();
   };
 }
 
-void waybar::modules::Battery::getBatteries() {
+void waybar::modules::Battery::refreshBatteries() {
+  std::lock_guard<std::mutex> guard(battery_list_mutex_);
+
+  // Mark existing list of batteries as not necessarily found
+  std::map<fs::path, bool> check_map;
+  for (auto const& bat : batteries_) {
+    check_map[bat.first] = false;
+  }
+
   try {
     for (auto& node : fs::directory_iterator(data_dir_)) {
       if (!fs::is_directory(node)) {
@@ -53,8 +89,23 @@ 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")) {
+          fs::exists(node.path() / "status") && fs::exists(node.path() / "type")) {
-        batteries_.push_back(node.path());
+        std::string type;
+        std::ifstream(node.path() / "type") >> type;
+
+        if (!type.compare("Battery")){
+          check_map[node.path()] = true;
+          auto search = batteries_.find(node.path());
+          if (search == batteries_.end()) {
+            // We've found a new battery save it and start listening for events
+            auto event_path = (node.path() / "uevent");
+            auto wd = inotify_add_watch(battery_watch_fd_, event_path.c_str(), IN_ACCESS);
+            if (wd < 0) {
+              throw std::runtime_error("Could not watch events for " + node.path().string());
+            }
+            batteries_[node.path()] = wd;
+          }
+        }
       }
       auto adap_defined = config_["adapter"].isString();
       if (((adap_defined && dir_name == config_["adapter"].asString()) || !adap_defined) &&
@@ -71,36 +122,86 @@ void waybar::modules::Battery::getBatteries() {
     }
     throw std::runtime_error("No batteries.");
   }
+
+  // Remove any batteries that are no longer present and unwatch them
+  for (auto const& check : check_map) {
+    if (!check.second) {
+      auto watch_id = batteries_[check.first];
+      if (watch_id >= 0) {
+        inotify_rm_watch(battery_watch_fd_, watch_id);
+      }
+      batteries_.erase(check.first);
+    }
+  }
 }
 
-const std::tuple<uint8_t, float, std::string> waybar::modules::Battery::getInfos() const {
+// Unknown > Full > Not charging > Discharging > Charging
+static bool status_gt(const std::string& a, const std::string& b) {
+  if (a == b) return false;
+  else if (a == "Unknown") return true;
+  else if (a == "Full" && b != "Unknown") return true;
+  else if (a == "Not charging" && b != "Unknown" && b != "Full") return true;
+  else if (a == "Discharging" && b != "Unknown" && b != "Full" && b != "Not charging") return true;
+  return false;
+}
+
+const std::tuple<uint8_t, float, std::string, float> waybar::modules::Battery::getInfos() {
+  std::lock_guard<std::mutex> guard(battery_list_mutex_);
+
   try {
-    uint16_t    total = 0;
     uint32_t    total_power = 0;   // μW
     uint32_t    total_energy = 0;  // μWh
     uint32_t    total_energy_full = 0;
+    uint32_t    total_energy_full_design = 0;
     std::string status = "Unknown";
-    for (auto const& bat : batteries_) {
+    for (auto const& item : batteries_) {
-      uint16_t    capacity;
+      auto bat = item.first;
       uint32_t    power_now;
       uint32_t    energy_full;
       uint32_t    energy_now;
+      uint32_t    energy_full_design;
       std::string _status;
-      std::ifstream(bat / "capacity") >> capacity;
       std::ifstream(bat / "status") >> _status;
-      auto rate_path = fs::exists(bat / "current_now") ? "current_now" : "power_now";
+
-      std::ifstream(bat / rate_path) >> power_now;
+      // Some battery will report current and charge in μA/μAh.
-      auto now_path = fs::exists(bat / "charge_now") ? "charge_now" : "energy_now";
+      // Scale these by the voltage to get μW/μWh.
-      std::ifstream(bat / now_path) >> energy_now;
+      if (fs::exists(bat / "current_now")) {
-      auto full_path = fs::exists(bat / "charge_full") ? "charge_full" : "energy_full";
+        uint32_t voltage_now;
-      std::ifstream(bat / full_path) >> energy_full;
+        uint32_t current_now;
-      if (_status != "Unknown") {
+        uint32_t charge_now;
+        uint32_t charge_full;
+        uint32_t charge_full_design;
+        std::ifstream(bat / "voltage_now") >> voltage_now;
+        std::ifstream(bat / "current_now") >> current_now;
+        std::ifstream(bat / "charge_full") >> charge_full;
+        std::ifstream(bat / "charge_full_design") >> charge_full_design;
+        if (fs::exists(bat / "charge_now"))
+          std::ifstream(bat / "charge_now") >> charge_now;
+        else {
+          // charge_now is missing on some systems, estimate using capacity.
+          uint32_t capacity;
+          std::ifstream(bat / "capacity") >> capacity;
+          charge_now = (capacity * charge_full) / 100;
+        }
+        power_now = ((uint64_t)current_now * (uint64_t)voltage_now) / 1000000;
+        energy_now = ((uint64_t)charge_now * (uint64_t)voltage_now) / 1000000;
+        energy_full = ((uint64_t)charge_full * (uint64_t)voltage_now) / 1000000;
+        energy_full_design = ((uint64_t)charge_full_design * (uint64_t)voltage_now) / 1000000;
+      } else {
+        std::ifstream(bat / "power_now") >> power_now;
+        std::ifstream(bat / "energy_now") >> energy_now;
+        std::ifstream(bat / "energy_full") >> energy_full;
+        std::ifstream(bat / "energy_full_design") >> energy_full_design;
+      }
+
+      // Show the "smallest" status among all batteries
+      if (status_gt(status, _status)) {
         status = _status;
       }
-      total += capacity;
       total_power += power_now;
       total_energy += energy_now;
       total_energy_full += energy_full;
+      total_energy_full_design += energy_full_design;
     }
     if (!adapter_.empty() && status == "Discharging") {
       bool online;
@@ -114,22 +215,40 @@ const std::tuple<uint8_t, float, std::string> waybar::modules::Battery::getInfos
       time_remaining = (float)total_energy / total_power;
     } else if (status == "Charging" && total_power != 0) {
       time_remaining = -(float)(total_energy_full - total_energy) / total_power;
+      if (time_remaining > 0.0f) {
+        // If we've turned positive it means the battery is past 100% and so
+        // just report that as no time remaining
+        time_remaining = 0.0f;
+      }
+    }
+    float capacity = ((float)total_energy * 100.0f / (float) total_energy_full);
+    // Handle design-capacity
+    if (config_["design-capacity"].isBool() ? config_["design-capacity"].asBool() : false) {
+        capacity = ((float)total_energy * 100.0f / (float) total_energy_full_design);
     }
-    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;
       }
     }
+    if (capacity > 100.f) {
+      // This can happen when the battery is calibrating and goes above 100%
+      // Handle it gracefully by clamping at 100%
+      capacity = 100.f;
     }
-    return {capacity, time_remaining, status};
+    uint8_t cap = round(capacity);
+    if (cap == 100 && status == "Charging") {
+      // If we've reached 100% just mark as full as some batteries can stay
+      // stuck reporting they're still charging but not yet done
+      status = "Full";
+    }
+
+    return {cap, time_remaining, status, total_power / 1e6};
   } catch (const std::exception& e) {
     spdlog::error("Battery: {}", e.what());
-    return {0, 0, "Unknown"};
+    return {0, 0, "Unknown", 0};
   }
 }
 
@@ -153,6 +272,10 @@ const std::string waybar::modules::Battery::formatTimeRemaining(float hoursRemai
   uint16_t full_hours = static_cast<uint16_t>(hoursRemaining);
   uint16_t minutes = static_cast<uint16_t>(60 * (hoursRemaining - full_hours));
   auto     format = std::string("{H} h {M} min");
+  if (full_hours == 0 && minutes == 0) {
+    // Migh as well not show "0h 0min"
+    return "";
+  }
   if (config_["format-time"].isString()) {
     format = config_["format-time"].asString();
   }
@@ -160,26 +283,41 @@ const std::string waybar::modules::Battery::formatTimeRemaining(float hoursRemai
 }
 
 auto waybar::modules::Battery::update() -> void {
-  auto [capacity, time_remaining, status] = getInfos();
+  auto [capacity, time_remaining, status, power] = getInfos();
   if (status == "Unknown") {
     status = getAdapterStatus(capacity);
   }
-  if (tooltipEnabled()) {
+  auto status_pretty = status;
-    std::string tooltip_text;
-    if (time_remaining != 0) {
-      std::string time_to = std::string("Time to ") + ((time_remaining > 0) ? "empty" : "full");
-      tooltip_text = time_to + ": " + formatTimeRemaining(time_remaining);
-    } else {
-      tooltip_text = status;
-    }
-    label_.set_tooltip_text(tooltip_text);
-  }
   // 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);
+  auto time_remaining_formatted = formatTimeRemaining(time_remaining);
+  if (tooltipEnabled()) {
+    std::string tooltip_text_default;
+    std::string tooltip_format = "{timeTo}";
+    if (time_remaining != 0) {
+      std::string time_to = std::string("Time to ") + ((time_remaining > 0) ? "empty" : "full");
+      tooltip_text_default = time_to + ": " + time_remaining_formatted;
+    } else {
+      tooltip_text_default = status_pretty;
+    }
+    if (!state.empty() && config_["tooltip-format-" + status + "-" + state].isString()) {
+      tooltip_format = config_["tooltip-format-" + status + "-" + state].asString();
+    } else if (config_["tooltip-format-" + status].isString()) {
+      tooltip_format = config_["tooltip-format-" + status].asString();
+    } else if (!state.empty() && config_["tooltip-format-" + state].isString()) {
+      tooltip_format = config_["tooltip-format-" + state].asString();
+    } else if (config_["tooltip-format"].isString()) {
+      tooltip_format = config_["tooltip-format"].asString();
+    }
+    label_.set_tooltip_text(fmt::format(tooltip_format,
+                                        fmt::arg("timeTo", tooltip_text_default),
+                                        fmt::arg("capacity", capacity),
+                                        fmt::arg("time", time_remaining_formatted)));
+  }
   if (!old_status_.empty()) {
     label_.get_style_context()->remove_class(old_status_);
   }
@@ -199,8 +337,9 @@ auto waybar::modules::Battery::update() -> void {
     auto icons = std::vector<std::string>{status + "-" + state, status, state};
     label_.set_markup(fmt::format(format,
                                   fmt::arg("capacity", capacity),
+                                  fmt::arg("power", power),
                                   fmt::arg("icon", getIcon(capacity, icons)),
-                                  fmt::arg("time", formatTimeRemaining(time_remaining))));
+                                  fmt::arg("time", time_remaining_formatted)));
   }
   // Call parent update
   ALabel::update();

src/modules/bluetooth.cpp

@@ -1,45 +1,25 @@
 #include "modules/bluetooth.hpp"
-#include "util/rfkill.hpp"
+
-#include <linux/rfkill.h>
+#include <fmt/format.h>
-#include <time.h>
 
 waybar::modules::Bluetooth::Bluetooth(const std::string& id, const Json::Value& config)
-    : ALabel(config, "bluetooth", id, "{icon}", 10),
+    : ALabel(config, "bluetooth", id, "{icon}", 10), rfkill_{RFKILL_TYPE_BLUETOOTH} {
-      status_("disabled"),
+  rfkill_.on_update.connect(sigc::hide(sigc::mem_fun(*this, &Bluetooth::update)));
-      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()) {
+  std::string status = rfkill_.getState() ? "disabled" : "enabled";
-    status_ = "disabled";
-  } else {
-    status_ = "enabled";
-  }
 
   label_.set_markup(
-      fmt::format(
+      fmt::format(format_, fmt::arg("status", status), fmt::arg("icon", getIcon(0, status))));
-        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_);
+      auto tooltip_text = fmt::format(tooltip_format, status, fmt::arg("status", status));
       label_.set_tooltip_text(tooltip_text);
     } else {
-      label_.set_tooltip_text(status_);
+      label_.set_tooltip_text(status);
     }
   }
 }

src/modules/clock.cpp

@@ -5,6 +5,7 @@
 
 #include <sstream>
 #include <type_traits>
+#include "util/ustring_clen.hpp"
 #ifdef HAVE_LANGINFO_1STDAY
 #include <langinfo.h>
 #include <locale.h>
@@ -13,11 +14,15 @@
 using waybar::modules::waybar_time;
 
 waybar::modules::Clock::Clock(const std::string& id, const Json::Value& config)
-    : ALabel(config, "clock", id, "{:%H:%M}", 60), fixed_time_zone_(false) {
+    : ALabel(config, "clock", id, "{:%H:%M}", 60, false, false, true), fixed_time_zone_(false) {
-  if (config_["timezone"].isString()) {
+  if (config_["timezones"].isArray() && !config_["timezones"].empty()) {
-    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_idx_ = 0;
-    time_zone_ = date::locate_zone(config_["timezone"].asString());
+    setTimeZone(config_["timezones"][time_zone_idx_]);
-    fixed_time_zone_ = true;
+  } else {
+    setTimeZone(config_["timezone"]);
+  }
+  if (fixed_time_zone_) {
+    spdlog::warn("As using a timezone, some format args may be missing as the date library haven't got a release since 2018.");
   }
 
   if (config_["locale"].isString()) {
@@ -71,6 +76,42 @@ auto waybar::modules::Clock::update() -> void {
   ALabel::update();
 }
 
+bool waybar::modules::Clock::setTimeZone(Json::Value zone_name) {
+  if (!zone_name.isString() || zone_name.asString().empty()) {
+      fixed_time_zone_ = false;
+      return false;
+  }
+
+  time_zone_ = date::locate_zone(zone_name.asString());
+  fixed_time_zone_ = true;
+  return true;
+}
+
+bool waybar::modules::Clock::handleScroll(GdkEventScroll *e) {
+  // defer to user commands if set
+  if (config_["on-scroll-up"].isString() || config_["on-scroll-down"].isString()) {
+    return AModule::handleScroll(e);
+  }
+
+  auto dir = AModule::getScrollDir(e);
+  if (dir != SCROLL_DIR::UP && dir != SCROLL_DIR::DOWN) {
+    return true;
+  }
+  if (!config_["timezones"].isArray() || config_["timezones"].empty()) {
+    return true;
+  }
+  auto nr_zones = config_["timezones"].size();
+  if (dir == SCROLL_DIR::UP) {
+    size_t new_idx = time_zone_idx_ + 1;
+    time_zone_idx_ = new_idx == nr_zones ? 0 : new_idx;
+  } else {
+    time_zone_idx_ = time_zone_idx_ == 0 ? nr_zones - 1 : time_zone_idx_ - 1;
+  }
+  setTimeZone(config_["timezones"][time_zone_idx_]);
+  update();
+  return true;
+}
+
 auto waybar::modules::Clock::calendar_text(const waybar_time& wtime) -> std::string {
   const auto daypoint = date::floor<date::days>(wtime.ztime.get_local_time());
   const auto ymd = date::year_month_day(daypoint);
@@ -99,7 +140,12 @@ auto waybar::modules::Clock::calendar_text(const waybar_time& wtime) -> std::str
       os << '\n';
     }
     if (d == curr_day) {
+      if (config_["today-format"].isString()) {
+        auto today_format = config_["today-format"].asString();
+        os << fmt::format(today_format, date::format("%e", d));
+      } else {
         os << "<b><u>" << date::format("%e", d) << "</u></b>";
+      }
     } else {
       os << date::format("%e", d);
     }
@@ -117,12 +163,14 @@ auto waybar::modules::Clock::weekdays_header(const date::weekday& first_dow, std
   do {
     if (wd != first_dow) os << ' ';
     Glib::ustring wd_ustring(date::format(locale_, "%a", wd));
+    auto clen = ustring_clen(wd_ustring);
     auto wd_len = wd_ustring.length();
-    if (wd_len > 2) {
+    while (clen > 2) {
-      wd_ustring = wd_ustring.substr(0, 2);
+      wd_ustring = wd_ustring.substr(0, wd_len-1);
-      wd_len = 2;
+      wd_len--;
+      clen = ustring_clen(wd_ustring);
     }
-    const std::string pad(2 - wd_len, ' ');
+    const std::string pad(2 - clen, ' ');
     os << pad << wd_ustring;
   } while (++wd != first_dow);
   os << "\n";
@@ -156,6 +204,9 @@ template <>
 struct fmt::formatter<waybar_time> : fmt::formatter<std::tm> {
   template <typename FormatContext>
   auto format(const waybar_time& t, FormatContext& ctx) {
+#if FMT_VERSION >= 80000
+	auto& tm_format = specs;
+#endif
     return format_to(ctx.out(), "{}", date::format(t.locale, fmt::to_string(tm_format), t.ztime));
   }
 };

src/modules/cpu/bsd.cpp

@@ -2,8 +2,10 @@
 
 #include <sys/types.h>
 #include <sys/sysctl.h>
+#include <spdlog/spdlog.h>
 #include <cstdlib>            // malloc
 #include <unistd.h>           // sysconf
+#include <cmath>              // NAN
 
 #if defined(__NetBSD__) || defined(__OpenBSD__)
 #  include <sys/sched.h>
@@ -95,3 +97,12 @@ std::vector<std::tuple<size_t, size_t>> waybar::modules::Cpu::parseCpuinfo() {
   free(cp_time);
   return cpuinfo;
 }
+
+std::vector<float> waybar::modules::Cpu::parseCpuFrequencies() {
+  static std::vector<float> frequencies;
+  if (frequencies.empty()) {
+    spdlog::warn("cpu/bsd: parseCpuFrequencies is not implemented, expect garbage in {*_frequency}");
+    frequencies.push_back(NAN);
+  }
+  return frequencies;
+}

src/modules/cpu/common.cpp

@@ -1,5 +1,14 @@
 #include "modules/cpu.hpp"
 
+// In the 80000 version of fmt library authors decided to optimize imports
+// and moved declarations required for fmt::dynamic_format_arg_store in new
+// header fmt/args.h
+#if (FMT_VERSION >= 80000)
+#include <fmt/args.h>
+#else
+#include <fmt/core.h>
+#endif
+
 waybar::modules::Cpu::Cpu(const std::string& id, const Json::Value& config)
     : ALabel(config, "cpu", id, "{usage}%", 10) {
   thread_ = [this] {
@@ -12,31 +21,60 @@ auto waybar::modules::Cpu::update() -> void {
   // TODO: as creating dynamic fmt::arg arrays is buggy we have to calc both
   auto cpu_load = getCpuLoad();
   auto [cpu_usage, tooltip] = getCpuUsage();
+  auto [max_frequency, min_frequency, avg_frequency] = getCpuFrequency();
   if (tooltipEnabled()) {
     label_.set_tooltip_text(tooltip);
   }
-  label_.set_markup(fmt::format(format_, fmt::arg("load", cpu_load), fmt::arg("usage", cpu_usage)));
+  auto format = format_;
-  getState(cpu_usage);
+  auto total_usage = cpu_usage.empty() ? 0 : cpu_usage[0];
+  auto state = getState(total_usage);
+  if (!state.empty() && config_["format-" + state].isString()) {
+    format = config_["format-" + state].asString();
+  }
+
+  if (format.empty()) {
+    event_box_.hide();
+  } else {
+    event_box_.show();
+    auto icons = std::vector<std::string>{state};
+    fmt::dynamic_format_arg_store<fmt::format_context> store;
+    store.push_back(fmt::arg("load", cpu_load));
+    store.push_back(fmt::arg("load", cpu_load));
+    store.push_back(fmt::arg("usage", total_usage));
+    store.push_back(fmt::arg("icon", getIcon(total_usage, icons)));
+    store.push_back(fmt::arg("max_frequency", max_frequency));
+    store.push_back(fmt::arg("min_frequency", min_frequency));
+    store.push_back(fmt::arg("avg_frequency", avg_frequency));
+    for (size_t i = 1; i < cpu_usage.size(); ++i) {
+	    auto core_i = i - 1;
+	    auto core_format = fmt::format("usage{}", core_i);
+	    store.push_back(fmt::arg(core_format.c_str(), cpu_usage[i]));
+	    auto icon_format = fmt::format("icon{}", core_i);
+	    store.push_back(fmt::arg(icon_format.c_str(), getIcon(cpu_usage[i], icons)));
+    }
+    label_.set_markup(fmt::vformat(format, store));
+  }
+
   // Call parent update
   ALabel::update();
 }
 
-uint16_t waybar::modules::Cpu::getCpuLoad() {
+double waybar::modules::Cpu::getCpuLoad() {
   double load[1];
   if (getloadavg(load, 1) != -1) {
-    return load[0] * 100 / sysconf(_SC_NPROCESSORS_ONLN);
+    return load[0];
   }
   throw std::runtime_error("Can't get Cpu load");
 }
 
-std::tuple<uint16_t, std::string> waybar::modules::Cpu::getCpuUsage() {
+std::tuple<std::vector<uint16_t>, std::string> waybar::modules::Cpu::getCpuUsage() {
   if (prev_times_.empty()) {
     prev_times_ = parseCpuinfo();
     std::this_thread::sleep_for(std::chrono::milliseconds(100));
   }
   std::vector<std::tuple<size_t, size_t>> curr_times = parseCpuinfo();
   std::string                             tooltip;
-  uint16_t                                usage = 0;
+  std::vector<uint16_t>                   usage;
   for (size_t i = 0; i < curr_times.size(); ++i) {
     auto [curr_idle, curr_total] = curr_times[i];
     auto [prev_idle, prev_total] = prev_times_[i];
@@ -44,12 +82,25 @@ std::tuple<uint16_t, std::string> waybar::modules::Cpu::getCpuUsage() {
     const float delta_total = curr_total - prev_total;
     uint16_t    tmp = 100 * (1 - delta_idle / delta_total);
     if (i == 0) {
-      usage = tmp;
       tooltip = fmt::format("Total: {}%", tmp);
     } else {
       tooltip = tooltip + fmt::format("\nCore{}: {}%", i - 1, tmp);
     }
+    usage.push_back(tmp);
   }
   prev_times_ = curr_times;
   return {usage, tooltip};
 }
+
+std::tuple<float, float, float> waybar::modules::Cpu::getCpuFrequency() {
+  std::vector<float> frequencies = parseCpuFrequencies();
+  auto [min, max] = std::minmax_element(std::begin(frequencies), std::end(frequencies));
+  float avg_frequency = std::accumulate(std::begin(frequencies), std::end(frequencies), 0.0) / frequencies.size();
+
+  // Round frequencies with double decimal precision to get GHz
+  float max_frequency = std::ceil(*max / 10.0) / 100.0;
+  float min_frequency = std::ceil(*min / 10.0) / 100.0;
+  avg_frequency = std::ceil(avg_frequency / 10.0) / 100.0;
+
+  return { max_frequency, min_frequency, avg_frequency };
+}

src/modules/cpu/linux.cpp

@@ -1,3 +1,4 @@
+#include <filesystem>
 #include "modules/cpu.hpp"
 
 std::vector<std::tuple<size_t, size_t>> waybar::modules::Cpu::parseCpuinfo() {
@@ -27,3 +28,50 @@ std::vector<std::tuple<size_t, size_t>> waybar::modules::Cpu::parseCpuinfo() {
   }
   return cpuinfo;
 }
+
+std::vector<float> waybar::modules::Cpu::parseCpuFrequencies() {
+  const std::string file_path_ = "/proc/cpuinfo";
+  std::ifstream info(file_path_);
+  if (!info.is_open()) {
+    throw std::runtime_error("Can't open " + file_path_);
+  }
+  std::vector<float> frequencies;
+  std::string line;
+  while (getline(info, line)) {
+    if (line.substr(0, 7).compare("cpu MHz") != 0) {
+      continue;
+    }
+
+    std::string frequency_str = line.substr(line.find(":") + 2);
+    float frequency = std::strtol(frequency_str.c_str(), nullptr, 10);
+    frequencies.push_back(frequency);
+  }
+  info.close();
+
+  if (frequencies.size() <= 0) {
+    std::string cpufreq_dir = "/sys/devices/system/cpu/cpufreq";
+    if (std::filesystem::exists(cpufreq_dir)) {
+      std::vector<std::string> frequency_files = {
+        "/cpuinfo_min_freq",
+        "/cpuinfo_max_freq"
+      };
+      for (auto& p: std::filesystem::directory_iterator(cpufreq_dir)) {
+        for (auto freq_file: frequency_files) {
+          std::string freq_file_path = p.path().string() + freq_file;
+          if (std::filesystem::exists(freq_file_path)) {
+            std::string freq_value;
+            std::ifstream freq(freq_file_path);
+            if (freq.is_open()) {
+              getline(freq, freq_value);
+              float frequency = std::strtol(freq_value.c_str(), nullptr, 10);
+              frequencies.push_back(frequency / 1000);
+              freq.close();
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return frequencies;
+}

src/modules/custom.cpp

@@ -50,7 +50,6 @@ void waybar::modules::Custom::continuousWorker() {
   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_) {
@@ -63,8 +62,8 @@ void waybar::modules::Custom::continuousWorker() {
         spdlog::error("{} stopped unexpectedly, is it endless?", name_);
       }
       if (config_["restart-interval"].isUInt()) {
-        restart = true;
         pid_ = -1;
+        thread_.sleep_for(std::chrono::seconds(config_["restart-interval"].asUInt()));
         fp_ = util::command::open(cmd, pid_);
         if (!fp_) {
           throw std::runtime_error("Unable to open " + cmd);
@@ -83,9 +82,6 @@ void waybar::modules::Custom::continuousWorker() {
       output_ = {0, output};
       dp.emit();
     }
-    if (restart) {
-      thread_.sleep_for(std::chrono::seconds(config_["restart-interval"].asUInt()));
-    }
   };
 }
 
@@ -95,15 +91,21 @@ void waybar::modules::Custom::refresh(int sig) {
   }
 }
 
+void waybar::modules::Custom::handleEvent() {
+  if (!config_["exec-on-event"].isBool() || config_["exec-on-event"].asBool()) {
+    thread_.wake_up();
+  }
+}
+
 bool waybar::modules::Custom::handleScroll(GdkEventScroll* e) {
   auto ret = ALabel::handleScroll(e);
-  thread_.wake_up();
+  handleEvent();
   return ret;
 }
 
 bool waybar::modules::Custom::handleToggle(GdkEventButton* const& e) {
   auto ret = ALabel::handleToggle(e);
-  thread_.wake_up();
+  handleEvent();
   return ret;
 }
 
@@ -129,9 +131,13 @@ auto waybar::modules::Custom::update() -> void {
       label_.set_markup(str);
       if (tooltipEnabled()) {
         if (text_ == tooltip_) {
-          label_.set_tooltip_text(str);
+          if (label_.get_tooltip_markup() != str) {
+            label_.set_tooltip_markup(str);
+          }
         } else {
-          label_.set_tooltip_text(tooltip_);
+          if (label_.get_tooltip_markup() != tooltip_) {
+            label_.set_tooltip_markup(tooltip_);
+          }
         }
       }
       auto classes = label_.get_style_context()->list_classes();