e_canvas: remove e_canvas_layer_tree_get

Change-Id: I4554db83d1d39d566b3f094a356dc35b5d819ed3

diff --git a/src/bin/core/e_canvas.c b/src/bin/core/e_canvas.c
index 06f6bc1c4628d7e09de27b1fea110d94b093879d..f2eb9a476a45f39721a07c9ebb2be0e0b9606259 100644 (file)
--- a/src/bin/core/e_canvas.c
+++ b/src/bin/core/e_canvas.c
@@ -2,20 +2,11 @@
 #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)
@@ -49,9 +40,6 @@ 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);
@@ -118,18 +106,6 @@ 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)
 {
@@ -142,51 +118,12 @@ 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)
 {
@@ -231,88 +168,12 @@ _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
@@ -321,52 +182,6 @@ 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 9fed953b5d297a5bd8e6616ecb79d95eb6140473..dd6da853a18e628918559a0a3d3de8aba75d6c31 100644 (file)
--- a/src/bin/core/e_canvas_intern.h
+++ b/src/bin/core/e_canvas_intern.h
@@ -9,19 +9,12 @@ 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;
 
@@ -102,18 +95,11 @@ 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 0a86167a95b0bbc86d35e1515702cbd1c0df39bb..5c07efb922aca7f5e576ef176c01e29d8f5f82c4 100644 (file)
--- a/src/bin/core/e_view.c
+++ b/src/bin/core/e_view.c
@@ -737,28 +737,6 @@ 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 1c66bb1112c01a75e3e9cd4b771c72e676fe87fa..2a89e7e6656c1ef84388da3385b7c3d684f9e704 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_Canvas_Layer prev_layer;
+   E_View_Tree *prev_parent;
    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_layer = e_view_layer_index_get(child);
+   li->prev_parent = e_view_parent_get(child);
 
    e_view_clip_set(child, e_view_rect_view_get(layout->clip));
    e_view_reparent(child, &layout->tree);
@@ -117,11 +117,6 @@ 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;
@@ -135,12 +130,7 @@ _e_view_layout_disown(E_View *child)
 
    if (!li->destroying)
      {
-        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);
+        if (li->prev_parent) e_view_reparent(child, li->prev_parent);
      }
 
    free(li);
@@ -357,36 +347,24 @@ e_view_layout_child_raise (E_View *child)
 }
 
 E_API void
-e_view_layout_layer_set(E_View_Layout *layout, E_Layer layer)
+e_view_layout_reparent(E_View_Layout *layout, E_View_Tree *parent)
 {
    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;
 
-   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);
+   e_view_reparent(e_view_tree_view_get(&layout->tree), parent);
 
    if (!wl_list_empty(&layout->items))
      {
         wl_list_for_each_reverse(li, &layout->items, link)
           {
-             evas_object_layer_set(li->view->eo, layer);
+            e_view_reparent(li->view, &layout->tree);
           }
      }
    view = e_view_rect_view_get(layout->clip);
-   evas_object_layer_set(view->eo, layer);
-
-   e_view_reparent(e_view_tree_view_get(&layout->tree), layer_tree);
+   e_view_reparent(view, &layout->tree);
 }
 
 E_API void

diff --git a/src/bin/debug/e_info_server.c b/src/bin/debug/e_info_server.c
index 03864f849618ed8d2936ca1de8d45e623d89cce6..8cbeb795a19839143287980fc0ce4cba10f3eae3 100644 (file)
--- a/src/bin/debug/e_info_server.c
+++ b/src/bin/debug/e_info_server.c
@@ -6638,7 +6638,6 @@ _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;
@@ -6681,9 +6680,7 @@ _msg_view_append(Eldbus_Message_Iter *iter, Eina_Bool is_visible)
 
         _e_info_server_ec_hwc_info_get(ec, &hwc, &hwc_policy, &pl_zpos);
 
