path: root/rounded_corners_40.5.patch

diff --git a/data/org.gnome.mutter.gschema.xml.in b/data/org.gnome.mutter.gschema.xml.in
index 23fa9f3ad..eee73e708 100644
--- a/data/org.gnome.mutter.gschema.xml.in
+++ b/data/org.gnome.mutter.gschema.xml.in
@@ -2,6 +2,78 @@
   <schema id="org.gnome.mutter" path="/org/gnome/mutter/"
           gettext-domain="@GETTEXT_DOMAIN@">
 
+    <key name="blur-sigmal" type="i">
+      <default>20</default>
+      <range min="0" max="100"/>
+      <summary>Blur sigmal</summary>
+    </key>
+
+    <key name="blur-brightness" type="i">
+      <default>100</default>
+      <range min="0" max="100"/>
+      <summary>Blur brightness</summary>
+    </key>
+
+    <key name="blur-list" type="as">
+      <default>[]</default>
+      <summary>windows will enable blur effect</summary>
+    </key>
+
+    <key name="blur-window-opacity" type="i">
+      <default>80</default>
+      <range min="0" max="100"/>
+      <summary>Blur brightness</summary>
+    </key>
+
+    <key name="border-width" type="i">
+      <default>0</default>
+      <range min="0" max="100"/>
+      <summary>Window border</summary>
+    </key>
+
+    <key name="round-corners-radius" type="i">
+      <default>12</default>
+      <range min="2" max="100"/>
+      <summary>Round Corners Radius</summary>
+    </key>
+
+    <key name="clip-edge-padding" type="s">
+      <default>"{\"global\": [0, 0, 0, 0], \"apps\": {}}"</default>
+      <summary>padding of window will be clipped</summary>
+      <description>
+        A JSON string, Represents the clipping range of the window edge.
+        The array represents the clipping range of the four sides (left,
+        right, top, bottom) of the window.
+        
+        The key of "apps" object represent the instance part of the window's
+        `WM_CLASS` property, as same as the output of `xprop WM_CLASS|cut -d 
+        \" -f 2`
+
+        This is a example:
+
+          {
+            'global': [1, 2, 3, 4],
+            'apps': {
+              'code': [5, 6, 7, 8],
+              'typora': [9, 10, 11, 12]
+            }
+          }
+
+        For all window, cut the left, right, top and bottom sides by 1, 2
+        , 3 and 4 pixels respectively. But for Visual Studio Code and
+        Typora, we will cut different pixels.        
+      </description>
+    </key>
+
+    <key name="black-list" type="as">
+      <default>["qq.exe", "tim.exe"]</default>
+      <summary>window here will not be rounded</summary>
+      <description>
+        The contents of the list represent the instance part of the window's
+        `WM_CLASS`, as same as the output of `xprop WM_CLASS|cut -d \" -f 2`
+      </description>
+    </key>
+
     <key name="overlay-key" type="s">
       <default>'Super_L'</default>
       <summary>Modifier to use for extended window management operations</summary>
diff --git a/src/compositor/compositor-private.h b/src/compositor/compositor-private.h
index 580618e48..f62de1924 100644
--- a/src/compositor/compositor-private.h
+++ b/src/compositor/compositor-private.h
@@ -82,6 +82,8 @@ gboolean meta_compositor_is_switching_workspace (MetaCompositor *compositor);
 
 MetaLaters * meta_compositor_get_laters (MetaCompositor *compositor);
 
