e_hwc_window: refactor updating the restriction of hwc_window

Previously, the restriction of hwc_window was updated in every idle time
if wait_commit is false.
For reducing usage of cpu, this patch makes the restriction of hwc_window
is updated when condition of the restriction is changed.

Change-Id: I4498ebeb81ff8bcf5e0074c560b0ef5336a78beb

diff --git a/src/bin/e_hwc_window.c b/src/bin/e_hwc_window.c
index e90d650..09b1102 100644 (file)
--- a/src/bin/e_hwc_window.c
+++ b/src/bin/e_hwc_window.c
@@ -64,42 +64,12 @@
      }                                                                 \
    while (0)
 
-typedef enum _E_Hwc_Window_Restriction
-{
-   E_HWC_WINDOW_RESTRICTION_NONE,
-   E_HWC_WINDOW_RESTRICTION_DELETED,
-   E_HWC_WINDOW_RESTRICTION_OVERRIDE,
-   E_HWC_WINDOW_RESTRICTION_ANIMATING,
-   E_HWC_WINDOW_RESTRICTION_BUFFER,
-   E_HWC_WINDOW_RESTRICTION_VIEWPORT,
-   E_HWC_WINDOW_RESTRICTION_NEVER_HWC,
-   E_HWC_WINDOW_RESTRICTION_TRANSFORM,
-   E_HWC_WINDOW_RESTRICTION_BUFFER_TYPE,
-   E_HWC_WINDOW_RESTRICTION_OUTPUT,
-   E_HWC_WINDOW_RESTRICTION_MIN_WIDTH,
-   E_HWC_WINDOW_RESTRICTION_MIN_HEIGHT,
-   E_HWC_WINDOW_RESTRICTION_TOUCH_PRESS,
-   E_HWC_WINDOW_RESTRICTION_OUTPUT_TRANSFORM,
-   E_HWC_WINDOW_RESTRICTION_CONTENT_IMAGE,
-   E_HWC_WINDOW_RESTRICTION_QUICKPANEL_OPEN,
-   E_HWC_WINDOW_RESTRICTION_PIXMAP_RESOURCE,
-   E_HWC_WINDOW_RESTRICTION_OBSCURED_BY_TARGET,
-   E_HWC_WINDOW_RESTRICTION_IMAGE_FILTER,
-   E_HWC_WINDOW_RESTRICTION_DESK_GEOMETRY,
-   E_HWC_WINDOW_RESTRICTION_EFFECT_RUNNING,
-   E_HWC_WINDOW_RESTRICTION_RENDER_UPDATE_LOCK,
-   E_HWC_WINDOW_RESTRICTION_DESK_ZOOM,
-   E_HWC_WINDOW_RESTRICTION_BLEND_ALPHA,
-   E_HWC_WINDOW_RESTRICTION_BLEND_EQUATION,
-   E_HWC_WINDOW_RESTRICTION_ZONE,
-   E_HWC_WINDOW_RESTRICTION_QUEUE_UNSET_WAITING,
-} E_Hwc_Window_Restriction;
-
 static Eina_Bool ehw_trace = EINA_FALSE;
 static Eina_List *hwc_window_client_hooks = NULL;
 static Eina_List *hwc_window_comp_wl_hooks = NULL;
 static Eina_List *hwc_window_event_hdlrs = NULL;
 static Eina_List *hwc_window_comp_object_hooks = NULL;
+static Eina_List *hwc_window_pixmap_hooks = NULL;
 
 static int _e_hwc_window_hooks_delete = 0;
 static int _e_hwc_window_hooks_walking = 0;
@@ -683,6 +653,18 @@ _e_hwc_window_del(E_Hwc_Window *hwc_window)
         hwc_window->queue = NULL;
      }
 
+   if (hwc_window->image_filter_set_listener.notify)
+     wl_list_remove(&hwc_window->image_filter_set_listener.link);
+
+   if (hwc_window->render_op_set_listener.notify)
+     wl_list_remove(&hwc_window->render_op_set_listener.link);
+
+   if (hwc_window->content_type_set_listener.notify)
+     wl_list_remove(&hwc_window->content_type_set_listener.link);
+
+   if (hwc_window->color_set_listener.notify)
+     wl_list_remove(&hwc_window->color_set_listener.link);
+
    e_hwc_window_below_transparent_obj_set(hwc_window, EINA_FALSE);
    e_hwc_window_state_set(hwc_window, E_HWC_WINDOW_STATE_NONE, EINA_TRUE);
 
@@ -704,6 +686,224 @@ _e_hwc_window_cb_ec_free(void *data, void *obj)
      }
 }
 
