version 40.5-1.2: should works in Wayland now

4 files changed, 571 insertions, 46 deletions

diff --git a/.SRCINFO b/.SRCINFO
index 64884f121bc5..942a0bb1ff9a 100644
--- a/.SRCINFO
+++ b/.SRCINFO
@@ -1,7 +1,7 @@
 pkgbase = mutter-rounded
 	pkgdesc = A window manager for GNOME, with rounded corners patch
 	pkgver = 40.5
-	pkgrel = 1.1
+	pkgrel = 1.2
 	url = https://gitlab.gnome.org/GNOME/mutter
 	install = mutter.install
 	arch = x86_64
@@ -43,10 +43,10 @@ pkgbase = mutter-rounded
 	source = shader.h
 	source = https://gitlab.gnome.org/GNOME/gnome-shell/-/raw/40.5/src/shell-blur-effect.h
 	source = https://gitlab.gnome.org/GNOME/gnome-shell/-/raw/40.5/src/shell-blur-effect.c
-	source = mutter_setting::https://gitlab.gnome.org/lluo/mutter-rounded-setting/uploads/b1ba5b74faf000b93a4ddcbd73ddcb98/main.js
+	source = mutter_setting::https://gitlab.gnome.org/lluo/mutter-rounded-setting/uploads/8f8e3f8d39f31e602c2d09884a6c5dd1/main.js
 	sha256sums = SKIP
-	sha256sums = 9fd2e457f2ef76b454bafee91b5d2d9fb2ac2e17b5aee780cd1dd2c7832a00c4
-	sha256sums = d749f90825025ef597ba20f9e51c11eeefd1ba359f9e01a369d0c0428f134bf5
+	sha256sums = 0c2fc381c7529d012d3d8a4368941db7b60ce6128005008b5ddfb4da16dc2b83
+	sha256sums = 579f8b6164beba2b7ee273bb6843f1681f697d59362d1d97a414cc484ef9b458
 	sha256sums = c47f3a998e5b8dbb53951be450a5f561f91ad8803a653dab2bcee69b1400e6d4
 	sha256sums = 2ec553a260497f0ac0180512201c9819b10159a15fcbc6d5007932d8e2a44844
 	sha256sums = a02e991156dc3b4418899b73a2e65187a43990851fb235ea128ed7650c839a3b
diff --git a/PKGBUILD b/PKGBUILD
index f619b54199df..1647711720a1 100644
--- a/PKGBUILD
+++ b/PKGBUILD
@@ -7,7 +7,7 @@
 
 pkgname=mutter-rounded
 pkgver=40.5
-pkgrel=1.1
+pkgrel=1.2
 pkgdesc="A window manager for GNOME, with rounded corners patch"
 url="https://gitlab.gnome.org/GNOME/mutter"
 arch=(x86_64)
@@ -28,11 +28,11 @@ _commit=2b2b3ab8502a5bcc2436e169279d2421f6f1a605  # tags/40.5^0
 _mutter_src="$pkgname::git+https://gitlab.gnome.org/GNOME/mutter.git#commit=$_commit"
 _shell_blur_h_src="https://gitlab.gnome.org/GNOME/gnome-shell/-/raw/${pkgver}/src/shell-blur-effect.h"
 _shell_blur_c_src="https://gitlab.gnome.org/GNOME/gnome-shell/-/raw/${pkgver}/src/shell-blur-effect.c"
-_setting_src="mutter_setting::https://gitlab.gnome.org/lluo/mutter-rounded-setting/uploads/b1ba5b74faf000b93a4ddcbd73ddcb98/main.js"
+_setting_src="mutter_setting::https://gitlab.gnome.org/lluo/mutter-rounded-setting/uploads/8f8e3f8d39f31e602c2d09884a6c5dd1/main.js"
 
 if [ "${LANG}" = "zh_CN.UTF-8" ] ; then
   _mutter_src="$pkgname::git+https://gitee.com/mirrors_GNOME/mutter.git#commit=$_commit"