+void meta_compositor_update_blur_behind(MetaCompositor *compositor);
+
 /*
  * 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..552d7bb24 100644
--- a/src/compositor/compositor.c
+++ b/src/compositor/compositor.c
@@ -84,6 +84,8 @@
 #include "wayland/meta-wayland-private.h"
 #endif
 
+#include "core/meta-workspace-manager-private.h"
+
 enum
 {
   PROP_0,
@@ -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);
 }
 
@@ -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);
+  meta_compositor_update_blur_behind(compositor);
 }
 
 void
@@ -992,6 +999,20 @@ meta_compositor_sync_stack (MetaCompositor  *compositor,
 
   sync_actor_stacking (compositor);
 
+  MetaWorkspaceManager *manager = priv->display->workspace_manager;
+  MetaWorkspace *active_workspace = manager->active_workspace;
+
+  for (GList *l = priv->windows; l; l = l->next)
+    {
+      MetaWindow *window = meta_window_actor_get_meta_window(l->data);
+      MetaWorkspace *workspace = meta_window_get_workspace(window);
+      if (workspace == active_workspace)
+        {
+          meta_window_actor_set_blur_behind(l->data);
+          meta_window_actor_update_blur_position_size(l->data);
+        }
+    }
+
   top_window_actor = get_top_visible_window_actor (compositor);
 
   if (priv->top_window_actor == top_window_actor)
@@ -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)
+  {
+    if (meta_window_actor_should_clip(window_actor))
+      meta_window_actor_update_clipped_bounds(window_actor);
     meta_plugin_manager_event_size_changed (priv->plugin_mgr, window_actor);
+    meta_window_actor_update_blur_position_size(window_actor);
+  }
+
+  if (changes & META_WINDOW_ACTOR_CHANGE_POSITION)
+    meta_window_actor_update_blur_position_size(window_actor);
+
+  meta_compositor_update_blur_behind(compositor);
 }
 
 static void
@@ -1188,6 +1219,44 @@ meta_compositor_get_property (GObject    *object,
     }
 }
 
+static void
+prefs_changed_cb(MetaPreference pref,
+                 gpointer       user_data)
+{
+  MetaCompositor *compositor = user_data;
+  MetaCompositorPrivate *priv =
+    meta_compositor_get_instance_private (compositor);
+  GList *l;
+
+  for (l = priv->windows; l; l = l->next)
+  {
+    switch (pref)
+    {
+    case META_PREF_CORNER_RADIUS:
+    case META_PREF_CLIP_EDGE_PADDING:
+    case META_PREF_BORDER_WIDTH:
+      if (pref == META_PREF_CLIP_EDGE_PADDING)
+        meta_window_actor_update_clip_padding (l->data);
+      
+      meta_window_actor_update_clipped_bounds (l->data);
+      meta_window_actor_update_glsl (l->data);
+      clutter_actor_queue_redraw (CLUTTER_ACTOR (l->data));
+      break;
+    case META_PREF_BLUR_SIGMAL:
+      meta_window_actor_update_blur_sigmal (l->data);
+      break;
+    case META_PREF_BLUR_BRIGHTNESS:
+      meta_window_actor_update_blur_brightness (l->data);
+      break;
+    case META_PREF_BLUR_WINDOW_OPACITY:
+      meta_window_actor_update_blur_window_opacity (l->data);
+      break;
+    default:
+      break;
+    }
+  }
+}
+
 static void
 meta_compositor_init (MetaCompositor *compositor)
 {
@@ -1218,6 +1287,8 @@ meta_compositor_constructed (GObject *object)
 
   priv->laters = meta_laters_new (compositor);
 
+  meta_prefs_add_listener(prefs_changed_cb, compositor);
+
   G_OBJECT_CLASS (meta_compositor_parent_class)->constructed (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);
 
+  meta_prefs_remove_listener(prefs_changed_cb, compositor);
+
   G_OBJECT_CLASS (meta_compositor_parent_class)->dispose (object);
 }
 
@@ -1576,3 +1649,20 @@ meta_compositor_get_laters (MetaCompositor *compositor)
 
   return priv->laters;
 }
+
+void meta_compositor_update_blur_behind(MetaCompositor *compositor)
+{
+  MetaCompositorPrivate *priv =
+    meta_compositor_get_instance_private (compositor);
+
+  MetaWorkspaceManager *manager = priv->display->workspace_manager;
+  MetaWorkspace *active_workspace = manager->active_workspace;
+
+  for (GList *l = priv->windows; l; l = l->next)
+    {
+      MetaWindow *window = meta_window_actor_get_meta_window(l->data);
+      MetaWorkspace *workspace = meta_window_get_workspace(window);
+      if (workspace == active_workspace)
+        meta_window_actor_set_blur_behind(l->data);
+    }
+}
\ No newline at end of file
diff --git a/src/compositor/meta-window-actor-private.h b/src/compositor/meta-window-actor-private.h
index 64741e416..98495f3d7 100644
--- a/src/compositor/meta-window-actor-private.h
+++ b/src/compositor/meta-window-actor-private.h
@@ -99,4 +99,15 @@ void meta_window_actor_update_regions (MetaWindowActor *self);
 
 gboolean meta_window_actor_can_freeze_commits (MetaWindowActor *self);
 
+gboolean meta_window_actor_should_clip (MetaWindowActor *self);
+void meta_window_actor_update_clipped_bounds (MetaWindowActor *window_actor);
+void meta_window_actor_update_glsl (MetaWindowActor *self);
+void meta_window_actor_get_corner_rect (MetaWindowActor *self, MetaRectangle *rect);
+void meta_window_actor_update_clip_padding (MetaWindowActor *self);
+void meta_window_actor_create_blur_actor (MetaWindowActor *self);
+void meta_window_actor_set_blur_behind (MetaWindowActor *self);
+void meta_window_actor_update_blur_position_size (MetaWindowActor *self);
+void meta_window_actor_update_blur_sigmal (MetaWindowActor *self);
+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
+++ b/src/compositor/meta-window-actor-x11.c
@@ -142,7 +142,8 @@ surface_repaint_scheduled (MetaSurfaceActor *actor,
                            gpointer          user_data)
 {
   MetaWindowActorX11 *actor_x11 = META_WINDOW_ACTOR_X11 (user_data);
-
+  MetaWindow *window = meta_window_actor_get_meta_window (META_WINDOW_ACTOR(actor_x11));
+  meta_compositor_update_blur_behind( meta_display_get_compositor (window->display));
   actor_x11->repaint_scheduled = TRUE;
 }
 
@@ -400,6 +401,8 @@ surface_size_changed (MetaSurfaceActor *actor,
   MetaWindowActorX11 *actor_x11 = META_WINDOW_ACTOR_X11 (user_data);
 
   meta_window_actor_x11_update_shape (actor_x11);
+
+  meta_window_actor_update_glsl(META_WINDOW_ACTOR(actor_x11));
 }
 
 static void
@@ -538,6 +541,9 @@ has_shadow (MetaWindowActorX11 *actor_x11)
   if (meta_window_get_frame (window))
     return TRUE;
 
+  if (meta_window_actor_should_clip(META_WINDOW_ACTOR(actor_x11)))
+    return TRUE;
+
   /*
    * Do not add shadows to non-opaque (ARGB32) windows, as we can't easily
    * generate shadows for them.
@@ -694,6 +700,8 @@ clip_shadow_under_window (MetaWindowActorX11 *actor_x11)
 
   if (window->frame)
     return TRUE;
+  if (meta_window_actor_should_clip(META_WINDOW_ACTOR(actor_x11)))
+    return TRUE;
 
   return meta_window_actor_is_opaque (META_WINDOW_ACTOR (actor_x11));
 }
@@ -1036,6 +1044,11 @@ update_shape_region (MetaWindowActorX11 *actor_x11)
     {
       region = cairo_region_reference (window->shape_region);
     }
+  else if (meta_window_actor_should_clip(META_WINDOW_ACTOR(actor_x11)) && !window->frame)
+    {
+      meta_window_actor_get_corner_rect(META_WINDOW_ACTOR(actor_x11), &client_area);
+      region = cairo_region_create_rectangle(&client_area);  
+    }
   else
     {
       /* If we don't have a shape on the server, that means that
@@ -1043,7 +1056,7 @@ update_shape_region (MetaWindowActorX11 *actor_x11)
        * entire window. */
       region = cairo_region_create_rectangle (&client_area);
     }