+static void
+_e_hwc_window_cb_image_filter_set(struct wl_listener *listener, void *data)
+{
+   E_Hwc_Window *hwc_window;
+
+   hwc_window = container_of(listener, E_Hwc_Window, image_filter_set_listener);
+   if (!hwc_window->ec) return;
+
+   if (e_comp_object_image_filter_get(hwc_window->ec->frame) != E_COMP_IMAGE_FILTER_NONE)
+     e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_IMAGE_FILTER);
+   else
+     e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_IMAGE_FILTER);
+}
+
+static void
+_e_hwc_window_cb_render_op_set(struct wl_listener *listener, void *data)
+{
+   E_Hwc_Window *hwc_window;
+
+   hwc_window = container_of(listener, E_Hwc_Window, render_op_set_listener);
+   if (!hwc_window->ec) return;
+
+   if (e_comp_object_render_op_get(hwc_window->ec->frame) != EVAS_RENDER_BLEND)
+     e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_BLEND_EQUATION);
+   else
+     e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_BLEND_EQUATION);
+}
+
+static void
+_e_hwc_window_cb_content_type_set(struct wl_listener *listener, void *data)
+{
+   E_Hwc_Window *hwc_window;
+
+   hwc_window = container_of(listener, E_Hwc_Window, content_type_set_listener);
+   if (!hwc_window->ec) return;
+
+   if (e_comp_object_content_type_get(hwc_window->ec->frame) != E_COMP_OBJECT_CONTENT_TYPE_INT_IMAGE)
+     e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_CONTENT_IMAGE);
+   else
+     e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_CONTENT_IMAGE);
+}
+
+static void
+_e_hwc_window_cb_color_set(struct wl_listener *listener, void *data)
+{
+   E_Hwc_Window *hwc_window;
+   int alpha = 255;
+
+   hwc_window = container_of(listener, E_Hwc_Window, color_set_listener);
+   if (!hwc_window->ec) return;
+
+   e_comp_object_color_get(hwc_window->ec->frame, NULL, NULL, NULL, &alpha);
+
+   if ((alpha != 255) && e_comp_object_redirected_get(hwc_window->ec->frame))
+     e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_BLEND_ALPHA);
+   else
+     e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_BLEND_ALPHA);
+}
+
+static Eina_Bool
+_e_hwc_window_client_transform_restriction_check(E_Client *ec, E_Output *output)
+{
+   E_Map *map;
+   int x[4], y[4], z[4];
+   int i;
+
+   if (!e_client_transform_core_enable_get(ec))
+     return EINA_FALSE;
+
+   map = e_client_map_get(ec);
+   if (!map) return EINA_FALSE;
+
+   for (i = 0; i < 4; i++)
+     {
+        if (!e_map_point_coord_get(map, i, &x[i], &y[i], &z[i]))
+          {
+             e_map_free(map);
+             return EINA_TRUE;
+          }
+     }
+
+   e_map_free(map);
+
+   /* check 2D */
+   if ((z[0] != z[1]) || (z[0] != z[2]) || (z[0] != z[3]))
+     return EINA_TRUE;
+
+   /* check rectangle */
+   if ((x[0] != x[3]) || (x[1] != x[2]))
+     return EINA_TRUE;
+
+   if ((y[0] != y[1]) || (y[2] != y[3]))
+     return EINA_TRUE;
+
+   if ((x[0] < 0) || (x[0] > output->config.geom.w) ||
+       (x[1] < 0) || (x[1] > output->config.geom.w) ||
+       (x[2] < 0) || (x[2] > output->config.geom.w) ||
+       (x[3] < 0) || (x[3] > output->config.geom.w))
+     return EINA_TRUE;
+
+   if ((y[0] < 0) || (y[0] > output->config.geom.h) ||
+       (y[1] < 0) || (y[1] > output->config.geom.h) ||
+       (y[2] < 0) || (y[2] > output->config.geom.h) ||
+       (y[3] < 0) || (y[3] > output->config.geom.h))
+     return EINA_TRUE;
+
+   return EINA_FALSE;
+}
+
+static void
+_e_hwc_window_commit_restriction_update(E_Hwc_Window  *hwc_window)
+{
+   E_Comp_Wl_Buffer *comp_buffer;
+   E_Output *output = NULL;
+   int transform;
+   E_Comp_Wl_Client_Data *cdata;
+   E_Client *ec;
+
+   ec = hwc_window->ec;
+
+   comp_buffer = _e_hwc_window_comp_wl_buffer_get(hwc_window);
+   if (!comp_buffer)
+     {
+        e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_BUFFER);
+        return;
+     }
+
+   e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_BUFFER);
+
+   switch (comp_buffer->type)
+     {
+      case E_COMP_WL_BUFFER_TYPE_NATIVE:
+      case E_COMP_WL_BUFFER_TYPE_TBM:
+         e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_BUFFER_TYPE);
+         break;
+      case E_COMP_WL_BUFFER_TYPE_SHM:
+         if (!e_util_strcmp("wl_pointer-cursor", ec->icccm.window_role))
+           {
+              e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_BUFFER_TYPE);
+              break;
+           }
+      default:
+         e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_BUFFER_TYPE);
+     }
+
+   if (((hwc_window->hwc->output_available.min_w > 0) &&  (hwc_window->hwc->output_available.min_w > comp_buffer->w)) ||
+       ((hwc_window->hwc->output_available.min_h > 0) &&  (hwc_window->hwc->output_available.min_h > comp_buffer->h)))
+     e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_MIN_SIZE);
+   else
+     e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_MIN_SIZE);
+
+   if ((hwc_window->zone) && (hwc_window->zone->output_id))
+     {
+        output = e_output_find(hwc_window->zone->output_id);
+        if (output)
+          {
+             transform = e_comp_wl_output_buffer_transform_get(ec);
+             if ((output->config.rotation / 90) != transform)
+               e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_OUTPUT_TRANSFORM);
+             else
+               e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_OUTPUT_TRANSFORM);
+          }
+     }
+
+   cdata = e_client_cdata_get(ec);
+   if ((cdata) &&
+       ((cdata->width_from_buffer != cdata->width_from_viewport) ||
+        (cdata->height_from_buffer != cdata->height_from_viewport)))
+     e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_VIEWPORT);
+   else
+     e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_VIEWPORT);
+}
+
+static void
+_e_hwc_window_restriction_init(E_Hwc_Window *hwc_window)
+{
+   int alpha = 255;
+   E_Output *output;
+
+   if (!hwc_window->ec) return;
+
+   if (e_comp_object_image_filter_get(hwc_window->ec->frame) != E_COMP_IMAGE_FILTER_NONE)
+     e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_IMAGE_FILTER);
+   else
+     e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_IMAGE_FILTER);
+
+   if (e_comp_object_render_op_get(hwc_window->ec->frame) != EVAS_RENDER_BLEND)
+     e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_BLEND_EQUATION);
+   else
+     e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_BLEND_EQUATION);
+
+   e_comp_object_color_get(hwc_window->ec->frame, NULL, NULL, NULL, &alpha);
+
+   if ((alpha != 255) && e_comp_object_redirected_get(hwc_window->ec->frame))
+     e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_BLEND_ALPHA);
+   else
+     e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_BLEND_ALPHA);
+
+   if (e_comp_object_render_update_lock_get(hwc_window->ec->frame))
+     e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_RENDER_UPDATE_LOCK);
+   else
+     e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_RENDER_UPDATE_LOCK);
+
+   if ((hwc_window->zone) && (hwc_window->zone->output_id))
+     {
+        output = e_output_find(hwc_window->zone->output_id);
+        if (output)
+          {
+             if (_e_hwc_window_client_transform_restriction_check(hwc_window->ec, output))
+               e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_TRANSFORM);
+             else
+               e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_TRANSFORM);
+          }
+     }
+
+   _e_hwc_window_commit_restriction_update(hwc_window);
+}
+
 static E_Hwc_Window *
 _e_hwc_window_new(E_Hwc *hwc, E_Client *ec, E_Hwc_Window_State state)
 {
@@ -726,7 +926,6 @@ _e_hwc_window_new(E_Hwc *hwc, E_Client *ec, E_Hwc_Window_State state)
    hwc_window->hwc = hwc;
    hwc_window->zpos = E_HWC_WINDOW_ZPOS_NONE;
    hwc_window->render_target = EINA_TRUE;
-   hwc_window->device_state_available = EINA_TRUE;
 
    hwc_window->thwc_window = tdm_hwc_create_window(thwc, &error);
    if (error != TDM_ERROR_NONE)
@@ -753,6 +952,18 @@ _e_hwc_window_new(E_Hwc *hwc, E_Client *ec, E_Hwc_Window_State state)
    e_hwc_presentation_callback_list_init(&hwc_window->pending_presentation_callbacks);
    e_hwc_presentation_callback_list_init(&hwc_window->presentation_callbacks);
 
+   hwc_window->image_filter_set_listener.notify = _e_hwc_window_cb_image_filter_set;
+   e_comp_object_image_filter_set_listener_add(ec->frame, &hwc_window->image_filter_set_listener);
+
+   hwc_window->render_op_set_listener.notify = _e_hwc_window_cb_render_op_set;
+   e_comp_object_render_op_set_listener_add(ec->frame, &hwc_window->render_op_set_listener);
+
+   hwc_window->content_type_set_listener.notify = _e_hwc_window_cb_content_type_set;
+   e_comp_object_content_type_set_listener_add(ec->frame, &hwc_window->content_type_set_listener);
+
+   hwc_window->color_set_listener.notify = _e_hwc_window_cb_color_set;
+   e_comp_object_color_set_listener_add(ec->frame, &hwc_window->color_set_listener);
+
    EHWINF("is created on eout:%p, video:%d cursor:%d",
           hwc_window->ec, hwc_window->hwc, hwc_window, hwc->output,
           hwc_window->is_video, hwc_window->is_cursor);
@@ -792,6 +1003,7 @@ _e_hwc_window_client_cb_del(void *data EINA_UNUSED, E_Client *ec)
 
    if (e_hwc_window_is_video(hwc_window)) return;
 
+   e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_DELETED);
    e_hwc_window_client_type_override(hwc_window);
 }
 