-  _setting_src="mutter_setting::https://gitee.com/lluo/mutter-rounded-setting/attach_files/847740/download/main.js"
+  _setting_src="mutter_setting::https://gitee.com/lluo/mutter-rounded-setting/attach_files/865566/download/main.js"
 fi
 
 source=("$_mutter_src"
@@ -45,14 +45,14 @@ source=("$_mutter_src"
         "$_shell_blur_c_src"
         "$_setting_src")
 sha256sums=('SKIP'
-            '9fd2e457f2ef76b454bafee91b5d2d9fb2ac2e17b5aee780cd1dd2c7832a00c4'
-            'd749f90825025ef597ba20f9e51c11eeefd1ba359f9e01a369d0c0428f134bf5'
+            '0c2fc381c7529d012d3d8a4368941db7b60ce6128005008b5ddfb4da16dc2b83'
+            '579f8b6164beba2b7ee273bb6843f1681f697d59362d1d97a414cc484ef9b458'
             'c47f3a998e5b8dbb53951be450a5f561f91ad8803a653dab2bcee69b1400e6d4'
             '2ec553a260497f0ac0180512201c9819b10159a15fcbc6d5007932d8e2a44844'
             'a02e991156dc3b4418899b73a2e65187a43990851fb235ea128ed7650c839a3b'
             '8fb024306843153b28db2f5347775ef7e8add1dd846345148a572ad5336e168b'
             'd58056b5028e1cf02a029036792f52e3429bd5f71a9403b5be93d95a7ba8252a'
-            '0182ba6d60c1bcc13d959b018662ea0bc1cc2347e6648fd455212fa3221dfd79')
+            'c0eff82301060044d231f0b674025e5a00d1152e515e08d16fd18363da5187e5')
 
 pkgver() {
   cd $pkgname
diff --git a/rounded_corners_40.5.patch b/rounded_corners_40.5.patch
index ce04dd3fe400..25f13a2fa546 100644
--- a/rounded_corners_40.5.patch
+++ b/rounded_corners_40.5.patch
@@ -95,7 +95,7 @@ index 580618e48..f62de1924 100644
   * This function takes a 64 bit time stamp from the monotonic clock, and clamps
   * it to the scope of the X server clock, without losing the granularity.
 diff --git a/src/compositor/compositor.c b/src/compositor/compositor.c
-index 1770550d4..26efc84c1 100644
+index 1770550d4..552d7bb24 100644
 --- a/src/compositor/compositor.c
 +++ b/src/compositor/compositor.c
 @@ -84,6 +84,8 @@
@@ -107,16 +107,18 @@ index 1770550d4..26efc84c1 100644
  enum
  {
    PROP_0,
-@@ -610,6 +612,8 @@ meta_compositor_add_window (MetaCompositor    *compositor,
-     window_group = priv->window_group;
- 
-   clutter_actor_add_child (window_group, CLUTTER_ACTOR (window_actor));
-+  meta_window_actor_create_blur_actor(window_actor);
+@@ -615,6 +617,10 @@ meta_compositor_add_window (MetaCompositor    *compositor,
+    * before we first paint.
+    */
+   priv->windows = g_list_append (priv->windows, window_actor);
 +
++  if (window->client_type == META_WINDOW_CLIENT_TYPE_X11)
++    meta_window_actor_create_blur_actor(window_actor);
++
+   sync_actor_stacking (compositor);
+ }
  
-   /* Initial position in the stack is arbitrary; stacking will be synced
-    * before we first paint.
-@@ -661,6 +665,7 @@ meta_compositor_queue_frame_drawn (MetaCompositor *compositor,
+@@ -661,6 +667,7 @@ meta_compositor_queue_frame_drawn (MetaCompositor *compositor,
    MetaWindowActor *window_actor = meta_window_actor_from_window (window);
  
    meta_window_actor_queue_frame_drawn (window_actor, no_delay_frame);
@@ -124,7 +126,7 @@ index 1770550d4..26efc84c1 100644
  }
  
  void
-@@ -992,6 +997,20 @@ meta_compositor_sync_stack (MetaCompositor  *compositor,
+@@ -992,6 +999,20 @@ meta_compositor_sync_stack (MetaCompositor  *compositor,
  
    sync_actor_stacking (compositor);
  
@@ -145,7 +147,7 @@ index 1770550d4..26efc84c1 100644
    top_window_actor = get_top_visible_window_actor (compositor);
  
    if (priv->top_window_actor == top_window_actor)
-@@ -1022,7 +1041,17 @@ meta_compositor_sync_window_geometry (MetaCompositor *compositor,
+@@ -1022,7 +1043,17 @@ meta_compositor_sync_window_geometry (MetaCompositor *compositor,
    changes = meta_window_actor_sync_actor_geometry (window_actor, did_placement);
  
    if (changes & META_WINDOW_ACTOR_CHANGE_SIZE)
@@ -163,7 +165,7 @@ index 1770550d4..26efc84c1 100644
  }
  
  static void
-@@ -1188,6 +1217,44 @@ meta_compositor_get_property (GObject    *object,
+@@ -1188,6 +1219,44 @@ meta_compositor_get_property (GObject    *object,
      }
  }
  
@@ -208,7 +210,7 @@ index 1770550d4..26efc84c1 100644
  static void
  meta_compositor_init (MetaCompositor *compositor)
  {
-@@ -1218,6 +1285,8 @@ meta_compositor_constructed (GObject *object)
+@@ -1218,6 +1287,8 @@ meta_compositor_constructed (GObject *object)
  
    priv->laters = meta_laters_new (compositor);
  
@@ -217,7 +219,7 @@ index 1770550d4..26efc84c1 100644
    G_OBJECT_CLASS (meta_compositor_parent_class)->constructed (object);
  }
  
-@@ -1243,6 +1312,8 @@ meta_compositor_dispose (GObject *object)
+@@ -1243,6 +1314,8 @@ meta_compositor_dispose (GObject *object)
    g_clear_pointer (&priv->feedback_group, clutter_actor_destroy);
    g_clear_pointer (&priv->windows, g_list_free);
  
@@ -226,7 +228,7 @@ index 1770550d4..26efc84c1 100644
    G_OBJECT_CLASS (meta_compositor_parent_class)->dispose (object);
  }
  
-@@ -1576,3 +1647,20 @@ meta_compositor_get_laters (MetaCompositor *compositor)
+@@ -1576,3 +1649,20 @@ meta_compositor_get_laters (MetaCompositor *compositor)
  
    return priv->laters;
  }
@@ -268,6 +270,471 @@ index 64741e416..98495f3d7 100644
 +void meta_window_actor_update_blur_brightness (MetaWindowActor *self);
 +void meta_window_actor_update_blur_window_opacity (MetaWindowActor *self);
  #endif /* META_WINDOW_ACTOR_PRIVATE_H */
+diff --git a/src/compositor/meta-window-actor-wayland.c b/src/compositor/meta-window-actor-wayland.c
+index 641c924db..28f1920f8 100644
+--- a/src/compositor/meta-window-actor-wayland.c
++++ b/src/compositor/meta-window-actor-wayland.c
+@@ -24,10 +24,36 @@
+ #include "compositor/meta-window-actor-wayland.h"
+ #include "meta/meta-window-actor.h"
+ #include "wayland/meta-wayland-surface.h"
++#include "meta/meta-shadow-factory.h"
++#include "ui/frames.h"
++#include "compositor/compositor-private.h"
+ 
+ struct _MetaWindowActorWayland
+ {
+   MetaWindowActor parent;
++
++  /* copy from meta-window-actor-x11.c */
++  MetaShadow *focused_shadow;
++  MetaShadow *unfocused_shadow;
++  gboolean recompute_focused_shadow;
++  gboolean recompute_unfocused_shadow;
++
++  /* The region we should clip to when painting the shadow */
++  cairo_region_t *shadow_clip;
++  /* The frame region */
++  cairo_region_t *frame_bounds;
++  /* A region that matches the shape of the window, including frame bounds */
++  cairo_region_t *shape_region;
++
++  MetaWindowShape *shadow_shape;
++
++  gboolean need_reshape;
++
++  MetaShadowFactory *shadow_factory;
++  gulong shadow_factory_changed_handler_id;
++  gulong size_changed_id;
++  gulong repaint_scheduled_id;
++  
+ };
+ 
+ G_DEFINE_TYPE (MetaWindowActorWayland, meta_window_actor_wayland, META_TYPE_WINDOW_ACTOR)
+@@ -88,18 +114,54 @@ meta_window_actor_wayland_rebuild_surface_tree (MetaWindowActor *actor)
+                    &traverse_data);
+ }
+ 
++static void
++surface_size_changed (MetaSurfaceActor *actor,
++                      gpointer          user_data)
++{
++  MetaWindowActorWayland *actor_wayland = META_WINDOW_ACTOR_WAYLAND (user_data);
++  actor_wayland->need_reshape = TRUE;
++}
++
++static void
++surface_repaint_scheduled (MetaSurfaceActor *actor,
++                           gpointer          user_data)
++{
++  MetaWindowActorWayland *actor_wayland = META_WINDOW_ACTOR_WAYLAND (user_data);
++  MetaWindow *window = meta_window_actor_get_meta_window (META_WINDOW_ACTOR(actor_wayland));
++  meta_compositor_update_blur_behind( meta_display_get_compositor (window->display));
++}
++
++
+ static void
+ meta_window_actor_wayland_assign_surface_actor (MetaWindowActor  *actor,
+                                                 MetaSurfaceActor *surface_actor)
+ {
+   MetaWindowActorClass *parent_class =
+     META_WINDOW_ACTOR_CLASS (meta_window_actor_wayland_parent_class);
++  MetaSurfaceActor *prev_surface_actor;
++  MetaWindowActorWayland *actor_wayland = META_WINDOW_ACTOR_WAYLAND (actor);
++
+ 
+   g_warn_if_fail (!meta_window_actor_get_surface (actor));
+ 
++  prev_surface_actor = meta_window_actor_get_surface (actor);
++  if (prev_surface_actor)
++    g_clear_signal_handler (&META_WINDOW_ACTOR_WAYLAND (actor)->size_changed_id,
++                            prev_surface_actor);
++
+   parent_class->assign_surface_actor (actor, surface_actor);
+ 
+   meta_window_actor_wayland_rebuild_surface_tree (actor);
++
++  actor_wayland->size_changed_id =
++    g_signal_connect (surface_actor, "size-changed",
++                      G_CALLBACK (surface_size_changed),
++                      actor_wayland);
++
++  actor_wayland->repaint_scheduled_id = 
++    g_signal_connect (surface_actor, "repaint-scheduled",
++                      G_CALLBACK (surface_repaint_scheduled),
++                      actor_wayland);
+ }
+ 
+ static void
+@@ -115,10 +177,287 @@ meta_window_actor_wayland_queue_frame_drawn (MetaWindowActor *actor,
+ {
+ }
+ 
++static const char *
++get_shadow_class (MetaWindowActorWayland *actor_x11)
++{
++  MetaWindow *window =
++    meta_window_actor_get_meta_window (META_WINDOW_ACTOR (actor_x11));
++  MetaWindowType window_type;
++
++  window_type = meta_window_get_window_type (window);
++  switch (window_type)
++    {
++    case META_WINDOW_DROPDOWN_MENU:
++    case META_WINDOW_COMBO:
++      return "dropdown-menu";
++    case META_WINDOW_POPUP_MENU:
++      return "popup-menu";
++    default:
++      {
++        MetaFrameType frame_type;
++
++        frame_type = meta_window_get_frame_type (window);
++        return meta_frame_type_to_string (frame_type);
++      }
++    }
++}
++
++static void
++invalidate_shadow (MetaWindowActorWayland *actor_wayland)
++{
++  actor_wayland->recompute_focused_shadow = TRUE;
++  actor_wayland->recompute_unfocused_shadow = TRUE;
++
++  if (meta_window_actor_is_frozen (META_WINDOW_ACTOR (actor_wayland)))
++    return;
++
++  clutter_actor_queue_redraw (CLUTTER_ACTOR (actor_wayland));
++  clutter_actor_invalidate_paint_volume (CLUTTER_ACTOR (actor_wayland));
++}
++
++static void
++update_shape_region (MetaWindowActorWayland *actor_wayland)
++{
++  MetaWindow *window =
++    meta_window_actor_get_meta_window (META_WINDOW_ACTOR (actor_wayland));
++  cairo_region_t *region = NULL;
++  cairo_rectangle_int_t client_area;
++
++  if (meta_window_actor_should_clip(META_WINDOW_ACTOR(actor_wayland)) && !window->frame)
++    {
++      meta_window_actor_get_corner_rect(META_WINDOW_ACTOR(actor_wayland), &client_area);
++      region = cairo_region_create_rectangle(&client_area);  
++    }
++  else
++    {
++      return;
++    }
++  
++  g_clear_pointer (&actor_wayland->shape_region, cairo_region_destroy);
++  actor_wayland->shape_region = region;
++
++  g_clear_pointer (&actor_wayland->shadow_shape, meta_window_shape_unref);
++
++  invalidate_shadow (actor_wayland);
++}
++
++static cairo_region_t *
++meta_window_get_clipped_frame_bounds(MetaWindow *window)
++{
++  g_return_val_if_fail(window, NULL);
++
++  MetaWindowActor *actor = meta_window_actor_from_window(window);
++  if (actor && !window->frame_bounds)
++  {
++    MetaRectangle rect;
++    meta_window_actor_get_corner_rect(actor, &rect);
++    window->frame_bounds = 
++      meta_ui_frame_get_bounds_clipped(&rect,
++                                       meta_prefs_get_round_corner_radius());
++  }
++  return window->frame_bounds;
++}
++
++static void
++update_frame_bounds (MetaWindowActorWayland *actor_wayland)
++{
++  MetaWindow *window =
++    meta_window_actor_get_meta_window (META_WINDOW_ACTOR (actor_wayland));
++
++  g_clear_pointer (&actor_wayland->frame_bounds, cairo_region_destroy);
++  
++  if (meta_window_actor_should_clip(META_WINDOW_ACTOR(actor_wayland)))
++    actor_wayland->frame_bounds =
++      cairo_region_copy(meta_window_get_clipped_frame_bounds(window));
++}
++
++static void
++get_shape_bounds (MetaWindowActorWayland    *actor_wayland,
++                  cairo_rectangle_int_t     *bounds)
++{
++  cairo_region_get_extents (actor_wayland->shape_region, bounds);
++}
++
++static void
++check_needs_shadow (MetaWindowActorWayland *actor_wayland)
++{
++  MetaWindow *window =
++    meta_window_actor_get_meta_window (META_WINDOW_ACTOR (actor_wayland));
++  MetaShadow *old_shadow = NULL;
++  MetaShadow **shadow_location;
++  gboolean recompute_shadow;
++  gboolean should_have_shadow;
++  gboolean appears_focused;
++
++  should_have_shadow = 
++    meta_window_actor_should_clip (META_WINDOW_ACTOR (actor_wayland));
++  appears_focused = meta_window_appears_focused (window);
++
++  if (appears_focused)
++    {
++      recompute_shadow = actor_wayland->recompute_focused_shadow;
++      actor_wayland->recompute_focused_shadow = FALSE;
++      shadow_location = &actor_wayland->focused_shadow;
++    }
++  else
++    {
++      recompute_shadow = actor_wayland->recompute_unfocused_shadow;
++      actor_wayland->recompute_unfocused_shadow = FALSE;
++      shadow_location = &actor_wayland->unfocused_shadow;
++    }
++
++  if (!should_have_shadow || recompute_shadow)
++    {
++      if (*shadow_location != NULL)
++        {
++          old_shadow = *shadow_location;
++          *shadow_location = NULL;
++        }
++    }
++
++  if (!*shadow_location && should_have_shadow)
++    {
++      MetaShadowFactory *factory = actor_wayland->shadow_factory;
++      const char *shadow_class = get_shadow_class (actor_wayland);
++      cairo_rectangle_int_t shape_bounds;
++
++      if (!actor_wayland->shadow_shape)
++        {
++          actor_wayland->shadow_shape =
++            meta_window_shape_new (actor_wayland->shape_region);
++        }
++
++      get_shape_bounds (actor_wayland, &shape_bounds);
++      *shadow_location =
++        meta_shadow_factory_get_shadow (factory,
++                                        actor_wayland->shadow_shape,
++                                        shape_bounds.width, shape_bounds.height,
++                                        shadow_class, appears_focused);
++    }
++
++  if (old_shadow)
++    meta_shadow_unref (old_shadow);
++}
++
++static void
++get_shadow_params (MetaWindowActorWayland *actor_wayland,
++                   gboolean                appears_focused,
++                   MetaShadowParams       *params)
++{
++  const char *shadow_class = get_shadow_class (actor_wayland);
++
++  meta_shadow_factory_get_params (actor_wayland->shadow_factory,
++                                  shadow_class, appears_focused,
++                                  params);
++}
++
++static gboolean
++clip_shadow_under_window (MetaWindowActorWayland *actor_wayland)
++{
++  return TRUE;
++}
++
+ static void
+ meta_window_actor_wayland_before_paint (MetaWindowActor  *actor,
+                                         ClutterStageView *stage_view)
+ {
++  MetaWindowActorWayland *actor_wayland = META_WINDOW_ACTOR_WAYLAND (actor);
++
++  if (meta_window_actor_should_clip (actor))
++    {
++      update_frame_bounds (actor_wayland);
++      if (actor_wayland->need_reshape)
++      {
++        update_shape_region (actor_wayland);
++        actor_wayland->need_reshape = FALSE;
++      }
++      check_needs_shadow (actor_wayland);
++    }
++}
++
++static void
++get_shadow_bounds (MetaWindowActorWayland    *actor_x11,
++                   gboolean                   appears_focused,
++                   cairo_rectangle_int_t     *bounds)
++{
++  MetaShadow *shadow;
++  cairo_rectangle_int_t shape_bounds;
++  MetaShadowParams params;
++
++  shadow = appears_focused ? actor_x11->focused_shadow
++                           : actor_x11->unfocused_shadow;
++
++  get_shape_bounds (actor_x11, &shape_bounds);
++  get_shadow_params (actor_x11, appears_focused, &params);
++
++  meta_shadow_get_bounds (shadow,
++                          params.x_offset + shape_bounds.x,
++                          params.y_offset + shape_bounds.y,
++                          shape_bounds.width,
++                          shape_bounds.height,
++                          bounds);
++}
++
++/* Copy from ./meta-window-actor-x11.c
++ * to draw shadows for rounded wayland clients
++ * because oragin shadows has been cutted out
++ */
++static void
++meta_window_actor_wayland_paint (ClutterActor        *actor,
++                                 ClutterPaintContext *paint_context)
++{
++  MetaWindowActorWayland *actor_wayland = META_WINDOW_ACTOR_WAYLAND (actor);
++  MetaWindow *window;
++  gboolean appears_focused;
++  MetaShadow *shadow;
++
++  window = meta_window_actor_get_meta_window (META_WINDOW_ACTOR (actor_wayland));
++  appears_focused = meta_window_appears_focused (window);
++  shadow = appears_focused ? actor_wayland->focused_shadow
++                           : actor_wayland->unfocused_shadow;
++
++  if (shadow && meta_window_actor_should_clip (META_WINDOW_ACTOR (actor_wayland)))
++    {
++      MetaShadowParams params;
++      cairo_rectangle_int_t shape_bounds;
++      cairo_region_t *clip = actor_wayland->shadow_clip;
++      CoglFramebuffer *framebuffer;
++
++      meta_window_actor_get_corner_rect(META_WINDOW_ACTOR(actor_wayland), &shape_bounds);
++      get_shadow_params (actor_wayland, appears_focused, &params);
++
++      /* The frame bounds are already subtracted from actor_wayland->shadow_clip
++       * if that exists.
++       */
++      if (!clip && clip_shadow_under_window (actor_wayland))
++        {
++          cairo_rectangle_int_t bounds;
++
++          get_shadow_bounds (actor_wayland, appears_focused, &bounds);
++          clip = cairo_region_create_rectangle (&bounds);
++
++          if (actor_wayland->frame_bounds)
++            cairo_region_subtract (clip, actor_wayland->frame_bounds);
++        }
++
++      framebuffer = clutter_paint_context_get_framebuffer (paint_context);
++      meta_shadow_paint (shadow,
++                         framebuffer,
++                         params.x_offset + shape_bounds.x,
++                         params.y_offset + shape_bounds.y,
++                         shape_bounds.width,
++                         shape_bounds.height,
++                         (clutter_actor_get_paint_opacity (actor) *
++                          params.opacity * window->opacity) / (255 * 255),
++                         clip,
++                         clip_shadow_under_window (actor_wayland));
++
++      if (clip && clip != actor_wayland->shadow_clip)
++        cairo_region_destroy (clip);
++    }
++
++  CLUTTER_ACTOR_CLASS (meta_window_actor_wayland_parent_class)->paint (actor,
++                                                                       paint_context);
+ }
+ 
+ static void
+@@ -149,15 +488,34 @@ meta_window_actor_wayland_can_freeze_commits (MetaWindowActor *actor)
+   return FALSE;
+ }
+ 
++static void
++meta_window_actor_wayland_constructed (GObject *object)
++{
++  MetaWindowActorWayland *actor_wayland = META_WINDOW_ACTOR_WAYLAND (object);
++
++  /*
++   * Start off with an empty shape region to maintain the invariant that it's
++   * always set.
++   */
++  actor_wayland->shape_region = cairo_region_create ();
++
++  G_OBJECT_CLASS (meta_window_actor_wayland_parent_class)->constructed (object);
++}
++
+ static void
+ meta_window_actor_wayland_dispose (GObject *object)
+ {
+   MetaWindowActor *window_actor = META_WINDOW_ACTOR (object);
++  MetaWindowActorWayland *actor_wayland = META_WINDOW_ACTOR_WAYLAND (object);
++
+   MetaSurfaceActor *surface_actor =
+     meta_window_actor_get_surface (window_actor);
+   GList *children;
+   GList *l;
+ 
++  g_clear_signal_handler (&actor_wayland->size_changed_id, surface_actor);
++  g_clear_signal_handler (&actor_wayland->repaint_scheduled_id, surface_actor);
++
+   children = clutter_actor_get_children (CLUTTER_ACTOR (window_actor));
+   for (l = children; l; l = l->next)
+     {
+@@ -167,7 +525,17 @@ meta_window_actor_wayland_dispose (GObject *object)
+           child_actor != CLUTTER_ACTOR (surface_actor))
+         clutter_actor_remove_child (CLUTTER_ACTOR (window_actor), child_actor);
+     }
++  
++  g_clear_pointer (&actor_wayland->shape_region, cairo_region_destroy);
++  g_clear_pointer (&actor_wayland->shadow_clip, cairo_region_destroy);
++  g_clear_pointer (&actor_wayland->frame_bounds, cairo_region_destroy);
++
++  g_clear_pointer (&actor_wayland->focused_shadow, meta_shadow_unref);
++  g_clear_pointer (&actor_wayland->unfocused_shadow, meta_shadow_unref);
++  g_clear_pointer (&actor_wayland->shadow_shape, meta_window_shape_unref);
+ 
++  g_clear_signal_handler (&actor_wayland->shadow_factory_changed_handler_id,
++                          actor_wayland->shadow_factory);
+   G_OBJECT_CLASS (meta_window_actor_wayland_parent_class)->dispose (object);
+ }
+ 
+@@ -175,6 +543,7 @@ static void
+ meta_window_actor_wayland_class_init (MetaWindowActorWaylandClass *klass)
+ {
+   MetaWindowActorClass *window_actor_class = META_WINDOW_ACTOR_CLASS (klass);
++  ClutterActorClass *actor_class = CLUTTER_ACTOR_CLASS (klass);
+   GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ 
+   window_actor_class->assign_surface_actor = meta_window_actor_wayland_assign_surface_actor;
+@@ -187,10 +556,19 @@ meta_window_actor_wayland_class_init (MetaWindowActorWaylandClass *klass)
+   window_actor_class->update_regions = meta_window_actor_wayland_update_regions;
+   window_actor_class->can_freeze_commits = meta_window_actor_wayland_can_freeze_commits;
+ 
++  actor_class->paint = meta_window_actor_wayland_paint;
++
++  object_class->constructed = meta_window_actor_wayland_constructed;
+   object_class->dispose = meta_window_actor_wayland_dispose;
+ }
+ 
+ static void
+ meta_window_actor_wayland_init (MetaWindowActorWayland *self)
+ {
++  self->shadow_factory = meta_shadow_factory_get_default ();
++  self->shadow_factory_changed_handler_id =
++    g_signal_connect_swapped (self->shadow_factory,
++                              "changed",
++                              G_CALLBACK (invalidate_shadow),
++                              self);
+ }
 diff --git a/src/compositor/meta-window-actor-x11.c b/src/compositor/meta-window-actor-x11.c
 index e4769e087..60d376858 100644
 --- a/src/compositor/meta-window-actor-x11.c