-
+  
   if (window->shape_region || window->frame)
     build_and_scan_frame_mask (actor_x11, region);
 
@@ -1151,6 +1164,23 @@ update_opaque_region (MetaWindowActorX11 *actor_x11)
   cairo_region_destroy (opaque_region);
 }
 
+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 (MetaWindowActorX11 *actor_x11)
 {
@@ -1158,8 +1188,13 @@ update_frame_bounds (MetaWindowActorX11 *actor_x11)
     meta_window_actor_get_meta_window (META_WINDOW_ACTOR (actor_x11));
 
   g_clear_pointer (&actor_x11->frame_bounds, cairo_region_destroy);
-  actor_x11->frame_bounds =
-    cairo_region_copy (meta_window_get_frame_bounds (window));
+  
+  if (meta_window_actor_should_clip(META_WINDOW_ACTOR(actor_x11)))
+    actor_x11->frame_bounds =
+      cairo_region_copy(meta_window_get_clipped_frame_bounds(window));
+  else
+    actor_x11->frame_bounds =
+      cairo_region_copy (meta_window_get_frame_bounds (window));
 }
 
 static void
@@ -1304,7 +1339,10 @@ meta_window_actor_x11_paint (ClutterActor        *actor,
       cairo_region_t *clip = actor_x11->shadow_clip;
       CoglFramebuffer *framebuffer;
 
-      get_shape_bounds (actor_x11, &shape_bounds);
+      if (meta_window_actor_should_clip(META_WINDOW_ACTOR(actor_x11)))
+        meta_window_actor_get_corner_rect(META_WINDOW_ACTOR(actor_x11), &shape_bounds);
+      else
+        get_shape_bounds (actor_x11, &shape_bounds);
       get_shadow_params (actor_x11, appears_focused, &params);
 
       /* 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..f4eb9ae37 100644
--- a/src/compositor/meta-window-actor.c
+++ b/src/compositor/meta-window-actor.c
@@ -41,6 +41,9 @@
 #include "wayland/meta-wayland-surface.h"
 #endif
 
+#include "meta_clip_effect.h"
+#include "shell-blur-effect.h"
+
 typedef enum
 {
   INITIALLY_FROZEN,
@@ -55,6 +58,15 @@ typedef struct _MetaWindowActorPrivate
 
   MetaSurfaceActor *surface;
 
+  MetaClipEffect *round_clip_effect;
+  gboolean effect_setuped;
+  gboolean should_clip;
+  int clip_padding[4];
+  ClutterActor *blur_actor;
+  MetaShellBlurEffect *blur_effect;
+
+  ulong visible_changed_id;
+  ulong wm_class_changed_id;
   int geometry_scale;
 
   /*
@@ -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));
 
+static gboolean _meta_window_actor_should_clip(MetaWindowActor *self);
+
+static MetaClipEffect*
+create_clip_effect(MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = meta_window_actor_get_instance_private(self);
+  if ((priv->should_clip = _meta_window_actor_should_clip(self)))
+    return meta_clip_effect_new();
+  else
+    return NULL;
+}
+
+void
+meta_window_actor_update_blur_position_size(MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv =
+    meta_window_actor_get_instance_private (self);
+
+  if (!priv->blur_actor)
+    return;
+
+  MetaRectangle buf_rect;
+  MetaRectangle frame_rect;
+  meta_window_get_frame_rect (priv->window, &frame_rect);
+  meta_window_get_buffer_rect (priv->window, &buf_rect);
+
+  if (meta_window_get_maximized (priv->window) ||
+      meta_window_is_fullscreen (priv->window))
+    {
+      clutter_actor_set_position (priv->blur_actor,
+                                  frame_rect.x,
+                                  frame_rect.y);
+      clutter_actor_set_size (priv->blur_actor,
+                              frame_rect.width,
+                              frame_rect.height);
+      meta_shell_blur_effect_set_skip (priv->blur_effect, true);
+    }
+  else
+   {
+      clutter_actor_set_position (priv->blur_actor,
+                                  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] + 1,
+                              frame_rect.height - priv->clip_padding[2] - priv->clip_padding[3] + 1);
+      meta_shell_blur_effect_set_skip (priv->blur_effect, false);
+   }
+}
+
+void
+meta_window_actor_set_blur_behind (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv =
+    meta_window_actor_get_instance_private (self);
+
+  if (!priv->blur_actor)
+    return;
+
+  ClutterActor *parent = clutter_actor_get_parent (CLUTTER_ACTOR(self));
+  clutter_actor_set_child_below_sibling (parent, priv->blur_actor, CLUTTER_ACTOR(self));  
+}
+
+static gboolean
+meta_window_is_normal (MetaWindowActor *actor)
+{
+  MetaWindowActorPrivate *priv = meta_window_actor_get_instance_private (actor);
+  MetaWindowType type = meta_window_get_window_type (priv->window);
+
+switch (type)
+  {
+    case META_WINDOW_NORMAL:
+    case META_WINDOW_DIALOG:
+    case META_WINDOW_MODAL_DIALOG:
+    case META_WINDOW_SPLASHSCREEN:
+      return TRUE;
+    default:
+      return FALSE;
+  }
+}
+
+
+/*
+ * 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)
+{
+  MetaWindowActorPrivate *priv =
+    meta_window_actor_get_instance_private (self);
+  
+  if (!meta_window_is_normal (self))
+    return;
+  if (!meta_prefs_in_blur_list (priv->window->res_name))
+    return;
+
+  priv->blur_actor = clutter_actor_new ();
+  priv->blur_effect = meta_shell_blur_effect_new ();
+
+  meta_shell_blur_effect_set_brightness (priv->blur_effect,
+                                    meta_prefs_get_blur_brightness());
+  meta_shell_blur_effect_set_sigma (priv->blur_effect,
+                               meta_prefs_get_blur_sigmal());
+  meta_shell_blur_effect_set_mode (priv->blur_effect, SHELL_BLUR_MODE_BACKGROUND);
+  clutter_actor_add_effect_with_name (priv->blur_actor,
+                                      "ShellBlurEffect",
+                                      CLUTTER_EFFECT(priv->blur_effect));
+
+  ClutterActor *parent = clutter_actor_get_parent (CLUTTER_ACTOR(self));
+  clutter_actor_insert_child_below (parent, priv->blur_actor, CLUTTER_ACTOR(self));
+  int opa = meta_prefs_get_blur_window_opacity();
+  meta_window_set_opacity(priv->window, opa);
+}
+
+static void
+check_meta_window_surface_actor(MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = meta_window_actor_get_instance_private(self);
+  MetaSurfaceActor *surface = meta_window_actor_get_surface(self);
+
+  if (!priv->effect_setuped && surface && priv->round_clip_effect)
+  {
+    clutter_actor_add_effect_with_name(CLUTTER_ACTOR(surface),
+                                       "Rounded Corners Effect(Surface)",
+                                       CLUTTER_EFFECT(priv->round_clip_effect));
+    priv->effect_setuped = true;
+  }
+}
+
+void
+meta_window_actor_update_glsl(MetaWindowActor *self)
+{
+  MetaRectangle frame_rect;
+  MetaRectangle buf_rect;
+  MetaWindow *window = meta_window_actor_get_meta_window(self);
+  MetaWindowActorPrivate *priv = meta_window_actor_get_instance_private(self);
+
+  if(!priv->round_clip_effect)
+    return;
+
+  check_meta_window_surface_actor(self);
+
+  if (!meta_window_actor_should_clip(self))
+  {
+    meta_clip_effect_skip(priv->round_clip_effect);
+    return;
+  }
+
+  meta_window_get_frame_rect(window, &frame_rect);
+  meta_window_get_buffer_rect(window, &buf_rect);
+
+  cairo_rectangle_int_t bounds;
+  bounds.x = frame_rect.x - buf_rect.x;
+  bounds.y = frame_rect.y - buf_rect.y;
+  bounds.width = frame_rect.width;
+  bounds.height = frame_rect.height;
+
+  if (bounds.width <= 0 || bounds.height <= 0)
+    return;
+
+  if (priv->clip_padding[0] == -1 && window->res_name)
+    meta_prefs_get_clip_edge_padding(window->res_name, priv->clip_padding);
+
+  meta_clip_effect_set_bounds(priv->round_clip_effect, &bounds, priv->clip_padding);
+}
+
+static gboolean
+_meta_window_actor_should_clip(MetaWindowActor *self)
+{
+  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 || */
+      meta_prefs_in_black_list(window->res_name))
+    {
+      return FALSE;
+    }
+
+  return meta_window_is_normal(self);
+}
+
+gboolean
+meta_window_actor_should_clip(MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = meta_window_actor_get_instance_private (self);
+
+  return priv->should_clip && 
+        !(meta_window_get_maximized(priv->window)||
+          meta_window_is_fullscreen(priv->window)); 
+}
+
+void
+meta_window_actor_get_corner_rect(MetaWindowActor *self,
+                                  MetaRectangle *rect)
+{
+  MetaWindowActorPrivate *priv = meta_window_actor_get_instance_private(self);
+  g_return_if_fail(priv->round_clip_effect);
+  meta_clip_effect_get_bounds(priv->round_clip_effect, rect);
+}
+
+void meta_window_actor_update_clip_padding(MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = meta_window_actor_get_instance_private(self);
+  if(priv->round_clip_effect)
+    meta_prefs_get_clip_edge_padding(priv->window->res_name,
+                                     priv->clip_padding);
+}
+
+void
+meta_window_actor_update_blur_sigmal (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = meta_window_actor_get_instance_private(self);
+  if (priv->blur_actor)
+    meta_shell_blur_effect_set_sigma (priv->blur_effect,
+                                 meta_prefs_get_blur_sigmal());
+}
+
+void
+meta_window_actor_update_blur_brightness (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = meta_window_actor_get_instance_private(self);
+  if (priv->blur_actor)
+    meta_shell_blur_effect_set_brightness (priv->blur_effect,
+                                 meta_prefs_get_blur_brightness());
+}
+
+void
+meta_window_actor_update_blur_window_opacity (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = meta_window_actor_get_instance_private(self);
+  if (priv->blur_actor)
+    meta_window_set_opacity (priv->window,
+                             meta_prefs_get_blur_window_opacity());
+}
+
 static void
 meta_window_actor_class_init (MetaWindowActorClass *klass)
 {
@@ -216,6 +467,11 @@ meta_window_actor_init (MetaWindowActor *self)
     meta_window_actor_get_instance_private (self);
 
   priv->geometry_scale = 1;
+  priv->effect_setuped = FALSE;
+  priv->clip_padding[0] = -1;
+
+  priv->blur_actor = NULL;
+  priv->blur_effect = NULL;
 }
 
 static void
