chore: v0.9.9

resources: don't break tray icon checkboxes via CSS

.github/workflows/freebsd.yml

@@ -0,0 +1,28 @@
+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:
+        mem: 2048
+        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,36 +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 pkg install -y gtk-layer-shell gtkmm30 jsoncpp libdbusmenu
-               libfmt libmpdclient libudev-devd meson pulseaudio scdoc spdlog
-      script:
-        - meson build -Dman-pages=enabled
-        - ninja -C build

Dockerfiles/alpine

@@ -2,4 +2,4 @@
 
 FROM alpine:latest
 
-RUN apk add --no-cache git meson alpine-sdk libinput-dev wayland-dev wayland-protocols mesa-dev libxkbcommon-dev eudev-dev pixman-dev gtkmm3-dev jsoncpp-dev 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 tzdata

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 gobject-introspection --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 libgirepository1.0-dev && \
+    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 && \
-    dnf group install "C Development Tools and Libraries" -y && \
+RUN dnf install -y @c-development git-core meson scdoc 'pkgconfig(date)' \
+    '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,8 +1,8 @@
-# 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>
+[AUR](https://aur.archlinux.org/packages/waybar-git/), [Gentoo](https://packages.gentoo.org/packages/gui-apps/waybar), [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
@@ -67,6 +67,9 @@ libnl [Network module]
 libappindicator-gtk3 [Tray module]
 libdbusmenu-gtk3 [Tray module]
 libmpdclient [MPD module]
+libsndio [sndio module]
+libevdev [KeyboardState module]
+xkbregistry
 ```
 
 **Build dependencies**
@@ -85,6 +88,7 @@ sudo apt install \
   clang-tidy \
   gobject-introspection \
   libdbusmenu-gtk3-dev \
+  libevdev-dev \
   libfmt-dev \
   libgirepository1.0-dev \
   libgtk-3-dev \
@@ -98,7 +102,8 @@ sudo apt install \
   libsigc++-2.0-dev \
   libspdlog-dev \
   libwayland-dev \
-  scdoc
+  scdoc \
+  libxkbregistry-dev
 ```
 
 

include/ALabel.hpp

@@ -14,12 +14,11 @@ class ALabel : public AModule {
   virtual ~ALabel() = default;
   virtual auto        update() -> void;
   virtual std::string getIcon(uint16_t, const std::string &alt = "", uint16_t max = 0);
-  virtual std::string getIcon(uint16_t, std::vector<std::string> &alts, uint16_t max = 0);
+  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/bar.hpp

@@ -7,9 +7,11 @@
 #include <gtkmm/main.h>
 #include <gtkmm/window.h>
 #include <json/json.h>
+
+#include <memory>
+#include <vector>
+
 #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,77 +20,106 @@ 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;
+};
+
+struct bar_mode {
+  bar_layer layer;
+  bool      exclusive;
+  bool      passthrough;
+  bool      visible;
+};
+
+#ifdef HAVE_SWAY
+namespace modules::sway {
+class BarIpcClient;
+}
+#endif  // HAVE_SWAY
+
+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:
+  using bar_mode_map = std::map<std::string_view, struct bar_mode>;
+  static const bar_mode_map     PRESET_MODES;
+  static const std::string_view MODE_DEFAULT;
+  static const std::string_view MODE_INVISIBLE;
+
   Bar(struct waybar_output *w_output, const Json::Value &);
   Bar(const Bar &) = delete;
-  ~Bar() = default;
+  ~Bar();
 
-  auto toggle() -> void;
+  void setMode(const std::string_view &);
+  void setVisible(bool visible);
+  void toggle();
   void handleSignal(int);
 
   struct waybar_output *output;
   Json::Value           config;
-  struct wl_surface *   surface;
+  struct wl_surface    *surface;
   bool                  visible = true;
   bool                  vertical = false;
   Gtk::Window           window;
 
- private:
-  static constexpr const char *MIN_HEIGHT_MSG =
-      "Requested height: {} exceeds the minimum height: {} required by the modules";
-  static constexpr const char *MIN_WIDTH_MSG =
-      "Requested width: {} exceeds the minimum width: {} required by the modules";
-  static constexpr const char *BAR_SIZE_MSG =
-      "Bar configured (width: {}, height: {}) for output: {}";
-  static constexpr const char *SIZE_DEFINED =
-      "{} size is defined in the config file so it will stay like that";
-  static void layerSurfaceHandleConfigure(void *, struct zwlr_layer_surface_v1 *, uint32_t,
-                                          uint32_t, uint32_t);
-  static void layerSurfaceHandleClosed(void *, struct zwlr_layer_surface_v1 *);
-
-#ifdef HAVE_GTK_LAYER_SHELL
-  /* gtk-layer-shell code */
-  void initGtkLayerShell();
-  void onConfigureGLS(GdkEventConfigure *ev);
-  void onMapGLS(GdkEventAny *ev);
+#ifdef HAVE_SWAY
+  std::string bar_id;
 #endif
-  /* fallback layer-surface code */
-  void onConfigure(GdkEventConfigure *ev);
-  void onRealize();
-  void onMap(GdkEventAny *ev);
-  void setSurfaceSize(uint32_t width, uint32_t height);
-  /* common code */
-  void setExclusiveZone(uint32_t width, uint32_t height);
+
+ private:
+  void onMap(GdkEventAny *);
   auto setupWidgets() -> void;
-  void getModules(const Factory &, const std::string &);
+  void getModules(const Factory &, const std::string &, Gtk::Box*);
   void setupAltFormatKeyForModule(const std::string &module_name);
   void setupAltFormatKeyForModuleList(const char *module_list_name);
+  void setMode(const bar_mode &);
 
-  struct margins {
-    int top = 0;
-    int right = 0;
-    int bottom = 0;
-    int left = 0;
-  } margins_;
-  struct zwlr_layer_surface_v1 *layer_surface_;
-  // use gtk-layer-shell instead of handling layer surfaces directly
-  bool                                          use_gls_ = false;
-  uint32_t                                      width_ = 0;
-  uint32_t                                      height_ = 1;
-  uint8_t                                       anchor_;
+  /* Copy initial set of modes to allow customization */
+  bar_mode_map configured_modes = PRESET_MODES;
+  std::string  last_mode_{MODE_DEFAULT};
+
+  std::unique_ptr<BarSurface>                   surface_impl_;
   Gtk::Box                                      left_;
   Gtk::Box                                      center_;
   Gtk::Box                                      right_;
   Gtk::Box                                      box_;
-  std::vector<std::unique_ptr<waybar::AModule>> modules_left_;
-  std::vector<std::unique_ptr<waybar::AModule>> modules_center_;
-  std::vector<std::unique_ptr<waybar::AModule>> modules_right_;
+  std::vector<std::shared_ptr<waybar::AModule>> modules_left_;
+  std::vector<std::shared_ptr<waybar::AModule>> modules_center_;
+  std::vector<std::shared_ptr<waybar::AModule>> modules_right_;
+#ifdef HAVE_SWAY
+  using BarIpcClient = modules::sway::BarIpcClient;
+  std::unique_ptr<BarIpcClient> _ipc_client;
+#endif
+  std::vector<std::shared_ptr<waybar::AModule>> modules_all_;
 };
 
 }  // namespace waybar

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,28 @@ 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;
+  std::string                         bar_id;
 
  private:
   Client() = default;
-  std::tuple<const std::string, const std::string> getConfigs(const std::string &config,
-                                                              const std::string &style) const;
-  void                                             bindInterfaces();
-  const std::string getValidPath(const std::vector<std::string> &paths) const;
-  void              handleOutput(struct waybar_output &output);
-  bool isValidOutput(const Json::Value &config, struct waybar_output &output);
-  auto setupConfig(const std::string &config_file) -> void;
-  auto setupCss(const std::string &css_file) -> void;
-  struct waybar_output &getOutput(void *);
+  const std::string        getStyle(const std::string &style);
+  void                     bindInterfaces();
+  void                     handleOutput(struct waybar_output &output);
+  auto                     setupCss(const std::string &css_file) -> void;
+  struct waybar_output &   getOutput(void *);
   std::vector<Json::Value> getOutputConfigs(struct waybar_output &output);
 
   static void handleGlobal(void *data, struct wl_registry *registry, uint32_t name,
                            const char *interface, uint32_t version);
   static void handleGlobalRemove(void *data, struct wl_registry *registry, uint32_t name);
+  static void 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,14 +1,20 @@
 #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"
@@ -33,11 +39,20 @@
 #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
+#ifdef HAVE_GIO_UNIX
+#include "modules/inhibitor.hpp"
 #endif
 #include "bar.hpp"
 #include "modules/custom.hpp"

