Revert "e_canvas: remove e_canvas_layer_tree_get"

This reverts commit 1455758129fc9cd11f90918e872cc29ca950c50f.

Change-Id: I8c2fd0bc373d1cc8ddee215f1844161a6bbaaa18

diff --git a/src/bin/core/e_canvas.c b/src/bin/core/e_canvas.c
index f2eb9a476a45f39721a07c9ebb2be0e0b9606259..06f6bc1c4628d7e09de27b1fea110d94b093879d 100644 (file)
--- a/src/bin/core/e_canvas.c
+++ b/src/bin/core/e_canvas.c
@@ -2,11 +2,20 @@
 #include "e_canvas_intern.h"
 #include "e_view_intern.h"
 
+#define E_CANVAS_LAYER_TREE_FOREACH(layer_tree, canvas, layer) \
+   for (layer = E_CANVAS_LAYER_BOTTOM, \
+        layer_tree = _canvas_layer_tree_get(canvas, layer); \
+        layer_tree != NULL; \
+        layer_tree = _canvas_layer_tree_get(canvas, ++layer))
+
+E_View_Tree_Impl layer_tree_impl;
+
 static void _canvas_cb_render_pre(void *data, Evas *e, void *event_info);
 static void _canvas_cb_render_post(void *data, Evas *e, void *event_info);
 static void _canvas_cb_render_flush_pre(void *data, Evas *e, void *event_info);
 static void _canvas_cb_render_flush_post(void *data, Evas *e, void *event_info);
 static void _canvas_tree_init(E_Canvas *canvas);
+static E_Canvas_Layer_Tree *_canvas_layer_tree_get(E_Canvas *canvas, E_Canvas_Layer layer);
 
 EINTERN E_Canvas *
 e_canvas_create(Evas *evas)
@@ -40,6 +49,9 @@ e_canvas_destroy(E_Canvas *canvas)
 {
    wl_signal_emit_mutable(&canvas->events.destroy, canvas);
 
+   // TODO
+   // cleanup canvas->layers[]
+
    evas_event_callback_del(canvas->evas, EVAS_CALLBACK_RENDER_PRE, _canvas_cb_render_pre);
    evas_event_callback_del(canvas->evas, EVAS_CALLBACK_RENDER_POST, _canvas_cb_render_post);
    evas_event_callback_del(canvas->evas, EVAS_CALLBACK_RENDER_FLUSH_PRE, _canvas_cb_render_flush_pre);
@@ -106,6 +118,18 @@ e_canvas_root_view_tree_get(E_Canvas *canvas)
    return &canvas->tree;
 }
 
+E_API E_View_Tree *
+e_canvas_layer_view_tree_get(E_Canvas *canvas, E_Canvas_Layer layer)
+{
+   E_Canvas_Layer_Tree *layer_tree;
+
+   layer_tree = _canvas_layer_tree_get(canvas, layer);
+   if (!layer_tree)
+     return NULL;
+
+   return &layer_tree->tree;
+}
+
 E_API void
 e_canvas_tree_for_each(E_Canvas *canvas, E_View_Iterator_Cb iterator, void *user_data)
 {
@@ -118,12 +142,51 @@ e_canvas_tree_for_each_reverse(E_Canvas *canvas, E_View_Iterator_Cb iterator, vo
    e_view_for_each_view_reverse(&canvas->tree.view, iterator, user_data);
 }
 
+EINTERN E_Canvas_Layer
+e_canvas_layer_find(E_Canvas *canvas, E_View *view)
+{
+   E_View_Tree *tree, *backup;
+   E_Canvas_Layer layer;
+
+   if (view->type == E_VIEW_TYPE_TREE)
+     tree = e_view_tree_from_view(view);
+   else
+     tree = view->parent;
+
+   backup = tree;
+   while (tree->view.parent)
+     {
+        backup = tree->view.parent;
+        if (backup->view.parent == NULL)
+          backup = tree;
+        tree = tree->view.parent;
+     }
+
+   for (layer = E_CANVAS_LAYER_BOTTOM; layer <= E_CANVAS_LAYER_MAX; layer++)
+     {
+        if (backup == e_canvas_layer_view_tree_get(canvas, layer))
+          return layer;
+     }
+
+   return E_CANVAS_LAYER_MAX;
+}
+
 EINTERN void
 e_canvas_damage_rectangle_add(E_Canvas *canvas, int x, int y, int w, int h)
 {
    evas_damage_rectangle_add(canvas->evas, x, y, w, h);
 }
 
+EINTERN E_Canvas_Layer_Tree *
+e_canvas_layer_tree_from_tree(E_View_Tree *tree)
+{
+   E_Canvas_Layer_Tree *layer_tree;
+
+   assert(tree->impl == &layer_tree_impl);
+
+   return wl_container_of(tree, layer_tree, tree);
+}
+
 E_API E_View *
 e_canvas_top_get(E_Canvas *canvas)
 {
@@ -168,12 +231,88 @@ _canvas_cb_render_flush_post(void *data, Evas *e, void *event_info)
    wl_signal_emit_mutable(&canvas->events.render_flush_post, canvas);
 }
 
+static E_Canvas_Layer_Tree *
+_canvas_layer_tree_get(E_Canvas *canvas, E_Canvas_Layer layer)
+{
+   if (layer < E_CANVAS_LAYER_BOTTOM || layer > E_CANVAS_LAYER_MAX)
+     return NULL;
+
+   return &canvas->layers[layer];
+}
+
+static E_Layer
+_canvas_layer_map_to(E_Canvas_Layer layer)
+{
+   switch (layer)
+     {
+      case E_CANVAS_LAYER_BOTTOM: return E_LAYER_BOTTOM;
+      case E_CANVAS_LAYER_BG: return E_LAYER_BG;
+      case E_CANVAS_LAYER_DESKTOP: return E_LAYER_DESKTOP;
+      case E_CANVAS_LAYER_DESKTOP_TOP: return E_LAYER_DESKTOP_TOP;
+      case E_CANVAS_LAYER_CLIENT_DESKTOP: return E_LAYER_CLIENT_DESKTOP;
+      case E_CANVAS_LAYER_CLIENT_BELOW: return E_LAYER_CLIENT_BELOW;
+      case E_CANVAS_LAYER_CLIENT_NORMAL: return E_LAYER_CLIENT_NORMAL;
+      case E_CANVAS_LAYER_CLIENT_ABOVE: return E_LAYER_CLIENT_ABOVE;
+      case E_CANVAS_LAYER_CLIENT_EDGE: return E_LAYER_CLIENT_EDGE;
+      case E_CANVAS_LAYER_CLIENT_FULLSCREEN: return E_LAYER_CLIENT_FULLSCREEN;
+      case E_CANVAS_LAYER_CLIENT_EDGE_FULLSCREEN: return E_LAYER_CLIENT_EDGE_FULLSCREEN;
+      case E_CANVAS_LAYER_CLIENT_POPUP: return E_LAYER_CLIENT_POPUP;
+      case E_CANVAS_LAYER_CLIENT_TOP: return E_LAYER_CLIENT_TOP;
+      case E_CANVAS_LAYER_CLIENT_PRIO: return E_LAYER_CLIENT_PRIO;
+      case E_CANVAS_LAYER_CLIENT_NOTIFICATION_LOW: return E_LAYER_CLIENT_NOTIFICATION_LOW;
+      case E_CANVAS_LAYER_CLIENT_NOTIFICATION_NORMAL: return E_LAYER_CLIENT_NOTIFICATION_NORMAL;
+      case E_CANVAS_LAYER_CLIENT_NOTIFICATION_HIGH: return E_LAYER_CLIENT_NOTIFICATION_HIGH;
+      case E_CANVAS_LAYER_CLIENT_NOTIFICATION_TOP: return E_LAYER_CLIENT_NOTIFICATION_TOP;
+      case E_CANVAS_LAYER_CLIENT_ALERT_LOW: return E_LAYER_CLIENT_ALERT_LOW;
+      case E_CANVAS_LAYER_CLIENT_ALERT: return E_LAYER_CLIENT_ALERT;
+      case E_CANVAS_LAYER_CLIENT_ALERT_HIGH: return E_LAYER_CLIENT_ALERT_HIGH;
+      case E_CANVAS_LAYER_CLIENT_DRAG: return E_LAYER_CLIENT_DRAG;
+      case E_CANVAS_LAYER_CLIENT_CURSOR: return E_LAYER_CLIENT_CURSOR;
+      case E_CANVAS_LAYER_POPUP: return E_LAYER_POPUP;
+      case E_CANVAS_LAYER_EFFECT: return E_LAYER_EFFECT;
+      case E_CANVAS_LAYER_DESK_OBJECT_BELOW: return E_LAYER_DESK_OBJECT_BELOW;
+      case E_CANVAS_LAYER_DESK_OBJECT: return E_LAYER_DESK_OBJECT;
+      case E_CANVAS_LAYER_DESK_OBJECT_ABOVE: return E_LAYER_DESK_OBJECT_ABOVE;
+      case E_CANVAS_LAYER_MENU: return E_LAYER_MENU;
+      case E_CANVAS_LAYER_DESKLOCK: return E_LAYER_DESKLOCK;
+      case E_CANVAS_LAYER_MAX: return E_LAYER_MAX;
+      default: assert(0);
+     }
+}
+
+static void
+_canvas_layer_tree_child_add(E_View_Tree *tree, E_View *child)
+{
+   E_Canvas_Layer layer;
+
+   if (!child->eo)
+     return;
+
+   layer = e_view_layer_index_get(&tree->view);
+   evas_object_layer_set(child->eo, _canvas_layer_map_to(layer));
+}
+
+E_View_Tree_Impl layer_tree_impl = {
+     .child_add = _canvas_layer_tree_child_add,
+};
+
 static void
 _canvas_tree_init(E_Canvas *canvas)
 {
+   E_Canvas_Layer_Tree *layer_tree;
+   E_Canvas_Layer layer;
+
    e_view_tree_init(&canvas->tree, NULL, NULL);
    e_view_show(&canvas->tree.view);
    e_view_reorderable_set(&canvas->tree.view, false);
+
+   E_CANVAS_LAYER_TREE_FOREACH(layer_tree, canvas, layer)
+     {
+        layer_tree->layer = layer;
+        e_view_tree_init(&layer_tree->tree, &layer_tree_impl, &canvas->tree);
+        e_view_show(&layer_tree->tree.view);
+        e_view_reorderable_set(&layer_tree->tree.view, false);
+     }
 }
 
 EINTERN void
@@ -182,6 +321,52 @@ e_canvas_size_get(E_Canvas *canvas, int *width, int *height)
    evas_output_size_get(canvas->evas, width, height);
 }
 