@@ -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);
 }
 
+static void
+on_visible_changed (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv = meta_window_actor_get_instance_private (self);
+  
+  if (!priv->blur_actor)
+    return;
+
+  if (priv->visible)
+    clutter_actor_show(priv->blur_actor);
+  else
+    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)
 {
@@ -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);
+
+  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
@@ -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);
+      priv->round_clip_effect = create_clip_effect(self);
       g_signal_connect_object (priv->window, "notify::appears-focused",
                                G_CALLBACK (window_appears_focused_notify), self, 0);
       break;
@@ -662,6 +960,20 @@ start_simple_effect (MetaWindowActor  *self,
   return TRUE;
 }
 
+static void
+meta_window_actor_remove_blur (MetaWindowActor *self)
+{
+  MetaWindowActorPrivate *priv =
+    meta_window_actor_get_instance_private (self);
+
+  if (!priv->blur_actor)
+    return;
+
+  ClutterActor *parent = clutter_actor_get_parent (CLUTTER_ACTOR (self));
+  clutter_actor_remove_effect (priv->blur_actor, CLUTTER_EFFECT (priv->blur_effect));
+  clutter_actor_remove_child (parent, priv->blur_actor);
+}
+
 static void
 meta_window_actor_after_effects (MetaWindowActor *self)
 {
@@ -675,6 +987,12 @@ meta_window_actor_after_effects (MetaWindowActor *self)
 
   if (priv->needs_destroy)
     {
+      if (priv->round_clip_effect)
+        {
+          clutter_actor_remove_effect (CLUTTER_ACTOR(self),
+                                       CLUTTER_EFFECT(priv->round_clip_effect));
+          meta_window_actor_remove_blur(self);
+        }
       clutter_actor_destroy (CLUTTER_ACTOR (self));
     }
   else
@@ -803,6 +1121,19 @@ meta_window_actor_queue_destroy (MetaWindowActor *self)
     clutter_actor_destroy (CLUTTER_ACTOR (self));
 }
 