include/group.hpp

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <gtkmm/widget.h>
+#include <gtkmm/box.h>
+#include <json/json.h>
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "factory.hpp"
+
+namespace waybar {
+
+class Group : public AModule {
+ public:
+  Group(const std::string&, const Bar&, const Json::Value&);
+  ~Group() = default;
+  auto update() -> void;
+  operator Gtk::Widget &();
+  Gtk::Box box;
+};
+
+}  // 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                                          worker();
-  const std::string                             getAdapterStatus(uint8_t capacity) const;
-  const std::tuple<uint8_t, float, std::string> getInfos() const;
-  const std::string                             formatTimeRemaining(float hoursRemaining);
+  void                                                 refreshBatteries();
+  void                                                 worker();
+  const std::string                                    getAdapterStatus(uint8_t capacity) 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_;
-  std::vector<int>      wds_;
+  int                   battery_watch_fd_;
+  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

@@ -1,21 +1,16 @@
 #pragma once
 
-#include <fmt/format.h>
-#if FMT_VERSION < 60000
-#include <fmt/time.h>
-#else
-#include <fmt/chrono.h>
-#endif
 #include <date/tz.h>
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 
-namespace waybar::modules {
+namespace waybar {
 
-struct waybar_time {
-  std::locale locale;
-  date::zoned_seconds ztime;
-};
+struct waybar_time;
+
+namespace modules {
+
+const std::string kCalendarPlaceholder = "calendar";
 
 class Clock : public ALabel {
  public:
@@ -26,17 +21,20 @@ class Clock : public ALabel {
  private:
   util::SleeperThread thread_;
   std::locale locale_;
-  const date::time_zone* time_zone_;
-  bool fixed_time_zone_;
-  int time_zone_idx_;
-  date::year_month_day cached_calendar_ymd_;
+  std::vector<const date::time_zone*> time_zones_;
+  int current_time_zone_idx_;
+  date::year_month_day cached_calendar_ymd_ = date::January/1/0;
   std::string cached_calendar_text_;
+  bool is_calendar_in_tooltip_;
 
   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;
+  const date::time_zone* current_timezone();
+  bool is_timezone_fixed();
 };
 
-}  // namespace waybar::modules
+}  // namespace modules
+}  // namespace waybar

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();
-  std::tuple<uint16_t, std::string>       getCpuUsage();
-  std::vector<std::tuple<size_t, size_t>> parseCpuinfo();
+  double                                         getCpuLoad();
+  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/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/inhibitor.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <memory>
+
+#include <gio/gio.h>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+
+namespace waybar::modules {
+
+class Inhibitor : public ALabel {
+ public:
+  Inhibitor(const std::string&, const waybar::Bar&, const Json::Value&);
+  ~Inhibitor() override;
+  auto update() -> void;
+  auto activated() -> bool;
+
+ private:
+  auto handleToggle(::GdkEventButton* const& e) -> bool;
+
+  const std::unique_ptr<::GDBusConnection, void(*)(::GDBusConnection*)> dbus_;
+  const std::string inhibitors_;
+  int handle_ = -1;
+};
+
+} // namespace waybar::modules

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,9 +2,7 @@
 
 #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>
@@ -28,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);
-  int               getPreferredIface(int skip_idx = -1, bool wait = true) const;
+  bool              checkInterface(std::string name);
   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_;
@@ -59,24 +55,31 @@ 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_;
+  std::string signal_strength_app_;
+  float       frequency_;
+  uint32_t    route_priority;
 
   util::SleeperThread thread_;
   util::SleeperThread thread_timer_;
 #ifdef WANT_RFKILL
-  util::SleeperThread thread_rfkill_;
-
   util::Rfkill rfkill_;
 #endif
 };

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

@@ -6,6 +6,7 @@
 #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 {
@@ -18,8 +19,14 @@ class Tags : public waybar::AModule {
   // 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_;

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/bar.hpp

@@ -0,0 +1,49 @@
+#pragma once
+#include <string>
+
+#include "modules/sway/ipc/client.hpp"
+#include "util/SafeSignal.hpp"
+#include "util/json.hpp"
+
+namespace waybar {
+
+class Bar;
+
+namespace modules::sway {
+
+/*
+ * Supported subset of i3/sway IPC barconfig object
+ */
+struct swaybar_config {
+  std::string id;
+  std::string mode;
+  std::string hidden_state;
+};
+
+/**
+ * swaybar IPC client
+ */
+class BarIpcClient {
+ public:
+  BarIpcClient(waybar::Bar& bar);
+
+ private:
+  void onInitialConfig(const struct Ipc::ipc_response& res);
+  void onIpcEvent(const struct Ipc::ipc_response&);
+  void onConfigUpdate(const swaybar_config& config);
+  void onVisibilityUpdate(bool visible_by_modifier);
+  void update();
+
+  Bar&             bar_;
+  util::JsonParser parser_;
+  Ipc              ipc_;
+
+  swaybar_config bar_config_;
+  bool           visible_by_modifier_ = false;
+
+  SafeSignal<bool>           signal_visible_;
+  SafeSignal<swaybar_config> signal_config_;
+};
+
+}  // namespace modules::sway
+}  // namespace waybar

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,70 @@
+#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;
+    std::string country_flag() const;
+  };
+
+  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,7 +20,7 @@ class Workspaces : public AModule, public sigc::trackable {
   auto update() -> void;
 
  private:
-  static inline const std::string workspace_switch_cmd_ = "workspace --no-auto-back-and-forth \"{}\"";
+  static inline const std::string workspace_switch_cmd_ = "workspace {} \"{}\"";
 
   static int convertWorkspaceNameToNum(std::string name);
 

include/modules/wlr/taskbar.hpp

@@ -3,11 +3,14 @@
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "client.hpp"
+#include "giomm/desktopappinfo.h"
 #include "util/json.hpp"
 
 #include <memory>
 #include <string>
 #include <vector>
+#include <map>
+#include <unordered_set>
 
 #include <gdk/gdk.h>
 
@@ -60,21 +63,28 @@ class Task
     Gtk::Image icon_;
     Gtk::Label text_before_;
     Gtk::Label text_after_;
-    bool button_visible_;
+    Glib::RefPtr<Gio::DesktopAppInfo> app_info_;
+    bool button_visible_ = false;
+    bool ignored_ = false;
 
-    bool with_icon_;
+    bool with_icon_ = false;
+    bool with_name_ = false;
     std::string format_before_;
     std::string format_after_;
 
     std::string format_tooltip_;
 
+    std::string name_;
     std::string title_;
     std::string app_id_;
-    uint32_t state_;
+    uint32_t state_ = 0;
 
    private:
     std::string repr() const;
     std::string state_string(bool = false) const;
+    void set_app_info_from_app_id_list(const std::string& app_id_list);
+    bool image_load_icon(Gtk::Image& image, const Glib::RefPtr<Gtk::IconTheme>& icon_theme, Glib::RefPtr<Gio::DesktopAppInfo> app_info, int size);
+    void hide_if_ignored();
 
    public:
     /* Getter functions */
@@ -132,6 +142,8 @@ class Taskbar : public waybar::AModule
     std::vector<TaskPtr> tasks_;
 
     std::vector<Glib::RefPtr<Gtk::IconTheme>> icon_themes_;
+    std::unordered_set<std::string> ignore_list_;
+    std::map<std::string, std::string> app_ids_replace_map_;
 
     struct zwlr_foreign_toplevel_manager_v1 *manager_;
     struct wl_seat *seat_;
@@ -154,7 +166,9 @@ class Taskbar : public waybar::AModule
     bool show_output(struct wl_output *) const;
     bool all_outputs() const;
 
-    std::vector<Glib::RefPtr<Gtk::IconTheme>> icon_themes() const;
+    const std::vector<Glib::RefPtr<Gtk::IconTheme>>& icon_themes() const;
+    const std::unordered_set<std::string>& ignore_list() const;
+    const std::map<std::string, std::string>& app_ids_replace_map() 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/SafeSignal.hpp

@@ -0,0 +1,75 @@
+#pragma once
+
+#include <glibmm/dispatcher.h>
+#include <sigc++/signal.h>
+
+#include <functional>
+#include <mutex>
+#include <queue>
+#include <thread>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+namespace waybar {
+
+/**
+ * Thread-safe signal wrapper.
+ * Uses Glib::Dispatcher to pass events to another thread and locked queue to pass the arguments.
+ */
+template <typename... Args>
+struct SafeSignal : sigc::signal<void(std::decay_t<Args>...)> {
+ public:
+  SafeSignal() { dp_.connect(sigc::mem_fun(*this, &SafeSignal::handle_event)); }
+
+  template <typename... EmitArgs>
+  void emit(EmitArgs&&... args) {
+    if (main_tid_ == std::this_thread::get_id()) {
+      /*
+       * Bypass the queue if the method is called the main thread.
+       * Ensures that events emitted from the main thread are processed synchronously and saves a
+       * few CPU cycles on locking/queuing.
+       * As a downside, this makes main thread events prioritized over the other threads and
+       * disrupts chronological order.
+       */
+      signal_t::emit(std::forward<EmitArgs>(args)...);
+    } else {
+      {
+        std::unique_lock lock(mutex_);
+        queue_.emplace(std::forward<EmitArgs>(args)...);
+      }
+      dp_.emit();
+    }
+  }
+
+  template <typename... EmitArgs>
+  inline void operator()(EmitArgs&&... args) {
+    emit(std::forward<EmitArgs>(args)...);
+  }
+
+ protected:
+  using signal_t = sigc::signal<void(std::decay_t<Args>...)>;
+  using slot_t = decltype(std::declval<signal_t>().make_slot());
+  using arg_tuple_t = std::tuple<std::decay_t<Args>...>;
+  // ensure that unwrapped methods are not accessible
+  using signal_t::emit_reverse;
+  using signal_t::make_slot;
+
+  void handle_event() {
+    for (std::unique_lock lock(mutex_); !queue_.empty(); lock.lock()) {
+      auto args = queue_.front();
+      queue_.pop();
+      lock.unlock();
+      std::apply(cached_fn_, args);
+    }
+  }
+
+  Glib::Dispatcher        dp_;
+  std::mutex              mutex_;
+  std::queue<arg_tuple_t> queue_;
+  const std::thread::id   main_tid_ = std::this_thread::get_id();
+  // cache functor for signal emission to avoid recreating it on each event
+  const slot_t cached_fn_ = make_slot();
+};
+
+}  // namespace waybar