@@ -847,6 +1059,11 @@ _e_hwc_window_client_cb_transform_change(void *data EINA_UNUSED, E_Client *ec)
     * there's no need to deal with hwc_windows. */
    if (e_hwc_policy_get(output->hwc) == E_HWC_POLICY_PLANES) return;
 
+   if (_e_hwc_window_client_transform_restriction_check(ec, output))
+     e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_TRANSFORM);
+   else
+     e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_TRANSFORM);
+
    if (!e_comp_wl_video_subsurface_has(ec) && !e_comp_wl_normal_subsurface_has(ec))
      return;
 
@@ -920,6 +1137,7 @@ _e_hwc_window_client_cb_zone_set(void *data, int type, void *event)
 
 done:
    _e_hwc_window_zone_set(hwc_window, zone);
+   _e_hwc_window_restriction_init(hwc_window);
 
    return ECORE_CALLBACK_PASS_ON;
 }
@@ -958,21 +1176,82 @@ _e_hwc_window_cb_subsurface_synchronized_commit(void *data, E_Client *ec)
      e_hwc_window_present_sync(ec->hwc_window);
 }
 
+static void
+_e_hwc_window_cb_surface_commit(void *data, E_Client *ec)
+{
+   if (!ec->hwc_window) return;
+
+   _e_hwc_window_commit_restriction_update(ec->hwc_window);
+}
+
 static Eina_Bool
 _e_hwc_window_cb_update_lock_set(void *data, E_Client *ec)
 {
    E_Hwc_Window *hwc_window;
 
-   if (e_object_is_del(E_OBJECT(ec))) return EINA_TRUE;
-
    hwc_window = ec->hwc_window;
    if (!hwc_window) return EINA_TRUE;
 
+   e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_RENDER_UPDATE_LOCK);
    e_hwc_window_client_type_override(hwc_window);
 
    return EINA_TRUE;
 }
 
+static Eina_Bool
+_e_hwc_window_cb_update_lock_unset(void *data, E_Client *ec)
+{
+   E_Hwc_Window *hwc_window;
+
+   hwc_window = ec->hwc_window;
+   if (!hwc_window) return EINA_TRUE;
+
+   e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_RENDER_UPDATE_LOCK);
+
+   return EINA_TRUE;
+}
+
+static Eina_Bool
+_e_hwc_window_cb_effect_start(void *data, E_Client *ec)
+{
+   E_Hwc_Window *hwc_window;
+
+   hwc_window = ec->hwc_window;
+   if (!hwc_window) return EINA_TRUE;
+
+   e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_EFFECT);
+
+   return EINA_TRUE;
+}
+
+static Eina_Bool
+_e_hwc_window_cb_effect_end(void *data, E_Client *ec)
+{
+   E_Hwc_Window *hwc_window;
+
+   hwc_window = ec->hwc_window;
+   if (!hwc_window) return EINA_TRUE;
+
+   e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_EFFECT);
+
+   return EINA_TRUE;
+}
+
+static void
+_e_hwc_window_cb_pixmap_buffer_clear_done(void *data EINA_UNUSED, E_Pixmap *cp)
+{
+   E_Client *ec;
+   E_Hwc_Window *hwc_window;
+
+   ec = e_pixmap_client_get(cp);
+   if (!ec) return;
+
+   hwc_window = ec->hwc_window;
+   if (!hwc_window) return;
+   
+   e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_BUFFER);
+}
+
 EINTERN Eina_Bool
 e_hwc_window_init(void)
 {
@@ -984,8 +1263,18 @@ e_hwc_window_init(void)
                          _e_hwc_window_client_cb_zone_set, NULL);
    E_COMP_WL_HOOK_APPEND(hwc_window_comp_wl_hooks, E_COMP_WL_HOOK_SUBSURFACE_SYNCHRONIZED_COMMIT,
                          _e_hwc_window_cb_subsurface_synchronized_commit, NULL);