+void
+meta_window_actor_update_clipped_bounds(MetaWindowActor *window_actor)
+{
+  MetaWindowActorPrivate *priv =
+    meta_window_actor_get_instance_private(window_actor);
+  MetaWindow *window = priv->window;
+
+  if (window && window->frame_bounds) {
+    cairo_region_destroy(window->frame_bounds);
+    window->frame_bounds = NULL;
+  }
+}
+
 MetaWindowActorChanges
 meta_window_actor_sync_actor_geometry (MetaWindowActor *self,
                                        gboolean         did_placement)
diff --git a/src/core/prefs.c b/src/core/prefs.c
index 60d7a278a..6c27d4556 100644
--- a/src/core/prefs.c
+++ b/src/core/prefs.c
@@ -33,6 +33,8 @@
 #include <string.h>
 #include <stdlib.h>
 
+#include <json-glib/json-glib.h>
+
 #include "compositor/meta-plugin-manager.h"
 #include "core/keybindings-private.h"
 #include "core/meta-accel-parse.h"
@@ -119,6 +121,16 @@ static gboolean show_fallback_app_menu = TRUE;
 static GDesktopVisualBellType visual_bell_type = G_DESKTOP_VISUAL_BELL_FULLSCREEN_FLASH;
 static MetaButtonLayout button_layout;
 