+EINTERN E_Canvas_Layer
+e_canvas_util_e_layer_map(short e_layer)
+{
+   switch (e_layer)
+     {
+      case E_LAYER_BOTTOM: return E_CANVAS_LAYER_BOTTOM;
+      case E_LAYER_BG: return E_CANVAS_LAYER_BG;
+      case E_LAYER_DESKTOP: return E_CANVAS_LAYER_DESKTOP;
+      case E_LAYER_DESKTOP_TOP: return E_CANVAS_LAYER_DESKTOP_TOP;
+      case E_LAYER_CLIENT_DESKTOP: return E_CANVAS_LAYER_CLIENT_DESKTOP;
+      case E_LAYER_CLIENT_BELOW: return E_CANVAS_LAYER_CLIENT_BELOW;
+      case E_LAYER_CLIENT_NORMAL: return E_CANVAS_LAYER_CLIENT_NORMAL;
+      case E_LAYER_CLIENT_ABOVE: return E_CANVAS_LAYER_CLIENT_ABOVE;
+      case E_LAYER_CLIENT_EDGE: return E_CANVAS_LAYER_CLIENT_EDGE;
+      case E_LAYER_CLIENT_FULLSCREEN: return E_CANVAS_LAYER_CLIENT_FULLSCREEN;
+      case E_LAYER_CLIENT_EDGE_FULLSCREEN: return E_CANVAS_LAYER_CLIENT_EDGE_FULLSCREEN;
+      case E_LAYER_CLIENT_POPUP: return E_CANVAS_LAYER_CLIENT_POPUP;
+      case E_LAYER_CLIENT_TOP: return E_CANVAS_LAYER_CLIENT_TOP;
+      case E_LAYER_CLIENT_PRIO: return E_CANVAS_LAYER_CLIENT_PRIO;
+      case E_LAYER_CLIENT_NOTIFICATION_LOW: return E_CANVAS_LAYER_CLIENT_NOTIFICATION_LOW;
+      case E_LAYER_CLIENT_NOTIFICATION_NORMAL: return E_CANVAS_LAYER_CLIENT_NOTIFICATION_NORMAL;
+      case E_LAYER_CLIENT_NOTIFICATION_HIGH: return E_CANVAS_LAYER_CLIENT_NOTIFICATION_HIGH;
+      case E_LAYER_CLIENT_NOTIFICATION_TOP: return E_CANVAS_LAYER_CLIENT_NOTIFICATION_TOP;
+      case E_LAYER_CLIENT_ALERT_LOW: return E_CANVAS_LAYER_CLIENT_ALERT_LOW;
+      case E_LAYER_CLIENT_ALERT: return E_CANVAS_LAYER_CLIENT_ALERT;
+      case E_LAYER_CLIENT_ALERT_HIGH: return E_CANVAS_LAYER_CLIENT_ALERT_HIGH;
+      case E_LAYER_CLIENT_DRAG: return E_CANVAS_LAYER_CLIENT_DRAG;
+      case E_LAYER_CLIENT_CURSOR: return E_CANVAS_LAYER_CLIENT_CURSOR;
+      case E_LAYER_POPUP: return E_CANVAS_LAYER_POPUP;
+      case E_LAYER_EFFECT: return E_CANVAS_LAYER_EFFECT;
+      case E_LAYER_DESK_OBJECT_BELOW: return E_CANVAS_LAYER_DESK_OBJECT_BELOW;
+      case E_LAYER_DESK_OBJECT: return E_CANVAS_LAYER_DESK_OBJECT;
+      case E_LAYER_DESK_OBJECT_ABOVE: return E_CANVAS_LAYER_DESK_OBJECT_ABOVE;
+      case E_LAYER_MENU: return E_CANVAS_LAYER_MENU;
+      case E_LAYER_DESKLOCK: return E_CANVAS_LAYER_DESKLOCK;
+      case E_LAYER_MAX: return E_CANVAS_LAYER_MAX;
+      default: assert(0);
+     }
+}
+
+EINTERN E_Layer
+e_canvas_util_layer_map(E_Canvas_Layer layer)
+{
+   return _canvas_layer_map_to(layer);
+}
+
 #ifndef E_VIEW_TEST
 #include "e_view_client_intern.h"
 

