Merge pull request #5348 from AntonyLittle/feat/bar-blur

Add bar blur option

Author: Alexays

include/bar.hpp

@@ -17,6 +17,10 @@
 #include "util/kill_signal.hpp"
 #include "xdg-output-unstable-v1-client-protocol.h"
 
+#ifdef HAVE_BAR_BLUR
+struct ext_background_effect_surface_v1;
+#endif
+
 namespace waybar {
 
 class Factory;
@@ -79,6 +83,12 @@ class Bar : public sigc::trackable {
 
   void toggleSuspend(bool suspend);
 
+#ifdef HAVE_BAR_BLUR
+  // Re-applies the blur region; called after a CSS reload since the bar's
+  // border-radius may have changed without a resize event.
+  void updateBlurRegion();
+#endif
+
   struct waybar_output* output;
   Json::Value config;
   struct wl_surface* surface;
@@ -107,6 +117,9 @@ class Bar : public sigc::trackable {
   void onConfigure(GdkEventConfigure* ev);
   void configureGlobalOffset(int width, int height);
   void onOutputGeometryChanged();
+#ifdef HAVE_BAR_BLUR
+  void setupBackgroundBlur();
+#endif
 
   /* Copy initial set of modes to allow customization */
   bar_mode_map configured_modes = PRESET_MODES;
@@ -115,6 +128,10 @@ class Bar : public sigc::trackable {
   struct bar_margins margins_;
   uint32_t width_, height_;
   bool passthrough_;
+#ifdef HAVE_BAR_BLUR
+  bool blur_enabled_ = false;
+  struct ext_background_effect_surface_v1* background_effect_surface_ = nullptr;
+#endif
 
   Gtk::Box left_;
   Gtk::Box center_;

include/client.hpp

@@ -13,6 +13,9 @@
 struct zwp_idle_inhibitor_v1;
 struct zwp_idle_inhibit_manager_v1;
 struct ext_idle_notifier_v1;
+#ifdef HAVE_BAR_BLUR
+struct ext_background_effect_manager_v1;
+#endif
 
 namespace waybar {
 
@@ -29,6 +32,9 @@ class Client {
   struct zxdg_output_manager_v1* xdg_output_manager = nullptr;
   struct zwp_idle_inhibit_manager_v1* idle_inhibit_manager = nullptr;
   struct ext_idle_notifier_v1* idle_notifier = nullptr;
+#ifdef HAVE_BAR_BLUR
+  struct ext_background_effect_manager_v1* background_effect_manager = nullptr;
+#endif
   std::vector<std::unique_ptr<Bar>> bars;
   Config config;
   std::string bar_id;

man/waybar.5.scd.in

@@ -169,6 +169,13 @@ The visual display elements for waybar use a CSS stylesheet. Waybar supports *st
 	Possible values: *show*, *hide*, *toggle*, *reload*, *noop*. ++
 	Default value: *reload*.
 
+*blur* ++
+	typeof: bool ++
+	default: false ++
+	Requests blur-behind for the bar's own background, via the standard
+	*ext-background-effect-v1* Wayland protocol. Has no effect if the
+	compositor doesn't support it.
+
 # MODULE FORMAT
 
 You can use PangoMarkupFormat (See https://developer.gnome.org/pango/stable/PangoMarkupFormat.html#PangoMarkupFormat).

meson.build

@@ -392,6 +392,10 @@ if get_option('mango')
     )
 endif
 
+if wayland_protos.version().version_compare('>=1.41')
+    # Bar-level blur-behind support (ext-background-effect-v1)
+    add_project_arguments('-DHAVE_BAR_BLUR', language: 'cpp')
+endif
 if true
     add_project_arguments('-DHAVE_WAYFIRE', language: 'cpp')
     src_files += files(

protocol/meson.build

@@ -38,6 +38,12 @@ if wayland_protos.version().version_compare('>=1.39')
     ]
 endif
 
+if wayland_protos.version().version_compare('>=1.41')
+    client_protocols += [
+        [wl_protocol_dir, 'staging/ext-background-effect/ext-background-effect-v1.xml'],
+    ]
+endif
+
 client_protos_src = []
 client_protos_headers = []
 

src/bar.cpp

@@ -3,6 +3,7 @@
 #include <gtk-layer-shell.h>
 #include <spdlog/spdlog.h>
 
+#include <algorithm>
 #include <ostream>
 #include <type_traits>
 
@@ -16,6 +17,11 @@
 #ifdef HAVE_SWAY
 #include "modules/sway/bar.hpp"
 #endif
+#ifdef HAVE_BAR_BLUR
+#include <gtk/gtk.h>
+
+#include "ext-background-effect-v1-client-protocol.h"
+#endif
 
 namespace waybar {
 static constexpr const char* MIN_HEIGHT_MSG =
@@ -181,6 +187,10 @@ waybar::Bar::Bar(struct waybar_output* w_output, const Json::Value& w_config)
   height_ = config["height"].isUInt() ? config["height"].asUInt() : 0;
   width_ = config["width"].isUInt() ? config["width"].asUInt() : 0;
 
+#ifdef HAVE_BAR_BLUR
+  blur_enabled_ = config["blur"].isBool() && config["blur"].asBool();
+#endif
+
   if (config["margin-top"].isInt() || config["margin-right"].isInt() ||
       config["margin-bottom"].isInt() || config["margin-left"].isInt()) {
     margins_ = {
@@ -301,7 +311,7 @@ waybar::Bar::Bar(struct waybar_output* w_output, const Json::Value& w_config)
     auto strSigusr1 = configSigusr1.asString();
     try {
       onSigusr1 =
-        util::parseStringToEnum<util::KillSignalAction>(strSigusr1, util::userKillSignalActions);
+          util::parseStringToEnum<util::KillSignalAction>(strSigusr1, util::userKillSignalActions);
     } catch (const std::invalid_argument& e) {
       onSigusr1 = util::SIGNALACTION_DEFAULT_SIGUSR1;
       spdlog::warn(
@@ -313,7 +323,7 @@ waybar::Bar::Bar(struct waybar_output* w_output, const Json::Value& w_config)
     auto strSigusr2 = configSigusr2.asString();
     try {
       onSigusr2 =
-        util::parseStringToEnum<util::KillSignalAction>(strSigusr2, util::userKillSignalActions);
+          util::parseStringToEnum<util::KillSignalAction>(strSigusr2, util::userKillSignalActions);
     } catch (const std::invalid_argument& e) {
       onSigusr2 = util::SIGNALACTION_DEFAULT_SIGUSR2;
       spdlog::warn(
@@ -356,6 +366,12 @@ waybar::Bar::~Bar() {
    * modules_all_ -- already freed by this point. Disconnect first (#5182). */
   unmap_conn_.disconnect();
   map_conn_.disconnect();
+#ifdef HAVE_BAR_BLUR
+  if (background_effect_surface_) {
+    ext_background_effect_surface_v1_destroy(background_effect_surface_);
+    background_effect_surface_ = nullptr;
+  }
+#endif
 }
 
 void waybar::Bar::setMode(const std::string& mode) {
@@ -492,8 +508,96 @@ void waybar::Bar::onMap(GdkEventAny* /*unused*/) {
   configureGlobalOffset(gdk_window_get_width(gdk_window), gdk_window_get_height(gdk_window));
 
   setPassThrough(passthrough_);
+#ifdef HAVE_BAR_BLUR
+  setupBackgroundBlur();
+#endif
+}
+
+#ifdef HAVE_BAR_BLUR
+// Requests blur-behind for this bar's own surface, via the standard
+// ext-background-effect-v1 protocol.
+void waybar::Bar::setupBackgroundBlur() {
+  if (!blur_enabled_ || background_effect_surface_ || !surface) {
+    return;
+  }
+  auto* manager = Client::inst()->background_effect_manager;
+  if (!manager) {
+    spdlog::warn("[bar]: Compositor does not support ext-background-effect-v1; blur disabled");
+    return;
+  }
+  background_effect_surface_ =
+      ext_background_effect_manager_v1_get_background_effect(manager, surface);
+  updateBlurRegion();
 }
 
+// Re-applies the blur region to match the bar's current pixel size, clipped to the bar's
+// actual rendered CSS background shape (rounded corners, including asymmetric top/bottom
+// radii) so blur doesn't leak past it as a rectangular "ghost".
+void waybar::Bar::updateBlurRegion() {
+  if (!blur_enabled_ || !background_effect_surface_ || !surface) {
+    return;
+  }
+  // Query the live GDK window size rather than width_/height_: those track the
+  // user-requested config size and may still be unset (0) the first time we're
+  // called, from onMap, before any configure event has landed.
+  auto gdk_window_ref = window.get_window();
+  if (!gdk_window_ref) {
+    return;
+  }
+  auto* gdk_window = gdk_window_ref->gobj();
+  const int32_t w = gdk_window_get_width(gdk_window);
+  const int32_t h = gdk_window_get_height(gdk_window);
+  if (w <= 0 || h <= 0) {
+    return;
+  }
+  auto* compositor = gdk_wayland_display_get_wl_compositor(window.get_display()->gobj());
+  if (!compositor) {
+    return;
+  }
+
+  auto* style_context = window.get_style_context()->gobj();
+  gint radius = 0;
+  gtk_style_context_get(style_context, GTK_STATE_FLAG_NORMAL, GTK_STYLE_PROPERTY_BORDER_RADIUS,
+                        &radius, nullptr);
+  radius = std::clamp<gint>(radius, 0, std::min(w, h) / 2);
+
+  wl_region* region = wl_compositor_create_region(compositor);
+  if (radius <= 0) {
+    wl_region_add(region, 0, 0, w, h);
+  } else {
+    // Middle band, full width, between the two corner strips.
+    wl_region_add(region, 0, radius, w, h - 2 * radius);
+    // Rasterize the actual CSS background to find each corner row's opaque span, so
+    // top and bottom corners are clipped correctly even when their radii differ.
+    cairo_surface_t* mask = cairo_image_surface_create(CAIRO_FORMAT_A8, w, h);
+    cairo_t* cr = cairo_create(mask);
+    gtk_render_background(style_context, cr, 0, 0, w, h);
+    cairo_surface_flush(mask);
+    const unsigned char* data = cairo_image_surface_get_data(mask);
+    const int stride = cairo_image_surface_get_stride(mask);
+
+    auto add_opaque_span = [&](int32_t y) {
+      const unsigned char* row = data + static_cast<size_t>(y) * stride;
+      int32_t left = 0;
+      while (left < w && row[left] == 0) ++left;
+      int32_t right = w;
+      while (right > left && row[right - 1] == 0) --right;
+      if (right > left) {
+        wl_region_add(region, left, y, right - left, 1);
+      }
+    };
+    for (int32_t y = 0; y < radius; ++y) add_opaque_span(y);
+    for (int32_t y = h - radius; y < h; ++y) add_opaque_span(y);
+
+    cairo_destroy(cr);
+    cairo_surface_destroy(mask);
+  }
+  ext_background_effect_surface_v1_set_blur_region(background_effect_surface_, region);
+  wl_region_destroy(region);
+  wl_surface_commit(surface);
+}
+#endif
+
 void waybar::Bar::setVisible(bool value) {
   visible = value;
   if (auto mode = config.get("mode", {}); mode.isString()) {
@@ -700,6 +804,9 @@ void waybar::Bar::onConfigure(GdkEventConfigure* ev) {
 
   configureGlobalOffset(ev->width, ev->height);
   spdlog::info(BAR_SIZE_MSG, ev->width, ev->height, output->name);
+#ifdef HAVE_BAR_BLUR
+  updateBlurRegion();
+#endif
 
   /*
    * gtk-layer-shell waits for the compositor's initial configure while realizing the window. On a

src/client.cpp

@@ -13,6 +13,9 @@
 #include "util/clara.hpp"
 #include "util/format.hpp"
 #include "util/hex_checker.hpp"
+#ifdef HAVE_BAR_BLUR
+#include "ext-background-effect-v1-client-protocol.h"
+#endif
 
 waybar::Client* waybar::Client::inst() {
   static auto* c = new Client();
@@ -47,6 +50,16 @@ void waybar::Client::handleGlobal(void* data, struct wl_registry* registry, uint
     client->idle_notifier = static_cast<struct ext_idle_notifier_v1 *>(
         wl_registry_bind(registry, name, &ext_idle_notifier_v1_interface, bind_version));
     spdlog::debug("Bound ext-idle-notifier-v1 at version {}", bind_version);
+#ifdef HAVE_BAR_BLUR
+  } else if (strcmp(interface, ext_background_effect_manager_v1_interface.name) == 0) {
+    if (client->background_effect_manager != nullptr) {
+      ext_background_effect_manager_v1_destroy(client->background_effect_manager);
+      client->background_effect_manager = nullptr;
+    }
+
+    client->background_effect_manager = static_cast<struct ext_background_effect_manager_v1*>(
+        wl_registry_bind(registry, name, &ext_background_effect_manager_v1_interface, 1));
+#endif
   }
 }
 
@@ -260,6 +273,12 @@ auto waybar::Client::setupCss(const std::string& css_file) -> void {
   }
   Gtk::StyleContext::add_provider_for_screen(screen, css_provider_,
                                              GTK_STYLE_PROVIDER_PRIORITY_USER);
+#ifdef HAVE_BAR_BLUR
+  // The bar's border-radius may have changed without a resize event.
+  for (auto& bar : bars) {
+    bar->updateBlurRegion();
+  }
+#endif
 }
 
 void waybar::Client::bindInterfaces() {