@@ -384,7 +851,7 @@ index e4769e087..60d376858 100644
  
        /* The frame bounds are already subtracted from actor_x11->shadow_clip
 diff --git a/src/compositor/meta-window-actor.c b/src/compositor/meta-window-actor.c
-index d4fc9a43a..61ba8416b 100644
+index d4fc9a43a..f4eb9ae37 100644
 --- a/src/compositor/meta-window-actor.c
 +++ b/src/compositor/meta-window-actor.c
 @@ -41,6 +41,9 @@
@@ -397,7 +864,7 @@ index d4fc9a43a..61ba8416b 100644
  typedef enum
  {
    INITIALLY_FROZEN,
-@@ -55,6 +58,13 @@ typedef struct _MetaWindowActorPrivate
+@@ -55,6 +58,15 @@ typedef struct _MetaWindowActorPrivate
  
    MetaSurfaceActor *surface;
  
@@ -408,10 +875,12 @@ index d4fc9a43a..61ba8416b 100644
 +  ClutterActor *blur_actor;
 +  MetaShellBlurEffect *blur_effect;
 +
++  ulong visible_changed_id;
++  ulong wm_class_changed_id;
    int geometry_scale;
  
    /*
-@@ -119,6 +129,235 @@ G_DEFINE_ABSTRACT_TYPE_WITH_CODE (MetaWindowActor, meta_window_actor, CLUTTER_TY
+@@ -119,6 +131,245 @@ G_DEFINE_ABSTRACT_TYPE_WITH_CODE (MetaWindowActor, meta_window_actor, CLUTTER_TY
                                    G_IMPLEMENT_INTERFACE (META_TYPE_CULLABLE, cullable_iface_init)
                                    G_IMPLEMENT_INTERFACE (META_TYPE_SCREEN_CAST_WINDOW, screen_cast_window_iface_init));
  
@@ -455,11 +924,11 @@ index d4fc9a43a..61ba8416b 100644
 +  else
 +   {
 +      clutter_actor_set_position (priv->blur_actor,
-+                                  frame_rect.x + priv->clip_padding[0] - 2,
-+                                  frame_rect.y + priv->clip_padding[2] - 2);
++                                  frame_rect.x + priv->clip_padding[0] - 1,
++                                  frame_rect.y + priv->clip_padding[2] - 1);
 +      clutter_actor_set_size (priv->blur_actor,
-+                              frame_rect.width - priv->clip_padding[0] - priv->clip_padding[1] + 3,
-+                              frame_rect.height - priv->clip_padding[2] - priv->clip_padding[3] + 3);
++                              frame_rect.width - priv->clip_padding[0] - priv->clip_padding[1] + 1,
++                              frame_rect.height - priv->clip_padding[2] - priv->clip_padding[3] + 1);
 +      meta_shell_blur_effect_set_skip (priv->blur_effect, false);
 +   }
 +}
@@ -495,6 +964,15 @@ index d4fc9a43a..61ba8416b 100644
 +  }
 +}
 +
++
++/*
++ * in wayland, `res-name` property of MetaWindow is empty when MetaWindow
++ * has been added to MetaWindowActor. So we have to create create blur actor
++ * in on_wm_class_changed callback.
++ * 
++ * in xorg, `res-name` property of MetaWindow has been setted when MetaWindow,
++ * so we can create blur actor when window actor be created.
++ */
 +void
 +meta_window_actor_create_blur_actor (MetaWindowActor *self)
 +{
@@ -520,7 +998,8 @@ index d4fc9a43a..61ba8416b 100644
 +
 +  ClutterActor *parent = clutter_actor_get_parent (CLUTTER_ACTOR(self));
 +  clutter_actor_insert_child_below (parent, priv->blur_actor, CLUTTER_ACTOR(self));
-+  meta_window_set_opacity(priv->window, meta_prefs_get_blur_window_opacity());
++  int opa = meta_prefs_get_blur_window_opacity();
++  meta_window_set_opacity(priv->window, opa);
 +}
 +
 +static void