diff --git a/src/bin/core/e_canvas_intern.h b/src/bin/core/e_canvas_intern.h
index dd6da853a18e628918559a0a3d3de8aba75d6c31..9fed953b5d297a5bd8e6616ecb79d95eb6140473 100644 (file)
--- a/src/bin/core/e_canvas_intern.h
+++ b/src/bin/core/e_canvas_intern.h
@@ -9,12 +9,19 @@ extern "C" {
 #include "e_view_intern.h"
 
 typedef struct _E_Canvas E_Canvas;
+typedef struct _E_Canvas_Layer_Tree E_Canvas_Layer_Tree;
 typedef struct _E_View_Client E_View_Client;
 
+struct _E_Canvas_Layer_Tree
+{
+   E_View_Tree tree;
+   E_Canvas_Layer layer;
+};
 
 struct _E_Canvas
 {
    E_View_Tree tree;
+   E_Canvas_Layer_Tree layers[E_CANVAS_LAYER_MAX + 1];
 
    Evas *evas;
 
@@ -95,11 +102,18 @@ void e_canvas_render_flush_post_listener_add(E_Canvas *canvas, struct wl_listene
  */
 
 EINTERN E_View_Tree *e_canvas_root_view_tree_get(E_Canvas *canvas);
+E_Canvas_Layer e_canvas_layer_find(E_Canvas *canvas, E_View *view);
 
 void e_canvas_damage_rectangle_add(E_Canvas *canvas, int x, int y, int w, int h);
 
+E_Canvas_Layer_Tree *e_canvas_layer_tree_from_tree(E_View_Tree *tree);
+
 void e_canvas_size_get(E_Canvas *canvas, int *width, int *height);
 
+E_Canvas_Layer e_canvas_util_e_layer_map(short layer);
+
+E_Layer e_canvas_util_layer_map(E_Canvas_Layer layer);
+
 /**
  * Retrieve the E_View_Client instance that can accept input events at the
  * specified location

diff --git a/src/bin/core/e_view.c b/src/bin/core/e_view.c
index 5d634ebdfce7c84c1a60d583bc7d42eeee55766b..b946da5bec097d2600d67b9d229df252e8bf9e1f 100644 (file)
--- a/src/bin/core/e_view.c
+++ b/src/bin/core/e_view.c
@@ -726,6 +726,28 @@ e_view_pass_events_get(E_View *view)
    return evas_object_pass_events_get(view->eo);
 }
 
+E_API E_Canvas_Layer
+e_view_layer_index_get(E_View *view)
+{
+   E_Canvas *canvas;
+   E_Canvas_Layer_Tree *layer_tree;
+
+   canvas = e_canvas_get(view);
+   while (1)
+     {
+        assert(view->parent);
+
+        if (view->parent == &canvas->tree)
+          {
+             layer_tree = e_canvas_layer_tree_from_tree(e_view_tree_from_view(view));
+             break;
+          }
+        view = e_view_tree_view_get(view->parent);
+     }
+
+   return layer_tree->layer;
+}
+
 EINTERN void
 e_view_reorderable_set(E_View *view, bool reorderable)
 {

diff --git a/src/bin/core/e_view_layout.c b/src/bin/core/e_view_layout.c
index 2a89e7e6656c1ef84388da3385b7c3d684f9e704..1c66bb1112c01a75e3e9cd4b771c72e676fe87fa 100644 (file)
--- a/src/bin/core/e_view_layout.c
+++ b/src/bin/core/e_view_layout.c
@@ -30,7 +30,7 @@ struct _E_View_Layout_Item
    E_View_Layout *layout;
    int x, y, w, h;
    E_View *view;
-   E_View_Tree *prev_parent;
+   E_Canvas_Layer prev_layer;
    bool destroying;
    struct wl_listener destroy;
    struct wl_list link;
@@ -97,7 +97,7 @@ _e_view_layout_adopt(E_View_Layout *layout, E_View *child)
 
    li->layout = layout;
    li->view = child;
-   li->prev_parent = e_view_parent_get(child);
+   li->prev_layer = e_view_layer_index_get(child);
 
    e_view_clip_set(child, e_view_rect_view_get(layout->clip));
    e_view_reparent(child, &layout->tree);
@@ -117,6 +117,11 @@ static void
 _e_view_layout_disown(E_View *child)
 {
    E_View_Layout_Item *li;
+   E_Zone *zone;
+   E_Desk *desk;
+   E_Desk_Area *eda;
+   E_Policy_Desk_Area *pda;
+   E_View_Tree *layer_tree;
 
    li = e_view_data_get(child, "e_view_layout_data");
    if (!li) return;
@@ -130,7 +135,12 @@ _e_view_layout_disown(E_View *child)
 
    if (!li->destroying)
      {
-        if (li->prev_parent) e_view_reparent(child, li->prev_parent);
+        zone = e_zone_current_get();
+        desk = e_desk_current_get(zone);
+        eda = e_desk_desk_area_base_get(desk);
+        pda = e_policy_desk_area_get(eda);
+        layer_tree = e_policy_desk_area_layer_tree_get(pda, e_canvas_util_layer_map(li->prev_layer));
+        e_view_reparent(child, layer_tree);
      }
 
    free(li);
@@ -347,24 +357,36 @@ e_view_layout_child_raise (E_View *child)
 }
 
 E_API void
-e_view_layout_reparent(E_View_Layout *layout, E_View_Tree *parent)
+e_view_layout_layer_set(E_View_Layout *layout, E_Layer layer)
 {
    E_View_Layout_Item *li;
+   E_View_Tree *layer_tree;
    E_View *view;
+   E_Zone *zone;
+   E_Desk *desk;
+   E_Desk_Area *eda;
+   E_Policy_Desk_Area *pda;
 
    if (!layout) return;
 
-   e_view_reparent(e_view_tree_view_get(&layout->tree), parent);
+   zone = e_zone_current_get();
+   desk = e_desk_current_get(zone);
+   eda = e_desk_desk_area_base_get(desk);
+   pda = e_policy_desk_area_get(eda);
+
+   layer_tree = e_policy_desk_area_layer_tree_get(pda, layer);
 
    if (!wl_list_empty(&layout->items))
      {
         wl_list_for_each_reverse(li, &layout->items, link)
           {
-            e_view_reparent(li->view, &layout->tree);
+             evas_object_layer_set(li->view->eo, layer);
           }
      }
    view = e_view_rect_view_get(layout->clip);
-   e_view_reparent(view, &layout->tree);
+   evas_object_layer_set(view->eo, layer);
+
+   e_view_reparent(e_view_tree_view_get(&layout->tree), layer_tree);
 }
 
 E_API void

diff --git a/src/bin/debug/e_info_server.c b/src/bin/debug/e_info_server.c
index 994a2e95bf2b050c8b39644effe71e92d04254fb..0064cafa59972bf109e59df2f42fe87ebc02f2a7 100644 (file)
--- a/src/bin/debug/e_info_server.c
+++ b/src/bin/debug/e_info_server.c
@@ -6634,6 +6634,7 @@ _msg_view_append(Eldbus_Message_Iter *iter, Eina_Bool is_visible)
         int iconified = 0;
         E_Iconified_Type iconified_type;
         int hwc = -1, hwc_policy = E_HWC_POLICY_NONE, pl_zpos = -999;
+        E_Canvas_Layer canvas_layer;
         char layer_name[128] = {0,};
         Eina_Bool has_input_region = EINA_FALSE;
         Eina_List *list_input_region = NULL;
@@ -6676,7 +6677,9 @@ _msg_view_append(Eldbus_Message_Iter *iter, Eina_Bool is_visible)
 
         _e_info_server_ec_hwc_info_get(ec, &hwc, &hwc_policy, &pl_zpos);
 
-        e_comp_layer_name_get(ec->layer, layer_name, sizeof(layer_name));
+        canvas_layer = e_view_layer_index_get(e_view_client_view_get(e_client_view_get(ec)));
+
+        e_comp_layer_name_get(e_comp_canvas_layer_map_to(canvas_layer), layer_name, sizeof(layer_name));
 
         e_view_client_input_rect_get(e_client_view_get(ec), &list_input_region);
         if (list_input_region)

diff --git a/src/bin/server/e_policy_wl.c b/src/bin/server/e_policy_wl.c
index f1b868f4c7187de2bb86df143935d3af5cd49f85..da7642b333cb4e49c3d151abebae876f8803a74f 100644 (file)
--- a/src/bin/server/e_policy_wl.c
+++ b/src/bin/server/e_policy_wl.c
@@ -1874,7 +1874,9 @@ _e_policy_wl_aux_hint_apply(E_Client *ec)
                       ec->changable_layer[E_CHANGABLE_LAYER_TYPE_ABOVE_NOTIFICATION].saved)
                     {
                        // restore original layer
-                       if (original_layer != e_client_layer_get(ec))
+                       E_View *view = e_view_client_view_get(e_client_view_get(ec));
+                       E_Layer ec_layer = e_canvas_util_layer_map(e_view_layer_index_get(view));
+                       if (original_layer != ec_layer)
                          {
                             Eina_Bool pend = EINA_FALSE;
                             pend = e_policy_visibility_client_layer_lower(ec, original_layer);

diff --git a/src/bin/server/e_tizen_launch_effect.c b/src/bin/server/e_tizen_launch_effect.c
index 9ba647959567a5b27ea96c5c9b14526ae734a4b0..f8d2dde9034a58f09b9830e05f79c497c7e1ba6a 100644 (file)
--- a/src/bin/server/e_tizen_launch_effect.c
+++ b/src/bin/server/e_tizen_launch_effect.c
@@ -295,7 +295,8 @@ _launchscreen_splash_setup(E_Tizen_Launch_Effect_Splash *splash,
 {
    E_Client *ec = NULL;
    E_View_Client *view_client;
-   E_View_Tree *parent_view_tree;
+   E_View_Tree *view_tree_layer;
+   E_Canvas_Layer layer;
    int comp_w = 0, comp_h = 0;
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(splash->ec, EINA_FALSE);
@@ -320,11 +321,12 @@ _launchscreen_splash_setup(E_Tizen_Launch_Effect_Splash *splash,
      ELOGF("TZPOL", "Launchscreen setup | INDICATOR of the splash screen has benn deprecated. please check!", NULL);
 
    view_client = e_client_view_get(ec);
-   parent_view_tree = e_view_parent_get(e_view_client_view_get(view_client));
+   layer = e_view_layer_index_get(e_view_client_view_get(view_client));
+   view_tree_layer = e_canvas_layer_view_tree_get(e_comp_canvas_get(), layer);
 
    if (splash->type == LAUNCH_IMG_FILE_TYPE_IMAGE)
       {
-        splash->view_image = e_view_image_create(parent_view_tree);
+        splash->view_image = e_view_image_create(view_tree_layer);
         EINA_SAFETY_ON_NULL_RETURN_VAL(splash->view_image, EINA_FALSE);
 
         splash->view = e_view_image_view_get(splash->view_image);
@@ -364,7 +366,7 @@ _launchscreen_splash_setup(E_Tizen_Launch_Effect_Splash *splash,
       }
    else
       {
-        splash->view_edje = e_view_edje_create(parent_view_tree);
+        splash->view_edje = e_view_edje_create(view_tree_layer);
         EINA_SAFETY_ON_NULL_RETURN_VAL(splash->view_edje, EINA_FALSE);
 
         splash->view = e_view_edje_view_get(splash->view_edje);

diff --git a/src/bin/windowmgr/e_policy.c b/src/bin/windowmgr/e_policy.c
index c1534996cc1957a339b17df7b81c6fed36c51451..f5a52a86be303cbadfc57e67c744370f1774b969 100644 (file)
--- a/src/bin/windowmgr/e_policy.c
+++ b/src/bin/windowmgr/e_policy.c
@@ -507,7 +507,9 @@ _e_policy_client_floating_policy_cancel(E_Policy_Client *pc)
 static void
 _e_policy_cb_hook_client_eval_pre_new_client(void *d EINA_UNUSED, E_Client *ec)
 {
+   E_View *view;
    E_View_Client *view_client;
+   E_Canvas_Layer layer;
    E_Layer ly;
 
    if (e_object_is_del(E_OBJECT(ec))) return;
@@ -527,11 +529,11 @@ _e_policy_cb_hook_client_eval_pre_new_client(void *d EINA_UNUSED, E_Client *ec)
      {
         if (view_client)
           {
-             ly = e_client_layer_get(ec);
+             view = e_view_client_view_get(view_client);
+             layer = e_view_layer_index_get(view);
+             ly = e_canvas_util_layer_map(layer);
              ELOGF("NOTI", "         |ec->layer:%d object->layer:%d", ec, ec->layer, ly);
-             if ((ly != ec->layer) ||
-                 (ec->layer < E_LAYER_CLIENT_NOTIFICATION_LOW) ||
-                 (ec->layer < E_LAYER_CLIENT_NOTIFICATION_TOP))
+             if (ly != ec->layer)
                e_client_layer_set(ec, ec->layer);
           }
      }

diff --git a/src/bin/windowmgr/e_policy_desk_area.c b/src/bin/windowmgr/e_policy_desk_area.c
index 2290c9fda76282ed4992e5d1dff554a4cf0e3751..d62dab456356bfcd329c7b01aef479e943f4dc61 100644 (file)
--- a/src/bin/windowmgr/e_policy_desk_area.c
+++ b/src/bin/windowmgr/e_policy_desk_area.c
@@ -28,42 +28,6 @@
 typedef struct _E_Policy_Desk_Area_Private_Client  E_Policy_Desk_Area_Private_Client;
 
 #define POLICY_DESK_AREA_EC_DATA_KEY  "E_Policy_Desk_Area_Client"
-
-typedef enum {
-     E_DESK_AREA_LAYER_BOTTOM,
-     E_DESK_AREA_LAYER_BG,
-     E_DESK_AREA_LAYER_DESKTOP,
-     E_DESK_AREA_LAYER_DESKTOP_TOP,
-     E_DESK_AREA_LAYER_CLIENT_DESKTOP,
-     E_DESK_AREA_LAYER_CLIENT_BELOW,
-     E_DESK_AREA_LAYER_CLIENT_NORMAL,
-     E_DESK_AREA_LAYER_CLIENT_ABOVE,
-     E_DESK_AREA_LAYER_CLIENT_EDGE,
-     E_DESK_AREA_LAYER_CLIENT_FULLSCREEN,
-     E_DESK_AREA_LAYER_CLIENT_EDGE_FULLSCREEN,
-     E_DESK_AREA_LAYER_CLIENT_POPUP,
-     E_DESK_AREA_LAYER_CLIENT_TOP,
-     E_DESK_AREA_LAYER_CLIENT_PRIO,
-     E_DESK_AREA_LAYER_CLIENT_NOTIFICATION_LOW,
-     E_DESK_AREA_LAYER_CLIENT_NOTIFICATION_NORMAL,
-     E_DESK_AREA_LAYER_CLIENT_NOTIFICATION_HIGH,
-     E_DESK_AREA_LAYER_CLIENT_NOTIFICATION_TOP,
-     E_DESK_AREA_LAYER_CLIENT_ALERT_LOW,
-     E_DESK_AREA_LAYER_CLIENT_ALERT,
-     E_DESK_AREA_LAYER_CLIENT_ALERT_HIGH,
-     E_DESK_AREA_LAYER_CLIENT_DRAG,
-     E_DESK_AREA_LAYER_CLIENT_CURSOR,
-     E_DESK_AREA_LAYER_POPUP,
-     E_DESK_AREA_LAYER_EFFECT,
-     E_DESK_AREA_LAYER_DESK_OBJECT_BELOW,
-     E_DESK_AREA_LAYER_DESK_OBJECT,
-     E_DESK_AREA_LAYER_DESK_OBJECT_ABOVE,
-     E_DESK_AREA_LAYER_MENU,
-     E_DESK_AREA_LAYER_DESKLOCK,
-     E_DESK_AREA_LAYER_MAX,
-} E_Desk_Area_Layer;
-
-
 struct _E_Policy_Desk_Area
 {
    E_Policy_Container container;
@@ -159,87 +123,6 @@ static E_Policy_Desk_Area_Private_Client *_e_policy_desk_area_private_client_get
 
 typedef void (*E_Policy_Desk_Area_Stack_Func)(Evas_Object *obj, Evas_Object *stack);
 
-static E_Layer
-_e_desk_area_layer_util_map_to_e_layer(E_Desk_Area_Layer layer)
-{
-   switch (layer)
-     {
-      case E_DESK_AREA_LAYER_BOTTOM: return E_LAYER_BOTTOM;
-      case E_DESK_AREA_LAYER_BG: return E_LAYER_BG;
-      case E_DESK_AREA_LAYER_DESKTOP: return E_LAYER_DESKTOP;
-      case E_DESK_AREA_LAYER_DESKTOP_TOP: return E_LAYER_DESKTOP_TOP;
-      case E_DESK_AREA_LAYER_CLIENT_DESKTOP: return E_LAYER_CLIENT_DESKTOP;
-      case E_DESK_AREA_LAYER_CLIENT_BELOW: return E_LAYER_CLIENT_BELOW;
-      case E_DESK_AREA_LAYER_CLIENT_NORMAL: return E_LAYER_CLIENT_NORMAL;
-      case E_DESK_AREA_LAYER_CLIENT_ABOVE: return E_LAYER_CLIENT_ABOVE;
-      case E_DESK_AREA_LAYER_CLIENT_EDGE: return E_LAYER_CLIENT_EDGE;
-      case E_DESK_AREA_LAYER_CLIENT_FULLSCREEN: return E_LAYER_CLIENT_FULLSCREEN;
-      case E_DESK_AREA_LAYER_CLIENT_EDGE_FULLSCREEN: return E_LAYER_CLIENT_EDGE_FULLSCREEN;
-      case E_DESK_AREA_LAYER_CLIENT_POPUP: return E_LAYER_CLIENT_POPUP;
-      case E_DESK_AREA_LAYER_CLIENT_TOP: return E_LAYER_CLIENT_TOP;
-      case E_DESK_AREA_LAYER_CLIENT_PRIO: return E_LAYER_CLIENT_PRIO;
-      case E_DESK_AREA_LAYER_CLIENT_NOTIFICATION_LOW: return E_LAYER_CLIENT_NOTIFICATION_LOW;
-      case E_DESK_AREA_LAYER_CLIENT_NOTIFICATION_NORMAL: return E_LAYER_CLIENT_NOTIFICATION_NORMAL;
-      case E_DESK_AREA_LAYER_CLIENT_NOTIFICATION_HIGH: return E_LAYER_CLIENT_NOTIFICATION_HIGH;
-      case E_DESK_AREA_LAYER_CLIENT_NOTIFICATION_TOP: return E_LAYER_CLIENT_NOTIFICATION_TOP;
-      case E_DESK_AREA_LAYER_CLIENT_ALERT_LOW: return E_LAYER_CLIENT_ALERT_LOW;
-      case E_DESK_AREA_LAYER_CLIENT_ALERT: return E_LAYER_CLIENT_ALERT;
-      case E_DESK_AREA_LAYER_CLIENT_ALERT_HIGH: return E_LAYER_CLIENT_ALERT_HIGH;
-      case E_DESK_AREA_LAYER_CLIENT_DRAG: return E_LAYER_CLIENT_DRAG;
-      case E_DESK_AREA_LAYER_CLIENT_CURSOR: return E_LAYER_CLIENT_CURSOR;
-      case E_DESK_AREA_LAYER_POPUP: return E_LAYER_POPUP;
-      case E_DESK_AREA_LAYER_EFFECT: return E_LAYER_EFFECT;
-      case E_DESK_AREA_LAYER_DESK_OBJECT_BELOW: return E_LAYER_DESK_OBJECT_BELOW;
-      case E_DESK_AREA_LAYER_DESK_OBJECT: return E_LAYER_DESK_OBJECT;
-      case E_DESK_AREA_LAYER_DESK_OBJECT_ABOVE: return E_LAYER_DESK_OBJECT_ABOVE;
-      case E_DESK_AREA_LAYER_MENU: return E_LAYER_MENU;
-      case E_DESK_AREA_LAYER_DESKLOCK: return E_LAYER_DESKLOCK;
-      case E_DESK_AREA_LAYER_MAX: return E_LAYER_MAX;
-      default: assert(0);
-     }
-}
-
-static E_Desk_Area_Layer
-_e_desk_area_layer_util_map_to_eda_layer(E_Layer e_layer)
-{
-   switch (e_layer)
-     {
-      case E_LAYER_BOTTOM: return E_DESK_AREA_LAYER_BOTTOM;
-      case E_LAYER_BG: return E_DESK_AREA_LAYER_BG;
-      case E_LAYER_DESKTOP: return E_DESK_AREA_LAYER_DESKTOP;
-      case E_LAYER_DESKTOP_TOP: return E_DESK_AREA_LAYER_DESKTOP_TOP;
-      case E_LAYER_CLIENT_DESKTOP: return E_DESK_AREA_LAYER_CLIENT_DESKTOP;
-      case E_LAYER_CLIENT_BELOW: return E_DESK_AREA_LAYER_CLIENT_BELOW;
-      case E_LAYER_CLIENT_NORMAL: return E_DESK_AREA_LAYER_CLIENT_NORMAL;
-      case E_LAYER_CLIENT_ABOVE: return E_DESK_AREA_LAYER_CLIENT_ABOVE;
-      case E_LAYER_CLIENT_EDGE: return E_DESK_AREA_LAYER_CLIENT_EDGE;
-      case E_LAYER_CLIENT_FULLSCREEN: return E_DESK_AREA_LAYER_CLIENT_FULLSCREEN;
-      case E_LAYER_CLIENT_EDGE_FULLSCREEN: return E_DESK_AREA_LAYER_CLIENT_EDGE_FULLSCREEN;
-      case E_LAYER_CLIENT_POPUP: return E_DESK_AREA_LAYER_CLIENT_POPUP;
-      case E_LAYER_CLIENT_TOP: return E_DESK_AREA_LAYER_CLIENT_TOP;
-      case E_LAYER_CLIENT_PRIO: return E_DESK_AREA_LAYER_CLIENT_PRIO;
-      case E_LAYER_CLIENT_NOTIFICATION_LOW: return E_DESK_AREA_LAYER_CLIENT_NOTIFICATION_LOW;
-      case E_LAYER_CLIENT_NOTIFICATION_NORMAL: return E_DESK_AREA_LAYER_CLIENT_NOTIFICATION_NORMAL;
-      case E_LAYER_CLIENT_NOTIFICATION_HIGH: return E_DESK_AREA_LAYER_CLIENT_NOTIFICATION_HIGH;
-      case E_LAYER_CLIENT_NOTIFICATION_TOP: return E_DESK_AREA_LAYER_CLIENT_NOTIFICATION_TOP;
-      case E_LAYER_CLIENT_ALERT_LOW: return E_DESK_AREA_LAYER_CLIENT_ALERT_LOW;
-      case E_LAYER_CLIENT_ALERT: return E_DESK_AREA_LAYER_CLIENT_ALERT;
-      case E_LAYER_CLIENT_ALERT_HIGH: return E_DESK_AREA_LAYER_CLIENT_ALERT_HIGH;
-      case E_LAYER_CLIENT_DRAG: return E_DESK_AREA_LAYER_CLIENT_DRAG;
-      case E_LAYER_CLIENT_CURSOR: return E_DESK_AREA_LAYER_CLIENT_CURSOR;
-      case E_LAYER_POPUP: return E_DESK_AREA_LAYER_POPUP;
-      case E_LAYER_EFFECT: return E_DESK_AREA_LAYER_EFFECT;
-      case E_LAYER_DESK_OBJECT_BELOW: return E_DESK_AREA_LAYER_DESK_OBJECT_BELOW;
-      case E_LAYER_DESK_OBJECT: return E_DESK_AREA_LAYER_DESK_OBJECT;
-      case E_LAYER_DESK_OBJECT_ABOVE: return E_DESK_AREA_LAYER_DESK_OBJECT_ABOVE;
-      case E_LAYER_MENU: return E_DESK_AREA_LAYER_MENU;
-      case E_LAYER_DESKLOCK: return E_DESK_AREA_LAYER_DESKLOCK;
-      case E_LAYER_MAX: return E_DESK_AREA_LAYER_MAX;
-      default: assert(0);
-     }
-}
-
-
 static void
 _e_policy_desk_area_hooks_clean(void)
 {
@@ -2143,23 +2026,18 @@ _desk_area_cb_client_layer_get(struct wl_listener *listener, void *data)
    E_Policy_Desk_Area_Private_Client *eda_client;
    E_Client *ec;
    E_Client_Data_Layer *layer_data;
-   E_Policy_Desk_Area *pda;
-   E_Policy_Desk_Area_Layer *pdal;
-   unsigned int comp_layer;
+   E_Canvas_Layer canvas_layer;
    E_Layer layer;
 
    eda_client = wl_container_of(listener, eda_client, client_layer_get);
    ec = eda_client->ec;
    layer_data = (E_Client_Data_Layer *) data;
 
+   canvas_layer = e_view_layer_index_get(e_view_client_view_get(e_client_view_get(ec)));
+   layer = e_canvas_util_layer_map(canvas_layer);
    layer_data->layer = ec->layer;
-   comp_layer = e_comp_object_layer_get(ec->frame);
-   layer = e_comp_canvas_layer_map_to(comp_layer);
-   pda = e_policy_desk_area_get(eda_client->eda);
-   pdal = pda->layers[_e_desk_area_layer_util_map_to_eda_layer(ec->layer)];
-
-   if (e_policy_desk_area_layer_has_ec(pdal, ec)) return;
 
+   if (ec->layer == layer) return;
    /* client could be on temperory layer while pending or block,
     * in that case, client restores back to ec->layer after pending/block finish */
    if (ec->layer_block || ec->layer_pending) return;
@@ -3226,7 +3104,7 @@ static void
 _e_policy_desk_area_init_layer(E_Policy_Desk_Area *pda)
 {
    E_Policy_Desk_Area_Layer *pdal;
-   E_Desk_Area_Layer eda_layer;
+   E_Canvas_Layer layer;
    Evas_Object *obj;
 #ifdef NEED_REFINE_EDA_LAYERS_LIST
    E_Comp *comp;
@@ -3234,19 +3112,17 @@ _e_policy_desk_area_init_layer(E_Policy_Desk_Area *pda)
 #endif
 
    /* init client's layers */
-   for (eda_layer = _e_desk_area_layer_util_map_to_eda_layer(E_LAYER_CLIENT_DESKTOP);
-        eda_layer <= _e_desk_area_layer_util_map_to_eda_layer(E_LAYER_CLIENT_CURSOR);
-        eda_layer++)
+   for (layer = e_comp_canvas_layer_map(E_LAYER_CLIENT_DESKTOP); layer <= e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR); layer++)
      {
 
 #ifdef NEED_REFINE_EDA_LAYERS_LIST
-        obj = comp->layers[eda_layer].obj = evas_object_rectangle_add(e_comp_evas_get());
+        obj = comp->layers[layer].obj = evas_object_rectangle_add(e_comp_evas_get());
 #else
-        obj = eda->layers[eda_layer].obj = evas_object_rectangle_add(e_comp_evas_get());
+        obj = eda->layers[layer].obj = evas_object_rectangle_add(e_comp_evas_get());
 #endif
-        pdal = e_policy_desk_area_layer_new(pda, _e_desk_area_layer_util_map_to_e_layer(eda_layer));
-        if (pdal) pda->layers[eda_layer] = pdal;
-        evas_object_layer_set(obj, _e_desk_area_layer_util_map_to_e_layer(eda_layer));
+        pdal = e_policy_desk_area_layer_new(pda, e_comp_canvas_layer_map_to(layer));
+        if (pdal) pda->layers[layer] = pdal;
+        evas_object_layer_set(obj, e_comp_canvas_layer_map_to(layer));
         evas_object_name_set(obj, "layer_obj");
      }
 }

diff --git a/src/bin/windowmgr/e_policy_desk_area_layer.c b/src/bin/windowmgr/e_policy_desk_area_layer.c
index ea0099bae3d3c6c8b5b3f66db5cb74f82a4eef35..f990702f02d55c1924b9e44d3a6ad992f927d27e 100644 (file)
--- a/src/bin/windowmgr/e_policy_desk_area_layer.c
+++ b/src/bin/windowmgr/e_policy_desk_area_layer.c
@@ -18,6 +18,9 @@ struct _E_Policy_Desk_Area_Layer
 };
 E_POLICY_CONTAINER_INIT(E_Policy_Desk_Area_Layer);
 
+//typedef unsigned int E_Layer_Order;
+typedef E_Canvas_Layer E_Layer_Order;
+
 
 static void
 _e_policy_desk_area_layer_tree_destroy(E_View_Tree *tree)

diff --git a/src/include/e_canvas.h b/src/include/e_canvas.h
index 571d2ee90a5072b7a801cde39e189dd74a7d0f2e..43ce0f466da63c24202b7e4e606fd5fe29467e15 100644 (file)
--- a/src/include/e_canvas.h
+++ b/src/include/e_canvas.h
@@ -9,6 +9,11 @@ extern "C" {
 
 typedef struct _E_Canvas E_Canvas;
 
+/**
+ * Get E_View_Tree instance for given E_Canvas_Layer
+ */
+E_View_Tree *e_canvas_layer_view_tree_get(E_Canvas *canvas, E_Canvas_Layer layer);
+
 void e_canvas_tree_for_each(E_Canvas *canvas, E_View_Iterator_Cb iterator, void *user_data);
 
 void e_canvas_tree_for_each_reverse(E_Canvas *canvas, E_View_Iterator_Cb iterator, void *user_data);

diff --git a/src/include/e_view.h b/src/include/e_view.h
index 7fe43259699a2be8b9050a2c89b9cae3b1c579a5..41f6af3457b45c1e6668859a9e70ebebc51a6b9d 100644 (file)
--- a/src/include/e_view.h
+++ b/src/include/e_view.h
@@ -15,6 +15,40 @@ typedef struct _E_View_Tree  E_View_Tree;
 
 typedef void (*E_View_Iterator_Cb)(E_View *view, int sx, int sy, void *user_data);
 
+typedef enum {
+     E_CANVAS_LAYER_BOTTOM,
+     E_CANVAS_LAYER_BG,
+     E_CANVAS_LAYER_DESKTOP,
+     E_CANVAS_LAYER_DESKTOP_TOP,
+     E_CANVAS_LAYER_CLIENT_DESKTOP,
+     E_CANVAS_LAYER_CLIENT_BELOW,
+     E_CANVAS_LAYER_CLIENT_NORMAL,
+     E_CANVAS_LAYER_CLIENT_ABOVE,
+     E_CANVAS_LAYER_CLIENT_EDGE,
+     E_CANVAS_LAYER_CLIENT_FULLSCREEN,
+     E_CANVAS_LAYER_CLIENT_EDGE_FULLSCREEN,
+     E_CANVAS_LAYER_CLIENT_POPUP,
+     E_CANVAS_LAYER_CLIENT_TOP,
+     E_CANVAS_LAYER_CLIENT_PRIO,
+     E_CANVAS_LAYER_CLIENT_NOTIFICATION_LOW,
+     E_CANVAS_LAYER_CLIENT_NOTIFICATION_NORMAL,
+     E_CANVAS_LAYER_CLIENT_NOTIFICATION_HIGH,
+     E_CANVAS_LAYER_CLIENT_NOTIFICATION_TOP,
+     E_CANVAS_LAYER_CLIENT_ALERT_LOW,
+     E_CANVAS_LAYER_CLIENT_ALERT,
+     E_CANVAS_LAYER_CLIENT_ALERT_HIGH,
+     E_CANVAS_LAYER_CLIENT_DRAG,
+     E_CANVAS_LAYER_CLIENT_CURSOR,
+     E_CANVAS_LAYER_POPUP,
+     E_CANVAS_LAYER_EFFECT,
+     E_CANVAS_LAYER_DESK_OBJECT_BELOW,
+     E_CANVAS_LAYER_DESK_OBJECT,
+     E_CANVAS_LAYER_DESK_OBJECT_ABOVE,
+     E_CANVAS_LAYER_MENU,
+     E_CANVAS_LAYER_DESKLOCK,
+     E_CANVAS_LAYER_MAX,
+} E_Canvas_Layer;
+
 typedef enum {
    E_VIEW_RENDER_OP_BLEND = 0,
    E_VIEW_RENDER_OP_COPY = 2,
@@ -329,6 +363,11 @@ E_View_Tree *e_view_tree_try_from_view(E_View *view);
  */
 E_View *e_view_tree_view_get(E_View_Tree *tree);
 
+/**
+ * TODO
+ */
+E_Canvas_Layer e_view_layer_index_get(E_View *view);
+
 #ifdef  __cplusplus
 }
 #endif

diff --git a/src/include/e_view_layout.h b/src/include/e_view_layout.h
index 938d35725d81b03b05d5a5aadd9a84ab098175b2..1aa94e02edf87f21deaf00b2fc8a7637efbeedfc 100644 (file)
--- a/src/include/e_view_layout.h
+++ b/src/include/e_view_layout.h
@@ -22,10 +22,7 @@ E_API void e_view_layout_child_move(E_View *child, int x, int y);
 E_API void e_view_layout_child_resize(E_View *child, int w, int h);
 E_API void e_view_layout_child_raise(E_View *child);
 
-/**
- * To set layer, use this e_view_layout_parent_view_set to pass the view tree of layer.
- */
-E_API void e_view_layout_reparent(E_View_Layout *layout, E_View_Tree *parent);
+E_API void e_view_layout_layer_set(E_View_Layout *layout, E_Layer layer);
 
 E_API void e_view_layout_show(E_View_Layout *layout);
 E_API void e_view_layout_hide(E_View_Layout *layout);

diff --git a/tests/tc-e_canvas.cpp b/tests/tc-e_canvas.cpp
index 2fb10295e34913beda75f9fee6d438f3f80845cc..5dff77b5d2c8bf01befed891e78964a5e572e489 100644 (file)
--- a/tests/tc-e_canvas.cpp
+++ b/tests/tc-e_canvas.cpp
@@ -7,8 +7,6 @@
 
 using ::testing::AnyNumber;
 
-#define MAX_VIEW_COUNT 10
-
 class ECanvasTest : public ::testing::Test
 {
 protected:
@@ -53,6 +51,34 @@ TEST_F(ECanvasTest, Test_E_Canvas_Root_Tree_Get)
    e_canvas_destroy(canvas);
 }
 
+TEST_F(ECanvasTest, Test_E_Canvas_Layer_Tree_Get)
+{
+   E_Canvas *canvas = e_canvas_create(this->evas);
+   ASSERT_NE(canvas, nullptr);
+
+   /* Check if all expected layers have been created */
+   for (int layer = E_CANVAS_LAYER_BOTTOM; layer <= E_CANVAS_LAYER_MAX; layer++) {
+      E_View_Tree *tree = e_canvas_layer_view_tree_get(canvas, static_cast<E_Canvas_Layer>(layer));
+      ASSERT_NE(tree, nullptr);
+   }
+
+   e_canvas_destroy(canvas);
+}
+
+TEST_F(ECanvasTest, Test_E_Canvas_Layer_Tree_Get_With_Invalid_Layer)
+{
+   E_Canvas *canvas = e_canvas_create(this->evas);
+   ASSERT_NE(canvas, nullptr);
+
+   E_View_Tree *tree = e_canvas_layer_view_tree_get(canvas, static_cast<E_Canvas_Layer>(E_CANVAS_LAYER_BOTTOM - 1));
+   ASSERT_EQ(tree, nullptr);
+
+   tree = e_canvas_layer_view_tree_get(canvas, static_cast<E_Canvas_Layer>(E_CANVAS_LAYER_MAX + 1));
+   ASSERT_EQ(tree, nullptr);
+
+   e_canvas_destroy(canvas);
+}
+
 static bool destroyed = false;
 static void
 canvas_handle_destroy(struct wl_listener *listener, void *data)
@@ -92,8 +118,8 @@ TEST_F(ECanvasTest, Test_E_Canvas_Render_Listener_Family_Test)
 
 typedef struct
 {
-   E_View views[MAX_VIEW_COUNT];
-   int index;
+   E_View views[E_CANVAS_LAYER_MAX + 1];
+   int expect_layer_index;
 } E_Canvas_For_Each_Data;
 
 static void
@@ -101,7 +127,7 @@ canvas_tree_for_each_test_cb(E_View *view, int sx, int sy, void *user_data)
 {
    E_Canvas_For_Each_Data *data = reinterpret_cast<E_Canvas_For_Each_Data *>(user_data);
 
-   ASSERT_EQ(view, &data->views[data->index++]);
+   ASSERT_EQ(view, &data->views[data->expect_layer_index++]);
 }
 
 TEST_F(ECanvasTest, Test_E_Canvas_Tree_For_Each)
@@ -109,14 +135,12 @@ TEST_F(ECanvasTest, Test_E_Canvas_Tree_For_Each)
    E_Canvas *canvas = e_canvas_create(this->evas);
    ASSERT_NE(canvas, nullptr);
 
-   E_View_Tree *tree = e_canvas_root_view_tree_get(canvas);
-   ASSERT_NE(tree, nullptr);
-
    E_Canvas_For_Each_Data data = {
-      .index = 0,
+      .expect_layer_index = E_CANVAS_LAYER_BOTTOM,
    };
-   for (int i = 0; i < MAX_VIEW_COUNT; i++) {
-      e_view_init(&data.views[i], E_VIEW_TYPE_RECT, NULL, NULL, tree);
+   for (int layer = E_CANVAS_LAYER_BOTTOM; layer <= E_CANVAS_LAYER_MAX; layer++) {
+      E_View_Tree *tree = e_canvas_layer_view_tree_get(canvas, static_cast<E_Canvas_Layer>(layer));
+      e_view_init(&data.views[layer], E_VIEW_TYPE_RECT, NULL, NULL, tree);
    }
 
    e_canvas_tree_for_each(canvas, canvas_tree_for_each_test_cb, &data);
@@ -127,7 +151,7 @@ canvas_tree_for_each_reverse_test_cb(E_View *view, int sx, int sy, void *user_da
 {
    E_Canvas_For_Each_Data *data = reinterpret_cast<E_Canvas_For_Each_Data *>(user_data);
 
-   ASSERT_EQ(view, &data->views[data->index--]);
+   ASSERT_EQ(view, &data->views[data->expect_layer_index--]);
 }
 
 TEST_F(ECanvasTest, Test_E_Canvas_Tree_For_Each_Reverse)
@@ -135,32 +159,42 @@ TEST_F(ECanvasTest, Test_E_Canvas_Tree_For_Each_Reverse)
    E_Canvas *canvas = e_canvas_create(this->evas);
    ASSERT_NE(canvas, nullptr);
 
-   E_View_Tree *tree = e_canvas_root_view_tree_get(canvas);
-   ASSERT_NE(tree, nullptr);
-
    E_Canvas_For_Each_Data data = {
-      .index = MAX_VIEW_COUNT-1,
+      .expect_layer_index = E_CANVAS_LAYER_MAX,
    };
-   for (int i = 0; i < MAX_VIEW_COUNT; i++) {
-      e_view_init(&data.views[i], E_VIEW_TYPE_RECT, NULL, NULL, tree);
+   for (int layer = E_CANVAS_LAYER_BOTTOM; layer <= E_CANVAS_LAYER_MAX; layer++) {
+      E_View_Tree *tree = e_canvas_layer_view_tree_get(canvas, static_cast<E_Canvas_Layer>(layer));
+      e_view_init(&data.views[layer], E_VIEW_TYPE_RECT, NULL, NULL, tree);
    }
 
    e_canvas_tree_for_each_reverse(canvas, canvas_tree_for_each_reverse_test_cb, &data);
 }
 
+TEST_F(ECanvasTest, Test_E_Canvas_Layer_Find)
+{
+   E_Canvas *canvas = e_canvas_create(this->evas);
+   ASSERT_NE(canvas, nullptr);
+
+   E_Canvas_For_Each_Data data = {
+      .expect_layer_index = E_CANVAS_LAYER_MAX,
+   };
+   for (int layer = E_CANVAS_LAYER_BOTTOM; layer < E_CANVAS_LAYER_MAX; layer++) {
+      E_View_Tree *tree = e_canvas_layer_view_tree_get(canvas, static_cast<E_Canvas_Layer>(layer));
+      e_view_init(&data.views[layer], E_VIEW_TYPE_RECT, NULL, NULL, tree);
+      ASSERT_EQ(e_canvas_layer_find(canvas, &data.views[layer]), layer);
+   }
+}
+
 TEST_F(ECanvasTest, Test_E_Canvas_Top_Get)
 {
    E_Canvas *canvas = e_canvas_create(this->evas);
    ASSERT_NE(canvas, nullptr);
    ASSERT_EQ(e_canvas_top_get(canvas), nullptr);
 
-   E_View_Tree *tree = e_canvas_root_view_tree_get(canvas);
-   ASSERT_NE(tree, nullptr);
-
    E_View top_view, middle_view, bottom_view;
-   e_view_init(&bottom_view, E_VIEW_TYPE_RECT, NULL, NULL, tree);
-   e_view_init(&middle_view, E_VIEW_TYPE_RECT, NULL, NULL, tree);
-   e_view_init(&top_view, E_VIEW_TYPE_RECT, NULL, NULL, tree);
+   e_view_init(&top_view, E_VIEW_TYPE_RECT, NULL, NULL, e_canvas_layer_view_tree_get(canvas, E_CANVAS_LAYER_MAX));
+   e_view_init(&middle_view, E_VIEW_TYPE_RECT, NULL, NULL, e_canvas_layer_view_tree_get(canvas, E_CANVAS_LAYER_CLIENT_ABOVE));
+   e_view_init(&bottom_view, E_VIEW_TYPE_RECT, NULL, NULL, e_canvas_layer_view_tree_get(canvas, E_CANVAS_LAYER_BG));
    ASSERT_EQ(e_canvas_top_get(canvas), &top_view);
 }
 
@@ -170,12 +204,9 @@ TEST_F(ECanvasTest, Test_E_Canvas_Bottom_Get)
    ASSERT_NE(canvas, nullptr);
    ASSERT_EQ(e_canvas_bottom_get(canvas), nullptr);
 
-   E_View_Tree *tree = e_canvas_root_view_tree_get(canvas);
-   ASSERT_NE(tree, nullptr);
-
    E_View top_view, middle_view, bottom_view;
-   e_view_init(&bottom_view, E_VIEW_TYPE_RECT, NULL, NULL, tree);
-   e_view_init(&middle_view, E_VIEW_TYPE_RECT, NULL, NULL, tree);
-   e_view_init(&top_view, E_VIEW_TYPE_RECT, NULL, NULL, tree);
+   e_view_init(&top_view, E_VIEW_TYPE_RECT, NULL, NULL, e_canvas_layer_view_tree_get(canvas, E_CANVAS_LAYER_MAX));
+   e_view_init(&middle_view, E_VIEW_TYPE_RECT, NULL, NULL, e_canvas_layer_view_tree_get(canvas, E_CANVAS_LAYER_CLIENT_ABOVE));
+   e_view_init(&bottom_view, E_VIEW_TYPE_RECT, NULL, NULL, e_canvas_layer_view_tree_get(canvas, E_CANVAS_LAYER_BG));
    ASSERT_EQ(e_canvas_bottom_get(canvas), &bottom_view);
 }

diff --git a/tests/tc-e_view.cpp b/tests/tc-e_view.cpp
index 3bdf36c8a3f9145f6a8710f4e44ab76a197697e0..cc6cd7665c2cec40a7bd6cd0ae4ff56e2cbbc468 100644 (file)
--- a/tests/tc-e_view.cpp
+++ b/tests/tc-e_view.cpp
@@ -781,7 +781,7 @@ TEST_F(EViewTest, Test_E_View_Root_Get)
 {
    Evas *evas = reinterpret_cast<Evas *>(malloc(sizeof(Evas)));
    E_Canvas *canvas = e_canvas_create(evas);
-   E_View_Tree *tree = e_canvas_root_view_tree_get(canvas);
+   E_View_Tree *tree = e_canvas_layer_view_tree_get(canvas, E_CANVAS_LAYER_BOTTOM);
 
    E_View view;
    e_view_init(&view, E_VIEW_TYPE_RECT, NULL, NULL, tree);
@@ -1136,3 +1136,25 @@ TEST_F(EViewTest, Test_E_View_Pass_Events_Set_Get)
 
    free(obj);
 }
+
+TEST_F(EViewTest, Test_E_View_Layer_Index_Get)
+{
+   Evas evas;
+   E_Canvas *canvas = e_canvas_create(&evas);
+
+   E_View views[E_CANVAS_LAYER_MAX + 1];
+   for (int layer = E_CANVAS_LAYER_BOTTOM; layer <= E_CANVAS_LAYER_MAX; layer++) {
+      E_View_Tree *tree = e_canvas_layer_view_tree_get(canvas, static_cast<E_Canvas_Layer>(layer));
+      E_View *view = &views[layer];
+      e_view_init(view, E_VIEW_TYPE_RECT, NULL, NULL, tree);
+      ASSERT_EQ(e_view_layer_index_get(view), static_cast<E_Canvas_Layer>(layer));
+   }
+}
+
+TEST_F(EViewTest, Test_E_View_Layer_Index_Get_With_Invalid_View)
+{
+   E_View view;
+   e_view_init(&view, E_VIEW_TYPE_RECT, NULL, NULL, NULL);
+
+   EXPECT_ABORT(e_view_layer_index_get(&view));
+}

diff --git a/tests/tc-e_view_image.cpp b/tests/tc-e_view_image.cpp
index 3b690e507e85c1cc181b596375141bd37c136739..fef192d18b6c2b99183c9834b6704fc345429411 100755 (executable)
--- a/tests/tc-e_view_image.cpp
+++ b/tests/tc-e_view_image.cpp
@@ -24,7 +24,7 @@ public:
       evasMock = new EvasMock();
       this->evas = (Evas_Object *)malloc(EVAS_OBJECT_SIZE);
       this->canvas = e_canvas_create(this->evas);
-      this->tree = e_canvas_root_view_tree_get(this->canvas);
+      this->tree = e_canvas_layer_view_tree_get(this->canvas, E_CANVAS_LAYER_BOTTOM);
    }
 
    void TearDown(void) override {
@@ -44,6 +44,7 @@ TEST_F(EViewImageTest, Test_E_View_Image_Create)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    EXPECT_NE(image, nullptr);
@@ -67,6 +68,7 @@ TEST_F(EViewImageTest, Test_e_view_image_view_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -98,6 +100,7 @@ TEST_F(EViewImageTest, Test_e_view_image_alpha_set_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -138,6 +141,7 @@ TEST_F(EViewImageTest, Test_e_view_image_animated_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -174,6 +178,7 @@ TEST_F(EViewImageTest, Test_e_vew_image_animated_frame_set_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -209,6 +214,7 @@ TEST_F(EViewImageTest, Test_e_view_image_animated_frame_count_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -241,6 +247,7 @@ TEST_F(EViewImageTest, Test_e_view_image_animated_frame_duration_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -274,6 +281,7 @@ TEST_F(EViewImageTest, Test_e_view_image_border_center_fill_set_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -336,6 +344,7 @@ TEST_F(EViewImageTest, Test_e_view_image_border_set_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -384,6 +393,7 @@ TEST_F(EViewImageTest, Test_e_view_image_colorspace_set_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -419,6 +429,7 @@ TEST_F(EViewImageTest, Test_e_view_image_data_copy_set)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -450,6 +461,7 @@ TEST_F(EViewImageTest, Test_e_view_image_data_set_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -489,6 +501,7 @@ TEST_F(EViewImageTest, Test_e_view_image_data_update_add)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -517,6 +530,7 @@ TEST_F(EViewImageTest, Test_e_view_image_file_set_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -559,6 +573,7 @@ TEST_F(EViewImageTest, Test_e_view_image_fill_set_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -605,6 +620,7 @@ TEST_F(EViewImageTest, Test_e_view_image_filled_set_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -648,6 +664,7 @@ TEST_F(EViewImageTest, Test_e_view_image_load_error_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -678,6 +695,8 @@ TEST_F(EViewImageTest, Test_e_view_image_load_size_set_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
       .Times(AnyNumber());
+
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -718,6 +737,7 @@ TEST_F(EViewImageTest, Test_e_view_image_native_surface_set_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
       .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -765,6 +785,8 @@ TEST_F(EViewImageTest, Test_e_view_image_pixels_dirty_set_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
       .Times(AnyNumber());
+
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -812,6 +834,7 @@ TEST_F(EViewImageTest, Test_e_view_image_pixels_get_callback_set)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
       .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -843,6 +866,7 @@ TEST_F(EViewImageTest, Test_e_view_image_pixels_noti_callback_set)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
       .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -874,6 +898,7 @@ TEST_F(EViewImageTest, Test_e_view_image_smooth_scale_set_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -915,6 +940,7 @@ TEST_F(EViewImageTest, Test_e_view_image_size_set_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -952,6 +978,7 @@ TEST_F(EViewImageTest, Test_e_view_image_source_set_get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -964,6 +991,7 @@ TEST_F(EViewImageTest, Test_e_view_image_source_set_get)
    // test code start
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    EXPECT_CALL(*evasMock, evas_object_stack_above(_, _));
    E_View_Image *img_source = e_view_image_create(this->tree);
@@ -1014,6 +1042,7 @@ TEST_F(EViewImageTest, Test_e_view_image_save)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);
@@ -1052,6 +1081,7 @@ TEST_F(EViewImageTest, Test_e_view_image_preload)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Image *image = e_view_image_create(this->tree);
    E_View *view = e_view_image_view_get(image);

diff --git a/tests/tc-e_view_layout.cpp b/tests/tc-e_view_layout.cpp
index 7da88e21242fa056b1b7c3d1a62f0065228539c9..928afba810f9693f657e9203e4790b5e8e4c008e 100644 (file)
--- a/tests/tc-e_view_layout.cpp
+++ b/tests/tc-e_view_layout.cpp
@@ -25,7 +25,7 @@ public:
       evasMock = new EvasMock();
       this->evas = (Evas_Object *)malloc(EVAS_OBJECT_SIZE);
       this->canvas = e_canvas_create(this->evas);
-      this->tree = e_canvas_root_view_tree_get(this->canvas);
+      this->tree = e_canvas_layer_view_tree_get(this->canvas, E_CANVAS_LAYER_BOTTOM);
    }
 
    void TearDown(void) override {
@@ -79,6 +79,8 @@ TEST_F(EViewLayoutTest, Test_E_View_Layout_Pack_UnPack)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
       .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _))
+      .Times(2);
    EXPECT_CALL(*evasMock, evas_object_stack_above(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _))
       .Times(3);
@@ -159,6 +161,8 @@ TEST_F(EViewLayoutTest, Test_E_View_Layout_Children_Move)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
       .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _))
+      .Times(2);
    EXPECT_CALL(*evasMock, evas_object_stack_above(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _))
       .Times(3);
@@ -217,6 +221,8 @@ TEST_F(EViewLayoutTest, Test_E_View_Layout_Children_Resize)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
       .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _))
+      .Times(2);
    EXPECT_CALL(*evasMock, evas_object_stack_above(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _))
       .Times(3);
@@ -275,6 +281,8 @@ TEST_F(EViewLayoutTest, Test_E_View_Layout_Children_Raise)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
       .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _))
+      .Times(2);
    EXPECT_CALL(*evasMock, evas_object_stack_above(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _))
       .Times(3);

diff --git a/tests/tc-e_view_rect.cpp b/tests/tc-e_view_rect.cpp
index d8d907409ad95ca887b544210ce0a6e839d2df31..0c99ce6003797b96074733fcb5193d7744748bad 100644 (file)
--- a/tests/tc-e_view_rect.cpp
+++ b/tests/tc-e_view_rect.cpp
@@ -23,7 +23,7 @@ protected:
        evasMock = new EvasMock();
        this->evas = (Evas_Object *)malloc(EVAS_OBJECT_SIZE);
        this->canvas = e_canvas_create(this->evas);
-       this->tree = e_canvas_root_view_tree_get(this->canvas);
+       this->tree = e_canvas_layer_view_tree_get(this->canvas, E_CANVAS_LAYER_BOTTOM);
    }
 
    void TearDown(void) override {
@@ -51,6 +51,7 @@ TEST_F(EViewRectTest, Test_E_View_Rect_Create)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Rect *rect = e_view_rect_create(this->tree, width, height, color);
    EXPECT_NE(rect, nullptr);
@@ -80,6 +81,7 @@ TEST_F(EViewRectTest, Test_E_View_Rect_Size_Set_Get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Rect *rect = e_view_rect_create(this->tree, 123, 456, color);
    ASSERT_NE(rect, nullptr);
@@ -126,6 +128,7 @@ TEST_F(EViewRectTest, Test_E_View_Rect_Try_From_View)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Rect *rect = e_view_rect_create(this->tree, width, height, color);
    E_View *view = e_view_rect_view_get(rect);
@@ -158,6 +161,7 @@ TEST_F(EViewRectTest, Test_E_View_Rect_Color_Set_Get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
      .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Rect *rect = e_view_rect_create(this->tree, width, height, color);
    E_View *view = e_view_rect_view_get(rect);

diff --git a/tests/tc-e_view_text.cpp b/tests/tc-e_view_text.cpp
index 9206793b21ec9066fbe83cfcc54be271d463dcd7..58bbb1fe3ced00091e24300e0ce162d0de279b92 100644 (file)
--- a/tests/tc-e_view_text.cpp
+++ b/tests/tc-e_view_text.cpp
@@ -23,7 +23,7 @@ protected:
        evasMock = new EvasMock();
        this->evas = (Evas_Object *)malloc(EVAS_OBJECT_SIZE);
        this->canvas = e_canvas_create(this->evas);
-       this->tree = e_canvas_root_view_tree_get(this->canvas);
+       this->tree = e_canvas_layer_view_tree_get(this->canvas, E_CANVAS_LAYER_BOTTOM);
    }
 
    void TearDown(void) override {
@@ -51,6 +51,7 @@ TEST_F(EViewTextTest, Test_E_View_Text_Create)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
       .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Text *text = e_view_text_create(this->tree, width, height, color);
    EXPECT_NE(text, nullptr);
@@ -80,6 +81,7 @@ TEST_F(EViewTextTest, Test_E_View_Text_Size_Set_Get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
       .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Text *text = e_view_text_create(this->tree, 123, 456, color);
    ASSERT_NE(text, nullptr);
@@ -126,6 +128,7 @@ TEST_F(EViewTextTest, Test_E_View_Text_Try_From_View)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
       .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Text *text = e_view_text_create(this->tree, width, height, color);
    E_View *view = e_view_text_view_get(text);
@@ -158,6 +161,7 @@ TEST_F(EViewTextTest, Test_E_View_Text_Color_Set_Get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
       .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Text *text = e_view_text_create(this->tree, width, height, color);
    E_View *view = e_view_text_view_get(text);
@@ -211,6 +215,7 @@ TEST_F(EViewTextTest, Test_E_View_Text_Font_Set_Get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
       .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Text *text = e_view_text_create(this->tree, width, height, color);
    E_View *view = e_view_text_view_get(text);
@@ -259,6 +264,7 @@ TEST_F(EViewTextTest, Test_E_View_Text_Text_Set_Get)
 
    EXPECT_CALL(*evasMock, evas_object_data_set(_, _, _))
       .Times(AnyNumber());
+   EXPECT_CALL(*evasMock, evas_object_layer_set(_, _));
    EXPECT_CALL(*evasMock, evas_object_move(_, _, _));
    E_View_Text *text = e_view_text_create(this->tree, width, height, color);
    E_View *view = e_view_text_view_get(text);