-        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_comp_layer_name_get(ec->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 98171e9137b7278e8b17a1ec77c02ba1b43cdd88..32cf93ef7250b1b3e13f2b24a0826c123cc47a12 100644 (file)
--- a/src/bin/server/e_policy_wl.c
+++ b/src/bin/server/e_policy_wl.c
@@ -1875,9 +1875,7 @@ _e_policy_wl_aux_hint_apply(E_Aux_Hint_Surface *hsurface)
                       ec->changable_layer[E_CHANGABLE_LAYER_TYPE_ABOVE_NOTIFICATION].saved)
                     {
                        // restore original layer
-                       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)
+                       if (original_layer != e_client_layer_get(ec))
                          {
                             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 f8d2dde9034a58f09b9830e05f79c497c7e1ba6a..9ba647959567a5b27ea96c5c9b14526ae734a4b0 100644 (file)
--- a/src/bin/server/e_tizen_launch_effect.c
+++ b/src/bin/server/e_tizen_launch_effect.c
@@ -295,8 +295,7 @@ _launchscreen_splash_setup(E_Tizen_Launch_Effect_Splash *splash,
 {
    E_Client *ec = NULL;
    E_View_Client *view_client;
-   E_View_Tree *view_tree_layer;
-   E_Canvas_Layer layer;
+   E_View_Tree *parent_view_tree;
    int comp_w = 0, comp_h = 0;
 
    EINA_SAFETY_ON_NULL_RETURN_VAL(splash->ec, EINA_FALSE);
@@ -321,12 +320,11 @@ _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);
-   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);
+   parent_view_tree = e_view_parent_get(e_view_client_view_get(view_client));
 
    if (splash->type == LAUNCH_IMG_FILE_TYPE_IMAGE)
       {
-        splash->view_image = e_view_image_create(view_tree_layer);
+        splash->view_image = e_view_image_create(parent_view_tree);
         EINA_SAFETY_ON_NULL_RETURN_VAL(splash->view_image, EINA_FALSE);
 
         splash->view = e_view_image_view_get(splash->view_image);
@@ -366,7 +364,7 @@ _launchscreen_splash_setup(E_Tizen_Launch_Effect_Splash *splash,
       }
    else
       {
-        splash->view_edje = e_view_edje_create(view_tree_layer);
+        splash->view_edje = e_view_edje_create(parent_view_tree);
         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 84e1f27b14537202f987eebb29c863896b88fadc..aaf31e0798e51b5c06eb3ff3bfe75303558d71f1 100644 (file)
--- a/src/bin/windowmgr/e_policy.c
+++ b/src/bin/windowmgr/e_policy.c
@@ -462,9 +462,7 @@ _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;
@@ -484,11 +482,11 @@ _e_policy_cb_hook_client_eval_pre_new_client(void *d EINA_UNUSED, E_Client *ec)
      {
         if (view_client)
           {
-             view = e_view_client_view_get(view_client);
-             layer = e_view_layer_index_get(view);
-             ly = e_canvas_util_layer_map(layer);
+             ly = e_client_layer_get(ec);
              ELOGF("NOTI", "         |ec->layer:%d object->layer:%d", ec, ec->layer, ly);
-             if (ly != ec->layer)
+             if ((ly != ec->layer) ||
+                 (ec->layer < E_LAYER_CLIENT_NOTIFICATION_LOW) ||
+                 (ec->layer < E_LAYER_CLIENT_NOTIFICATION_TOP))
                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 e691c308fa3a73deef10465a57651d4c9a866bdb..35c563598c13c00e1ef67c5842a820cfb84b1c0a 100644 (file)
--- a/src/bin/windowmgr/e_policy_desk_area.c
+++ b/src/bin/windowmgr/e_policy_desk_area.c
@@ -27,6 +27,42 @@
 
 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
 {
@@ -128,6 +164,87 @@ 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)
 {
@@ -2004,18 +2121,23 @@ _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_Canvas_Layer canvas_layer;
+   E_Policy_Desk_Area *pda;
+   E_Policy_Desk_Area_Layer *pdal;
+   unsigned int comp_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;
@@ -3110,7 +3232,7 @@ static void
 _e_policy_desk_area_init_layer(E_Policy_Desk_Area *pda)
 {
    E_Policy_Desk_Area_Layer *pdal;
-   E_Canvas_Layer layer;
+   E_Desk_Area_Layer eda_layer;
    Evas_Object *obj;
 #ifdef NEED_REFINE_EDA_LAYERS_LIST
    E_Comp *comp;
@@ -3118,17 +3240,19 @@ _e_policy_desk_area_init_layer(E_Policy_Desk_Area *pda)
 #endif
 
    /* init client's layers */
-   for (layer = e_comp_canvas_layer_map(E_LAYER_CLIENT_DESKTOP); layer <= e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR); layer++)
+   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++)
      {
 
 #ifdef NEED_REFINE_EDA_LAYERS_LIST
-        obj = comp->layers[layer].obj = evas_object_rectangle_add(e_comp_evas_get());
+        obj = comp->layers[eda_layer].obj = evas_object_rectangle_add(e_comp_evas_get());
 #else
-        obj = eda->layers[layer].obj = evas_object_rectangle_add(e_comp_evas_get());
+        obj = eda->layers[eda_layer].obj = evas_object_rectangle_add(e_comp_evas_get());
 #endif
-        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));
+        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));
         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 f990702f02d55c1924b9e44d3a6ad992f927d27e..ea0099bae3d3c6c8b5b3f66db5cb74f82a4eef35 100644 (file)
--- a/src/bin/windowmgr/e_policy_desk_area_layer.c
+++ b/src/bin/windowmgr/e_policy_desk_area_layer.c
@@ -18,9 +18,6 @@ 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 43ce0f466da63c24202b7e4e606fd5fe29467e15..571d2ee90a5072b7a801cde39e189dd74a7d0f2e 100644 (file)
--- a/src/include/e_canvas.h
+++ b/src/include/e_canvas.h
@@ -9,11 +9,6 @@ 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 9809bb2532202c77874879428ce90ed99f86b877..5dca15b21ae92ec63be65c99c66a2583158998b6 100644 (file)
--- a/src/include/e_view.h
+++ b/src/include/e_view.h
@@ -15,40 +15,6 @@ 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,
@@ -368,11 +334,6 @@ E_API E_View_Tree *e_view_tree_try_from_view(E_View *view);
  */
 E_API E_View *e_view_tree_view_get(E_View_Tree *tree);
 
-/**
- * TODO
- */
-E_API 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 1aa94e02edf87f21deaf00b2fc8a7637efbeedfc..938d35725d81b03b05d5a5aadd9a84ab098175b2 100644 (file)
--- a/src/include/e_view_layout.h
+++ b/src/include/e_view_layout.h
@@ -22,7 +22,10 @@ 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);
 
-E_API void e_view_layout_layer_set(E_View_Layout *layout, E_Layer layer);
+/**
+ * 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_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 5dff77b5d2c8bf01befed891e78964a5e572e489..2fb10295e34913beda75f9fee6d438f3f80845cc 100644 (file)
--- a/tests/tc-e_canvas.cpp
+++ b/tests/tc-e_canvas.cpp
@@ -7,6 +7,8 @@
 
 using ::testing::AnyNumber;
 
+#define MAX_VIEW_COUNT 10
+
 class ECanvasTest : public ::testing::Test
 {
 protected:
@@ -51,34 +53,6 @@ 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)
@@ -118,8 +92,8 @@ TEST_F(ECanvasTest, Test_E_Canvas_Render_Listener_Family_Test)
 
 typedef struct
 {
-   E_View views[E_CANVAS_LAYER_MAX + 1];
-   int expect_layer_index;
+   E_View views[MAX_VIEW_COUNT];
+   int index;
 } E_Canvas_For_Each_Data;
 
 static void
@@ -127,7 +101,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->expect_layer_index++]);
+   ASSERT_EQ(view, &data->views[data->index++]);
 }
 
 TEST_F(ECanvasTest, Test_E_Canvas_Tree_For_Each)
@@ -135,12 +109,14 @@ 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 = {
-      .expect_layer_index = E_CANVAS_LAYER_BOTTOM,
+      .index = 0,
    };
-   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);
+   for (int i = 0; i < MAX_VIEW_COUNT; i++) {
+      e_view_init(&data.views[i], E_VIEW_TYPE_RECT, NULL, NULL, tree);
    }
 
    e_canvas_tree_for_each(canvas, canvas_tree_for_each_test_cb, &data);
@@ -151,7 +127,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->expect_layer_index--]);
+   ASSERT_EQ(view, &data->views[data->index--]);
 }
 
 TEST_F(ECanvasTest, Test_E_Canvas_Tree_For_Each_Reverse)
@@ -159,42 +135,32 @@ 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 = {
-      .expect_layer_index = E_CANVAS_LAYER_MAX,
+      .index = MAX_VIEW_COUNT-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_init(&data.views[layer], E_VIEW_TYPE_RECT, NULL, NULL, tree);
+   for (int i = 0; i < MAX_VIEW_COUNT; i++) {
+      e_view_init(&data.views[i], 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(&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));
+   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);
    ASSERT_EQ(e_canvas_top_get(canvas), &top_view);
 }
 
@@ -204,9 +170,12 @@ 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(&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));
+   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);
    ASSERT_EQ(e_canvas_bottom_get(canvas), &bottom_view);
 }

diff --git a/tests/tc-e_view.cpp b/tests/tc-e_view.cpp
index cc6cd7665c2cec40a7bd6cd0ae4ff56e2cbbc468..3bdf36c8a3f9145f6a8710f4e44ab76a197697e0 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_layer_view_tree_get(canvas, E_CANVAS_LAYER_BOTTOM);
+   E_View_Tree *tree = e_canvas_root_view_tree_get(canvas);
 
    E_View view;
    e_view_init(&view, E_VIEW_TYPE_RECT, NULL, NULL, tree);
@@ -1136,25 +1136,3 @@ 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 fef192d18b6c2b99183c9834b6704fc345429411..3b690e507e85c1cc181b596375141bd37c136739 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_layer_view_tree_get(this->canvas, E_CANVAS_LAYER_BOTTOM);
+      this->tree = e_canvas_root_view_tree_get(this->canvas);
    }
 
    void TearDown(void) override {
@@ -44,7 +44,6 @@ 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);
@@ -68,7 +67,6 @@ 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);
@@ -100,7 +98,6 @@ 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);
@@ -141,7 +138,6 @@ 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);
@@ -178,7 +174,6 @@ 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);
@@ -214,7 +209,6 @@ 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);
@@ -247,7 +241,6 @@ 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);
@@ -281,7 +274,6 @@ 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);
@@ -344,7 +336,6 @@ 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);
@@ -393,7 +384,6 @@ 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);
@@ -429,7 +419,6 @@ 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);
@@ -461,7 +450,6 @@ 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);
@@ -501,7 +489,6 @@ 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);
@@ -530,7 +517,6 @@ 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);
@@ -573,7 +559,6 @@ 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);
@@ -620,7 +605,6 @@ 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);
@@ -664,7 +648,6 @@ 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);
@@ -695,8 +678,6 @@ 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);
@@ -737,7 +718,6 @@ 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);
@@ -785,8 +765,6 @@ 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);
@@ -834,7 +812,6 @@ 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);
@@ -866,7 +843,6 @@ 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);
@@ -898,7 +874,6 @@ 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);
@@ -940,7 +915,6 @@ 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);
@@ -978,7 +952,6 @@ 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);
@@ -991,7 +964,6 @@ 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);
@@ -1042,7 +1014,6 @@ 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);
@@ -1081,7 +1052,6 @@ 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 928afba810f9693f657e9203e4790b5e8e4c008e..7da88e21242fa056b1b7c3d1a62f0065228539c9 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_layer_view_tree_get(this->canvas, E_CANVAS_LAYER_BOTTOM);
+      this->tree = e_canvas_root_view_tree_get(this->canvas);
    }
 
    void TearDown(void) override {
@@ -79,8 +79,6 @@ 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);
@@ -161,8 +159,6 @@ 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);
@@ -221,8 +217,6 @@ 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);
@@ -281,8 +275,6 @@ 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 0c99ce6003797b96074733fcb5193d7744748bad..d8d907409ad95ca887b544210ce0a6e839d2df31 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_layer_view_tree_get(this->canvas, E_CANVAS_LAYER_BOTTOM);
+       this->tree = e_canvas_root_view_tree_get(this->canvas);
    }
 
    void TearDown(void) override {
@@ -51,7 +51,6 @@ 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);
@@ -81,7 +80,6 @@ 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);
@@ -128,7 +126,6 @@ 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);
@@ -161,7 +158,6 @@ 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 58bbb1fe3ced00091e24300e0ce162d0de279b92..9206793b21ec9066fbe83cfcc54be271d463dcd7 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_layer_view_tree_get(this->canvas, E_CANVAS_LAYER_BOTTOM);
+       this->tree = e_canvas_root_view_tree_get(this->canvas);
    }
 
    void TearDown(void) override {
@@ -51,7 +51,6 @@ 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);
@@ -81,7 +80,6 @@ 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);
@@ -128,7 +126,6 @@ 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);
@@ -161,7 +158,6 @@ 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);
@@ -215,7 +211,6 @@ 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);
@@ -264,7 +259,6 @@ 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);