@@ -581,7 +1060,7 @@ index d4fc9a43a..61ba8416b 100644
 +  MetaWindowActorPrivate *priv = meta_window_actor_get_instance_private (self);
 +  MetaWindow *window = priv->window;
 +
-+  if (meta_window_get_client_type(window) == META_WINDOW_CLIENT_TYPE_WAYLAND ||
++  if (/* meta_window_get_client_type(window) == META_WINDOW_CLIENT_TYPE_WAYLAND || */
 +      meta_prefs_in_black_list(window->res_name))
 +    {
 +      return FALSE;
@@ -647,7 +1126,7 @@ index d4fc9a43a..61ba8416b 100644
  static void
  meta_window_actor_class_init (MetaWindowActorClass *klass)
  {
-@@ -216,6 +455,11 @@ meta_window_actor_init (MetaWindowActor *self)
+@@ -216,6 +467,11 @@ meta_window_actor_init (MetaWindowActor *self)
      meta_window_actor_get_instance_private (self);
  
    priv->geometry_scale = 1;
@@ -659,7 +1138,19 @@ index d4fc9a43a..61ba8416b 100644
  }
  
  static void
-@@ -399,6 +643,20 @@ init_surface_actor (MetaWindowActor *self)
+@@ -368,6 +624,11 @@ meta_window_actor_real_assign_surface_actor (MetaWindowActor  *self,
+     meta_window_actor_set_frozen (self, TRUE);
+   else
+     meta_window_actor_sync_thawed_state (self);
++
++  if (priv->blur_actor)
++    {
++      meta_window_actor_update_opacity (self);
++    }
+ }
+ 
+ void
+@@ -399,6 +660,31 @@ init_surface_actor (MetaWindowActor *self)
      meta_window_actor_assign_surface_actor (self, surface_actor);
  }
  
@@ -677,19 +1168,53 @@ index d4fc9a43a..61ba8416b 100644
 +    clutter_actor_hide(priv->blur_actor);
 +}
 +