+   E_COMP_WL_HOOK_APPEND(hwc_window_comp_wl_hooks, E_COMP_WL_HOOK_CLIENT_SURFACE_COMMIT,
+                         _e_hwc_window_cb_surface_commit, NULL);
+   E_PIXMAP_HOOK_APPEND(hwc_window_pixmap_hooks, E_PIXMAP_HOOK_BUFFER_CLEAR_DONE,
+                        _e_hwc_window_cb_pixmap_buffer_clear_done, NULL);
    E_COMP_COMP_HOOK_APPEND(hwc_window_comp_object_hooks, E_COMP_OBJECT_HOOK_RENDER_UPDATE_LOCK_SET,
                            _e_hwc_window_cb_update_lock_set, NULL);
+   E_COMP_COMP_HOOK_APPEND(hwc_window_comp_object_hooks, E_COMP_OBJECT_HOOK_RENDER_UPDATE_LOCK_UNSET,
+                           _e_hwc_window_cb_update_lock_unset, NULL);
+   E_COMP_COMP_HOOK_APPEND(hwc_window_comp_object_hooks, E_COMP_OBJECT_HOOK_EFFECT_START,
+                           _e_hwc_window_cb_effect_start, NULL);
+   E_COMP_COMP_HOOK_APPEND(hwc_window_comp_object_hooks, E_COMP_OBJECT_HOOK_EFFECT_END,
+                           _e_hwc_window_cb_effect_end, NULL);
 
    return EINA_TRUE;
 }
@@ -997,6 +1286,7 @@ e_hwc_window_deinit(void)
    E_FREE_LIST(hwc_window_event_hdlrs, ecore_event_handler_del);
    E_FREE_LIST(hwc_window_comp_wl_hooks, e_comp_wl_hook_del);
    E_FREE_LIST(hwc_window_comp_object_hooks, e_comp_object_hook_del);
+   E_FREE_LIST(hwc_window_pixmap_hooks, e_pixmap_hook_del);
 }
 
 EINTERN E_Hwc_Window *
@@ -2059,286 +2349,37 @@ e_hwc_window_state_get(E_Hwc_Window *hwc_window)
    return hwc_window->state;
 }
 
-EINTERN Eina_Bool
-e_hwc_window_device_state_available_get(E_Hwc_Window *hwc_window)
-{
-   EINA_SAFETY_ON_NULL_RETURN_VAL(hwc_window, EINA_FALSE);
-
-   return hwc_window->device_state_available;
-}
-
-static Eina_Bool
-_e_hwc_window_client_transform_device_state_available_get(E_Client *ec)
+EINTERN void
+e_hwc_window_restriction_set(E_Hwc_Window *hwc_window, E_Hwc_Window_Restriction restriction)
 {
-   E_Map *map;
-   int x[4], y[4], z[4];
-   int i;
-
-   if (!e_client_transform_core_enable_get(ec))
-     return EINA_TRUE;
-
-   map = e_client_map_get(ec);
-   if (!map) return EINA_TRUE;
-
-   for (i = 0; i < 4; i++)
-     {
-        if (!e_map_point_coord_get(map, i, &x[i], &y[i], &z[i]))
-          {
-             e_map_free(map);
-             return EINA_FALSE;
-          }
-     }
-
-   e_map_free(map);
-
-   /* check 2D */
-   if ((z[0] != z[1]) || (z[0] != z[2]) || (z[0] != z[3]))
-     return EINA_FALSE;
+   EINA_SAFETY_ON_NULL_RETURN(hwc_window);
 
-   /* check rectangle */
-   if ((x[0] != x[3]) || (x[1] != x[2]))
-     return EINA_FALSE;
+   if (hwc_window->restriction & restriction) return;
 
-   if ((y[0] != y[1]) || (y[2] != y[3]))
-     return EINA_FALSE;
+   hwc_window->restriction |= restriction;
 
-   return EINA_TRUE;
+   EHWTRACE("restriction set:0x%x", hwc_window->ec, hwc_window->hwc, hwc_window, restriction);
 }
 
