blur: Support wtz_blur_rectangle protocol

Support create_rectangle request and Remove set_region request

Change-Id: I673d777e55fdd3a270b97c87ca1ada757ad6c96b

diff --git a/include/libds-tizen/blur.h b/include/libds-tizen/blur.h
index 84fe80f2e597797ec7dadf10de6b6e3bff04fe7d..811290853ec389d1aba31f44b54e30eeeeeb6ec2 100644 (file)
--- a/include/libds-tizen/blur.h
+++ b/include/libds-tizen/blur.h
@@ -11,18 +11,20 @@ extern "C" {
 
 struct ds_tizen_blur_manager;
 struct ds_tizen_blur;
+struct ds_tizen_blur_rectangle;
 
 enum ds_tizen_blur_state_field {
     DS_TIZEN_BLUR_STATE_NONE = 0,
-    DS_TIZEN_BLUR_STATE_REGION = (1 << 0),
+    DS_TIZEN_BLUR_STATE_REGION = (1 << 0),//temporary
     DS_TIZEN_BLUR_STATE_RADIUS = (1 << 1),
+    DS_TIZEN_BLUR_STATE_RECTANGLE = (1 << 2),
 };
 
 struct ds_tizen_blur_state
 {
     enum ds_tizen_blur_state_field committed;
 
-    pixman_region32_t region;
+    pixman_region32_t region; //temporary
     uint32_t radius;
 };
 
@@ -55,6 +57,22 @@ ds_tizen_blur_get_surface(struct ds_tizen_blur *blur);
 struct ds_tizen_blur_state *
 ds_tizen_blur_get_state(struct ds_tizen_blur *blur);
 
+void
+ds_tizen_blur_add_new_rectangle_listener(struct ds_tizen_blur *blur,
+        struct wl_listener *listener);
+
+void
+ds_tizen_blur_rectangle_add_destroy_listener(struct ds_tizen_blur_rectangle *blur_rectangle,
+        struct wl_listener *listener);
+
+void
+ds_tizen_blur_rectangle_get_geometry(struct ds_tizen_blur_rectangle *blur_rectangle,
+        int *x, int *y, int *width, int *height);
+
+void
+ds_tizen_blur_rectangle_get_corner_radius(struct ds_tizen_blur_rectangle *blur_rectangle,
+        int *rx, int *ry);
+
 #ifdef __cplusplus
 }
 #endif

diff --git a/src/blur/blur.c b/src/blur/blur.c
index e15840f7acda7874796eae4f349a4a075786230c..fd3768bbc64717090c16466dadc89e8b166cd2ef 100644 (file)
--- a/src/blur/blur.c
+++ b/src/blur/blur.c
@@ -48,6 +48,8 @@ struct ds_tizen_blur
     struct wl_resource *resource;
     struct wl_client *wl_client;
 
+    struct wl_list rectangles;
+
     struct ds_tizen_blur_state current, pending;
 
     struct ds_surface *surface;
@@ -60,6 +62,34 @@ struct ds_tizen_blur
     struct {
         struct wl_signal commit;
         struct wl_signal destroy;
+        struct wl_signal new_rectangle;
+    } events;
+};
+
+struct ds_tizen_blur_rectangle
+{
+    struct wl_list link; //rectangles
+
+    struct wl_resource *resource;
+    struct wl_client *wl_client;
+
+    struct ds_tizen_blur *blur;
+
+    bool pending;
+
+    int x;
+    int y;
+    int width;
+    int height;
+    int rx;
+    int ry;
+
+    struct {
+        struct wl_listener blur_destroy;
+    } listener;
+
+    struct {
+        struct wl_signal destroy;
     } events;
 };
 
@@ -141,6 +171,38 @@ ds_tizen_blur_get_state(struct ds_tizen_blur *blur)
     return &blur->current;
 }
 