include/util/command.hpp

@@ -5,6 +5,13 @@
 #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;
@@ -77,6 +84,18 @@ inline FILE* open(const std::string& cmd, int& pid) {
     // 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);

include/util/format.hpp

@@ -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:
   Rfkill(enum rfkill_type rfkill_type);
-  ~Rfkill() = default;
-  void waitForEvent();
+  ~Rfkill();
   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;
@@ -33,14 +47,16 @@ class SleeperThread {
   bool isRunning() const { return do_run_; }
 
   auto sleep_for(std::chrono::system_clock::duration dur) {
-    std::unique_lock lk(mutex_);
+    std::unique_lock  lk(mutex_);
+    CancellationGuard cancel_lock;
     return condvar_.wait_for(lk, dur, [this] { return signal_ || !do_run_; });
   }
 
   auto sleep_until(
       std::chrono::time_point<std::chrono::system_clock, std::chrono::system_clock::duration>
           time_point) {
-    std::unique_lock lk(mutex_);
+    std::unique_lock  lk(mutex_);
+    CancellationGuard cancel_lock;
     return condvar_.wait_until(lk, time_point, [this] { return signal_ || !do_run_; });
   }
 

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);

include/util/waybar_time.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <date/tz.h>
+#include <fmt/format.h>
+
+namespace waybar {
+
+struct waybar_time {
+  std::locale         locale;
+  date::zoned_seconds ztime;
+};
+
+}  // namespace waybar
+
+template <>
+struct fmt::formatter<waybar::waybar_time> {
+  std::string_view specs;
+
+  template <typename ParseContext>
+  constexpr auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
+    auto it = ctx.begin();
+    if (it != ctx.end() && *it == ':') {
+      ++it;
+    }
+    auto end = it;
+    while (end != ctx.end() && *end != '}') {
+      ++end;
+    }
+    if (end != it) {
+      specs = {it, std::string_view::size_type(end - it)};
+    }
+    return end;
+  }
+
+  template <typename FormatContext>
+  auto format(const waybar::waybar_time& t, FormatContext& ctx) {
+    return format_to(ctx.out(), "{}", date::format(t.locale, fmt::to_string(specs), t.ztime));
+  }
+};

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, useful 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,7 +24,8 @@ 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 ++
@@ -45,6 +46,14 @@ The *clock* module displays the current date and time.
 	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

@@ -67,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-inhibitor.5.scd

@@ -0,0 +1,92 @@
+waybar-inhibitor(5)
+
+# NAME
+
+waybar - inhibitor module
+
+# DESCRIPTION
+
+The *inhibitor* module allows to take an inhibitor lock that logind provides.
+See *systemd-inhibit*(1) for more information.
+
+# CONFIGURATION
+
+*what*: ++
+	typeof: string or array ++
+	The inhibitor lock or locks that should be taken when active. The available inhibitor locks are *idle*, *shutdown*, *sleep*, *handle-power-key*, *handle-suspend-key*, *handle-hibernate-key* and *handle-lid-switch*.
+
+*format*: ++
+	typeof: string ++
+	The format, how the state should be displayed.
+
+*format-icons*: ++
+	typeof: array ++
+	Based on the current state, the corresponding icon gets selected.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in character the module should display.
+
+*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
+
+*on-click-middle*: ++
+	typeof: string ++
+	Command to execute when middle-clicked on the module using mousewheel.
+
+*on-click-right*: ++
+	typeof: string ++
+	Command to execute when you right clicked on the module.
+
+*on-update*: ++
+	typeof: string ++
+	Command to execute when the module is updated.
+
+*on-scroll-up*: ++
+	typeof: string ++
+	Command to execute when scrolling up on the module.
+
+*on-scroll-down*: ++
+	typeof: string ++
+	Command to execute when scrolling down on the module.
+
+*smooth-scrolling-threshold*: ++
+	typeof: double ++
+	Threshold to be used when scrolling.
+
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
+
+# FORMAT REPLACEMENTS
+
+*{status}*: status (*activated* or *deactivated*)
+
+*{icon}*: Icon, as defined in *format-icons*
+
+# EXAMPLES
+
+```
+"inhibitor": {
+	"what": "handle-lid-switch",
+	"format": "{icon}",
+	"format-icons": {
+	    "activated": "",
+	    "deactivated": ""
+	}
+}
+```

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,6 +172,8 @@ 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)

man/waybar-network.5.scd

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

@@ -15,7 +15,16 @@ Addressed by *river/tags*
 *num-tags*: ++
     typeof: uint ++
     default: 9 ++
-    The number of tags that should be displayed.
+    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
 
@@ -30,8 +39,10 @@ Addressed by *river/tags*
 - *#tags button*
 - *#tags button.occupied*
 - *#tags button.focused*
+- *#tags button.urgent*
 
-Note that a tag can be both occupied and focused at the same time.
+Note that occupied/focused/urgent status may overlap. That is, a tag may be
+both occupied and focused at the same time.
 
 # SEE ALSO
 

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,56 @@
+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").
+
+*{flag}*: Country flag of layout.
+
+# 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

@@ -66,12 +66,12 @@ Addressed by *sway/workspaces*
     Lists workspaces that should always be shown, even when non existent
 
 *on-update*: ++
-	typeof: string ++
-	Command to execute when the module is updated.
+    typeof: string ++
+    Command to execute when the module is updated.
 
-*numeric-first*: ++
-	typeof: bool ++
-	Whether to put workspaces starting with numbers before workspaces that do not start with a number.
+*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
 