+static int round_corner_radius = 8;
+static int border_width = 0;
+static int blur_sigmal = 20;
+static int blur_window_opacity = 80;
+static int blur_brightness = 100;
+static JsonNode *clip_edge_padding = NULL;
+/* NULL-terminated array */
+static char **black_list = NULL;
+static char **blur_list = NULL;
+
 /* NULL-terminated array */
 static char **workspace_names = NULL;
 
@@ -149,6 +161,7 @@ static gboolean mouse_button_mods_handler (GVariant*, gpointer*, gpointer);
 static gboolean button_layout_handler (GVariant*, gpointer*, gpointer);
 static gboolean overlay_key_handler (GVariant*, gpointer*, gpointer);
 static gboolean locate_pointer_key_handler (GVariant*, gpointer*, gpointer);
+static gboolean clip_edge_padding_handler (GVariant*, gpointer*, gpointer);
 
 static gboolean iso_next_group_handler (GVariant*, gpointer*, gpointer);
 
@@ -453,6 +466,15 @@ static MetaStringPreference preferences_string[] =
       locate_pointer_key_handler,
       NULL,
     },
+    {
+      {
+        "clip-edge-padding",
+        SCHEMA_MUTTER,
+        META_PREF_CLIP_EDGE_PADDING,
+      },
+      clip_edge_padding_handler,
+      NULL,
+    },
     { { NULL, 0, 0 }, NULL },
   };
 
@@ -474,6 +496,22 @@ static MetaStringArrayPreference preferences_string_array[] =
       iso_next_group_handler,
       NULL,
     },
+    {
+      { "black-list",
+        SCHEMA_MUTTER,
+        META_PREF_BLACK_LIST,
+      },
+      NULL,
+      &black_list,
+    },
+    {
+      { "blur-list",
+        SCHEMA_MUTTER,
+        META_PREF_BLUR_LIST,
+      },
+      NULL,
+      &blur_list,
+    },
     { { NULL, 0, 0 }, NULL },
   };
 
@@ -514,6 +552,46 @@ static MetaIntPreference preferences_int[] =
       },
       &cursor_size
     },
+    {
+      {
+        "round-corners-radius",
+        SCHEMA_MUTTER,
+        META_PREF_CORNER_RADIUS,
+      },
+      &round_corner_radius,
+    },
+    {
+      {
+        "border-width",
+        SCHEMA_MUTTER,
+        META_PREF_BORDER_WIDTH,
+      },
+      &border_width,
+    },
+    {
+      {
+        "blur-sigmal",
+        SCHEMA_MUTTER,
+        META_PREF_BLUR_SIGMAL,
+      },
+      &blur_sigmal,
+    },
+    {
+      {
+        "blur-brightness",
+        SCHEMA_MUTTER,
+        META_PREF_BLUR_BRIGHTNESS,
+      },
+      &blur_brightness,
+    },
+    {
+      {
+        "blur-window-opacity",
+        SCHEMA_MUTTER,
+        META_PREF_BLUR_WINDOW_OPACITY,
+      },
+      &blur_window_opacity,
+    },
     { { NULL, 0, 0 }, NULL },
   };
 
@@ -1587,6 +1665,81 @@ locate_pointer_key_handler (GVariant *value,
   return TRUE;
 }
 