-// if ec has invalid buffer or scaled( transformed ) or forced composite(never_hwc)
-EINTERN Eina_Bool
-e_hwc_window_device_state_available_update(E_Hwc_Window *hwc_window)
+EINTERN void
+e_hwc_window_restriction_unset(E_Hwc_Window *hwc_window, E_Hwc_Window_Restriction restriction)
 {
-   E_Client *ec;
-   E_Comp_Wl_Client_Data *cdata;
-   E_Pixmap *pixmap;
-   E_Output *eout;
-   int minw = 0, minh = 0;
-   int transform;
-   Eina_Bool available = EINA_TRUE;
-   E_Hwc_Window_Restriction restriction = E_HWC_WINDOW_RESTRICTION_NONE;
-   E_Desk *desk;
-   E_Zone *zone;
-   int alpha;
-   Evas_Render_Op render_op;
-
-   EINA_SAFETY_ON_NULL_RETURN_VAL(hwc_window, EINA_FALSE);
-
-   ec = hwc_window->ec;
-
-   if ((hwc_window->is_deleted) || (!ec) || e_object_is_del(E_OBJECT(ec)))
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_DELETED;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   if (ec->comp_override > 0)
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_OVERRIDE;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   if (hwc_window->obscured_by_target)
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_OBSCURED_BY_TARGET;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   if (e_comp_object_is_animating(ec->frame))
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_ANIMATING;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   if (evas_object_data_get(ec->frame, "effect_running"))
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_EFFECT_RUNNING;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   cdata = e_client_cdata_get(ec);
-   if ((!cdata) || (!cdata->buffer_ref.buffer))
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_BUFFER;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   pixmap = ec->pixmap;
-   if ((!pixmap) || (!e_pixmap_resource_get(pixmap)))
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_PIXMAP_RESOURCE;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   if ((cdata->width_from_buffer != cdata->width_from_viewport) ||
-       (cdata->height_from_buffer != cdata->height_from_viewport))
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_VIEWPORT;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   if (cdata->never_hwc)
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_NEVER_HWC;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   if (!_e_hwc_window_client_transform_device_state_available_get(ec))
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_TRANSFORM;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   switch (cdata->buffer_ref.buffer->type)
-     {
-      case E_COMP_WL_BUFFER_TYPE_NATIVE:
-      case E_COMP_WL_BUFFER_TYPE_TBM:
-         break;
-      case E_COMP_WL_BUFFER_TYPE_SHM:
-         if (!e_util_strcmp("wl_pointer-cursor", ec->icccm.window_role))
-           break;
-      default:
-        restriction = E_HWC_WINDOW_RESTRICTION_BUFFER_TYPE;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   zone = hwc_window->zone;
-   if (!zone)
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_ZONE;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   eout = e_output_find(zone->output_id);
-   if (!eout)
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_OUTPUT;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   tdm_output_get_available_size(eout->toutput, &minw, &minh, NULL, NULL, NULL);
-
-   if ((minw > 0) && (minw > cdata->buffer_ref.buffer->w))
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_MIN_WIDTH;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   if ((minh > 0) && (minh > cdata->buffer_ref.buffer->h))
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_MIN_HEIGHT;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   desk = e_desk_current_get(zone);
-   if (desk)
-     {
-        if ((desk->geom.x != zone->x) || (desk->geom.y != zone->y) ||
-            (desk->geom.w != zone->w) || (desk->geom.h != zone->h))
-          {
-             restriction = E_HWC_WINDOW_RESTRICTION_DESK_GEOMETRY;
-             available = EINA_FALSE;
-             goto finish;
-          }
-     }
-
-   transform = e_comp_wl_output_buffer_transform_get(ec);
-   if ((eout->config.rotation / 90) != transform)
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_OUTPUT_TRANSFORM;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   // if ec->frame is not for client buffer (e.g. launchscreen)
-   if (e_comp_object_content_type_get(ec->frame) != E_COMP_OBJECT_CONTENT_TYPE_INT_IMAGE)
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_CONTENT_IMAGE;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   if (e_comp_object_image_filter_get(ec->frame) != E_COMP_IMAGE_FILTER_NONE)
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_IMAGE_FILTER;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   // if there is a ec which is lower than quickpanel and quickpanel is opened.
-   if (E_POLICY_QUICKPANEL_LAYER >= evas_object_layer_get(ec->frame))
-     {
-        // check whether quickpanel is open than break
-        if (e_qps_visible_get())
-          {
-             restriction = E_HWC_WINDOW_RESTRICTION_QUICKPANEL_OPEN;
-             available = EINA_FALSE;
-             goto finish;
-          }
-     }
-
-   if (e_comp_object_render_update_lock_get(ec->frame))
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_RENDER_UPDATE_LOCK;
-        available = EINA_FALSE;
-        goto finish;
-     }
+   EINA_SAFETY_ON_NULL_RETURN(hwc_window);
 
-   if (e_client_desk_zoom_enable_get(ec))
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_DESK_ZOOM;
-        available = EINA_FALSE;
-        goto finish;
-     }
+   if (!(hwc_window->restriction & restriction)) return;
 
-   e_comp_object_color_get(ec->frame, NULL, NULL, NULL, &alpha);
-   if (alpha != 255)
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_BLEND_ALPHA;
-        available = EINA_FALSE;
-        goto finish;
-     }
+   hwc_window->restriction &= ~restriction;
 
-   render_op = e_comp_object_render_op_get(ec->frame);
-   if (render_op != EVAS_RENDER_BLEND)
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_BLEND_EQUATION;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-   if (hwc_window->queue_unset_waiting)
-     {
-        restriction = E_HWC_WINDOW_RESTRICTION_QUEUE_UNSET_WAITING;
-        available = EINA_FALSE;
-        goto finish;
-     }
-
-finish:
-   hwc_window->restriction = restriction;
-
-   if (hwc_window->device_state_available == available) return EINA_FALSE;
+   EHWTRACE("restriction unset:0x%x", hwc_window->ec, hwc_window->hwc, hwc_window, restriction);
+}
 
-   hwc_window->device_state_available = available;
+EINTERN unsigned int
+e_hwc_window_restriction_get(E_Hwc_Window *hwc_window)
+{
+   EINA_SAFETY_ON_NULL_RETURN_VAL(hwc_window, 0);
 
-   return EINA_TRUE;
+   return hwc_window->restriction;
 }
-
 EINTERN Eina_Bool
 e_hwc_window_constraints_update(E_Hwc_Window *hwc_window)
 {
@@ -2553,7 +2594,6 @@ e_hwc_window_client_type_override(E_Hwc_Window *hwc_window)
    if (hwc_window->ec && !hwc_window->ec->redirected)
      return;
 
-   e_hwc_window_device_state_available_update(hwc_window);
    e_hwc_window_state_set(hwc_window, E_HWC_WINDOW_STATE_CLIENT, EINA_TRUE);
    e_hwc_window_constraints_reset(hwc_window);
    e_hwc_window_rendered_window_update(hwc_window);
@@ -2582,72 +2622,6 @@ e_hwc_window_state_string_get(E_Hwc_Window_State hwc_window_state)
 }
 
 EINTERN const char*