@@ -116,7 +116,6 @@ n.b.: the list of outputs can be obtained from command line using *swaymsg -t ge
 "sway/workspaces": {
     "disable-scroll": true,
     "all-outputs": true,
-    "numeric-first": false,
     "format": "{name}: {icon}",
     "format-icons": {
         "1": "",

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

@@ -68,10 +68,20 @@ Addressed by *wlr/taskbar*
 	typeof: string ++
 	Command to execute when the module is updated.
 
+*ignore-list*: ++
+	typeof: array ++
+	List of app_id/titles to be invisible.
+
+*app_ids-mapping*: ++
+	typeof: object ++
+	Dictionary of app_id to be replaced with
+
 # FORMAT REPLACEMENTS
 
 *{icon}*: The icon of the application.
 
+*{title}*: The application name as in desktop file if appropriate desktop fils found, otherwise same as {app_id}
+
 *{title}*: The title of the application.
 
 *{app_id}*: The app_id (== application name) of the application.
@@ -83,9 +93,10 @@ Addressed by *wlr/taskbar*
 # CLICK ACTIONS
 
 *activate*: Bring the application into foreground.
-*minimize*: Minimize the application.
-*maximize*: Maximize the application.
-*fullscreen*: Set the application to fullscreen.
+*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
@@ -97,7 +108,13 @@ Addressed by *wlr/taskbar*
 	"icon-theme": "Numix-Circle",
 	"tooltip-format": "{title}",
 	"on-click": "activate",
-	"on-click-middle": "close"
+	"on-click-middle": "close",
+	"ignore-list": [
+	    "Alacritty"
+	],
+	"app_ids-mapping": {
+		"firefoxdeveloperedition": "firefox-developer-edition"
+	}
 }
 ```
 

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,58 @@ 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.
 
+*mode* ++
+	typeof: string ++
+	Selects one of the preconfigured display modes. This is an equivalent of the sway-bar(5) *mode* command and supports the same values: *dock*, *hide*, *invisible*, *overlay*. ++
+	Note: *hide* and *invisible* modes may be not as useful without Sway IPC.
+
+*exclusive* ++
+	typeof: bool ++
+	default: *true* ++
+	Option to request an exclusive zone from the compositor. Disable this to allow drawing application windows underneath or on top of the bar.
+
+*fixed-center* ++
+	typeof: bool ++
+	default: *true*
+	Prefer fixed center position for the `modules-center` block. The center block will stay in the middle of the bar whenever possible. It can still be pushed around if other blocks need more space.
+	When false, the center block is centered in the space between the left and right block.
+
+*passthrough* ++
+	typeof: bool ++
+	default: *false* ++
+	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.
 
+*ipc* ++
+	typeof: bool ++
+	default: false ++
+	Option to subscribe to the Sway IPC bar configuration and visibility events and control waybar with *swaymsg bar* commands. ++
+	Requires *bar_id* value from sway configuration to be either passed with the *-b* commandline argument or specified with the *id* option.
+
+*id* ++
+	typeof: string ++
+	*bar_id* for the Sway IPC. Use this if you need to override the value passed with the *-b bar_id* commandline argument for the specific bar instance.
+
+*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).
@@ -181,6 +224,28 @@ When positioning Waybar on the left or right side of the screen, sometimes it's
 
 Valid options for the "rotate" property are: 0, 90, 180 and 270.
 
+## Grouping modules
+
+Module groups allow stacking modules in the direction orthogonal to the bar direction. When the bar is positioned on the top or bottom of the screen, modules in a group are stacked vertically. Likewise, when positioned on the left or right, modules in a group are stacked horizontally.
+
+A module group is defined by specifying a module named "group/some-group-name". The group must also be configured with a list of contained modules. Example:
+
+```
+{
+	"modules-right": ["group/hardware", "clock"],
+
+	"group/hardware": {
+		"modules": [
+			"cpu",
+			"memory",
+			"battery"
+		]
+	},
+
+	...
+}
+```
+
 # SUPPORTED MODULES
 
 - *waybar-backlight(5)*
@@ -191,6 +256,7 @@ Valid options for the "rotate" property are: 0, 90, 180 and 270.
 - *waybar-custom(5)*
 - *waybar-disk(5)*
 - *waybar-idle-inhibitor(5)*
+- *waybar-keyboard-state(5)*
 - *waybar-memory(5)*
 - *waybar-mpd(5)*
 - *waybar-network(5)*
@@ -201,5 +267,6 @@ Valid options for the "rotate" property are: 0, 90, 180 and 270.
 - *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.4',
+    version: '0.9.9',
     license: 'MIT',
+    meson_version: '>= 0.49.0',
     default_options : [
         'cpp_std=c++17',
         'buildtype=release',
@@ -78,14 +79,14 @@ is_netbsd = host_machine.system() == 'netbsd'
 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'])
+fmt = dependency('fmt', version : ['>=7.0.0'], fallback : ['fmt', 'fmt_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')
 gtkmm = dependency('gtkmm-3.0', version : ['>=3.22.0'])
 dbusmenu_gtk = dependency('dbusmenu-gtk3-0.4', required: get_option('dbusmenu-gtk'))
-giounix = dependency('gio-unix-2.0', required: get_option('dbusmenu-gtk'))
+giounix = dependency('gio-unix-2.0', required: (get_option('dbusmenu-gtk').enabled() or get_option('logind').enabled()))
 jsoncpp = dependency('jsoncpp')
 sigcpp = dependency('sigc++-2.0')
 libepoll = dependency('epoll-shim', required: false)
@@ -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' ], modules : [ 'date::date', 'date::date-tz' ], 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,9 @@ src_files = files(
     'src/main.cpp',
     'src/bar.cpp',
     'src/client.cpp',
+    'src/config.cpp',
+    'src/group.cpp',
+    'src/util/ustring_clen.cpp'
 )
 
 if is_linux
@@ -156,7 +178,9 @@ endif
 add_project_arguments('-DHAVE_SWAY', language: 'cpp')
 src_files += [
     'src/modules/sway/ipc/client.cpp',
+    'src/modules/sway/bar.cpp',
     'src/modules/sway/mode.cpp',
+    'src/modules/sway/language.cpp',
     'src/modules/sway/window.cpp',
     'src/modules/sway/workspaces.cpp'
 ]
@@ -164,6 +188,8 @@ src_files += [
 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
@@ -196,15 +222,31 @@ 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 (giounix.found() and not get_option('logind').disabled())
+    add_project_arguments('-DHAVE_GIO_UNIX', language: 'cpp')
+    src_files += 'src/modules/inhibitor.cpp'
+endif
+
 if get_option('rfkill').enabled()
     if is_linux
         add_project_arguments('-DWANT_RFKILL', language: 'cpp')
@@ -215,6 +257,17 @@ if get_option('rfkill').enabled()
     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
+
+if get_option('experimental')
+    add_project_arguments('-DUSE_EXPERIMENTAL', language: 'cpp')
+endif
+
 subdir('protocol')
 
 executable(
@@ -238,8 +291,11 @@ executable(
         libudev,
         libepoll,
         libmpdclient,
+        libevdev,
         gtk_layer_shell,
-        tz_dep
+        libsndio,
+        tz_dep,
+		xkbregistry 
     ],
     include_directories: [include_directories('include')],
     install: true,
@@ -256,9 +312,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',
@@ -266,11 +333,13 @@ 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',
@@ -278,17 +347,27 @@ if scdoc.found()
         '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
-        topic = filename.split('.')[-3].split('/')[-1]
-        section = filename.split('.')[-2]
+    if (giounix.found() and not get_option('logind').disabled())
+        man_files += 'waybar-inhibitor.5.scd'
+    endif
+
+    foreach file : man_files
+        path = '@0@'.format(file)
+        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)
@@ -299,6 +378,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()
@@ -310,3 +398,4 @@ if clangtidy.found()
             '-p', meson.build_root()
         ] + src_files)
 endif
+

meson_options.txt

@@ -1,6 +1,7 @@
 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')
@@ -8,3 +9,7 @@ option('man-pages', type: 'feature', value: 'auto', description: 'Generate and i
 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('logind', type: 'feature', value: 'auto', description: 'Enable support for logind')
+option('tests', type: 'feature', value: 'auto', description: 'Enable tests')
+option('experimental', type : 'boolean', value : false, description: 'Enable experimental features')

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

@@ -27,7 +27,9 @@ client_protocols = [
 	[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

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <protocol name="river_status_unstable_v1">
   <copyright>
-    Copyright 2020 Isaac Freund
+    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
@@ -16,7 +16,7 @@
     OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   </copyright>
 
-  <interface name="zriver_status_manager_v1" version="1">
+  <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.
@@ -47,7 +47,7 @@
     </request>
   </interface>
 
-  <interface name="zriver_output_status_v1" version="1">
+  <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.
@@ -75,12 +75,21 @@
       </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.
+      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">

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

@@ -25,7 +25,7 @@
     THIS SOFTWARE.
   </copyright>
 
-  <interface name="zwlr_foreign_toplevel_manager_v1" version="2">
+  <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
@@ -68,7 +68,7 @@
     </event>
   </interface>
 
-  <interface name="zwlr_foreign_toplevel_handle_v1" version="2">
+  <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.
@@ -255,5 +255,16 @@
         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>

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}) ⸨{songPosition}|{queueLength}⸩ ",
+        "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
@@ -110,6 +110,7 @@ def main():
 
     signal.signal(signal.SIGINT, signal_handler)
     signal.signal(signal.SIGTERM, signal_handler)
+    signal.signal(signal.SIGPIPE, signal.SIG_DFL)
 
     for player in manager.props.player_names:
         if arguments.player is not None and arguments.player != player.name:

resources/style.css

@@ -1,10 +1,7 @@
 * {
-    border: none;
-    border-radius: 0;
     /* `otf-font-awesome` is required to be installed for icons */
     font-family: Roboto, Helvetica, Arial, sans-serif;
     font-size: 13px;
-    min-height: 0;
 }
 
 window#waybar {
@@ -41,19 +38,22 @@ 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;
+    /* Avoid rounded borders under each workspace name */
+    border: none;
+    border-radius: 0;
 }
 
 /* https://github.com/Alexays/Waybar/wiki/FAQ#the-workspace-buttons-have-a-strange-hover-effect */
 #workspaces button:hover {
     background: rgba(0, 0, 0, 0.2);
-    box-shadow: inherit;
-    border-bottom: 3px solid #ffffff;
+    box-shadow: inset 0 -3px #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

@@ -3,9 +3,12 @@ Description=Highly customizable Wayland bar for Sway and Wlroots based composito
 Documentation=https://github.com/Alexays/Waybar/wiki/
 PartOf=graphical-session.target
 After=graphical-session.target
+Requisite=graphical-session.target
 
 [Service]
 ExecStart=@prefix@/bin/waybar
+ExecReload=kill -SIGUSR2 $MAINPID
+Restart=on-failure
 
 [Install]
 WantedBy=graphical-session.target

src/ALabel.cpp

@@ -20,7 +20,7 @@ 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) {
@@ -28,9 +28,28 @@ ALabel::ALabel(const Json::Value& config, const std::string& name, const std::st
     label_.set_single_line_mode(true);
   }
 
-  if (config_["rotate"].isUInt()) {
-    label_.set_angle(config["rotate"].asUInt());
+  if (config_["min-length"].isUInt()) {
+    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 {
@@ -48,8 +67,10 @@ std::string ALabel::getIcon(uint16_t percentage, const std::string& alt, uint16_
   }
   if (format_icons.isArray()) {
     auto size = format_icons.size();
-    auto idx = std::clamp(percentage / ((max == 0 ? 100 : max) / size), 0U, size - 1);
-    format_icons = format_icons[idx];
+    if (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();
@@ -57,22 +78,24 @@ std::string ALabel::getIcon(uint16_t percentage, const std::string& alt, uint16_
   return "";
 }
 
-std::string ALabel::getIcon(uint16_t percentage, std::vector<std::string>& alts, uint16_t max) {
+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();
-    auto idx = std::clamp(percentage / ((max == 0 ? 100 : max) / size), 0U, size - 1);
-    format_icons = format_icons[idx];
+    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

@@ -44,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,478 @@
 #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 "group.hpp"
+#include "wlr-layer-shell-unstable-v1-client-protocol.h"
+
+#ifdef HAVE_SWAY
+#include "modules/sway/bar.hpp"
+#endif
+
+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";
+
+const Bar::bar_mode_map Bar::PRESET_MODES = {  //
+    {"default",
+     {// Special mode to hold the global bar configuration
+      .layer = bar_layer::BOTTOM,
+      .exclusive = true,
+      .passthrough = false,
+      .visible = true}},
+    {"dock",
+     {// Modes supported by the sway config; see man sway-bar(5)
+      .layer = bar_layer::BOTTOM,
+      .exclusive = true,
+      .passthrough = false,
+      .visible = true}},
+    {"hide",
+     {//
+      .layer = bar_layer::TOP,
+      .exclusive = false,
+      .passthrough = false,
+      .visible = true}},
+    {"invisible",
+     {//
+      .layer = bar_layer::BOTTOM,
+      .exclusive = false,
+      .passthrough = true,
+      .visible = false}},
+    {"overlay",
+     {//
+      .layer = bar_layer::TOP,
+      .exclusive = false,
+      .passthrough = true,
+      .visible = true}}};
+
+const std::string_view Bar::MODE_DEFAULT = "default";
+const std::string_view Bar::MODE_INVISIBLE = "invisible";
+const std::string_view DEFAULT_BAR_ID = "bar-0";
+
+/* Deserializer for enum bar_layer */
+void from_json(const Json::Value& j, bar_layer& l) {
+  if (j == "bottom") {
+    l = bar_layer::BOTTOM;
+  } else if (j == "top") {
+    l = bar_layer::TOP;
+  } else if (j == "overlay") {
+    l = bar_layer::OVERLAY;
+  }
+}
+
+/* Deserializer for struct bar_mode */
+void from_json(const Json::Value& j, bar_mode& m) {
+  if (j.isObject()) {
+    if (auto v = j["layer"]; v.isString()) {
+      from_json(v, m.layer);
+    }
+    if (auto v = j["exclusive"]; v.isBool()) {
+      m.exclusive = v.asBool();
+    }
+    if (auto v = j["passthrough"]; v.isBool()) {
+      m.passthrough = v.asBool();
+    }
+    if (auto v = j["visible"]; v.isBool()) {
+      m.visible = v.asBool();
+    }
+  }
+}
+
+/* Deserializer for JSON Object -> map<string compatible type, Value>
+ * Assumes that all the values in the object are deserializable to the same type.
+ */
+template <typename Key, typename Value,
+          typename = std::enable_if_t<std::is_convertible<std::string_view, Key>::value>>
+void from_json(const Json::Value& j, std::map<Key, Value>& m) {
+  if (j.isObject()) {
+    for (auto it = j.begin(); it != j.end(); ++it) {
+      from_json(*it, m[it.key().asString()]);
+    }
+  }
+}
+
+#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),
-      surface(nullptr),
       window{Gtk::WindowType::WINDOW_TOPLEVEL},
-      layer_surface_(nullptr),
-      anchor_(ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP),
       left_(Gtk::ORIENTATION_HORIZONTAL, 0),
       center_(Gtk::ORIENTATION_HORIZONTAL, 0),
       right_(Gtk::ORIENTATION_HORIZONTAL, 0),
@@ -25,26 +485,9 @@ 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") {
-    height_ = 0;
-    width_ = 1;
-  }
-  height_ = config["height"].isUInt() ? config["height"].asUInt() : height_;
-  width_ = config["width"].isUInt() ? config["width"].asUInt() : width_;
+  auto position = config["position"].asString();
 
-  if (config["position"] == "bottom") {
-    anchor_ = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
-  } else if (config["position"] == "left") {
-    anchor_ = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT;
-  } else if (config["position"] == "right") {
-    anchor_ = ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
-  }
-  if (anchor_ == ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM ||
-      anchor_ == ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP) {
-    anchor_ |= ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
-  } else if (anchor_ == ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT ||
-             anchor_ == ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT) {
-    anchor_ |= ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
+  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 +495,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,207 +557,119 @@ 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;
-  if (use_gls_) {
-    initGtkLayerShell();
-    window.signal_map_event().connect_notify(sigc::mem_fun(*this, &Bar::onMapGLS));
-    window.signal_configure_event().connect_notify(sigc::mem_fun(*this, &Bar::onConfigureGLS));
-  }
-#endif
-
-  if (!use_gls_) {
-    window.signal_realize().connect_notify(sigc::mem_fun(*this, &Bar::onRealize));
-    window.signal_map_event().connect_notify(sigc::mem_fun(*this, &Bar::onMap));
-    window.signal_configure_event().connect_notify(sigc::mem_fun(*this, &Bar::onConfigure));
-  }
-  window.set_size_request(width_, height_);
-  setupWidgets();
-
-  if (!use_gls_ && window.get_realized()) {
-    onRealize();
-  }
-  window.show_all();
-}
-
-#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_);
-  }
-}
-
-void waybar::Bar::onConfigureGLS(GdkEventConfigure* ev) {
-  /*
-   * GTK wants new size for the window.
-   * Actual resizing is done within the gtk-layer-shell code; the only remaining action is to apply
-   * exclusive zone.
-   * gtk_layer_auto_exclusive_zone_enable() could handle even that, but at the cost of ignoring
-   * margins on unanchored edge.
-   *
-   * Note: forced resizing to a window smaller than required by GTK would not work with
-   * gtk-layer-shell.
-   */
-  if (vertical) {
-    if (width_ > 1 && ev->width > static_cast<int>(width_)) {
-      spdlog::warn(MIN_WIDTH_MSG, width_, ev->width);
-    }
-  } else {
-    if (!vertical && height_ > 1 && ev->height > static_cast<int>(height_)) {
-      spdlog::warn(MIN_HEIGHT_MSG, height_, ev->height);
-    }
-  }
-  width_ = ev->width;
-  height_ = ev->height;
-  spdlog::info(BAR_SIZE_MSG, width_, height_, output->name);
-  setExclusiveZone(width_, height_);
-}
-
-void waybar::Bar::onMapGLS(GdkEventAny* ev) {
-  /*
-   * Obtain a pointer to the custom layer surface for modules that require it (idle_inhibitor).
-   */
-  auto gdk_window = window.get_window();
-  surface = gdk_wayland_window_get_wl_surface(gdk_window->gobj());
-}
-
-#endif
-
-void waybar::Bar::onConfigure(GdkEventConfigure* ev) {
-  /*
-   * GTK wants new size for the window.
-   *
-   * Prefer configured size if it's non-default.
-   * If the size is not set and the window is smaller than requested by GTK, request resize from
-   * layer surface.
-   */
-  auto tmp_height = height_;
-  auto tmp_width = width_;
-  if (ev->height > static_cast<int>(height_)) {
-    // Default minimal value
-    if (height_ > 1) {
-      spdlog::warn(MIN_HEIGHT_MSG, height_, ev->height);
-    }
-    if (config["height"].isUInt()) {
-      spdlog::info(SIZE_DEFINED, "Height");
-    } else {
-      tmp_height = ev->height;
-    }
-  }
-  if (ev->width > static_cast<int>(width_)) {
-    // Default minimal value
-    if (width_ > 1) {
-      spdlog::warn(MIN_WIDTH_MSG, width_, ev->width);
-    }
-    if (config["width"].isUInt()) {
-      spdlog::info(SIZE_DEFINED, "Width");
-    } else {
-      tmp_width = ev->width;
-    }
-  }
-  if (tmp_width != width_ || tmp_height != height_) {
-    setSurfaceSize(tmp_width, tmp_height);
-  }
-}
-
-void waybar::Bar::onRealize() {
-  auto gdk_window = window.get_window()->gobj();
-  gdk_wayland_window_set_use_custom_surface(gdk_window);
-}
-
-void waybar::Bar::onMap(GdkEventAny* ev) {
-  auto gdk_window = window.get_window()->gobj();
-  surface = gdk_wayland_window_get_wl_surface(gdk_window);
-
-  auto client = waybar::Client::inst();
-  // owned by output->monitor; no need to destroy
-  auto wl_output = gdk_wayland_monitor_get_wl_output(output->monitor->gobj());
-  auto layer =
-      config["layer"] == "top" ? ZWLR_LAYER_SHELL_V1_LAYER_TOP : ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM;
-  layer_surface_ = zwlr_layer_shell_v1_get_layer_surface(
-      client->layer_shell, surface, wl_output, layer, "waybar");
-
-  zwlr_layer_surface_v1_set_keyboard_interactivity(layer_surface_, false);
-  zwlr_layer_surface_v1_set_anchor(layer_surface_, anchor_);
-  zwlr_layer_surface_v1_set_margin(
-      layer_surface_, margins_.top, margins_.right, margins_.bottom, margins_.left);
-  setSurfaceSize(width_, height_);
-  setExclusiveZone(width_, height_);
-
-  static const struct zwlr_layer_surface_v1_listener layer_surface_listener = {
-      .configure = layerSurfaceHandleConfigure,
-      .closed = layerSurfaceHandleClosed,
-  };
-  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);
+  bool use_gls = config["gtk-layer-shell"].isBool() ? config["gtk-layer-shell"].asBool() : true;
+  if (use_gls) {
+    surface_impl_ = std::make_unique<GLSSurfaceImpl>(window, *output);
   } else
 #endif
   {
-    zwlr_layer_surface_v1_set_exclusive_zone(layer_surface_, zone);
+    surface_impl_ = std::make_unique<RawSurfaceImpl>(window, *output);
+  }
+
+  surface_impl_->setMargins(margins_);
+  surface_impl_->setPosition(position);
+  surface_impl_->setSize(width, height);
+
+  /* Read custom modes if available */
+  if (auto modes = config.get("modes", {}); modes.isObject()) {
+    from_json(modes, configured_modes);
+  }
+
+  /* Update "default" mode with the global bar options */
+  from_json(config, configured_modes[MODE_DEFAULT]);
+
+  if (auto mode = config.get("mode", {}); mode.isString()) {
+    setMode(config["mode"].asString());
+  } else {
+    setMode(MODE_DEFAULT);
+  }
+
+  window.signal_map_event().connect_notify(sigc::mem_fun(*this, &Bar::onMap));
+
+#if HAVE_SWAY
+  if (auto ipc = config["ipc"]; ipc.isBool() && ipc.asBool()) {
+    bar_id = Client::inst()->bar_id;
+    if (auto id = config["id"]; id.isString()) {
+      bar_id = id.asString();
+    }
+    if (bar_id.empty()) {
+      bar_id = DEFAULT_BAR_ID;
+    }
+    try {
+      _ipc_client = std::make_unique<BarIpcClient>(*this);
+    } catch (const std::exception& exc) {
+      spdlog::warn("Failed to open bar ipc connection: {}", exc.what());
+    }
+  }
+#endif
+
+  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) {
-  /* If the client is anchored to two opposite edges, layer_surface.configure will return
-   * size without margins for the axis.
-   * layer_surface.set_size, however, expects size with margins for the anchored axis.
-   * This is not specified by wlr-layer-shell and based on actual behavior of sway.
-   */
-  if (vertical && height > 1) {
-    height += margins_.top + margins_.bottom;
+/* Need to define it here because of forward declared members */
+waybar::Bar::~Bar() = default;
+
+void waybar::Bar::setMode(const std::string_view& mode) {
+  using namespace std::literals::string_literals;
+
+  auto style = window.get_style_context();
+  /* remove styles added by previous setMode calls */
+  style->remove_class("mode-"s + last_mode_);
+
+  auto it = configured_modes.find(mode);
+  if (it != configured_modes.end()) {
+    last_mode_ = mode;
+    style->add_class("mode-"s + last_mode_);
+    setMode(it->second);
+  } else {
+    spdlog::warn("Unknown mode \"{}\" requested", mode);
+    last_mode_ = MODE_DEFAULT;
+    style->add_class("mode-"s + last_mode_);
+    setMode(configured_modes.at(MODE_DEFAULT));
   }
-  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::setMode(const struct bar_mode& mode) {
+  surface_impl_->setLayer(mode.layer);
+  surface_impl_->setExclusiveZone(mode.exclusive);
+  surface_impl_->setPassThrough(mode.passthrough);
+
+  if (mode.visible) {
+    window.get_style_context()->remove_class("hidden");
+    window.set_opacity(1);
+  } else {
+    window.get_style_context()->add_class("hidden");
+    window.set_opacity(0);
+  }
+  surface_impl_->commit();
+}
+
+void waybar::Bar::onMap(GdkEventAny*) {
+  /*
+   * Obtain a pointer to the custom layer surface for modules that require it (idle_inhibitor).
+   */
+  auto gdk_window = window.get_window()->gobj();
+  surface = gdk_wayland_window_get_wl_surface(gdk_window);
+}
+
+void waybar::Bar::setVisible(bool value) {
+  visible = value;
+  setMode(visible ? MODE_DEFAULT : MODE_INVISIBLE);
+}
+
+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)) {
@@ -340,19 +711,7 @@ void waybar::Bar::setupAltFormatKeyForModuleList(const char* module_list_name) {
 }
 
 void waybar::Bar::handleSignal(int signal) {
-  for (auto& module : modules_left_) {
-    auto* custom = dynamic_cast<waybar::modules::Custom*>(module.get());
-    if (custom != nullptr) {
-      custom->refresh(signal);
-    }
-  }
-  for (auto& module : modules_center_) {
-    auto* custom = dynamic_cast<waybar::modules::Custom*>(module.get());
-    if (custom != nullptr) {
-      custom->refresh(signal);
-    }
-  }
-  for (auto& module : modules_right_) {
+  for (auto& module : modules_all_) {
     auto* custom = dynamic_cast<waybar::modules::Custom*>(module.get());
     if (custom != nullptr) {
       custom->refresh(signal);
@@ -360,63 +719,36 @@ 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_);
-  if (!use_gls_) {
-    wl_surface_commit(surface);
-  }
-}
-
-void waybar::Bar::getModules(const Factory& factory, const std::string& pos) {
-  if (config[pos].isArray()) {
-    for (const auto& name : config[pos]) {
+void waybar::Bar::getModules(const Factory& factory, const std::string& pos, Gtk::Box* group = nullptr) {
+  auto module_list = group ? config[pos]["modules"] : config[pos];
+  if (module_list.isArray()) {
+    for (const auto& name : module_list) {
       try {
-        auto module = factory.makeModule(name.asString());
-        if (pos == "modules-left") {
-          modules_left_.emplace_back(module);
+        auto ref = name.asString();
+        AModule* module;
+
+        if (ref.compare(0, 6, "group/") == 0 && ref.size() > 6) {
+          auto group_module = new waybar::Group(ref, *this, config[ref]);
+          getModules(factory, ref, &group_module->box);
+          module = group_module;
+        } else {
+          module = factory.makeModule(ref);
         }
-        if (pos == "modules-center") {
-          modules_center_.emplace_back(module);
-        }
-        if (pos == "modules-right") {
-          modules_right_.emplace_back(module);
+
+        std::shared_ptr<AModule> module_sp(module);
+        modules_all_.emplace_back(module_sp);
+        if (group) {
+          group->pack_start(*module, false, false);
+        } else {
+          if (pos == "modules-left") {
+            modules_left_.emplace_back(module_sp);
+          }
+          if (pos == "modules-center") {
+            modules_center_.emplace_back(module_sp);
+          }
+          if (pos == "modules-right") {
+            modules_right_.emplace_back(module_sp);
+          }
         }
         module->dp.connect([module, &name] {
           try {
@@ -435,7 +767,11 @@ void waybar::Bar::getModules(const Factory& factory, const std::string& pos) {
 auto waybar::Bar::setupWidgets() -> void {
   window.add(box_);
   box_.pack_start(left_, false, false);
-  box_.set_center_widget(center_);
+  if (config["fixed-center"].isBool() ? config["fixed-center"].asBool() : true) {
+    box_.set_center_widget(center_);
+  } else {
+    box_.pack_start(center_, true, false);
+  }
   box_.pack_end(right_, false, false);
 
   // Convert to button code for every module that is used.

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;
-  if (config_.isArray()) {
-    for (auto const &config : config_) {
-      if (config.isObject() && isValidOutput(config, output)) {
-        configs.push_back(config);
+  return config.getOutputConfigs(output.name, output.identifier);
+}
+
+void waybar::Client::handleOutputDone(void *data, struct zxdg_output_v1 * /*xdg_output*/) {
+  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_);
+  } catch (const std::exception &e) {
+    std::cerr << e.what() << std::endl;
   }
-  return configs;
 }
 
 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: {} ({} {})",
-                  name,
-                  output.monitor->get_manufacturer(),
-                  output.monitor->get_model());
-    auto configs = client->getOutputConfigs(output);
-    if (configs.empty()) {
-      output.xdg_output.reset();
-    } else {
-      wl_display_roundtrip(client->wl_display);
-      for (const auto &config : configs) {
-        client->bars.emplace_back(std::make_unique<Bar>(&output, config));
-        Glib::RefPtr<Gdk::Screen> screen = client->bars.back()->window.get_screen();
-        client->style_context_->add_provider_for_screen(
-            screen, client->css_provider_, GTK_STYLE_PROVIDER_PRIORITY_USER);
-      }
-    }
+  } catch (const std::exception &e) {
+    std::cerr << e.what() << std::endl;
+  }
+}
+
+void waybar::Client::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,6 +127,16 @@ 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;
@@ -156,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 &config, const std::string &style) const {
-  auto config_file = config.empty() ? getValidPath({
-                                          "$XDG_CONFIG_HOME/waybar/config",
-                                          "$HOME/.config/waybar/config",
-                                          "$HOME/waybar/config",
-                                          SYSCONFDIR "/xdg/waybar/config",
-                                          "./resources/config",
-                                      })
-                                    : config;
-  auto css_file = style.empty() ? getValidPath({
-                                      "$XDG_CONFIG_HOME/waybar/style.css",
-                                      "$HOME/.config/waybar/style.css",
-                                      "$HOME/waybar/style.css",
-                                      SYSCONFDIR "/xdg/waybar/style.css",
-                                      "./resources/style.css",
-                                  })
-                                : style;
-  if (css_file.empty() || config_file.empty()) {
-    throw std::runtime_error("Missing required resources files");
+const std::string waybar::Client::getStyle(const std::string &style) {
+  auto css_file = style.empty() ? Config::findConfigPath({"style.css"}) : style;
+  if (!css_file) {
+    throw std::runtime_error("Missing required resource files");
   }
-  spdlog::info("Resources files: {}, {}", config_file, css_file);
-  return {config_file, css_file};
-}
-
-auto waybar::Client::setupConfig(const std::string &config_file) -> void {
-  std::ifstream file(config_file);
-  if (!file.is_open()) {
-    throw std::runtime_error("Can't open config file");
-  }
-  std::string      str((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
-  util::JsonParser parser;
-  config_ = parser.parse(str);
-}
+  spdlog::info("Using CSS file {}", css_file.value());
+  return css_file.value();
+};
 
 auto waybar::Client::setupCss(const std::string &css_file) -> void {
   css_provider_ = Gtk::CssProvider::create();
@@ -199,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() {
@@ -225,14 +197,13 @@ 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 style;
-  std::string bar_id;
+  std::string config_opt;
+  std::string style_opt;
   std::string log_level;
   auto        cli = clara::detail::Help(show_help) |
              clara::detail::Opt(show_version)["-v"]["--version"]("Show version") |
-             clara::detail::Opt(config, "config")["-c"]["--config"]("Config path") |
-             clara::detail::Opt(style, "style")["-s"]["--style"]("Style path") |
+             clara::detail::Opt(config_opt, "config")["-c"]["--config"]("Config 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") |
@@ -253,7 +224,8 @@ int waybar::Client::main(int argc, char *argv[]) {
   if (!log_level.empty()) {
     spdlog::set_level(spdlog::level::from_str(log_level));
   }
-  gtk_app = Gtk::Application::create(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");
@@ -262,17 +234,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);
-  setupConfig(config_file);
+  config.load(config_opt);
+  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,11 +22,19 @@ 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]);
     }
+#ifdef USE_EXPERIMENTAL
+    if (ref == "wlr/workspaces") {
+      return new waybar::modules::wlr::WorkspaceManager(id, bar_, config_[name]);
+    }
+#endif
 #endif
 #ifdef HAVE_RIVER
     if (ref == "river/tags") {
@@ -67,6 +75,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]);
@@ -76,6 +89,16 @@ 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
+#ifdef HAVE_GIO_UNIX
+    if (ref == "inhibitor") {
+      return new waybar::modules::Inhibitor(id, bar_, config_[name]);
+    }
 #endif
     if (ref == "temperature") {
       return new waybar::modules::Temperature(id, config_[name]);

src/group.cpp

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

src/main.cpp

@@ -8,6 +8,7 @@
 
 std::mutex reap_mtx;
 std::list<pid_t> reap;
+volatile bool reload;
 
 void* signalThread(void* args) {
   int err, signum;
@@ -70,12 +71,19 @@ void startSignalThread(void) {
 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) {
@@ -85,7 +93,12 @@ int main(int argc, char* argv[]) {
     }
     startSignalThread();
 
-    auto ret = client->main(argc, argv);
+    auto ret = 0;
+    do {
+      reload = false;
+      ret = client->main(argc, argv);
+    } while (reload);
+
     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();
-  fd_ = inotify_init1(IN_CLOEXEC);
-  if (fd_ == -1) {
+  battery_watch_fd_ = inotify_init1(IN_CLOEXEC);
+  if (battery_watch_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);
-    if (wd != -1) {
-      wds_.push_back(wd);
-    }
+
+  global_watch_fd_ = inotify_init1(IN_CLOEXEC);
+  if (global_watch_fd_ == -1) {
+    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_) {
-    inotify_rm_watch(fd_, wd);
+  std::lock_guard<std::mutex> guard(battery_list_mutex_);
+
+  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 :?
-    // thread_timer_.stop();
+    dp.emit();
+  };
+  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)) {
@@ -54,12 +90,22 @@ void waybar::modules::Battery::getBatteries() {
       if (((bat_defined && dir_name == config_["bat"].asString()) || !bat_defined) &&
           fs::exists(node.path() / "capacity") && fs::exists(node.path() / "uevent") &&
           fs::exists(node.path() / "status") && fs::exists(node.path() / "type")) {
-            std::string type;
-            std::ifstream(node.path() / "type") >> type;
+        std::string type;
+        std::ifstream(node.path() / "type") >> type;
 
-            if (!type.compare("Battery")){
-              batteries_.push_back(node.path());
+        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) &&
@@ -76,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_) {
-      uint16_t    capacity;
+    for (auto const& item : batteries_) {
+      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;
-      auto now_path = fs::exists(bat / "charge_now") ? "charge_now" : "energy_now";
-      std::ifstream(bat / now_path) >> energy_now;
-      auto full_path = fs::exists(bat / "charge_full") ? "charge_full" : "energy_full";
-      std::ifstream(bat / full_path) >> energy_full;
-      if (_status != "Unknown") {
+
+      // Some battery will report current and charge in μA/μAh.
+      // Scale these by the voltage to get μW/μWh.
+      if (fs::exists(bat / "current_now")) {
+        uint32_t voltage_now;
+        uint32_t current_now;
+        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;
@@ -119,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;
-        }
       }
     }
-    return {capacity, time_remaining, status};
+    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;
+    }
+    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};
   }
 }
 
@@ -158,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();
   }
@@ -165,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()) {
-    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);
-  }
+  auto status_pretty = status;
   // 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_);
   }
@@ -204,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 <time.h>
+
+#include <fmt/format.h>
 
 waybar::modules::Bluetooth::Bluetooth(const std::string& id, const Json::Value& config)
-    : ALabel(config, "bluetooth", id, "{icon}", 10),
-      status_("disabled"),
-      rfkill_{RFKILL_TYPE_BLUETOOTH} {
-  thread_ = [this] {
-    dp.emit();
-    rfkill_.waitForEvent();
-  };
-  intervall_thread_ = [this] {
-    auto now = std::chrono::system_clock::now();
-    auto timeout = std::chrono::floor<std::chrono::seconds>(now + interval_);
-    auto diff = std::chrono::seconds(timeout.time_since_epoch().count() % interval_.count());
-    thread_.sleep_until(timeout - diff);
-    dp.emit();
-  };
+    : ALabel(config, "bluetooth", id, "{icon}", 10), rfkill_{RFKILL_TYPE_BLUETOOTH} {
+  rfkill_.on_update.connect(sigc::hide(sigc::mem_fun(*this, &Bluetooth::update)));
 }
 
 auto waybar::modules::Bluetooth::update() -> void {
-  if (rfkill_.getState()) {
-    status_ = "disabled";
-  } else {
-    status_ = "enabled";
-  }
+  std::string status = rfkill_.getState() ? "disabled" : "enabled";
 
   label_.set_markup(
-      fmt::format(
-        format_,
-        fmt::arg("status", status_),
-        fmt::arg("icon", getIcon(0, status_))));
+      fmt::format(format_, fmt::arg("status", status), fmt::arg("icon", getIcon(0, status))));
 
   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

@@ -1,23 +1,69 @@
 #include "modules/clock.hpp"
 
-#include <time.h>
 #include <spdlog/spdlog.h>
+#if FMT_VERSION < 60000
+#include <fmt/time.h>
+#else
+#include <fmt/chrono.h>
+#endif
 
+#include <ctime>
 #include <sstream>
 #include <type_traits>
+
+#include "util/ustring_clen.hpp"
+#include "util/waybar_time.hpp"
 #ifdef HAVE_LANGINFO_1STDAY
 #include <langinfo.h>
 #include <locale.h>
 #endif
 
-using waybar::modules::waybar_time;
+using waybar::waybar_time;
 
 waybar::modules::Clock::Clock(const std::string& id, const Json::Value& config)
-    : ALabel(config, "clock", id, "{:%H:%M}", 60, false, false, true), fixed_time_zone_(false) {
-  if (config_["timezone"].isString()) {
-    spdlog::warn("As using a timezone, some format args may be missing as the date library havn't got a release since 2018.");
-    time_zone_ = date::locate_zone(config_["timezone"].asString());
-    fixed_time_zone_ = true;
+    : ALabel(config, "clock", id, "{:%H:%M}", 60, false, false, true),
+      current_time_zone_idx_(0),
+      is_calendar_in_tooltip_(false)
+{
+  if (config_["timezones"].isArray() && !config_["timezones"].empty()) {
+    for (const auto& zone_name: config_["timezones"]) {
+      if (!zone_name.isString() || zone_name.asString().empty()) {
+        time_zones_.push_back(nullptr);
+        continue;
+      }
+      time_zones_.push_back(
+        date::locate_zone(
+          zone_name.asString()
+        )
+      );
+    }
+  } else if (config_["timezone"].isString() && !config_["timezone"].asString().empty()) {
+    time_zones_.push_back(
+        date::locate_zone(
+          config_["timezone"].asString()
+        )
+      );
+  }
+
+  // If all timezones are parsed and no one is good, add nullptr to the timezones vector, to mark that local time should be shown.
+  if (!time_zones_.size()) {
+    time_zones_.push_back(nullptr);
+  }
+
+  if (!is_timezone_fixed()) {
+    spdlog::warn("As using a timezone, some format args may be missing as the date library haven't got a release since 2018.");
+  }
+
+  // Check if a particular placeholder is present in the tooltip format, to know what to calculate on update.
+  if (config_["tooltip-format"].isString()) {
+    std::string trimmed_format = config_["tooltip-format"].asString();
+    trimmed_format.erase(std::remove_if(trimmed_format.begin(),
+                              trimmed_format.end(),
+                              [](unsigned char x){return std::isspace(x);}),
+               trimmed_format.end());
+    if (trimmed_format.find("{" + kCalendarPlaceholder + "}") != std::string::npos) {
+      is_calendar_in_tooltip_ = true;
+    }
   }
 
   if (config_["locale"].isString()) {
@@ -35,38 +81,42 @@ waybar::modules::Clock::Clock(const std::string& id, const Json::Value& config)
   };
 }
 
+const date::time_zone* waybar::modules::Clock::current_timezone() {
+  return time_zones_[current_time_zone_idx_] ? time_zones_[current_time_zone_idx_] : date::current_zone();
+}
+
+bool waybar::modules::Clock::is_timezone_fixed() {
+  return time_zones_[current_time_zone_idx_] != nullptr;
+}
+
 auto waybar::modules::Clock::update() -> void {
-  if (!fixed_time_zone_) {
-    // Time zone can change. Be sure to pick that.
-    time_zone_ = date::current_zone();
-  }
-
-  auto        now = std::chrono::system_clock::now();
+  auto time_zone = current_timezone();
+  auto now = std::chrono::system_clock::now();
   waybar_time wtime = {locale_,
-                       date::make_zoned(time_zone_, date::floor<std::chrono::seconds>(now))};
-
-  std::string text;
-  if (!fixed_time_zone_) {
+                       date::make_zoned(time_zone, date::floor<std::chrono::seconds>(now))};
+  std::string text = "";
+  if (!is_timezone_fixed()) {
     // As date dep is not fully compatible, prefer fmt
     tzset();
     auto localtime = fmt::localtime(std::chrono::system_clock::to_time_t(now));
     text = fmt::format(format_, localtime);
-    label_.set_markup(text);
   } else {
     text = fmt::format(format_, wtime);
-    label_.set_markup(text);
   }
+  label_.set_markup(text);
 
   if (tooltipEnabled()) {
     if (config_["tooltip-format"].isString()) {
-      const auto calendar = calendar_text(wtime);
-      auto       tooltip_format = config_["tooltip-format"].asString();
-      auto       tooltip_text = fmt::format(tooltip_format, wtime, fmt::arg("calendar", calendar));
-      label_.set_tooltip_markup(tooltip_text);
-    } else {
-      label_.set_tooltip_markup(text);
+      std::string calendar_lines = "";
+      if (is_calendar_in_tooltip_) {
+        calendar_lines = calendar_text(wtime);
+      }
+      auto tooltip_format = config_["tooltip-format"].asString();
+      text = fmt::format(tooltip_format, wtime, fmt::arg(kCalendarPlaceholder.c_str(), calendar_lines));
     }
   }
+
+  label_.set_tooltip_markup(text);
   // Call parent update
   ALabel::update();
 }
@@ -81,24 +131,16 @@ bool waybar::modules::Clock::handleScroll(GdkEventScroll *e) {
   if (dir != SCROLL_DIR::UP && dir != SCROLL_DIR::DOWN) {
     return true;
   }
-  if (!config_["timezones"].isArray() || config_["timezones"].empty()) {
+  if (time_zones_.size() == 1) {
     return true;
   }
-  auto nr_zones = config_["timezones"].size();
-  int new_idx = time_zone_idx_ + ((dir == SCROLL_DIR::UP) ? 1 : -1);
-  if (new_idx < 0) {
-    time_zone_idx_ = nr_zones - 1;
-  } else if (new_idx >= nr_zones) {
-    time_zone_idx_ = 0;
+
+  auto nr_zones = time_zones_.size();
+  if (dir == SCROLL_DIR::UP) {
+    size_t new_idx = current_time_zone_idx_ + 1;
+    current_time_zone_idx_ = new_idx == nr_zones ? 0 : new_idx;
   } else {
-    time_zone_idx_ = new_idx;
-  }
-  auto zone_name = config_["timezones"][time_zone_idx_];
-  if (!zone_name.isString() || zone_name.empty()) {
-    fixed_time_zone_ = false;
-  } else {
-    time_zone_ = date::locate_zone(zone_name.asString());
-    fixed_time_zone_ = true;
+    current_time_zone_idx_ = current_time_zone_idx_ == 0 ? nr_zones - 1 : current_time_zone_idx_ - 1;
   }
 
   update();
@@ -156,12 +198,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          wd_len = wd_ustring.length();
-    if (wd_len > 2) {
-      wd_ustring = wd_ustring.substr(0, 2);
-      wd_len = 2;
+    auto clen = ustring_clen(wd_ustring);
+    auto wd_len = wd_ustring.length();
+    while (clen > 2) {
+      wd_ustring = wd_ustring.substr(0, wd_len-1);
+      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";
@@ -190,11 +234,3 @@ auto waybar::modules::Clock::first_day_of_week() -> date::weekday {
 #endif
   return date::Sunday;
 }
-
-template <>
-struct fmt::formatter<waybar_time> : fmt::formatter<std::tm> {
-  template <typename FormatContext>
-  auto format(const waybar_time& t, FormatContext& ctx) {
-    return format_to(ctx.out(), "{}", date::format(t.locale, fmt::to_string(tm_format), t.ztime));
-  }
-};

src/modules/cpu/bsd.cpp

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