+static gboolean
+clip_edge_padding_handler (GVariant *value,
+                           gpointer *result,
+                           gpointer  data)
+{
+  /* json string looks like this:
+   * 
+   * {
+   *    // array represent the clip padding of window: [left, right, top, bottom]
+   *    "global": [1, 1, 1, 1],
+   *    // special app settings,
+   *    "apps": {
+   *       // second part in `WM_CLASS` property of a window
+   *       "Typora": [0, 0, 0, 0],
+   *       ...
+   *    }
+   * } 
+   */
+
+  JsonNode *json;
+  JsonObject *obj;
+  JsonArray *arr;
+  JsonNode *element;
+  JsonObject *apps_obj;
+  GList *app_names;
+
+  const char *string_value;
+  GError *error = NULL;
+
+  *result = NULL;
+  string_value = g_variant_get_string(value, NULL);
+  json = json_from_string(string_value, &error);
+
+  if (error)
+  {
+    meta_topic(META_DEBUG_PREFS, "Failed to parse value for clip-edge-padding: %s", error->message);
+    g_error_free(error);
+    return FALSE;
+  }
+
+  if (!JSON_NODE_HOLDS_OBJECT(json))
+    goto failed;
+
+  obj = json_node_get_object(json);
+  arr = json_object_get_array_member(obj, "global");
+  if (!arr || json_array_get_length(arr) != 4)
+    goto failed;
+  
+  if (!(element = json_object_get_member(obj, "apps")))
+    goto failed;
+  if (!JSON_NODE_HOLDS_OBJECT(element))
+    goto failed;
+  apps_obj = json_node_get_object(element);
+
+  app_names = json_object_get_members(apps_obj);
+  for (GList *l = app_names; l != NULL; l = l->next)
+  {
+    arr = json_object_get_array_member(apps_obj, l->data);
+    if (!arr || json_array_get_length(arr) != 4)
+      goto failed;
+  }
+
+  if (clip_edge_padding != NULL)
+    json_node_unref(clip_edge_padding);
+  clip_edge_padding = json;
+  queue_changed(META_PREF_CLIP_EDGE_PADDING);
+
+  return TRUE;
+
+failed:
+  meta_topic(META_DEBUG_PREFS, "Failed to parse value for clip-edge-padding");
+  json_node_unref(json);
+  return FALSE;
+}
+
 static gboolean
 iso_next_group_handler (GVariant *value,
                         gpointer *result,
@@ -1758,6 +1911,30 @@ meta_preference_to_string (MetaPreference pref)
 
     case META_PREF_CHECK_ALIVE_TIMEOUT:
       return "CHECK_ALIVE_TIMEOUT";
+
+    case META_PREF_CORNER_RADIUS:
+      return "CORNER_RADIUS";
+
+    case META_PREF_CLIP_EDGE_PADDING:
+      return "CLIP_EDGE_PADDING";
+
+    case META_PREF_BLACK_LIST:
+      return "BLACK_LIST";
+
+    case META_PREF_BORDER_WIDTH:
+      return "BORDER_WIDTH";
+    
+    case META_PREF_BLUR_SIGMAL:
+      return "BLUR_SIGMAL";
+
+    case META_PREF_BLUR_BRIGHTNESS:
+      return "BLUR_BRIGHTNESS";
+
+    case META_PREF_BLUR_LIST:
+      return "BLUR_LIST";
+
+    case META_PREF_BLUR_WINDOW_OPACITY:
+      return "BLUR_WINDOW_OPACITY";
     }
 
   return "(unknown)";
@@ -2226,3 +2403,88 @@ meta_prefs_set_force_fullscreen (gboolean whether)
 {
   force_fullscreen = whether;
 }
+
+int
+meta_prefs_get_round_corner_radius (void)
+{
+  return round_corner_radius;
+}
+
+#define SET_PADDING(arr, v0, v1, v2, v3) \
+  { (arr)[0] = (v0); (arr)[1] = (v1); (arr)[2] = (v2); (arr)[3] = (v3); }
+
+void
+meta_prefs_get_clip_edge_padding (const char *name, int padding[4])
+{
+  JsonObject *obj;
+  JsonArray *arr;
+
+  if (!clip_edge_padding || !name) {
+    SET_PADDING(padding, 0, 0, 0, 0);
+    return;
+  }
+
+  obj = json_node_get_object(clip_edge_padding);
+  arr = json_object_get_array_member(obj, "global");
+  obj = json_object_get_object_member(obj, "apps");
+
+  if (json_object_has_member(obj, name))
+    arr = json_object_get_array_member(obj, name);
+
+  // array: { left, right, top, bottom }
+  SET_PADDING(padding, 
+              json_array_get_int_element(arr, 0) + 1,
+              json_array_get_int_element(arr, 1),
+              json_array_get_int_element(arr, 2) + 1,
+              json_array_get_int_element(arr, 3));
+}
+
+gboolean
+meta_prefs_in_black_list(const char *name)
+{
+  g_return_val_if_fail(black_list, FALSE);
+
+  int len = g_strv_length(black_list);
+
+  for (int i = 0; i < len; i++)
+    if (g_strcmp0(name, black_list[i]) == 0)
+      return TRUE;
+  return FALSE;
+}
+
+int
+meta_prefs_get_border_width(void)
+{
+  return border_width;
+}
+
+int
+meta_prefs_get_blur_sigmal(void)
+{
+  return blur_sigmal;
+}
+
+double
+meta_prefs_get_blur_brightness(void)
+{
+  return (double) blur_brightness * 0.01;
+}
+
+int
+meta_prefs_get_blur_window_opacity(void)
+{
+  return blur_window_opacity * 255 * 0.01;
+}
+
+gboolean
+meta_prefs_in_blur_list(const char *name)
+{
+  g_return_val_if_fail(blur_list, FALSE);
+
+  int len = g_strv_length(blur_list);
+
+  for (int i = 0; i < len; i++)
+    if (g_strcmp0(name, blur_list[i]) == 0)
+      return TRUE;
+  return FALSE;
+}
\ No newline at end of file
diff --git a/src/meson.build b/src/meson.build
index 284bdf522..a0c5e2d4b 100644
--- a/src/meson.build
+++ b/src/meson.build
@@ -163,6 +163,18 @@ if get_option('verbose')
   ]
 endif
 