++static void
++on_wm_class_changed (MetaWindow *self,
++                     gpointer    user_data)
++{
++  MetaWindowActor *actor = meta_window_actor_from_window (self);
++  MetaWindowActorPrivate *priv = meta_window_actor_get_instance_private (actor);
++
++  meta_window_actor_create_blur_actor(actor);
++  g_clear_signal_handler(&priv->wm_class_changed_id, self);
++}
++
  static void
  meta_window_actor_constructed (GObject *object)
  {
-@@ -424,6 +682,8 @@ meta_window_actor_constructed (GObject *object)
+@@ -406,6 +692,7 @@ meta_window_actor_constructed (GObject *object)
+   MetaWindowActorPrivate *priv =
+     meta_window_actor_get_instance_private (self);
+   MetaWindow *window = priv->window;
++  MetaWindowClientType type = meta_window_get_client_type (window);
+ 
+   priv->compositor = window->display->compositor;
+ 
+@@ -424,6 +711,15 @@ meta_window_actor_constructed (GObject *object)
      priv->first_frame_state = DRAWING_FIRST_FRAME;
  
    meta_window_actor_sync_actor_geometry (self, priv->window->placed);
 +
-+  g_signal_connect (object, "notify::visible", G_CALLBACK (on_visible_changed), object);
++  priv->visible_changed_id = 
++    g_signal_connect (object, "notify::visible", G_CALLBACK (on_visible_changed), NULL);
++
++  if (type == META_WINDOW_CLIENT_TYPE_WAYLAND)
++  {
++    priv->wm_class_changed_id =
++      g_signal_connect (window, "notify::wm-class", G_CALLBACK (on_wm_class_changed), object);
++  }
  }
  
  static void