-e_hwc_window_restriction_string_get(E_Hwc_Window *hwc_window)
-{
-   if (!hwc_window) return "UNKNOWN";
-
-   switch (hwc_window->restriction)
-    {
-     case E_HWC_WINDOW_RESTRICTION_NONE:
-       return "none";
-     case E_HWC_WINDOW_RESTRICTION_DELETED:
-       return "deleted";
-     case E_HWC_WINDOW_RESTRICTION_OVERRIDE:
-       return "override";
-     case E_HWC_WINDOW_RESTRICTION_ANIMATING:
-       return "animating";
-     case E_HWC_WINDOW_RESTRICTION_BUFFER:
-       return "buffer";
-     case E_HWC_WINDOW_RESTRICTION_VIEWPORT:
-       return "viewport";
-     case E_HWC_WINDOW_RESTRICTION_NEVER_HWC:
-       return "never hwc";
-     case E_HWC_WINDOW_RESTRICTION_TRANSFORM:
-       return "window transform";
-     case E_HWC_WINDOW_RESTRICTION_BUFFER_TYPE:
-       return "buffer type";
-     case E_HWC_WINDOW_RESTRICTION_OUTPUT:
-       return "output";
-     case E_HWC_WINDOW_RESTRICTION_MIN_WIDTH:
-       return "min width";
-     case E_HWC_WINDOW_RESTRICTION_MIN_HEIGHT:
-       return "min height";
-     case E_HWC_WINDOW_RESTRICTION_TOUCH_PRESS:
-       return "touch press";
-     case E_HWC_WINDOW_RESTRICTION_OUTPUT_TRANSFORM:
-       return "output transform";
-     case E_HWC_WINDOW_RESTRICTION_CONTENT_IMAGE:
-       return "content image";
-     case E_HWC_WINDOW_RESTRICTION_QUICKPANEL_OPEN:
-       return "quickpanel open";
-     case E_HWC_WINDOW_RESTRICTION_PIXMAP_RESOURCE:
-       return "pixmap resource";
-     case E_HWC_WINDOW_RESTRICTION_OBSCURED_BY_TARGET:
-       return "obscured by target";
-     case E_HWC_WINDOW_RESTRICTION_IMAGE_FILTER:
-       return "image filter";
-     case E_HWC_WINDOW_RESTRICTION_DESK_GEOMETRY:
-       return "desk geometry";
-     case E_HWC_WINDOW_RESTRICTION_EFFECT_RUNNING:
-       return "effect running";
-     case E_HWC_WINDOW_RESTRICTION_RENDER_UPDATE_LOCK:
-       return "render update lock";
-     case E_HWC_WINDOW_RESTRICTION_DESK_ZOOM:
-       return "desk zoom";
-     case E_HWC_WINDOW_RESTRICTION_BLEND_ALPHA:
-       return "blend alpha";
-     case E_HWC_WINDOW_RESTRICTION_BLEND_EQUATION:
-       return "blend equation";
-     case E_HWC_WINDOW_RESTRICTION_ZONE:
-       return "zone";
-     case E_HWC_WINDOW_RESTRICTION_QUEUE_UNSET_WAITING:
-       return "queue unset waiting";
-     default:
-       return "UNKNOWN";
-    }
-}
-
-EINTERN const char*
 e_hwc_window_name_get(E_Hwc_Window *hwc_window)
 {
    const char *name;
@@ -3362,6 +3336,11 @@ e_hwc_window_comp_override_set(E_Hwc_Window *hwc_window, Eina_Bool set)
 
    if (hwc_window->comp_override == set) return EINA_TRUE;
 
+   if (set)
+     e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_OVERRIDE);
+   else
+     e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_OVERRIDE);
+
    hwc_window->comp_override = set;
 
    return EINA_TRUE;
@@ -3374,6 +3353,11 @@ e_hwc_window_never_hwc_set(E_Hwc_Window *hwc_window, Eina_Bool set)
 
    if (hwc_window->never_hwc == set) return EINA_TRUE;
 
+   if (set)
+     e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_NEVER_HWC);
+   else
+     e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_NEVER_HWC);
+
    hwc_window->never_hwc = set;
 
    return EINA_TRUE;

diff --git a/src/bin/e_hwc_window_intern.h b/src/bin/e_hwc_window_intern.h
index 359b704..3262237 100644 (file)
--- a/src/bin/e_hwc_window_intern.h
+++ b/src/bin/e_hwc_window_intern.h
@@ -15,6 +15,28 @@ typedef struct _E_Hwc_Window_Hook                 E_Hwc_Window_Hook;
 
 typedef void (*E_Hwc_Window_Hook_Cb) (void *data, E_Hwc_Window *hwc_window);
 