+libshell_enums = gnome.mkenums_simple('shell-enum-types',
+  sources: [
+    'shell-blur-effect.h',
+  ]
+)
+
+libshell_src = [
+  libshell_enums,
+  'shell-blur-effect.h',
+  'shell-blur-effect.c',
+]
+
 mutter_sources = [
   'backends/edid.h',
   'backends/edid-parse.c',
@@ -444,6 +456,8 @@ mutter_sources = [
   'x11/window-x11-private.h',
   'x11/xprops.c',
   'x11/xprops.h',
+  'meta_clip_effect.c',
+  'meta_clip_effect.h',
 ]
 
 if have_egl
@@ -966,7 +980,8 @@ subdir('meta')
 mutter_built_sources += mutter_enum_types
 
 libmutter = shared_library(libmutter_name,
-  mutter_sources,
+  # mutter_sources,
+  mutter_sources + libshell_src,
   mutter_built_sources,
   version: '0.0.0',
   soversion: 0,
diff --git a/src/meta/prefs.h b/src/meta/prefs.h
index e2c8b46cf..f1ee72576 100644
--- a/src/meta/prefs.h
+++ b/src/meta/prefs.h
@@ -106,6 +106,15 @@ typedef enum
   META_PREF_DRAG_THRESHOLD,
   META_PREF_LOCATE_POINTER,
   META_PREF_CHECK_ALIVE_TIMEOUT,
+
+  META_PREF_CORNER_RADIUS,
+  META_PREF_CLIP_EDGE_PADDING,
+  META_PREF_BLACK_LIST,
+  META_PREF_BORDER_WIDTH,
+  META_PREF_BLUR_SIGMAL,
+  META_PREF_BLUR_BRIGHTNESS,
+  META_PREF_BLUR_LIST,
+  META_PREF_BLUR_WINDOW_OPACITY,
 } MetaPreference;
 
 typedef void (* MetaPrefsChangedFunc) (MetaPreference pref,
@@ -236,6 +245,30 @@ int      meta_prefs_get_draggable_border_width (void);
 META_EXPORT
 int      meta_prefs_get_drag_threshold (void);
 
+META_EXPORT
+int      meta_prefs_get_round_corner_radius (void);
+
+META_EXPORT
+void     meta_prefs_get_clip_edge_padding (const char *name, int padding[4]);
+
+META_EXPORT
+gboolean meta_prefs_in_black_list(const char *name);
+
+META_EXPORT
+int      meta_prefs_get_border_width(void);
+
+META_EXPORT
+int      meta_prefs_get_blur_sigmal(void);
+
+META_EXPORT
+double   meta_prefs_get_blur_brightness(void);
+
+META_EXPORT
+int      meta_prefs_get_blur_window_opacity(void);
+
+META_EXPORT
+gboolean meta_prefs_in_blur_list(const char *name);
+
 /**
  * MetaKeyBindingAction:
  * @META_KEYBINDING_ACTION_NONE: FILLME
diff --git a/src/ui/frames.c b/src/ui/frames.c
index 48b2a361c..8be6a8f8b 100644
--- a/src/ui/frames.c
+++ b/src/ui/frames.c
@@ -711,6 +711,27 @@ meta_ui_frame_get_bounds (MetaUIFrame *frame)
   return get_visible_region (frame, &fgeom);
 }
 
+cairo_region_t * 
+meta_ui_frame_get_bounds_clipped (const MetaRectangle *bounds,
+                                  float radius)
+{
+  MetaFrameGeometry fgeom;
+ 
+  fgeom.borders.invisible.left = bounds->x;
+  fgeom.borders.invisible.top =  bounds->y;
+  fgeom.borders.invisible.bottom = 0;
+  fgeom.borders.invisible.right =  0;
+  fgeom.width  = bounds->width + bounds->x;
+  fgeom.height = bounds->height + bounds->y;
+
+  fgeom.top_left_corner_rounded_radius = radius;
+  fgeom.top_right_corner_rounded_radius = radius;
+  fgeom.bottom_left_corner_rounded_radius = radius;
+  fgeom.bottom_right_corner_rounded_radius = radius;
+  
+  return get_visible_region (NULL, &fgeom);
+}
+
 void
 meta_ui_frame_move_resize (MetaUIFrame *frame,
                            int x, int y, int width, int height)
diff --git a/src/ui/frames.h b/src/ui/frames.h
index 73dee1737..03b19ba40 100644
--- a/src/ui/frames.h
+++ b/src/ui/frames.h
@@ -135,6 +135,10 @@ void meta_ui_frame_get_borders (MetaUIFrame      *frame,
 
 cairo_region_t * meta_ui_frame_get_bounds (MetaUIFrame *frame);
 
+cairo_region_t * 
+meta_ui_frame_get_bounds_clipped (const MetaRectangle *bounds,
+                                  float radius);
+
 void meta_ui_frame_get_mask (MetaUIFrame           *frame,
                              cairo_rectangle_int_t *frame_rect,
                              cairo_t               *cr);
diff --git a/src/wayland/meta-window-wayland.c b/src/wayland/meta-window-wayland.c
index 12e9567d9..7138330bc 100644
--- a/src/wayland/meta-window-wayland.c
+++ b/src/wayland/meta-window-wayland.c
@@ -1002,6 +1002,9 @@ meta_window_wayland_finish_move_resize (MetaWindow              *window,
     gravity = META_GRAVITY_STATIC;
   meta_window_move_resize_internal (window, flags, gravity, rect);
 
+  if (flags & META_MOVE_RESIZE_RESIZE_ACTION)
+    meta_window_actor_update_glsl(meta_window_actor_from_window(window));
+
   g_clear_pointer (&acked_configuration, meta_wayland_window_configuration_free);
 }