chore: v0.9.13

River Window Module

.clang-format

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

.github/workflows/freebsd.yml

@@ -4,19 +4,25 @@ on: [ push, pull_request ]
 
 jobs:
   clang:
-    runs-on: macos-latest # until https://github.com/actions/runner/issues/385
+    # 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.0.9 # aka FreeBSD 12.2
+      uses: vmactions/freebsd-vm@v0.1.6 # 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 gtk-layer-shell gtkmm30 jsoncpp libdbusmenu sndio \
-               libfmt libmpdclient libudev-devd meson pkgconf pulseaudio scdoc spdlog
+          pkg install -y catch evdev-proto gtk-layer-shell gtkmm30 jsoncpp \
+            libdbusmenu libevdev libfmt libmpdclient libudev-devd meson \
+            pkgconf pulseaudio scdoc sndio spdlog wayland-protocols
         run: |
           meson build -Dman-pages=enabled
           ninja -C build
+          meson test -C build --no-rebuild --print-errorlogs --suite waybar

.github/workflows/lint.yml

@@ -0,0 +1,14 @@
+name: Linter
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: DoozyX/clang-format-lint-action@v0.13
+      with:
+        source: '.'
+        extensions: 'h,cpp,c'
+        clangFormatVersion: 12

.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,38 +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:
-        - export CPPFLAGS+=-isystem/usr/local/include LDFLAGS+=-L/usr/local/lib # sndio
-        - sudo sed -i '' 's/quarterly/latest/' /etc/pkg/FreeBSD.conf
-        - sudo pkg install -y gtk-layer-shell gtkmm30 jsoncpp libdbusmenu sndio
-               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 sndio-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
@@ -20,7 +20,7 @@
 - MPD
 - Custom scripts
 - Multiple output configuration
-- And much more customizations
+- And many more customizations
 
 #### Configuration and Styling
 
@@ -68,6 +68,8 @@ libappindicator-gtk3 [Tray module]
 libdbusmenu-gtk3 [Tray module]
 libmpdclient [MPD module]
 libsndio [sndio module]
+libevdev [KeyboardState module]
+xkbregistry
 ```
 
 **Build dependencies**
@@ -79,13 +81,14 @@ scdoc
 wayland-protocols
 ```
 
-On Ubuntu you can install all the relevant dependencies using this command (tested with 19.10 and 20.04):
+On Ubuntu, you can install all the relevant dependencies using this command (tested with 19.10 and 20.04):
 
 ```
 sudo apt install \
   clang-tidy \
   gobject-introspection \
   libdbusmenu-gtk3-dev \
+  libevdev-dev \
   libfmt-dev \
   libgirepository1.0-dev \
   libgtk-3-dev \
@@ -99,12 +102,14 @@ sudo apt install \
   libsigc++-2.0-dev \
   libspdlog-dev \
   libwayland-dev \
-  scdoc
+  scdoc \
+  libxkbregistry-dev
 ```
 
 