+typedef enum _E_Hwc_Window_Restriction
+{
+   E_HWC_WINDOW_RESTRICTION_NONE = 0,
+   E_HWC_WINDOW_RESTRICTION_DELETED = (1 << 0),
+   E_HWC_WINDOW_RESTRICTION_OVERRIDE = (1 << 1),
+   E_HWC_WINDOW_RESTRICTION_BUFFER = (1 << 2),
+   E_HWC_WINDOW_RESTRICTION_VIEWPORT = (1 << 3),
+   E_HWC_WINDOW_RESTRICTION_NEVER_HWC = (1 << 4),
+   E_HWC_WINDOW_RESTRICTION_TRANSFORM = (1 << 5),
+   E_HWC_WINDOW_RESTRICTION_BUFFER_TYPE = (1 << 6),
+   E_HWC_WINDOW_RESTRICTION_MIN_SIZE = (1 << 7),
+   E_HWC_WINDOW_RESTRICTION_OUTPUT_TRANSFORM = (1 << 8),
+   E_HWC_WINDOW_RESTRICTION_CONTENT_IMAGE = (1 << 9),
+   E_HWC_WINDOW_RESTRICTION_IMAGE_FILTER = (1 << 10),
+   E_HWC_WINDOW_RESTRICTION_EFFECT = (1 << 11),
+   E_HWC_WINDOW_RESTRICTION_RENDER_UPDATE_LOCK = (1 << 12),
+   E_HWC_WINDOW_RESTRICTION_BLEND_ALPHA = (1 << 13),
+   E_HWC_WINDOW_RESTRICTION_BLEND_EQUATION = (1 << 14),
+   E_HWC_WINDOW_RESTRICTION_QUEUE_UNSET_WAITING = (1 << 15),
+   E_HWC_WINDOW_RESTRICTION_QUICKPANEL_OPEN = (1 << 16),
+} E_Hwc_Window_Restriction;
+
 typedef enum _E_Hwc_Window_Hook_Point
 {
    E_HWC_WINDOW_HOOK_ACCEPTED_STATE_SET,
@@ -60,8 +82,6 @@ EINTERN Eina_Bool               e_hwc_window_state_set(E_Hwc_Window *hwc_window,
 EINTERN E_Hwc_Window_State      e_hwc_window_state_get(E_Hwc_Window *hwc_window);
 EINTERN Eina_Bool               e_hwc_window_accepted_state_set(E_Hwc_Window *hwc_window, E_Hwc_Window_State state);
 EINTERN E_Hwc_Window_State      e_hwc_window_accepted_state_get(E_Hwc_Window *hwc_window);
-EINTERN Eina_Bool               e_hwc_window_device_state_available_update(E_Hwc_Window *hwc_window);
-EINTERN Eina_Bool               e_hwc_window_device_state_available_get(E_Hwc_Window *hwc_window);
 EINTERN const char*             e_hwc_window_restriction_string_get(E_Hwc_Window *hwc_window);
 
 EINTERN Eina_Bool               e_hwc_window_constraints_update(E_Hwc_Window *hwc_window);
@@ -105,4 +125,8 @@ EINTERN Eina_Bool                 e_hwc_window_comp_override_set(E_Hwc_Window *h
 EINTERN Eina_Bool                 e_hwc_window_never_hwc_set(E_Hwc_Window *hwc_window, Eina_Bool set);
 EINTERN Eina_Bool                 e_hwc_window_visible_skip_set(E_Hwc_Window *hwc_window, Eina_Bool set);
 
+EINTERN void                      e_hwc_window_restriction_set(E_Hwc_Window *hwc_window, E_Hwc_Window_Restriction restriction);
+EINTERN void                      e_hwc_window_restriction_unset(E_Hwc_Window *hwc_window, E_Hwc_Window_Restriction restriction);
+EINTERN unsigned int              e_hwc_window_restriction_get(E_Hwc_Window *hwc_window);
+
 #endif

diff --git a/src/bin/e_hwc_window_queue.c b/src/bin/e_hwc_window_queue.c
index c2da681..2d8a30b 100644 (file)
--- a/src/bin/e_hwc_window_queue.c
+++ b/src/bin/e_hwc_window_queue.c
@@ -1559,7 +1559,7 @@ _e_hwc_window_queue_prepare_unset(E_Hwc_Window_Queue *queue)
    _e_hwc_window_queue_buffers_retrieve(queue);
 
    queue->state = E_HWC_WINDOW_QUEUE_STATE_UNSET_WAITING;
-   hwc_window->queue_unset_waiting = EINA_TRUE;
+   e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_QUEUE_UNSET_WAITING);
 
    EHWQINF("Unset Waiting user ehw:%p - {%s}",
             hwc_window->ec, queue->hwc, queue, hwc_window,
@@ -1651,7 +1651,7 @@ _e_hwc_window_queue_unset(E_Hwc_Window_Queue *queue)
            (queue->user->ec ? queue->user->ec->icccm.title : "UNKNOWN"));
 
    /* unset the hwc_window from the queue */
-   queue->user->queue_unset_waiting = EINA_FALSE;
+   e_hwc_window_restriction_unset(queue->user, E_HWC_WINDOW_RESTRICTION_QUEUE_UNSET_WAITING);
    e_hwc_window_unref(queue->user);
    queue->user = NULL;
 

diff --git a/src/bin/e_hwc_windows.c b/src/bin/e_hwc_windows.c
index 781ff5c..1d64d79 100644 (file)
--- a/src/bin/e_hwc_windows.c
+++ b/src/bin/e_hwc_windows.c
@@ -14,6 +14,9 @@
 #include "e_client_intern.h"
 #include "e_comp_object_intern.h"
 #include "e_utils_intern.h"
+#include "services/e_service_quickpanel_intern.h"
+#include "e_policy_private_data.h"
+#include "e_policy_intern.h"
 
 # include <Evas_Engine_GL_Tbm.h>
 # include <Evas_Engine_Software_Tbm.h>
@@ -913,43 +916,29 @@ _e_hwc_windows_visible_windows_list_get(E_Hwc *hwc)
    Evas_Object *o;
    int ee_w, ee_h;
    int x, y, w, h, x1, x2, y1, y2;
-   int r, g, b, a;
    int ui_skip = EINA_FALSE;
-   int obscured_by_target = EINA_FALSE;
-   const char *type;
    Eina_Bool effect_client;
    Evas_Render_Op render_op;
    E_Map *map;
+   Eina_Bool qps_visible;
 
    ecore_evas_geometry_get(e_comp->ee, NULL, NULL, &ee_w, &ee_h);
+   qps_visible = e_qps_visible_get();
 
    for (o = evas_object_top_get(e_comp->evas); o; o = evas_object_below_get(o))
      {
         ec = _e_hwc_windows_client_get_from_object(o, &effect_client);
-        if (!ec)
-          {
-             if (obscured_by_target) continue;
-             if (!evas_object_visible_get(o)) continue;
-
-             type = evas_object_type_get(o);
-             if (!e_util_strcmp(type, "image"))
-               {
-                  evas_object_color_get(o, &r, &g, &b, &a);
-                  evas_object_geometry_get(o, &x, &y, &w, &h);
-
-                  if ((a > 0) && ((r > 0)  || (g > 0) || (b > 0)) &&
-                      (E_INTERSECTS(0, 0, ee_w, ee_h, x, y, w, h)))
-                    obscured_by_target = EINA_TRUE;
-               }
-
-             continue;
-          }
+        if (!ec) continue;
 
         hwc_window = ec->hwc_window;
         if (!hwc_window) continue;
 
         e_hwc_window_name_set(hwc_window);
-        hwc_window->obscured_by_target = obscured_by_target;
+
+        if ((qps_visible) && (E_POLICY_QUICKPANEL_LAYER >= evas_object_layer_get(ec->frame)))
+          e_hwc_window_restriction_set(hwc_window, E_HWC_WINDOW_RESTRICTION_QUICKPANEL_OPEN);
+        else
+          e_hwc_window_restriction_unset(hwc_window, E_HWC_WINDOW_RESTRICTION_QUICKPANEL_OPEN);
 
         if (hwc)
           {
@@ -1865,12 +1854,12 @@ _e_hwc_windows_status_print(E_Hwc *hwc, Eina_Bool with_target)
 
    EINA_LIST_FOREACH(visible_windows, l, hwc_window)
      {
-        EHWSTRACE("  ehw:%p ts:%p - {%s} state:%s zpos:%d deleted:%s restrict:%s",
+        EHWSTRACE("  ehw:%p ts:%p - {%s} state:%s zpos:%d deleted:%s restrict:0x%x",
                   hwc_window->ec, hwc, hwc_window,
                   hwc_window->current.buffer.tsurface, e_hwc_window_name_get(hwc_window),
                   e_hwc_window_state_string_get(hwc_window->state),
                   hwc_window->zpos, hwc_window->is_deleted ? "yes" : "no",
-                  e_hwc_window_restriction_string_get(hwc_window));
+                  e_hwc_window_restriction_get(hwc_window));
      }
 }
 
@@ -2129,7 +2118,7 @@ _e_hwc_windows_visible_windows_states_update(E_Hwc *hwc)
 
              /* filter the visible clients which e20 prevent to shown by hw directly
                 by demand of e20 */
-             if (e_hwc_window_device_state_available_get(hwc_window))
+             if (!e_hwc_window_restriction_get(hwc_window))
                e_hwc_window_state_set(hwc_window, E_HWC_WINDOW_STATE_DEVICE, EINA_TRUE);
              else
                {
@@ -2313,7 +2302,7 @@ _e_hwc_windows_pp_hwc_window_update(E_Hwc *hwc)
             (tbm_surface_get_height(hwc_window->current.buffer.tsurface)) != h)
           goto clear;
 
-        if (!hwc_window->device_state_available)
+        if (e_hwc_window_restriction_get(hwc_window))
           goto clear;
      }
 
@@ -2377,9 +2366,6 @@ _e_hwc_windows_changes_update(E_Hwc *hwc)
         /* update the window's props */
         if (e_hwc_window_prop_update(hwc_window))
           update_changes = EINA_TRUE;
-
-        if (e_hwc_window_device_state_available_update(hwc_window))
-          update_changes = EINA_TRUE;
      }
 
    if (hwc->primary_output)
@@ -3837,7 +3823,7 @@ _e_hwc_windows_window_debug_info_get(Eldbus_Message_Iter *iter, E_Hwc_Wins_Debug
 
              snprintf(info_str, sizeof(info_str),
                       "%3d 0x%08zx 0x%08zx %4d   %s    %s     %s   0x%08zx %04dx%04d %04dx%04d+%04d+%04d"
-                      " %4s %04dx%04d+%04d+%04d  %c%3d  0x%08zx  0x%08zx 0x%08zx   %6s   %s",
+                      " %4s %04dx%04d+%04d+%04d  %c%3d  0x%08zx  0x%08zx 0x%08zx   %6s   0x%x",
                       ++idx,
                       e_client_util_win_get(hwc_window->ec),
                       (uintptr_t)hwc_window,
@@ -3863,7 +3849,7 @@ _e_hwc_windows_window_debug_info_get(Eldbus_Message_Iter *iter, E_Hwc_Wins_Debug
                       (uintptr_t)hwc_window->queue,
                       hwc_window->ec ? (uintptr_t)e_comp_wl_tbm_client_queue_get(hwc_window->ec) : 0,
                       vis_skip ? "TRUE" : "FALSE",
-                      e_hwc_window_restriction_string_get(hwc_window));
+                      e_hwc_window_restriction_get(hwc_window));
              eldbus_message_iter_basic_append(line_array, 's', info_str);
 
              pending_idx = 0;

diff --git a/src/include/e_hwc_window.h b/src/include/e_hwc_window.h
index 6c0f0a2..dcb47f3 100644 (file)
--- a/src/include/e_hwc_window.h
+++ b/src/include/e_hwc_window.h
@@ -44,7 +44,6 @@ struct _E_Hwc_Window
    Eina_Bool                      is_cursor;
    Eina_Bool                      is_deleted;
    Eina_Bool                      set_name;
-   Eina_Bool                      device_state_available;
 
    E_Hwc_Window_Activation_State  activation_state; /* hwc_window has occupied the hw layer or not */
 
@@ -94,7 +93,6 @@ struct _E_Hwc_Window
    Eina_Bool                      on_rendered_target;
 
    unsigned int                   restriction;
-   Eina_Bool                      obscured_by_target;
 
    E_Presentation_Time_Container  presentation_container;
 
@@ -110,11 +108,14 @@ struct _E_Hwc_Window
 
    Evas_Object                   *below_transparent_obj;
 
-   Eina_Bool                      queue_unset_waiting;
-
    Eina_Bool                      comp_override;
    Eina_Bool                      never_hwc;
    Eina_Bool                      visible_skip;
+
+   struct wl_listener             image_filter_set_listener;
+   struct wl_listener             render_op_set_listener;
+   struct wl_listener             content_type_set_listener;
+   struct wl_listener             color_set_listener;
 };
 
 struct _E_Hwc_Window_Target