+WL_EXPORT void
+ds_tizen_blur_add_new_rectangle_listener(struct ds_tizen_blur *blur,
+        struct wl_listener *listener)
+{
+    wl_signal_add(&blur->events.new_rectangle, listener);
+}
+
+WL_EXPORT void
+ds_tizen_blur_rectangle_add_destroy_listener(struct ds_tizen_blur_rectangle *blur_rectangle,
+        struct wl_listener *listener)
+{
+    wl_signal_add(&blur_rectangle->events.destroy, listener);
+}
+
+WL_EXPORT void
+ds_tizen_blur_rectangle_get_geometry(struct ds_tizen_blur_rectangle *blur_rectangle,
+        int *x, int *y, int *width, int *height)
+{
+    if (x) *x = blur_rectangle->x;
+    if (y) *y = blur_rectangle->y;
+    if (width) *width = blur_rectangle->width;
+    if (height) *height = blur_rectangle->height;
+}
+
+WL_EXPORT void
+ds_tizen_blur_rectangle_get_corner_radius(struct ds_tizen_blur_rectangle *blur_rectangle,
+        int *rx, int *ry)
+{
+    if (rx) *rx = blur_rectangle->rx;
+    if (ry) *ry = blur_rectangle->ry;
+}
+
 static void
 blur_manager_handle_display_destroy(struct wl_listener *listener, void *data)
 {
@@ -194,10 +256,129 @@ blur_handle_set_radius(struct wl_client *client, struct wl_resource *resource,
     blur->pending.committed |= DS_TIZEN_BLUR_STATE_RADIUS;
 }
 
+static void
+blur_rectangle_handle_destroy(struct wl_client *client, struct wl_resource *resource)
+{
+    wl_resource_destroy(resource);
+}
+
+static const struct wtz_blur_rectangle_interface blur_rectangle_impl = {
+   blur_rectangle_handle_destroy,
+};
+
+static void
+blur_rectangle_destroy(struct ds_tizen_blur_rectangle *blur_rectangle)
+{
+    ds_inf("blur_rectangle_destroy (blur_rectangle:%p)", blur_rectangle);
+
+    wl_signal_emit(&blur_rectangle->events.destroy, blur_rectangle);
+
+    if (blur_rectangle->listener.blur_destroy.notify)
+        wl_list_remove(&blur_rectangle->listener.blur_destroy.link);
+
+    if (blur_rectangle->blur)
+        wl_list_remove(&blur_rectangle->link);
+
+    free(blur_rectangle);
+}
+
+static void
+blur_rectangle_handle_resource_destroy(struct wl_resource *resource)
+{
+    struct ds_tizen_blur_rectangle *blur_rectangle;
+
+    blur_rectangle = wl_resource_get_user_data(resource);
+
+    ds_inf("blur_rectangle_handle_resource_destroy (blur_rectangle:%p)", blur_rectangle);
+
+    if (blur_rectangle->blur) {
+        blur_rectangle->resource = NULL;
+        blur_rectangle->pending = true;
+        blur_rectangle->blur->pending.committed |= DS_TIZEN_BLUR_STATE_RECTANGLE;
+        return;
+    }
+
+    blur_rectangle_destroy(blur_rectangle);
+}
+
+static void
+blur_rectangle_handle_blur_destroy(struct wl_listener *listener, void *data)
+{
+    struct ds_tizen_blur_rectangle *blur_rectangle;
+
+    blur_rectangle = wl_container_of(listener, blur_rectangle, listener.blur_destroy);
+
+    blur_rectangle->listener.blur_destroy.notify = NULL;
+    wl_list_remove(&blur_rectangle->listener.blur_destroy.link);
+
+    blur_rectangle->blur = NULL;
+    wl_list_remove(&blur_rectangle->link);
+
+    if (!blur_rectangle->resource)
+        blur_rectangle_destroy(blur_rectangle);
+}
+
+static void
+blur_handle_create_rectangle(struct wl_client *wl_client, struct wl_resource *resource,
+        uint32_t id, int32_t x, int32_t y,
+        int32_t width, int32_t height, int32_t rx, int32_t ry)
+{
+    struct ds_tizen_blur *blur;
+    struct ds_tizen_blur_rectangle *blur_rectangle;
+
+    ds_inf("tizen_blur: create_rectangle");
+
+    blur = wl_resource_get_user_data(resource);
+    if (!blur) {
+        wl_resource_post_error(resource, WL_DISPLAY_ERROR_INVALID_OBJECT,
+                "invalid blur resource:%u",
+                (unsigned int)wl_resource_get_id(resource));
+        return;
+    }
+
+    blur_rectangle = calloc(1, sizeof *blur_rectangle);
+    if (blur_rectangle == NULL) {
+        ds_err("calloc() failed. tizen_blur_rectangle");
+        wl_client_post_no_memory(wl_client);
+        return;
+    }
+
+    blur_rectangle->resource = wl_resource_create(wl_client, &wtz_blur_rectangle_interface,
+           wl_resource_get_version(resource), id);
+    if (blur_rectangle->resource == NULL) {
+        ds_err("tizen_blur_rectangle : wl_resource_create() failed.");
+        free(blur_rectangle);
+        wl_client_post_no_memory(wl_client);
+        return;
+    }
+
+    wl_resource_set_implementation(blur_rectangle->resource, &blur_rectangle_impl, blur_rectangle,
+        blur_rectangle_handle_resource_destroy);
+
+    blur_rectangle->listener.blur_destroy.notify = blur_rectangle_handle_blur_destroy;
+    ds_tizen_blur_add_destroy_listener(blur, &blur_rectangle->listener.blur_destroy);
+
+    blur_rectangle->x = x;
+    blur_rectangle->y = y;
+    blur_rectangle->width = width;
+    blur_rectangle->height = height;
+    blur_rectangle->rx = rx;
+    blur_rectangle->ry = ry;
+
+    blur_rectangle->blur = blur;
+    wl_list_insert(&blur->rectangles, &blur_rectangle->link);
+
+    wl_signal_init(&blur_rectangle->events.destroy);
+
+    blur_rectangle->pending = true;
+    blur->pending.committed |= DS_TIZEN_BLUR_STATE_RECTANGLE;
+}
+
 static const struct wtz_blur_interface blur_impl = {
    blur_handle_destroy,
    blur_handle_set_region,
    blur_handle_set_radius,
+   blur_handle_create_rectangle,
 };
 
 static void
@@ -239,6 +420,7 @@ static void
 blur_handle_surface_commit(struct wl_listener *listener, void *data)
 {
     struct ds_tizen_blur *blur;
+    struct ds_tizen_blur_rectangle *blur_rectangle, *tmp;
 
     blur = wl_container_of(listener, blur, listener.surface_commit);
 
@@ -247,6 +429,15 @@ blur_handle_surface_commit(struct wl_listener *listener, void *data)
         return;
     }
 
+    wl_list_for_each_safe(blur_rectangle, tmp, &blur->rectangles, link) {
+        if (!blur_rectangle->pending) continue;
+
+        if (blur_rectangle->resource)
+            wl_signal_emit(&blur->events.new_rectangle, blur_rectangle);
+        else
+            blur_rectangle_destroy(blur_rectangle);
+    }
+
     if (blur->pending.committed == DS_TIZEN_BLUR_STATE_NONE) {
         blur->current.committed = DS_TIZEN_BLUR_STATE_NONE;
         return;
@@ -359,8 +550,11 @@ blur_manager_handle_get_blur(struct wl_client *wl_client,
 
     blur->surface = surface;
 
+    wl_list_init(&blur->rectangles);
+
     wl_signal_init(&blur->events.destroy);
     wl_signal_init(&blur->events.commit);
+    wl_signal_init(&blur->events.new_rectangle);
 
     wl_signal_emit(&client->blur_manager->events.new_blur, blur);
 }