-@@ -470,6 +730,7 @@ meta_window_actor_set_property (GObject      *object,
+@@ -442,6 +738,7 @@ meta_window_actor_dispose (GObject *object)
+ 
+   priv->disposed = TRUE;
+ 
++  g_clear_signal_handler(&priv->visible_changed_id, object);
+   meta_compositor_remove_window_actor (compositor, self);
+ 
+   g_clear_object (&priv->window);
+@@ -470,6 +767,7 @@ meta_window_actor_set_property (GObject      *object,
      {
      case PROP_META_WINDOW:
        priv->window = g_value_dup_object (value);
@@ -697,7 +1222,7 @@ index d4fc9a43a..61ba8416b 100644
        g_signal_connect_object (priv->window, "notify::appears-focused",
                                 G_CALLBACK (window_appears_focused_notify), self, 0);
        break;
-@@ -662,6 +923,20 @@ start_simple_effect (MetaWindowActor  *self,
+@@ -662,6 +960,20 @@ start_simple_effect (MetaWindowActor  *self,
    return TRUE;
  }
  
@@ -718,7 +1243,7 @@ index d4fc9a43a..61ba8416b 100644
  static void
  meta_window_actor_after_effects (MetaWindowActor *self)
  {
-@@ -675,6 +950,12 @@ meta_window_actor_after_effects (MetaWindowActor *self)
+@@ -675,6 +987,12 @@ meta_window_actor_after_effects (MetaWindowActor *self)
  
    if (priv->needs_destroy)
      {
@@ -731,7 +1256,7 @@ index d4fc9a43a..61ba8416b 100644
        clutter_actor_destroy (CLUTTER_ACTOR (self));
      }
    else
-@@ -803,6 +1084,19 @@ meta_window_actor_queue_destroy (MetaWindowActor *self)
+@@ -803,6 +1121,19 @@ meta_window_actor_queue_destroy (MetaWindowActor *self)
      clutter_actor_destroy (CLUTTER_ACTOR (self));
  }
  
diff --git a/shell_blur_effect_40.5.patch b/shell_blur_effect_40.5.patch
index e592fc1cb800..2189ab285210 100644
--- a/shell_blur_effect_40.5.patch
+++ b/shell_blur_effect_40.5.patch
@@ -1,6 +1,6 @@
 diff -Narup a/src/shell-blur-effect.c b/src/shell-blur-effect.c
---- a/src/shell-blur-effect.c	2021-10-27 19:03:17.979246987 +0800
-+++ b/src/shell-blur-effect.c	2021-10-27 19:03:17.982580970 +0800
+--- a/src/shell-blur-effect.c	2021-10-28 21:09:19.663157558 +0800
++++ b/src/shell-blur-effect.c	2021-10-28 21:09:19.663157558 +0800
 @@ -22,6 +22,9 @@
  
  #include "shell-enum-types.h"
@@ -426,8 +426,8 @@ diff -Narup a/src/shell-blur-effect.c b/src/shell-blur-effect.c
 +    clutter_effect_queue_repaint (CLUTTER_EFFECT (self));
 +}
 diff -Narup a/src/shell-blur-effect.h b/src/shell-blur-effect.h
---- a/src/shell-blur-effect.h	2021-10-27 19:03:17.979246987 +0800
-+++ b/src/shell-blur-effect.h	2021-10-27 19:03:17.982580970 +0800
+--- a/src/shell-blur-effect.h	2021-10-28 21:09:19.663157558 +0800
++++ b/src/shell-blur-effect.h	2021-10-28 21:09:19.663157558 +0800
 @@ -20,6 +20,10 @@
  
  #pragma once