-Contributions welcome! - have fun :)<br>
-The style guidelines is [Google's](https://google.github.io/styleguide/cppguide.html)
+Contributions welcome!<br>
+Have fun :)<br>
+The style guidelines are [Google's](https://google.github.io/styleguide/cppguide.html)
 
 ## License
 

include/AIconLabel.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <gtkmm/box.h>
+#include <gtkmm/image.h>
+
+#include "ALabel.hpp"
+
+namespace waybar {
+
+class AIconLabel : public ALabel {
+ public:
+  AIconLabel(const Json::Value &config, const std::string &name, const std::string &id,
+             const std::string &format, uint16_t interval = 0, bool ellipsize = false,
+             bool enable_click = false, bool enable_scroll = false);
+  virtual ~AIconLabel() = default;
+  virtual auto update() -> void;
+
+ protected:
+  Gtk::Image image_;
+  Gtk::Box box_;
+
+  bool iconEnabled() const;
+};
+
+}  // namespace waybar

include/ALabel.hpp

@@ -3,6 +3,7 @@
 #include <glibmm/markup.h>
 #include <gtkmm/label.h>
 #include <json/json.h>
+
 #include "AModule.hpp"
 
 namespace waybar {
@@ -10,20 +11,21 @@ namespace waybar {
 class ALabel : public AModule {
  public:
   ALabel(const Json::Value &, const std::string &, const std::string &, const std::string &format,
-         uint16_t interval = 0, bool ellipsize = false, bool enable_click = false, bool enable_scroll = false);
+         uint16_t interval = 0, bool ellipsize = false, bool enable_click = false,
+         bool enable_scroll = false);
   virtual ~ALabel() = default;
-  virtual auto        update() -> void;
+  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_;
+  Gtk::Label label_;
+  std::string format_;
   const std::chrono::seconds interval_;
-  bool                       alt_ = false;
-  std::string                default_format_;
+  bool alt_ = false;
+  std::string default_format_;
 
-  virtual bool        handleToggle(GdkEventButton *const &e);
+  virtual bool handleToggle(GdkEventButton *const &e);
   virtual std::string getState(uint8_t value, bool lesser = false);
 };
 

include/AModule.hpp

@@ -15,7 +15,7 @@ class AModule : public IModule {
           bool enable_scroll = false);
   virtual ~AModule();
   virtual auto update() -> void;
-  virtual      operator Gtk::Widget &();
+  virtual operator Gtk::Widget &();
 
   Glib::Dispatcher dp;
 
@@ -23,19 +23,35 @@ class AModule : public IModule {
   enum SCROLL_DIR { NONE, UP, DOWN, LEFT, RIGHT };
 
   SCROLL_DIR getScrollDir(GdkEventScroll *e);
-  bool       tooltipEnabled();
+  bool tooltipEnabled();
 
-  const std::string  name_;
+  const std::string name_;
   const Json::Value &config_;
-  Gtk::EventBox      event_box_;
+  Gtk::EventBox event_box_;
 
   virtual bool handleToggle(GdkEventButton *const &ev);
   virtual bool handleScroll(GdkEventScroll *);
 
  private:
   std::vector<int> pid_;
-  gdouble          distance_scrolled_y_;
-  gdouble          distance_scrolled_x_;
+  gdouble distance_scrolled_y_;
+  gdouble distance_scrolled_x_;
+  static const inline std::map<std::pair<uint, GdkEventType>, std::string> eventMap_{
+      {std::make_pair(1, GdkEventType::GDK_BUTTON_PRESS), "on-click"},
+      {std::make_pair(1, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click"},
+      {std::make_pair(1, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click"},
+      {std::make_pair(2, GdkEventType::GDK_BUTTON_PRESS), "on-click-middle"},
+      {std::make_pair(2, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-middle"},
+      {std::make_pair(2, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click-middle"},
+      {std::make_pair(3, GdkEventType::GDK_BUTTON_PRESS), "on-click-right"},
+      {std::make_pair(3, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-right"},
+      {std::make_pair(3, GdkEventType::GDK_3BUTTON_PRESS), "on-triple-click-right"},
+      {std::make_pair(8, GdkEventType::GDK_BUTTON_PRESS), "on-click-backward"},
+      {std::make_pair(8, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-backward"},
+      {std::make_pair(8, GdkEventType::GDK_2BUTTON_PRESS), "on-triple-click-backward"},
+      {std::make_pair(9, GdkEventType::GDK_BUTTON_PRESS), "on-click-forward"},
+      {std::make_pair(9, GdkEventType::GDK_2BUTTON_PRESS), "on-double-click-forward"},
+      {std::make_pair(9, GdkEventType::GDK_2BUTTON_PRESS), "on-triple-click-forward"}};
 };
 
 }  // namespace waybar

include/IModule.hpp

@@ -7,8 +7,8 @@ namespace waybar {
 class IModule {
  public:
   virtual ~IModule() = default;
-  virtual auto     update() -> void = 0;
-  virtual          operator Gtk::Widget &() = 0;
+  virtual auto update() -> void = 0;
+  virtual operator Gtk::Widget&() = 0;
 };
 
 }  // namespace waybar

include/bar.hpp

@@ -8,6 +8,9 @@
 #include <gtkmm/window.h>
 #include <json/json.h>
 
+#include <memory>
+#include <vector>
+
 #include "AModule.hpp"
 #include "xdg-output-unstable-v1-client-protocol.h"
 
@@ -16,8 +19,8 @@ namespace waybar {
 class Factory;
 struct waybar_output {
   Glib::RefPtr<Gdk::Monitor> monitor;
-  std::string                name;
-  std::string                identifier;
+  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};
@@ -36,6 +39,19 @@ struct bar_margins {
   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;
@@ -44,6 +60,7 @@ class BarSurface {
   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(){};
@@ -53,37 +70,56 @@ class BarSurface {
 
 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();
 
+  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;
-  bool                  visible = true;
-  bool                  vertical = false;
-  Gtk::Window           window;
+  Json::Value config;
+  struct wl_surface *surface;
+  bool visible = true;
+  bool vertical = false;
+  Gtk::Window window;
+
+#ifdef HAVE_SWAY
+  std::string bar_id;
+#endif
 
  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 &);
 
-  std::unique_ptr<BarSurface>                   surface_impl_;
-  bar_layer                                     layer_;
-  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_;
+  /* 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::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,11 +3,10 @@
 #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;
@@ -18,29 +17,27 @@ namespace waybar {
 class Client {
  public:
   static Client *inst();
-  int            main(int argc, char *argv[]);
-  void           reset();
+  int main(int argc, char *argv[]);
+  void reset();
 
-  Glib::RefPtr<Gtk::Application>      gtk_app;
-  Glib::RefPtr<Gdk::Display>          gdk_display;
-  struct wl_display *                 wl_display = nullptr;
-  struct wl_registry *                registry = nullptr;
-  struct zwlr_layer_shell_v1 *        layer_shell = nullptr;
-  struct zxdg_output_manager_v1 *     xdg_output_manager = nullptr;
+  Glib::RefPtr<Gtk::Application> gtk_app;
+  Glib::RefPtr<Gdk::Display> gdk_display;
+  struct wl_display *wl_display = nullptr;
+  struct wl_registry *registry = nullptr;
+  struct zwlr_layer_shell_v1 *layer_shell = nullptr;
+  struct zxdg_output_manager_v1 *xdg_output_manager = nullptr;
   struct zwp_idle_inhibit_manager_v1 *idle_inhibit_manager = nullptr;
-  std::vector<std::unique_ptr<Bar>>   bars;
+  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,
@@ -49,13 +46,12 @@ class Client {
   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);
+  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_;
+  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

@@ -7,16 +7,18 @@
 #include "modules/simpleclock.hpp"
 #endif
 #ifdef HAVE_SWAY
+#include "modules/sway/language.hpp"
 #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"
+#include "modules/river/window.hpp"
 #endif
 #if defined(__linux__) && !defined(NO_FILESYSTEM)
 #include "modules/battery.hpp"
@@ -38,6 +40,15 @@
 #ifdef HAVE_LIBUDEV
 #include "modules/backlight.hpp"
 #endif
+#ifdef HAVE_LIBEVDEV
+#include "modules/keyboard_state.hpp"
+#endif
+#ifdef HAVE_GAMEMODE
+#include "modules/gamemode.hpp"
+#endif
+#ifdef HAVE_UPOWER
+#include "modules/upower/upower.hpp"
+#endif
 #ifdef HAVE_LIBPULSE
 #include "modules/pulseaudio.hpp"
 #endif
@@ -47,14 +58,13 @@
 #ifdef HAVE_LIBSNDIO
 #include "modules/sndio.hpp"
 #endif
+#ifdef HAVE_GIO_UNIX
+#include "modules/bluetooth.hpp"
+#include "modules/inhibitor.hpp"
+#endif
 #include "bar.hpp"
 #include "modules/custom.hpp"
 #include "modules/temperature.hpp"
-#if defined(__linux__)
-#  ifdef WANT_RFKILL
-#    include "modules/bluetooth.hpp"
-#  endif
-#endif
 
 namespace waybar {
 
@@ -64,7 +74,7 @@ class Factory {
   AModule* makeModule(const std::string& name) const;
 
  private:
-  const Bar&         bar_;
+  const Bar& bar_;
   const Json::Value& config_;
 };
 

include/group.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <gtkmm/box.h>
+#include <gtkmm/widget.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/backlight.hpp

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

include/modules/battery.hpp

@@ -7,10 +7,12 @@
 #endif
 #include <fmt/format.h>
 #include <sys/inotify.h>
+
 #include <algorithm>
 #include <fstream>
 #include <string>
 #include <vector>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 
@@ -31,23 +33,24 @@ class Battery : public ALabel {
  private:
   static inline const fs::path data_dir_ = "/sys/class/power_supply/";
 
-  void                                                 refreshBatteries();
-  void                                                 worker();
-  const std::string                                    getAdapterStatus(uint8_t capacity) const;
+  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);
+  const std::string formatTimeRemaining(float hoursRemaining);
 
-  int                   global_watch;
-  std::map<fs::path,int> batteries_;
-  fs::path              adapter_;
-  int                   battery_watch_fd_;
-  int                   global_watch_fd_;
-  std::mutex            battery_list_mutex_;
-  std::string           old_status_;
+  int global_watch;
+  std::map<fs::path, int> batteries_;
+  fs::path adapter_;
+  int battery_watch_fd_;
+  int global_watch_fd_;
+  std::mutex battery_list_mutex_;
+  std::string old_status_;
+  bool warnFirstTime_{true};
 
-  util::SleeperThread   thread_;
-  util::SleeperThread   thread_battery_update_;
-  util::SleeperThread   thread_timer_;
+  util::SleeperThread thread_;
+  util::SleeperThread thread_battery_update_;
+  util::SleeperThread thread_timer_;
 };
 
 }  // namespace waybar::modules

include/modules/bluetooth.hpp

@@ -1,18 +1,79 @@
 #pragma once
 
 #include "ALabel.hpp"
+#ifdef WANT_RFKILL
 #include "util/rfkill.hpp"
+#endif
+#include <gio/gio.h>
+
+#include <optional>
+#include <string>
+#include <vector>
 
 namespace waybar::modules {
 
 class Bluetooth : public ALabel {
+  struct ControllerInfo {
+    std::string path;
+    std::string address;
+    std::string address_type;
+    // std::string name; // just use alias instead
+    std::string alias;
+    bool powered;
+    bool discoverable;
+    bool pairable;
+    bool discovering;
+  };
+
+  // NOTE: there are some properties that not all devices provide
+  struct DeviceInfo {
+    std::string path;
+    std::string paired_controller;
+    std::string address;
+    std::string address_type;
+    // std::optional<std::string> name; // just use alias instead
+    std::string alias;
+    std::optional<std::string> icon;
+    bool paired;
+    bool trusted;
+    bool blocked;
+    bool connected;
+    bool services_resolved;
+    // NOTE: experimental feature in bluez
+    std::optional<unsigned char> battery_percentage;
+  };
+
  public:
   Bluetooth(const std::string&, const Json::Value&);
   ~Bluetooth() = default;
   auto update() -> void;
 
  private:
+  static auto onInterfaceAddedOrRemoved(GDBusObjectManager*, GDBusObject*, GDBusInterface*,
+                                        gpointer) -> void;
+  static auto onInterfaceProxyPropertiesChanged(GDBusObjectManagerClient*, GDBusObjectProxy*,
+                                                GDBusProxy*, GVariant*, const gchar* const*,
+                                                gpointer) -> void;
+
+  auto getDeviceBatteryPercentage(GDBusObject*) -> std::optional<unsigned char>;
+  auto getDeviceProperties(GDBusObject*, DeviceInfo&) -> bool;
+  auto getControllerProperties(GDBusObject*, ControllerInfo&) -> bool;
+
+  auto findCurController(ControllerInfo&) -> bool;
+  auto findConnectedDevices(const std::string&, std::vector<DeviceInfo>&) -> void;
+
+#ifdef WANT_RFKILL
   util::Rfkill rfkill_;
+#endif
+  const std::unique_ptr<GDBusObjectManager, void (*)(GDBusObjectManager*)> manager_;
+
+  std::string state_;
+  ControllerInfo cur_controller_;
+  std::vector<DeviceInfo> connected_devices_;
+  DeviceInfo cur_focussed_device_;
+  std::string device_enumerate_;
+
+  std::vector<std::string> device_preference_;
 };
 
 }  // namespace waybar::modules

include/modules/clock.hpp

@@ -1,21 +1,18 @@
 #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";
+const std::string KTimezonedTimeListPlaceholder = "timezoned_time_list";
 
 class Clock : public ALabel {
  public:
@@ -26,17 +23,23 @@ 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_ = date::January/1/0;
+  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 is_timezoned_list_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();
+  auto print_iso_weeknum(std::ostream& os, int weeknum) -> void;
+  bool is_timezone_fixed();
+  auto timezones_text(std::chrono::system_clock::time_point* now) -> std::string;
 };
 
-}  // namespace waybar::modules
+}  // namespace modules
+}  // namespace waybar

include/modules/cpu.hpp

@@ -1,12 +1,14 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include <cstdint>
 #include <fstream>
 #include <numeric>
 #include <string>
 #include <utility>
 #include <vector>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 
@@ -19,11 +21,11 @@ class Cpu : public ALabel {
   auto update() -> void;
 
  private:
-  double                                  getCpuLoad();
-  std::tuple<uint16_t, std::string>       getCpuUsage();
-  std::tuple<float, float, float>         getCpuFrequency();
+  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<float> parseCpuFrequencies();
 
   std::vector<std::tuple<size_t, size_t>> prev_times_;
 

include/modules/custom.hpp

@@ -1,8 +1,10 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include <csignal>
 #include <string>
+
 #include "ALabel.hpp"
 #include "util/command.hpp"
 #include "util/json.hpp"
@@ -26,16 +28,16 @@ class Custom : public ALabel {
   bool handleScroll(GdkEventScroll* e);
   bool handleToggle(GdkEventButton* const& e);
 
-  const std::string        name_;
-  std::string              text_;
-  std::string              alt_;
-  std::string              tooltip_;
+  const std::string name_;
+  std::string text_;
+  std::string alt_;
+  std::string tooltip_;
   std::vector<std::string> class_;
-  int                      percentage_;
-  FILE*                    fp_;
-  int                      pid_;
-  util::command::res       output_;
-  util::JsonParser         parser_;
+  int percentage_;
+  FILE* fp_;
+  int pid_;
+  util::command::res output_;
+  util::JsonParser parser_;
 
   util::SleeperThread thread_;
 };

include/modules/disk.hpp

@@ -1,11 +1,13 @@
 #pragma once
 
 #include <fmt/format.h>
-#include <fstream>
 #include <sys/statvfs.h>
+
+#include <fstream>
+
 #include "ALabel.hpp"
-#include "util/sleeper_thread.hpp"
 #include "util/format.hpp"
+#include "util/sleeper_thread.hpp"
 
 namespace waybar::modules {
 

include/modules/gamemode.hpp

@@ -0,0 +1,77 @@
+#pragma once
+
+#include <iostream>
+#include <map>
+#include <string>
+
+#include "ALabel.hpp"
+#include "giomm/dbusconnection.h"
+#include "giomm/dbusproxy.h"
+#include "glibconfig.h"
+#include "gtkmm/box.h"
+#include "gtkmm/image.h"
+#include "gtkmm/label.h"
+#include "gtkmm/overlay.h"
+
+namespace waybar::modules {
+
+class Gamemode : public AModule {
+ public:
+  Gamemode(const std::string &, const Json::Value &);
+  ~Gamemode();
+  auto update() -> void;
+
+ private:
+  const std::string DEFAULT_ICON_NAME = "input-gaming-symbolic";
+  const std::string DEFAULT_FORMAT = "{glyph}";
+  const std::string DEFAULT_FORMAT_ALT = "{glyph} {count}";
+  const std::string DEFAULT_TOOLTIP_FORMAT = "Games running: {count}";
+  const std::string DEFAULT_GLYPH = "";
+
+  void appear(const Glib::RefPtr<Gio::DBus::Connection> &connection, const Glib::ustring &name,
+              const Glib::ustring &name_owner);
+  void disappear(const Glib::RefPtr<Gio::DBus::Connection> &connection, const Glib::ustring &name);
+  void prepareForSleep_cb(const Glib::RefPtr<Gio::DBus::Connection> &connection,
+                          const Glib::ustring &sender_name, const Glib::ustring &object_path,
+                          const Glib::ustring &interface_name, const Glib::ustring &signal_name,
+                          const Glib::VariantContainerBase &parameters);
+  void notify_cb(const Glib::ustring &sender_name, const Glib::ustring &signal_name,
+                 const Glib::VariantContainerBase &arguments);
+
+  void getData();
+  bool handleToggle(GdkEventButton *const &);
+
+  // Config
+  std::string format = DEFAULT_FORMAT;
+  std::string format_alt = DEFAULT_FORMAT_ALT;
+  std::string tooltip_format = DEFAULT_TOOLTIP_FORMAT;
+  std::string glyph = DEFAULT_GLYPH;
+  bool tooltip = true;
+  bool hideNotRunning = true;
+  bool useIcon = true;
+  uint iconSize = 20;
+  uint iconSpacing = 4;
+  std::string iconName = DEFAULT_ICON_NAME;
+
+  Gtk::Box box_;
+  Gtk::Image icon_;
+  Gtk::Label label_;
+
+  const std::string dbus_name = "com.feralinteractive.GameMode";
+  const std::string dbus_obj_path = "/com/feralinteractive/GameMode";
+  const std::string dbus_interface = "org.freedesktop.DBus.Properties";
+  const std::string dbus_get_interface = "com.feralinteractive.GameMode";
+
+  uint gameCount = 0;
+
+  std::string lastStatus;
+  bool showAltText = false;
+
+  guint login1_id;
+  Glib::RefPtr<Gio::DBus::Proxy> gamemode_proxy;
+  Glib::RefPtr<Gio::DBus::Connection> system_connection;
+  bool gamemodeRunning;
+  guint gamemodeWatcher_id;
+};
+
+}  // namespace waybar::modules

include/modules/idle_inhibitor.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include "ALabel.hpp"
 #include "bar.hpp"
 #include "client.hpp"
@@ -8,19 +9,21 @@
 namespace waybar::modules {
 
 class IdleInhibitor : public ALabel {
+  sigc::connection timeout_;
+
  public:
   IdleInhibitor(const std::string&, const waybar::Bar&, const Json::Value&);
   ~IdleInhibitor();
   auto update() -> void;
   static std::list<waybar::AModule*> modules;
-  static bool                        status;
+  static bool status;
 
  private:
   bool handleToggle(GdkEventButton* const& e);
 
-  const Bar&                    bar_;
+  const Bar& bar_;
   struct zwp_idle_inhibitor_v1* idle_inhibitor_;
-  int                           pid_;
+  int pid_;
 };
 
 }  // namespace waybar::modules

include/modules/inhibitor.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <gio/gio.h>
+
+#include <memory>
+
+#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,46 @@
+#pragma once
+
+#include <fmt/format.h>
+#if FMT_VERSION < 60000
+#include <fmt/time.h>
+#else
+#include <fmt/chrono.h>
+#endif
+#include <gtkmm/label.h>
+
+#include "AModule.hpp"
+#include "bar.hpp"
+#include "util/sleeper_thread.hpp"
+
+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:
+  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/memory.hpp

@@ -1,8 +1,10 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include <fstream>
 #include <unordered_map>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 
@@ -15,7 +17,7 @@ class Memory : public ALabel {
   auto update() -> void;
 
  private:
-  void                            parseMeminfo();
+  void parseMeminfo();
 
   std::unordered_map<std::string, unsigned long> meminfo_;
 

include/modules/mpd/mpd.hpp

@@ -22,8 +22,8 @@ class MPD : public ALabel {
 
   // 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 char* server_;
+  const unsigned port_;
   const std::string password_;
 
   unsigned timeout_;
@@ -31,8 +31,8 @@ class MPD : public ALabel {
   detail::unique_connection connection_;
 
   detail::unique_status status_;
-  mpd_state             state_;
-  detail::unique_song   song_;
+  mpd_state state_;
+  detail::unique_song song_;
 
  public:
   MPD(const std::string&, const Json::Value&);
@@ -41,7 +41,7 @@ class MPD : public ALabel {
 
  private:
   std::string getTag(mpd_tag_type type, unsigned idx = 0) const;
-  void        setLabel();
+  void setLabel();
   std::string getStateIcon() const;
   std::string getOptionIcon(std::string optionName, bool activated) const;
 

include/modules/mpd/state.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
-#include <mpd/client.h>
 #include <fmt/format.h>
+#include <mpd/client.h>
 #include <spdlog/spdlog.h>
 
 #include <condition_variable>
@@ -57,7 +57,7 @@ class State {
 };
 
 class Idle : public State {
-  Context* const   ctx_;
+  Context* const ctx_;
   sigc::connection idle_connection_;
 
  public:
@@ -80,7 +80,7 @@ class Idle : public State {
 };
 
 class Playing : public State {
-  Context* const   ctx_;
+  Context* const ctx_;
   sigc::connection timer_connection_;
 
  public:
@@ -102,7 +102,7 @@ class Playing : public State {
 };
 
 class Paused : public State {
-  Context* const   ctx_;
+  Context* const ctx_;
   sigc::connection timer_connection_;
 
  public:
@@ -124,7 +124,7 @@ class Paused : public State {
 };
 
 class Stopped : public State {
-  Context* const   ctx_;
+  Context* const ctx_;
   sigc::connection timer_connection_;
 
  public:
@@ -146,7 +146,7 @@ class Stopped : public State {
 };
 
 class Disconnected : public State {
-  Context* const   ctx_;
+  Context* const ctx_;
   sigc::connection timer_connection_;
 
  public:
@@ -170,7 +170,7 @@ class Disconnected : public State {
 
 class Context {
   std::unique_ptr<State> state_;
-  waybar::modules::MPD*  mpd_module_;
+  waybar::modules::MPD* mpd_module_;
 
   friend class State;
   friend class Playing;
@@ -188,18 +188,18 @@ class Context {
     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;
+  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:

include/modules/mpd/state.inl.hpp

@@ -8,13 +8,11 @@ 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::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::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(); }

include/modules/network.hpp

@@ -2,13 +2,14 @@
 
 #include <arpa/inet.h>
 #include <fmt/format.h>
-#include <ifaddrs.h>
 #include <linux/nl80211.h>
-#include <net/if.h>
 #include <netlink/genl/ctrl.h>
 #include <netlink/genl/genl.h>
 #include <netlink/netlink.h>
 #include <sys/epoll.h>
+
+#include <optional>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 #ifdef WANT_RFKILL
@@ -28,49 +29,56 @@ 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              worker();
-  void              createInfoSocket();
-  void              createEventSocket();
-  int               getExternalInterface(int skip_idx = -1) const;
-  void              getInterfaceAddress();
-  int               netlinkRequest(void*, uint32_t, uint32_t groups = 0) const;
-  int               netlinkResponse(void*, uint32_t, uint32_t groups = 0) const;
-  void              parseEssid(struct nlattr**);
-  void              parseSignal(struct nlattr**);
-  void              parseFreq(struct nlattr**);
-  bool              associatedOrJoined(struct nlattr**);
-  bool              checkInterface(struct ifinfomsg* rtif, std::string name);
-  int               getPreferredIface(int skip_idx = -1, bool wait = true) const;
-  auto              getInfo() -> void;
-  void              checkNewInterface(struct ifinfomsg* rtif);
-  const std::string getNetworkState() const;
-  void              clearIface();
-  bool              wildcardMatch(const std::string& pattern, const std::string& text) const;
+  void askForStateDump(void);
 
-  int                ifid_;
-  sa_family_t        family_;
+  void worker();
+  void createInfoSocket();
+  void createEventSocket();
+  void parseEssid(struct nlattr**);
+  void parseSignal(struct nlattr**);
+  void parseFreq(struct nlattr**);
+  bool associatedOrJoined(struct nlattr**);
+  bool checkInterface(std::string name);
+  auto getInfo() -> void;
+  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_;
   struct sockaddr_nl nladdr_ = {0};
-  struct nl_sock*    sock_ = nullptr;
-  struct nl_sock*    ev_sock_ = nullptr;
-  int                efd_;
-  int                ev_fd_;
-  int                nl80211_id_;
-  std::mutex         mutex_;
+  struct nl_sock* sock_ = nullptr;
+  struct nl_sock* ev_sock_ = nullptr;
+  int efd_;
+  int ev_fd_;
+  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_;
+  int cidr_;
+  int32_t signal_strength_dbm_;
+  uint8_t signal_strength_;
+  std::string signal_strength_app_;
+  float frequency_;
+  uint32_t route_priority;
 
   util::SleeperThread thread_;
   util::SleeperThread thread_timer_;

include/modules/pulseaudio.hpp

@@ -3,8 +3,10 @@
 #include <fmt/format.h>
 #include <pulse/pulseaudio.h>
 #include <pulse/volume.h>
+
 #include <algorithm>
 #include <array>
+
 #include "ALabel.hpp"
 
 namespace waybar::modules {
@@ -23,26 +25,27 @@ class Pulseaudio : public ALabel {
   static void serverInfoCb(pa_context*, const pa_server_info*, void*);
   static void volumeModifyCb(pa_context*, int, void*);
 
-  bool              handleScroll(GdkEventScroll* e);
-  const std::string getPortIcon() const;
+  bool handleScroll(GdkEventScroll* e);
+  const std::vector<std::string> getPulseIcon() const;
 
   pa_threaded_mainloop* mainloop_;
-  pa_mainloop_api*      mainloop_api_;
-  pa_context*           context_;
+  pa_mainloop_api* mainloop_api_;
+  pa_context* context_;
   // SINK
-  uint32_t    sink_idx_{0};
-  uint16_t    volume_;
-  pa_cvolume  pa_volume_;
-  bool        muted_;
+  uint32_t sink_idx_{0};
+  uint16_t volume_;
+  pa_cvolume pa_volume_;
+  bool muted_;
   std::string port_name_;
   std::string form_factor_;
   std::string desc_;
   std::string monitor_;
-  std::string default_sink_name_;
+  std::string current_sink_name_;
+  bool current_sink_running_;
   // SOURCE
-  uint32_t    source_idx_{0};
-  uint16_t    source_volume_;
-  bool        source_muted_;
+  uint32_t source_idx_{0};
+  uint16_t source_volume_;
+  bool source_muted_;
   std::string source_port_name_;
   std::string source_desc_;
   std::string default_source_name_;

include/modules/river/tags.hpp

@@ -5,6 +5,7 @@
 
 #include "AModule.hpp"
 #include "bar.hpp"
+#include "river-control-unstable-v1-client-protocol.h"
 #include "river-status-unstable-v1-client-protocol.h"
 #include "xdg-output-unstable-v1-client-protocol.h"
 
@@ -18,12 +19,18 @@ 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_;
-  Gtk::Box                 box_;
+  const waybar::Bar &bar_;
+  Gtk::Box box_;
   std::vector<Gtk::Button> buttons_;
   struct zriver_output_status_v1 *output_status_;
 };

include/modules/river/window.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <gtkmm/button.h>
+#include <wayland-client.h>
+
+#include "ALabel.hpp"
+#include "bar.hpp"
+#include "river-status-unstable-v1-client-protocol.h"
+#include "xdg-output-unstable-v1-client-protocol.h"
+
+namespace waybar::modules::river {
+
+class Window : public waybar::ALabel {
+ public:
+  Window(const std::string &, const waybar::Bar &, const Json::Value &);
+  ~Window();
+
+  // Handlers for wayland events
+  void handle_focused_view(const char *title);
+  void handle_focused_output(struct wl_output *output);
+  void handle_unfocused_output(struct wl_output *output);
+
+  struct zriver_status_manager_v1 *status_manager_;
+  struct wl_seat *seat_;
+
+ private:
+  const waybar::Bar &bar_;
+  struct wl_output *output_;          // stores the output this module belongs to
+  struct wl_output *focused_output_;  // stores the currently focused output
+  struct zriver_seat_status_v1 *seat_status_;
+};
+
+} /* namespace waybar::modules::river */

include/modules/sndio.hpp

@@ -1,7 +1,9 @@
 #pragma once
 
 #include <sndio.h>
+
 #include <vector>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 
@@ -9,13 +11,13 @@ namespace waybar::modules {
 
 class Sndio : public ALabel {
  public:
-  Sndio(const std::string&, const Json::Value&);
+  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&);
+  bool handleToggle(GdkEventButton *const &);
 
  private:
   auto connect_to_sndio() -> void;

include/modules/sni/host.hpp

@@ -4,38 +4,43 @@
 #include <giomm.h>
 #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();
 
  private:
-  void        busAcquired(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring);
-  void        nameAppeared(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring,
-                           const Glib::ustring&);
-  void        nameVanished(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring);
+  void busAcquired(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring);
+  void nameAppeared(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring,
+                    const Glib::ustring&);
+  void nameVanished(const Glib::RefPtr<Gio::DBus::Connection>&, Glib::ustring);
   static void proxyReady(GObject*, GAsyncResult*, gpointer);
   static void registerHost(GObject*, GAsyncResult*, gpointer);
   static void itemRegistered(SnWatcher*, const gchar*, gpointer);
   static void itemUnregistered(SnWatcher*, const gchar*, gpointer);
 
   std::tuple<std::string, std::string> getBusNameAndObjectPath(const std::string);
-  void                                 addRegisteredItem(std::string service);
+  void addRegisteredItem(std::string service);
 
-  std::vector<std::unique_ptr<Item>>                items_;
-  const std::string                                 bus_name_;
-  const std::string                                 object_path_;
-  std::size_t                                       bus_name_id_;
-  std::size_t                                       watcher_id_;
-  GCancellable*                                     cancellable_ = nullptr;
-  SnWatcher*                                        watcher_ = nullptr;
-  const Json::Value&                                config_;
+  std::vector<std::unique_ptr<Item>> items_;
+  const std::string bus_name_;
+  const std::string object_path_;
+  std::size_t bus_name_id_;
+  std::size_t watcher_id_;
+  GCancellable* cancellable_ = nullptr;
+  SnWatcher* watcher_ = nullptr;
+  const Json::Value& config_;
+  const 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,36 +11,45 @@
 #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;
   std::string object_path;
 
-  int           icon_size;
-  int           effective_icon_size;
-  Gtk::Image    image;
+  int icon_size;
+  int effective_icon_size;
+  Gtk::Image image;
   Gtk::EventBox event_box;
-  std::string   category;
-  std::string   id;
-  std::string   status;
+  std::string category;
+  std::string id;
 
-  std::string                  title;
-  int32_t                      window_id;
-  std::string                  icon_name;
-  Glib::RefPtr<Gdk::Pixbuf>    icon_pixmap;
+  std::string title;
+  std::string icon_name;
+  Glib::RefPtr<Gdk::Pixbuf> icon_pixmap;
   Glib::RefPtr<Gtk::IconTheme> icon_theme;
-  std::string                  overlay_icon_name;
-  std::string                  attention_icon_name;
-  std::string                  attention_movie_name;
-  std::string                  icon_theme_path;
-  std::string                  menu;
-  DbusmenuGtkMenu*             dbus_menu = nullptr;
-  Gtk::Menu*                   gtk_menu = nullptr;
+  std::string overlay_icon_name;
+  std::string attention_icon_name;
+  std::string attention_movie_name;
+  std::string icon_theme_path;
+  std::string menu;
+  ToolTip tooltip;
+  DbusmenuGtkMenu* dbus_menu = nullptr;
+  Gtk::Menu* gtk_menu = nullptr;
   /**
    * ItemIsMenu flag means that the item only supports the context menu.
    * Default value is true because libappindicator supports neither ItemIsMenu nor Activate method
@@ -49,23 +58,35 @@ 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,
                 const Glib::VariantContainerBase& arguments);
 
-  void                      updateImage();
+  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);
-  static void               onMenuDestroyed(Item* self, GObject* old_menu_pointer);
-  void                      makeMenu();
-  bool                      handleClick(GdkEventButton* const& /*ev*/);
+  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/sni/tray.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "modules/sni/host.hpp"
@@ -20,9 +21,9 @@ class Tray : public AModule {
   void onRemove(std::unique_ptr<Item>& item);
 
   static inline std::size_t nb_hosts_ = 0;
-  Gtk::Box                  box_;
-  SNI::Watcher::singleton   watcher_;
-  SNI::Host                 host_;
+  Gtk::Box box_;
+  SNI::Watcher::singleton watcher_;
+  SNI::Host host_;
 };
 
 }  // namespace waybar::modules::SNI

include/modules/sni/watcher.hpp

@@ -30,26 +30,26 @@ class Watcher {
 
   typedef struct {
     GfWatchType type;
-    Watcher *   watcher;
-    gchar *     service;
-    gchar *     bus_name;
-    gchar *     object_path;
-    guint       watch_id;
+    Watcher *watcher;
+    gchar *service;
+    gchar *bus_name;
+    gchar *object_path;
+    guint watch_id;
   } GfWatch;
 
-  void            busAcquired(const Glib::RefPtr<Gio::DBus::Connection> &, Glib::ustring);
+  void busAcquired(const Glib::RefPtr<Gio::DBus::Connection> &, Glib::ustring);
   static gboolean handleRegisterHost(Watcher *, GDBusMethodInvocation *, const gchar *);
   static gboolean handleRegisterItem(Watcher *, GDBusMethodInvocation *, const gchar *);
   static GfWatch *gfWatchFind(GSList *list, const gchar *bus_name, const gchar *object_path);
   static GfWatch *gfWatchNew(GfWatchType, const gchar *, const gchar *, const gchar *, Watcher *);
-  static void     nameVanished(GDBusConnection *connection, const char *name, gpointer data);
-  static void     gfWatchFree(gpointer data);
+  static void nameVanished(GDBusConnection *connection, const char *name, gpointer data);
+  static void gfWatchFree(gpointer data);
 
   void updateRegisteredItems(SnWatcher *obj);
 
-  uint32_t   bus_name_id_;
-  GSList *   hosts_ = nullptr;
-  GSList *   items_ = nullptr;
+  uint32_t bus_name_id_;
+  GSList *hosts_ = nullptr;
+  GSList *items_ = nullptr;
   SnWatcher *watcher_ = nullptr;
 };
 

include/modules/sway/bar.hpp

@@ -0,0 +1,60 @@
+#pragma once
+#include <atomic>
+#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 onCmd(const struct Ipc::ipc_response&);
+  void onConfigUpdate(const swaybar_config& config);
+  void onVisibilityUpdate(bool visible_by_modifier);
+  void onModeUpdate(bool visible_by_modifier);
+  void onUrgencyUpdate(bool visible_by_urgency);
+  void update();
+  bool isModuleEnabled(std::string name);
+
+  Bar& bar_;
+  util::JsonParser parser_;
+  Ipc ipc_;
+
+  swaybar_config bar_config_;
+  std::string modifier_reset_;
+  bool visible_by_mode_ = false;
+  bool visible_by_modifier_ = false;
+  bool visible_by_urgency_ = false;
+  std::atomic<bool> modifier_no_action_ = false;
+
+  SafeSignal<bool> signal_mode_;
+  SafeSignal<bool> signal_visible_;
+  SafeSignal<bool> signal_urgency_;
+  SafeSignal<swaybar_config> signal_config_;
+};
+
+}  // namespace modules::sway
+}  // namespace waybar

include/modules/sway/ipc/client.hpp

@@ -4,9 +4,11 @@
 #include <sys/socket.h>
 #include <sys/un.h>
 #include <unistd.h>
+
 #include <cstring>
 #include <memory>
 #include <mutex>
+
 #include "ipc.hpp"
 #include "util/sleeper_thread.hpp"
 
@@ -18,8 +20,8 @@ class Ipc {
   ~Ipc();
 
   struct ipc_response {
-    uint32_t    size;
-    uint32_t    type;
+    uint32_t size;
+    uint32_t type;
     std::string payload;
   };
 
@@ -33,16 +35,16 @@ class Ipc {
 
  protected:
   static inline const std::string ipc_magic_ = "i3-ipc";
-  static inline const size_t      ipc_header_size_ = ipc_magic_.size() + 8;
+  static inline const size_t ipc_header_size_ = ipc_magic_.size() + 8;
 
-  const std::string   getSocketPath() const;
-  int                 open(const std::string &) const;
+  const std::string getSocketPath() const;
+  int open(const std::string &) const;
   struct ipc_response send(int fd, uint32_t type, const std::string &payload = "");
   struct ipc_response recv(int fd);
 
-  int                 fd_;
-  int                 fd_event_;
-  std::mutex          mutex_;
+  int fd_;
+  int fd_event_;
+  std::mutex mutex_;
   util::SleeperThread thread_;
 };
 

include/modules/sway/ipc/ipc.hpp

@@ -1,8 +1,10 @@
 #pragma once
 
+#include <cstdint>
+
 #define event_mask(ev) (1u << (ev & 0x7F))
 
-enum ipc_command_type {
+enum ipc_command_type : uint32_t {
   // i3 command types - see i3's I3_REPLY_TYPE constants
   IPC_COMMAND = 0,
   IPC_GET_WORKSPACES = 1,
@@ -21,12 +23,16 @@ enum ipc_command_type {
   IPC_GET_SEATS = 101,
 
   // Events sent from sway to clients. Events have the highest bits set.
-  IPC_EVENT_WORKSPACE = ((1 << 31) | 0),
-  IPC_EVENT_OUTPUT = ((1 << 31) | 1),
-  IPC_EVENT_MODE = ((1 << 31) | 2),
-  IPC_EVENT_WINDOW = ((1 << 31) | 3),
-  IPC_EVENT_BARCONFIG_UPDATE = ((1 << 31) | 4),
-  IPC_EVENT_BINDING = ((1 << 31) | 5),
-  IPC_EVENT_SHUTDOWN = ((1 << 31) | 6),
-  IPC_EVENT_TICK = ((1 << 31) | 7),
+  IPC_EVENT_WORKSPACE = ((1U << 31) | 0),
+  IPC_EVENT_OUTPUT = ((1U << 31) | 1),
+  IPC_EVENT_MODE = ((1U << 31) | 2),
+  IPC_EVENT_WINDOW = ((1U << 31) | 3),
+  IPC_EVENT_BARCONFIG_UPDATE = ((1U << 31) | 4),
+  IPC_EVENT_BINDING = ((1U << 31) | 5),
+  IPC_EVENT_SHUTDOWN = ((1U << 31) | 6),
+  IPC_EVENT_TICK = ((1U << 31) | 7),
+
+  // sway-specific event types
+  IPC_EVENT_BAR_STATE_UPDATE = ((1U << 31) | 20),
+  IPC_EVENT_INPUT = ((1U << 31) | 21),
 };

include/modules/sway/language.hpp

@@ -1,6 +1,11 @@
 #pragma once
 
 #include <fmt/format.h>
+#include <xkbcommon/xkbregistry.h>
+
+#include <map>
+#include <string>
+
 #include "ALabel.hpp"
 #include "bar.hpp"
 #include "client.hpp"
@@ -16,13 +21,47 @@ class Language : public ALabel, public sigc::trackable {
   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&);
-  
-  std::string      lang_;
+
+  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_;
+  std::mutex mutex_;
+  Ipc ipc_;
 };
 
 }  // namespace waybar::modules::sway

include/modules/sway/mode.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include "ALabel.hpp"
 #include "bar.hpp"
 #include "client.hpp"
@@ -18,10 +19,10 @@ class Mode : public ALabel, public sigc::trackable {
  private:
   void onEvent(const struct Ipc::ipc_response&);
 
-  std::string      mode_;
+  std::string mode_;
   util::JsonParser parser_;
-  std::mutex       mutex_;
-  Ipc              ipc_;
+  std::mutex mutex_;
+  Ipc ipc_;
 };
 
 }  // namespace waybar::modules::sway

include/modules/sway/window.hpp

@@ -1,8 +1,10 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include <tuple>
-#include "ALabel.hpp"
+
+#include "AIconLabel.hpp"
 #include "bar.hpp"
 #include "client.hpp"
 #include "modules/sway/ipc/client.hpp"
@@ -10,28 +12,35 @@
 
 namespace waybar::modules::sway {
 
-class Window : public ALabel, public sigc::trackable {
+class Window : public AIconLabel, public sigc::trackable {
  public:
   Window(const std::string&, const waybar::Bar&, const Json::Value&);
   ~Window() = default;
   auto update() -> void;
 
  private:
-  void                                                   onEvent(const struct Ipc::ipc_response&);
-  void                                                   onCmd(const struct Ipc::ipc_response&);
-  std::tuple<std::size_t, int, std::string, std::string> getFocusedNode(const Json::Value& nodes,
-                                                                        std::string&       output);
-  void                                                   getTree();
+  void onEvent(const struct Ipc::ipc_response&);
+  void onCmd(const struct Ipc::ipc_response&);
+  std::tuple<std::size_t, int, std::string, std::string, std::string> getFocusedNode(
+      const Json::Value& nodes, std::string& output);
+  void getTree();
+  std::string rewriteTitle(const std::string& title);
+  void updateAppIconName();
+  void updateAppIcon();
 
-  const Bar&       bar_;
-  std::string      window_;
-  int              windowId_;
-  std::string      app_id_;
-  std::string      old_app_id_;
-  std::size_t      app_nb_;
+  const Bar& bar_;
+  std::string window_;
+  int windowId_;
+  std::string app_id_;
+  std::string app_class_;
+  std::string old_app_id_;
+  std::size_t app_nb_;
+  unsigned app_icon_size_{24};
+  bool update_app_icon_{true};
+  std::string app_icon_name_;
   util::JsonParser parser_;
-  std::mutex       mutex_;
-  Ipc              ipc_;
+  std::mutex mutex_;
+  Ipc ipc_;
 };
 
 }  // namespace waybar::modules::sway

include/modules/sway/workspaces.hpp

@@ -1,10 +1,11 @@
 #pragma once
 
-#include <unordered_map>
 #include <fmt/format.h>
 #include <gtkmm/button.h>
 #include <gtkmm/label.h>
+
 #include <unordered_map>
+
 #include "AModule.hpp"
 #include "bar.hpp"
 #include "client.hpp"
@@ -24,25 +25,25 @@ class Workspaces : public AModule, public sigc::trackable {
 
   static int convertWorkspaceNameToNum(std::string name);
 
-  void              onCmd(const struct Ipc::ipc_response&);
-  void              onEvent(const struct Ipc::ipc_response&);
-  bool              filterButtons();
-  Gtk::Button&      addButton(const Json::Value&);
-  void              onButtonReady(const Json::Value&, Gtk::Button&);
-  std::string       getIcon(const std::string&, const Json::Value&);
+  void onCmd(const struct Ipc::ipc_response&);
+  void onEvent(const struct Ipc::ipc_response&);
+  bool filterButtons();
+  Gtk::Button& addButton(const Json::Value&);
+  void onButtonReady(const Json::Value&, Gtk::Button&);
+  std::string getIcon(const std::string&, const Json::Value&);
   const std::string getCycleWorkspace(std::vector<Json::Value>::iterator, bool prev) const;
-  uint16_t          getWorkspaceIndex(const std::string& name) const;
-  std::string       trimWorkspaceName(std::string);
-  bool              handleScroll(GdkEventScroll*);
+  uint16_t getWorkspaceIndex(const std::string& name) const;
+  std::string trimWorkspaceName(std::string);
+  bool handleScroll(GdkEventScroll*);
 
-  const Bar&                                   bar_;
-  std::vector<Json::Value>                     workspaces_;
-  std::vector<std::string>                     workspaces_order_;
-  Gtk::Box                                     box_;
-  util::JsonParser                             parser_;
+  const Bar& bar_;
+  std::vector<Json::Value> workspaces_;
+  std::vector<std::string> workspaces_order_;
+  Gtk::Box box_;
+  util::JsonParser parser_;
   std::unordered_map<std::string, Gtk::Button> buttons_;
-  std::mutex                                   mutex_;
-  Ipc                                          ipc_;
+  std::mutex mutex_;
+  Ipc ipc_;
 };
 
 }  // namespace waybar::modules::sway

include/modules/temperature.hpp

@@ -1,7 +1,9 @@
 #pragma once
 
 #include <fmt/format.h>
+
 #include <fstream>
+
 #include "ALabel.hpp"
 #include "util/sleeper_thread.hpp"
 
@@ -14,10 +16,10 @@ class Temperature : public ALabel {
   auto update() -> void;
 
  private:
-  float               getTemperature();
-  bool                isCritical(uint16_t);
+  float getTemperature();
+  bool isCritical(uint16_t);
 
-  std::string         file_path_;
+  std::string file_path_;
   util::SleeperThread thread_;
 };
 

include/modules/upower/upower.hpp

@@ -0,0 +1,78 @@
+#pragma once
+
+#include <libupower-glib/upower.h>
+
+#include <iostream>
+#include <map>
+#include <string>
+
+#include "ALabel.hpp"
+#include "glibconfig.h"
+#include "gtkmm/box.h"
+#include "gtkmm/image.h"
+#include "gtkmm/label.h"
+#include "modules/upower/upower_tooltip.hpp"
+
+namespace waybar::modules::upower {
+
+class UPower : public AModule {
+ public:
+  UPower(const std::string &, const Json::Value &);
+  ~UPower();
+  auto update() -> void;
+
+ private:
+  typedef std::unordered_map<std::string, UpDevice *> Devices;
+
+  const std::string DEFAULT_FORMAT = "{percentage}";
+  const std::string DEFAULT_FORMAT_ALT = "{percentage} {time}";
+
+  static void deviceAdded_cb(UpClient *client, UpDevice *device, gpointer data);
+  static void deviceRemoved_cb(UpClient *client, const gchar *objectPath, gpointer data);
+  static void deviceNotify_cb(UpDevice *device, GParamSpec *pspec, gpointer user_data);
+  static void prepareForSleep_cb(GDBusConnection *system_bus, const gchar *sender_name,
+                                 const gchar *object_path, const gchar *interface_name,
+                                 const gchar *signal_name, GVariant *parameters,
+                                 gpointer user_data);
+  static void upowerAppear(GDBusConnection *conn, const gchar *name, const gchar *name_owner,
+                           gpointer data);
+  static void upowerDisappear(GDBusConnection *connection, const gchar *name, gpointer user_data);
+
+  void removeDevice(const gchar *objectPath);
+  void addDevice(UpDevice *device);
+  void setDisplayDevice();
+  void resetDevices();
+  void removeDevices();
+  bool show_tooltip_callback(int, int, bool, const Glib::RefPtr<Gtk::Tooltip> &tooltip);
+  bool handleToggle(GdkEventButton *const &);
+  std::string timeToString(gint64 time);
+
+  const std::string getDeviceStatus(UpDeviceState &state);
+
+  Gtk::Box box_;
+  Gtk::Image icon_;
+  Gtk::Label label_;
+
+  // Config
+  bool hideIfEmpty = true;
+  bool tooltip_enabled = true;
+  uint tooltip_spacing = 4;
+  uint tooltip_padding = 4;
+  uint iconSize = 20;
+  std::string format = DEFAULT_FORMAT;
+  std::string format_alt = DEFAULT_FORMAT_ALT;
+
+  Devices devices;
+  std::mutex m_Mutex;
+  UpClient *client;
+  UpDevice *displayDevice;
+  guint login1_id;
+  GDBusConnection *login1_connection;
+  UPowerTooltip *upower_tooltip;
+  std::string lastStatus;
+  bool showAltText;
+  bool upowerRunning;
+  guint upowerWatcher_id;
+};
+
+}  // namespace waybar::modules::upower

include/modules/upower/upower_tooltip.hpp

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <libupower-glib/upower.h>
+
+#include "gtkmm/box.h"
+#include "gtkmm/label.h"
+#include "gtkmm/window.h"
+
+namespace waybar::modules::upower {
+
+class UPowerTooltip : public Gtk::Window {
+ private:
+  typedef std::unordered_map<std::string, UpDevice*> Devices;
+
+  const std::string getDeviceIcon(UpDeviceKind& kind);
+
+  Gtk::Box* contentBox;
+
+  uint iconSize;
+  uint tooltipSpacing;
+  uint tooltipPadding;
+
+ public:
+  UPowerTooltip(uint iconSize, uint tooltipSpacing, uint tooltipPadding);
+  ~UPowerTooltip();
+
+  uint updateTooltip(Devices& devices);
+};
+
+}  // namespace waybar::modules::upower

include/modules/wlr/taskbar.hpp

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

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

@@ -20,13 +20,13 @@ extern std::list<pid_t> reap;
 namespace waybar::util::command {
 
 struct res {
-  int         exit_code;
+  int exit_code;
   std::string out;
 };
 
 inline std::string read(FILE* fp) {
   std::array<char, 128> buffer = {0};
-  std::string           output;
+  std::string output;
   while (feof(fp) == 0) {
     if (fgets(buffer.data(), 128, fp) != nullptr) {
       output += buffer.data();
@@ -68,7 +68,10 @@ inline int close(FILE* fp, pid_t pid) {
 inline FILE* open(const std::string& cmd, int& pid) {
   if (cmd == "") return nullptr;
   int fd[2];
-  pipe(fd);
+  if (pipe(fd) != 0) {
+    spdlog::error("Unable to pipe fd");
+    return nullptr;
+  }
 
   pid_t child_pid = fork();
 
@@ -109,7 +112,7 @@ inline FILE* open(const std::string& cmd, int& pid) {
 }
 
 inline struct res exec(const std::string& cmd) {
-  int  pid;
+  int pid;
   auto fp = command::open(cmd, pid);
   if (!fp) return {-1, ""};
   auto output = command::read(fp);
@@ -118,7 +121,7 @@ inline struct res exec(const std::string& cmd) {
 }
 
 inline struct res execNoRead(const std::string& cmd) {
-  int  pid;
+  int pid;
   auto fp = command::open(cmd, pid);
   if (!fp) return {-1, ""};
   auto stat = command::close(fp, pid);

include/util/format.hpp

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

include/util/json.hpp

@@ -13,7 +13,7 @@ struct JsonParser {
       return root;
     }
     std::unique_ptr<Json::CharReader> const reader(builder_.newCharReader());
-    std::string                             err;
+    std::string err;
     bool res = reader->parse(data.c_str(), data.c_str() + data.size(), &root, &err);
     if (!res) throw std::runtime_error(err);
     return root;

include/util/rfkill.hpp

@@ -17,8 +17,8 @@ class Rfkill : public sigc::trackable {
 
  private:
   enum rfkill_type rfkill_type_;
-  bool             state_ = false;
-  int              fd_ = -1;
+  bool state_ = false;
+  int fd_ = -1;
 
   bool on_event(Glib::IOCondition cond);
 };

include/util/sleeper_thread.hpp

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

include/util/string.hpp

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

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-battery.5.scd

@@ -120,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

@@ -6,21 +6,41 @@ waybar - bluetooth module
 
 # DESCRIPTION
 
-The *bluetooth* module displays information about the status of the device's bluetooth device.
+The *bluetooth* module displays information about a bluetooth controller and its connections.
 
 # CONFIGURATION
 
 Addressed by *bluetooth*
 
+*controller*: ++
+	typeof: string ++
+	Use the controller with the defined alias. Otherwise a random controller is used. Recommended to define when there is more than 1 controller available to the system.
+
+*format-device-preference*: ++
+	typeof: array ++
+	A ranking of bluetooth devices, addressed by their alias. The order is from *first displayed* to *last displayed*. ++
+	If this config option is not defined or none of the devices in the list are connected, it will fall back to showing the last connected device.
+
 *format*: ++
 	typeof: string  ++
-	default: *{icon}* ++
+	default: * {status}* ++
 	The format, how information should be displayed. This format is used when other formats aren't specified.
 
-*format-icons*: ++
-	typeof: array/object ++
-	Based on the device status, the corresponding icon gets selected. ++
-	The order is *low* to *high*. Or by the state if it is an object.
+*format-disabled*: ++
+	typeof: string ++
+	This format is used when the displayed controller is disabled.
+
+*format-off*: ++
+	typeof: string ++
+	This format is used when the displayed controller is turned off.
+
+*format-on*: ++
+	typeof: string ++
+	This format is used when the displayed controller is turned on with no devices connected.
+
+*format-connected*: ++
+	typeof: string ++
+	This format is used when the displayed controller is connected to at least 1 device.
 
 *rotate*: ++
 	typeof: integer ++
@@ -71,26 +91,104 @@ Addressed by *bluetooth*
 	typeof: string ++
 	The format, how information should be displayed in the tooltip. This format is used when other formats aren't specified.
 
+*tooltip-format-disabled*: ++
+	typeof: string ++
+	This format is used when the displayed controller is disabled.
+
+*tooltip-format-off*: ++
+	typeof: string ++
+	This format is used when the displayed controller is turned off.
+
+*tooltip-format-on*: ++
+	typeof: string ++
+	This format is used when the displayed controller is turned on with no devices connected.
+
+*tooltip-format-connected*: ++
+	typeof: string ++
+	This format is used when the displayed controller is connected to at least 1 device.
+
+*tooltip-format-enumerate-connected*: ++
+	typeof: string ++
+	This format is used to define how each connected device should be displayed within the *device_enumerate* format replacement in the tooltip menu.
+
 # FORMAT REPLACEMENTS
 
 *{status}*: Status of the bluetooth device.
 
-*{icon}*: Icon, as defined in *format-icons*.
+*{num_connections}*: Number of connections the displayed controller has.
+
+*{controller_address}*: Address of the displayed controller.
+
+*{controller_address_type}*: Address type of the displayed controller.
+
+*{controller_alias}*: Alias of the displayed controller.
+
+*{device_address}*: Address of the displayed device.
+
+*{device_address_type}*: Address type of the displayed device.
+
+*{device_alias}*: Alias of the displayed device.
+
+*{device_enumerate}*: Show a list of all connected devices, each on a seperate line. Define the format of each device with the *tooltip-format-enumerate-connected* ++
+and/or *tooltip-format-enumerate-connected-battery* config options. Can only be used in the tooltip related format options.
+
+# EXPERIMENTAL BATTERY PERCENTAGE FEATURE
+
+At the time of writing, the experimental features of BlueZ need to be turned on, for the battery percentage options listed below to work.
+
+## FORMAT REPLACEMENT
+
+*{device_battery_percentage}*: Battery percentage of the displayed device if available. Use only in the config options defined below.
+
+## CONFIGURATION
+
+*format-connected-battery*: ++
+	typeof: string ++
+	This format is used when the displayed device provides its battery percentage.
+
+*tooltip-format-connected-battery*: ++
+	typeof: string ++
+	This format is used when the displayed device provides its battery percentage.
+
+*tooltip-format-enumerate-connected-battery*: ++
+	typeof: string ++
+	This format is used to define how each connected device with a battery should be displayed within the *device_enumerate* format replacement option. ++
+	When this config option is not defined, it will fall back on the *tooltip-format-enumerate-connected* config option.
 
 # EXAMPLES
 
 ```
 "bluetooth": {
-	"format": "{icon}",
-	"format-alt": "bluetooth: {status}",
-	"format-icons": {
-		"enabled": "",
-		"disabled": ""
-	},
-	"tooltip-format": "{}"
+	// "controller": "controller1", // specify the alias of the controller if there are more than 1 on the system
+	"format": " {status}",
+	"format-disabled": "", // an empty format will hide the module
+	"format-connected": " {num_connections} connected",
+	"tooltip-format": "{controller_alias}\\t{controller_address}",
+	"tooltip-format-connected": "{controller_alias}\\t{controller_address}\\n\\n{device_enumerate}",
+	"tooltip-format-enumerate-connected": "{device_alias}\\t{device_address}"
+}
+```
+
+```
+"bluetooth": {
+	"format": " {status}",
+	"format-connected": " {device_alias}",
+	"format-connected-battery": " {device_alias} {device_battery_percentage}%",
+	// "format-device-preference": [ "device1", "device2" ], // preference list deciding the displayed device
+	"tooltip-format": "{controller_alias}\\t{controller_address}\\n\\n{num_connections} connected",
+	"tooltip-format-connected": "{controller_alias}\\t{controller_address}\\n\\n{num_connections} connected\\n\\n{device_enumerate}",
+	"tooltip-format-enumerate-connected": "{device_alias}\\t{device_address}",
+	"tooltip-format-enumerate-connected-battery": "{device_alias}\\t{device_address}\\t{device_battery_percentage}%"
 }
 ```
 
 # STYLE
 
 - *#bluetooth*
+- *#bluetooth.disabled*
+- *#bluetooth.off*
+- *#bluetooth.on*
+- *#bluetooth.connected*
+- *#bluetooth.discoverable*
+- *#bluetooth.discovering*
+- *#bluetooth.pairable*

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 ++
@@ -85,11 +86,17 @@ The *clock* module displays the current date and time.
 	typeof: double ++
 	Threshold to be used when scrolling.
 
+*tooltip*: ++
+	typeof: bool ++
+	default: true ++
+	Option to disable tooltip on hover.
+
 View all valid format options in *strftime(3)*.
 
 # FORMAT REPLACEMENTS
 
 *{calendar}*: Current month calendar
+*{timezoned_time_list}*: List of time in the rest timezones, if more than one timezone is set in the config
 
 # EXAMPLES
 

man/waybar-cpu.5.scd

@@ -20,6 +20,11 @@ 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.
@@ -77,7 +82,9 @@ The *cpu* module displays the current cpu utilization.
 
 *{load}*: Current cpu load.
 
-*{usage}*: Current cpu usage.
+*{usage}*: Current overall cpu usage.
+
+*{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.
 
@@ -85,7 +92,13 @@ The *cpu* module displays the current cpu utilization.
 
 *{min_frequency}*: Current cpu min frequency (based on the core with the lowest frequency) in GHz.
 
-# EXAMPLE
+*{icon}*: Icon for overall cpu usage.
+
+*{icon*{n}*}*: Icon for cpu core n usage. Use like {icon0}.
+
+# EXAMPLES
+
+Basic configuration:
 
 ```
 "cpu": {
@@ -95,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

@@ -151,7 +151,8 @@ $text\\n$tooltip\\n$class*
 	"max-length": 40,
 	"interval": 30, // Remove this if your script is endless and write in loop
 	"exec": "$HOME/.config/waybar/mediaplayer.sh 2> /dev/null", // Script in resources folder
-	"exec-if": "pgrep spotify"
+	"exec-if": "pgrep spotify",
+	"return-type": "json"
 }
 ```
 

man/waybar-gamemode.5.scd

@@ -0,0 +1,95 @@
+waybar-gamemode(5)
+
+# NAME
+
+waybar - gamemode module
+
+# DESCRIPTION
+
+The *gamemode* module displays if any game or application is running with ++
+Feral Gamemode optimizations.
+
+# CONFIGURATION
+
+*format*: ++
+	typeof: string ++
+	default: {glyph} ++
+	The text format.
+
+*format-alt*: ++
+	typeof: string ++
+	default: {glyph} {count} ++
+	The text format when toggled.
+
+*tooltip*: ++
+	typeof: bool ++
+	defualt: true ++
+	Option to disable tooltip on hover.
+
+*tooltip-format*: ++
+	typeof: string ++
+	default: Games running: {glyph} ++
+	The text format of the tooltip.
+
+*hide-not-running*: ++
+	typeof: bool ++
+	default: true ++
+	Defines if the module should be hidden if no games are running.
+
+*use-icon*: ++
+	typeof: bool ++
+	default: true ++
+	Defines if the module should display a GTK icon instead of the specified *glyph*
+
+*glyph*: ++
+	typeof: string ++
+	default:  ++
+	The string icon to display. Only visible if *use-icon* is set to false.
+
+*icon-name*: ++
+	typeof: string ++
+	default: input-gaming-symbolic ++
+	The GTK icon to display. Only visible if *use-icon* is set to true.
+
+*icon-size*: ++
+	typeof: unsigned integer ++
+	default: 20 ++
+	Defines the size of the icons.
+
+*icon-spacing*: ++
+	typeof: unsigned integer ++
+	default: 4 ++
+	Defines the spacing between the icon and the text.
+
+# FORMAT REPLACEMENTS
+
+*{glyph}*: The string icon glyph to use instead.
+
+*{count}*: The amount of games running with gamemode optimizations.
+
+# TOOLTIP FORMAT REPLACEMENTS
+
+*{count}*: The amount of games running with gamemode optimizations.
+
+# EXAMPLES
+
+```
+"gamemode": {
+	"format": "{glyph}",
+	"format-alt": "{glyph} {count}",
+	"glyph": "",
+	"hide-not-running": true,
+	"use-icon": true,
+	"icon-name": "input-gaming-symbolic",
+	"icon-spacing": 4,
+	"icon-size": 20,
+	"tooltip": true,
+	"tooltip-format": "Games running: {count}"
+}
+
+```
+
+# STYLE
+
+- *#gamemode*
+- *#gamemode.running*

man/waybar-idle-inhibitor.5.scd

@@ -63,6 +63,10 @@ screensaving, also known as "presentation mode".
 	typeof: double ++
 	Threshold to be used when scrolling.
 
+*timeout*: ++
+	typeof: double ++
+	The number of minutes the inhibit should last.
+
 *tooltip*: ++
 	typeof: bool ++
 	default: true ++
@@ -82,6 +86,7 @@ screensaving, also known as "presentation mode".
 	"format-icons": {
 	    "activated": "",
 	    "deactivated": ""
-	}
+	},
+	"timeout": 30.5
 }
 ```

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,87 @@
+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.
+
+You must be a member of the input group to use this module.
+
+# 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*
+- *#keyboard-state label.numlock*
+- *#keyboard-state label.numlock.locked*
+- *#keyboard-state label.capslock*
+- *#keyboard-state label.capslock.locked*
+- *#keyboard-state label.scrolllock*
+- *#keyboard-state label.scrolllock.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.
@@ -79,12 +84,20 @@ Addressed by *memory*
 
 *{percentage}*: Percentage of memory in use.
 
+*{swapPercentage}*: Percentage of swap in use.
+
 *{total}*: Amount of total memory available in GiB.
 
+*{swapTotal}*: Amount of total swap available in GiB.
+
 *{used}*: Amount of used memory in GiB.
 
+*{swapUsed}*: Amount of used swap in GiB.
+
 *{avail}*: Amount of available memory in GiB.
 
+*{swapAvail}*: Amount of available swap in GiB.
+
 # EXAMPLES
 
 ```

man/waybar-mpd.5.scd

@@ -172,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

@@ -131,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

@@ -109,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)
@@ -131,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,12 +15,17 @@ 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
 
 ```
@@ -34,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-river-window.5.scd

@@ -0,0 +1,59 @@
+waybar-river-window(5)
+
+# NAME
+
+waybar - river window module
+
+# DESCRIPTION
+
+The *window* module displays the title of the currently focused window in river
+
+# CONFIGURATION
+
+Addressed by *river/window*
+
+*format*: ++
+	typeof: string ++
+	default: {} ++
+	The format, how information should be displayed. On {} data gets inserted.
+
+*rotate*: ++
+	typeof: integer ++
+	Positive value to rotate the text label.
+
+*max-length*: ++
+	typeof: integer ++
+	The maximum length in character the module should display.
+
+*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.
+
+*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.
+
+# EXAMPLES
+
+```
+"river/window": {
+    "format": "{}"
+}
+```
+
+# STYLE
+
+- *#window*
+- *#window.focused* Applied when the output this module's bar belongs to is focused.

man/waybar-sway-language.5.scd

@@ -15,63 +15,39 @@ Addressed by *sway/language*
 *format*: ++
 	typeof: string ++
 	default: {} ++
-	The format, how information should be displayed. On {} data gets inserted.
+	The format, how layout 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.
-
-*on-click*: ++
+*tooltip-format*: ++
 	typeof: string ++
-	Command to execute when clicked on the module.
-
-*on-click-middle*: ++
-	typeof: string ++
-	Command to execute when middle-clicked on the module using mousewheel.
-
-*on-click-right*: ++
-	typeof: string ++
-	Command to execute when you right clicked on the module.
-
-*on-update*: ++
-	typeof: string ++
-	Command to execute when the module is updated.
-
-*on-scroll-up*: ++
-	typeof: string ++
-	Command to execute when scrolling up on the module.
-
-*on-scroll-down*: ++
-	typeof: string ++
-	Command to execute when scrolling down on the module.
-
-*smooth-scrolling-threshold*: ++
-	typeof: double ++
-	Threshold to be used when scrolling.
+	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": "{}",
-    "max-length": 50
+},
+
+"sway/language": {
+    "format": "{short} {variant}",
 }
 ```
 

man/waybar-sway-mode.5.scd

@@ -69,7 +69,7 @@ Addressed by *sway/mode*
 # EXAMPLES
 
 ```
-"sway/window": {
+"sway/mode": {
     "format": " {}",
     "max-length": 50
 }

man/waybar-sway-window.5.scd

@@ -66,12 +66,42 @@ Addressed by *sway/window*
 	default: true ++
 	Option to disable tooltip on hover.
 
+*rewrite*: ++
+	typeof: object ++
+	Rules to rewrite window title. See *rewrite rules*.
+
+*icon*: ++
+	typeof: bool ++
+	default: false ++
+	Option to hide the application icon.
+
+*icon-size*: ++
+	typeof: integer ++
+	default: 24 ++
+	Option to change the size of the application icon.
+
+# 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

@@ -69,10 +69,6 @@ Addressed by *sway/workspaces*
     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.
@@ -120,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-tray.5.scd

@@ -16,10 +16,23 @@ 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.
 
+*reverse-direction*: ++
+    typeof: bool ++
+    Defines if new app icons should be added in a reverse order
+
 *on-update*: ++
 	typeof: string ++
 	Command to execute when the module is updated.
@@ -37,3 +50,6 @@ Addressed by *tray*
 # STYLE
 
 - *#tray*
+- *#tray > .passive*
+- *#tray > .active*
+- *#tray > .needs-attention*

man/waybar-upower.5.scd

@@ -0,0 +1,76 @@
+waybar-upower(5)
+
+# NAME
+
+waybar - upower module
+
+# DESCRIPTION
+
+The *upower* module displays the main battery capacity with all other upower
+compatible devices in the tooltip.
+
+# CONFIGURATION
+
+*icon-size*: ++
+	typeof: integer ++
+	default: 20 ++
+	Defines the size of the icons.
+
+*format*: ++
+	typeof: string ++
+	default: {percentage} ++
+	The text format.
+
+*format-alt*: ++
+	typeof: string ++
+	default: {percentage} {time} ++
+	The text format when toggled.
+
+*hide-if-empty*: ++
+	typeof: bool ++
+	default: true ++
+	Defines visibility of the module if no devices can be found.
+
+*tooltip*: ++
+	typeof: bool ++
+	defualt: true ++
+	Option to disable tooltip on hover.
+
+*tooltip-spacing*: ++
+	typeof: integer ++
+	default: 4 ++
+	Defines the spacing between the tooltip device name and device battery ++
+	status.
+
+*tooltip-padding*: ++
+	typeof: integer ++
+	default: 4 ++
+	Defines the spacing between the tooltip window edge and the tooltip content.
+
+# FORMAT REPLACEMENTS
+
+*{percentage}*: The battery capacity in percentage
+
+*{time}*: An estimated time either until empty or until fully charged ++
+depending on the charging state.
+
+# EXAMPLES
+
+```
+"upower": {
+	"icon-size": 20,
+	"hide-if-empty": true,
+	"tooltip": true,
+	"tooltip-spacing": 20
+}
+
+```
+
+# STYLE
+
+- *#upower*
+- *#upower.charging*
+- *#upower.discharging*
+- *#upower.full*
+- *#upower.empty*
+- *#upower.unknown-status*

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,10 +93,15 @@ Addressed by *wlr/taskbar*
 # CLICK ACTIONS
 
 *activate*: Bring the application into foreground.
+
 *minimize*: Toggle application's minimized state.
+
 *minimize-raise*: Bring the application into foreground or toggle its minimized state.
+
 *maximize*: Toggle application's maximized state.
+
 *fullscreen*: Toggle application's fullscreen state.
+
 *close*: Close the application.
 
 # EXAMPLES
@@ -98,7 +113,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,88 @@
+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

@@ -64,16 +64,65 @@ 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.
+
+modifier-reset ++
+	typeof: string ++
+	default: *press*
+	Defines the timing of modifier key to reset the bar visibility.
+	To reset the visibility of the bar with the press of the modifier key use *press*.
+	Use *release* to reset the visibility upon the release of the modifier key and only if no other action happened while the key was pressed. This prevents hiding the bar when the modifier is used to switch a workspace, change binding mode or start a keybinding.
+
+*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).
@@ -182,6 +231,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)*
@@ -192,6 +263,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)*
@@ -202,5 +274,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,6 +1,6 @@
 project(
     'waybar', 'cpp', 'c',
-    version: '0.9.6',
+    version: '0.9.13',
     license: 'MIT',
     meson_version: '>= 0.49.0',
     default_options : [
@@ -79,22 +79,25 @@ 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.8.0'], fallback : ['spdlog', 'spdlog_dep'], default_options : ['external_fmt=true'])
+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() or get_option('upower_glib').enabled()))
 jsoncpp = dependency('jsoncpp')
 sigcpp = dependency('sigc++-2.0')
 libepoll = dependency('epoll-shim', required: false)
 libnl = dependency('libnl-3.0', required: get_option('libnl'))
 libnlgen = dependency('libnl-genl-3.0', required: get_option('libnl'))
+upower_glib = dependency('upower-glib', required: get_option('upower_glib'))
 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()
@@ -140,6 +143,7 @@ src_files = files(
     'src/factory.cpp',
     'src/AModule.cpp',
     'src/ALabel.cpp',
+    'src/AIconLabel.cpp',
     'src/modules/custom.cpp',
     'src/modules/disk.cpp',
     'src/modules/idle_inhibitor.cpp',
@@ -147,6 +151,8 @@ src_files = files(
     'src/main.cpp',
     'src/bar.cpp',
     'src/client.cpp',
+    'src/config.cpp',
+    'src/group.cpp',
     'src/util/ustring_clen.cpp'
 )
 
@@ -174,6 +180,7 @@ 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',
@@ -183,11 +190,14 @@ 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
     add_project_arguments('-DHAVE_RIVER', language: 'cpp')
     src_files += 'src/modules/river/tags.cpp'
+    src_files += 'src/modules/river/window.cpp'
 endif
 
 if libnl.found() and libnlgen.found()
@@ -195,6 +205,17 @@ if libnl.found() and libnlgen.found()
     src_files += 'src/modules/network.cpp'
 endif
 
+if (giounix.found() and not get_option('logind').disabled())
+    add_project_arguments('-DHAVE_GAMEMODE', language: 'cpp')
+    src_files += 'src/modules/gamemode.cpp'
+endif
+
+if (upower_glib.found() and giounix.found() and not get_option('logind').disabled())
+    add_project_arguments('-DHAVE_UPOWER', language: 'cpp')
+    src_files += 'src/modules/upower/upower.cpp'
+    src_files += 'src/modules/upower/upower_tooltip.cpp'
+endif
+
 if libpulse.found()
     add_project_arguments('-DHAVE_LIBPULSE', language: 'cpp')
     src_files += 'src/modules/pulseaudio.cpp'
@@ -215,6 +236,11 @@ 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/mpd.cpp'
@@ -230,14 +256,17 @@ if libsndio.found()
     src_files += 'src/modules/sndio.cpp'
 endif
 
-if get_option('rfkill').enabled()
-    if is_linux
-        add_project_arguments('-DWANT_RFKILL', language: 'cpp')
-        src_files += files(
-            'src/modules/bluetooth.cpp',
-            'src/util/rfkill.cpp'
-        )
-    endif
+if (giounix.found() and not get_option('logind').disabled())
+    add_project_arguments('-DHAVE_GIO_UNIX', language: 'cpp')
+    src_files += 'src/modules/inhibitor.cpp'
+    src_files += 'src/modules/bluetooth.cpp'
+endif
+
+if get_option('rfkill').enabled() and is_linux
+    add_project_arguments('-DWANT_RFKILL', language: 'cpp')
+    src_files += files(
+        'src/util/rfkill.cpp'
+    )
 endif
 
 if tz_dep.found()
@@ -247,6 +276,10 @@ else
     src_files += 'src/modules/simpleclock.cpp'
 endif
 
+if get_option('experimental')
+    add_project_arguments('-DUSE_EXPERIMENTAL', language: 'cpp')
+endif
+
 subdir('protocol')
 
 executable(
@@ -266,13 +299,16 @@ executable(
         giounix,
         libnl,
         libnlgen,
+        upower_glib,
         libpulse,
         libudev,
         libepoll,
         libmpdclient,
+        libevdev,
         gtk_layer_shell,
         libsndio,
-        tz_dep
+        tz_dep,
+		xkbregistry
     ],
     include_directories: [include_directories('include')],
     install: true,
@@ -310,11 +346,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-river-window.5.scd',
         'waybar-sway-language.5.scd',
         'waybar-sway-mode.5.scd',
         'waybar-sway-window.5.scd',
@@ -323,10 +361,16 @@ 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',
+        'waybar-upower.5.scd',
     ]
 
+    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]
@@ -349,6 +393,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()
@@ -360,3 +413,4 @@ if clangtidy.found()
             '-p', meson.build_root()
         ] + src_files)
 endif
+

meson_options.txt

@@ -1,7 +1,9 @@
 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('upower_glib', type: 'feature', value: 'auto', description: 'Enable support for upower')
 option('systemd', type: 'feature', value: 'auto', description: 'Install systemd user service unit')
 option('dbusmenu-gtk', type: 'feature', value: 'auto', description: 'Enable support for tray')
 option('man-pages', type: 'feature', value: 'auto', description: 'Generate and install man pages')
@@ -9,3 +11,6 @@ option('mpd', type: 'feature', value: 'auto', description: 'Enable support for t
 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">

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", "sway/language", "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",
@@ -86,7 +96,7 @@
     "backlight": {
         // "device": "acpi_video1",
         "format": "{percent}% {icon}",
-        "format-icons": ["", ""]
+        "format-icons": ["", "", "", "", "", "", "", "", ""]
     },
     "battery": {
         "states": {
@@ -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-family: FontAwesome, Roboto, Helvetica, Arial, sans-serif;
     font-size: 13px;
-    min-height: 0;
 }
 
 window#waybar {
@@ -43,6 +40,9 @@ window#waybar.chromium {
     color: #ffffff;
     /* 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 */
@@ -80,7 +80,6 @@ window#waybar.chromium {
 #idle_inhibitor,
 #mpd {
     padding: 0 10px;
-    margin: 0 4px;
     color: #ffffff;
 }
 
@@ -195,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;
 }
@@ -228,3 +236,19 @@ label:focus {
     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);
+}