e_desk_area: use the layers in e_desk_area

instead of the layers in e_comp

Change-Id: I0b0261143bca1aa9e20a18fe3b306446b8c4b8eb

diff --git a/src/bin/e_comp.h b/src/bin/e_comp.h
index ee78165..a34639d 100644 (file)
--- a/src/bin/e_comp.h
+++ b/src/bin/e_comp.h
@@ -118,12 +118,15 @@ struct _E_Comp
    E_Comp_Wl_Data *wl_comp_data;
 
    Eina_Stringshare *name;
+
+//#ifdef REFACTOR_DESK_AREA
+//#else
    struct {
       Evas_Object *obj;
       Eina_Inlist *clients; /* E_Client, bottom to top */
       unsigned int clients_count;
    } layers[E_LAYER_COUNT];
-
+//#endif
    struct
    {
       Evas_Object *rect;

diff --git a/src/bin/e_comp_object.c b/src/bin/e_comp_object.c
index 24e552c..db0102f 100644 (file)
--- a/src/bin/e_comp_object.c
+++ b/src/bin/e_comp_object.c
@@ -607,12 +607,9 @@ _e_comp_shaped_check(int w, int h, const Eina_Rectangle *rects, int num)
 
 /* add a client to the layer-client list */
 #ifdef REFACTOR_DESK_AREA
-EINTERN void
-_e_comp_object_layers_add(E_Comp_Object *cw, E_Comp_Object *above, E_Comp_Object *below, Eina_Bool prepend)
 #else
 static void
 _e_comp_object_layers_add(E_Comp_Object *cw, E_Comp_Object *above, E_Comp_Object *below, Eina_Bool prepend)
-#endif
 {
    g_rec_mutex_lock(&e_comp->ec_list_mutex);
 
@@ -632,13 +629,8 @@ _e_comp_object_layers_add(E_Comp_Object *cw, E_Comp_Object *above, E_Comp_Object
    g_rec_mutex_unlock(&e_comp->ec_list_mutex);
 }
 
-#ifdef REFACTOR_DESK_AREA
-EINTERN void
-_e_comp_object_layers_remove(E_Comp_Object *cw)
-#else
 static void
 _e_comp_object_layers_remove(E_Comp_Object *cw)
-#endif
 {
    g_rec_mutex_lock(&e_comp->ec_list_mutex);
 
@@ -650,6 +642,7 @@ _e_comp_object_layers_remove(E_Comp_Object *cw)
 
    g_rec_mutex_unlock(&e_comp->ec_list_mutex);
 }
+#endif
 
 /////////////////////////////////////
 static void
@@ -2042,6 +2035,8 @@ _e_comp_object_layer_set(Evas_Object *obj, short layer)
      }
 }
 
+#ifdef REFACTOR_DESK_AREA
+#else
 static Eina_Bool
 _e_comp_object_is_pending(E_Client *ec)
 {
@@ -2054,13 +2049,8 @@ _e_comp_object_is_pending(E_Client *ec)
    return (topmost) ? topmost->layer_pending : EINA_FALSE;
 }
 
-#ifdef REFACTOR_DESK_AREA
-EINTERN void
-_e_comp_intercept_stack_helper(E_Comp_Object *cw, Evas_Object *stack, E_Comp_Object_Stack_Func stack_cb)
-#else
 static void
 _e_comp_intercept_stack_helper(E_Comp_Object *cw, Evas_Object *stack, E_Comp_Object_Stack_Func stack_cb)
-#endif
 {
    E_Comp_Object *cw2 = NULL;
    E_Client *ecstack;
@@ -2210,6 +2200,7 @@ _e_comp_intercept_stack_helper(E_Comp_Object *cw, Evas_Object *stack, E_Comp_Obj
    if (!cw->visible) return;
    e_comp_render_queue();
 }
+#endif
 
 static void
 _e_comp_intercept_stack_above(void *data, Evas_Object *obj, Evas_Object *above)
@@ -3410,7 +3401,10 @@ _e_comp_smart_del(Evas_Object *obj)
              evas_object_del(o);
           }
      }
+#ifdef REFACTOR_DESK_AREA
+#else
    _e_comp_object_layers_remove(cw);
+#endif
    l = evas_object_data_get(obj, "comp_object-to_del");
    E_FREE_LIST(l, evas_object_del);
    _e_comp_object_mouse_event_callback_unset(cw);
@@ -5766,6 +5760,8 @@ e_comp_object_transform_transp_vertices_set_with_zoom(Evas_Object *obj, E_Util_T
    _e_comp_object_transform_obj_map_set_with_zoom(cw->transform_tranp_obj, vertices, zoom);
 }
 
+#ifdef REFACTOR_DESK_AREA
+#else
 EINTERN void
 e_comp_object_layer_update(Evas_Object *obj,
                            Evas_Object *above, Evas_Object *below)
@@ -5830,6 +5826,7 @@ e_comp_object_layer_update(Evas_Object *obj,
    else
      _e_comp_object_layers_add(cw, NULL, NULL, 0);
 }
+#endif
 
 EINTERN int
 e_comp_object_layer_get(Evas_Object *obj)

diff --git a/src/bin/e_comp_object.h b/src/bin/e_comp_object.h
index dc786f8..87e9568 100644 (file)
--- a/src/bin/e_comp_object.h
+++ b/src/bin/e_comp_object.h
@@ -163,7 +163,10 @@ E_API void e_comp_object_transform_transp_set(Evas_Object *obj, Eina_Bool set);
 EINTERN void e_comp_object_transform_transp_vertices_set(Evas_Object *obj, E_Util_Transform_Rect_Vertex *vertices);
 EINTERN void e_comp_object_transform_transp_vertices_set_with_zoom(Evas_Object *obj, E_Util_Transform_Rect_Vertex *vertices, E_Util_Transform_Zoom zoom);
 
+//#ifdef REFACTOR_DESK_AREA
+//#else
 EINTERN void e_comp_object_layer_update(Evas_Object *obj, Evas_Object *above, Evas_Object *below);
+//#endif
 EINTERN int e_comp_object_layer_get(Evas_Object *obj);
 
 E_API Eina_Bool                  e_comp_object_content_set(Evas_Object* obj, Evas_Object *content, E_Comp_Object_Content_Type type);

diff --git a/src/bin/e_comp_object_intern.h b/src/bin/e_comp_object_intern.h
index 1195410..7cac84d 100644 (file)
--- a/src/bin/e_comp_object_intern.h
+++ b/src/bin/e_comp_object_intern.h
@@ -169,14 +169,11 @@ typedef struct _E_Comp_Object_Data_Stack_Below
 //#ifdef REFACTOR_DESK_AREA
 typedef void (*E_Comp_Object_Stack_Func)(Evas_Object *obj, Evas_Object *stack);
 
-EINTERN void _e_comp_object_layers_add(E_Comp_Object *cw, E_Comp_Object *above, E_Comp_Object *below, Eina_Bool prepend);
-EINTERN void _e_comp_object_layers_remove(E_Comp_Object *cw);
 EINTERN void _e_comp_object_lower(E_Comp_Object *cw, Evas_Object *obj);
 EINTERN void _e_comp_object_raise(Evas_Object *obj);
 EINTERN void e_comp_object_layer_set(Evas_Object *obj, short layer);
 EINTERN void _e_comp_object_stack_above(Evas_Object *obj, Evas_Object *target);
 EINTERN void _e_comp_object_stack_below(Evas_Object *obj, Evas_Object *target);
-EINTERN void _e_comp_intercept_stack_helper(E_Comp_Object *cw, Evas_Object *stack, E_Comp_Object_Stack_Func stack_cb);
 EINTERN void _e_comp_object_transform_obj_stack_update(Evas_Object *obj);
 //#endif
 

diff --git a/src/bin/e_desk_area.c b/src/bin/e_desk_area.c
index 3950f58..3bc4364 100644 (file)
--- a/src/bin/e_desk_area.c
+++ b/src/bin/e_desk_area.c
@@ -97,6 +97,270 @@ EVAS_SMART_SUBCLASS_NEW(E_DESK_AREA_SMART_OBJ_TYPE, _e_desk_area,
 #endif
 
 #ifdef REFACTOR_DESK_AREA
+static void
+_e_comp_object_layers_add(E_Desk_Area *eda, E_Comp_Object *cw, E_Comp_Object *above, E_Comp_Object *below, Eina_Bool prepend)
+{
+   g_rec_mutex_lock(&e_comp->ec_list_mutex);
+
+   if (above)
+    eda->layers[above->layer].clients = eina_inlist_append_relative(eda->layers[above->layer].clients, EINA_INLIST_GET(cw->ec), EINA_INLIST_GET(above->ec));
+   else if (below)
+     eda->layers[below->layer].clients = eina_inlist_prepend_relative(eda->layers[below->layer].clients, EINA_INLIST_GET(cw->ec), EINA_INLIST_GET(below->ec));
+   if ((!above) && (!below))
+     {
+        if (prepend)
+          eda->layers[cw->layer].clients = eina_inlist_prepend(eda->layers[cw->layer].clients, EINA_INLIST_GET(cw->ec));
+        else //this is either the layer object or a tough actin tinactin^W^W^Wfast stacking client
+          eda->layers[cw->layer].clients = eina_inlist_append(eda->layers[cw->layer].clients, EINA_INLIST_GET(cw->ec));
+     }
+   eda->layers[cw->layer].clients_count++;
+
+   g_rec_mutex_unlock(&e_comp->ec_list_mutex);
+}
+
+static void
+_e_comp_object_layers_remove(E_Desk_Area *eda, E_Comp_Object *cw)
+{
+   g_rec_mutex_lock(&e_comp->ec_list_mutex);
+
+   if (cw->ec && eda->layers[cw->layer].clients)
+     {
+        eda->layers[cw->layer].clients = eina_inlist_remove(eda->layers[cw->layer].clients, EINA_INLIST_GET(cw->ec));
+        eda->layers[cw->layer].clients_count--;
+     }
+
+   g_rec_mutex_unlock(&e_comp->ec_list_mutex);
+}
+
+static Eina_Bool
+_e_comp_object_is_pending(E_Client *ec)
+{
+   E_Client *topmost;
+
+   if (!ec) return EINA_FALSE;
+
+   topmost = e_comp_wl_topmost_parent_get(ec);
+
+   return (topmost) ? topmost->layer_pending : EINA_FALSE;
+}
+
+static void
+_e_comp_object_layer_update(E_Desk_Area *eda, Evas_Object *obj,
+                           Evas_Object *above, Evas_Object *below)
+{
+   E_Comp_Object *cw, *cw2 = NULL;
+   Evas_Object *o = NULL;
+   short layer;
+
+   cw = evas_object_smart_data_get(obj);
+   if (!cw) return;
+
+   if (cw->ec->layer_block) return;
+   if ((above) && (below))
+     {
+        ERR("Invalid layer update request! cw=%p", cw);
+        return;
+     }
+
+   o = above?:below;
+
+   if (o)
+     {
+        layer = evas_object_layer_get(o);
+        cw2 = evas_object_data_get(o, "comp_obj");
+        while (!cw2)
+          {
+             if (!e_util_strcmp(evas_object_name_get(o), "layer_obj")) break;
+
+             o = evas_object_above_get(o);
+             if ((!o) || (o == cw->smart_obj)) break;
+             if (evas_object_layer_get(o) != layer)
+               {
+                  o = eda->layers[e_comp_canvas_layer_map(E_LAYER_CLIENT_ALERT)].obj;
+               }
+             if (!o)
+               {
+                  E_Client *ec;
+                  ec = e_client_top_get();
+                  if (ec) o = ec->frame;
+               }
+
+             if (o) cw2 = evas_object_data_get(o, "comp_obj");
+          }
+     }
+
+   _e_comp_object_layers_remove(eda, cw);
+   if (cw2)
+     {
+        if (cw2->layer > cw->layer)
+          _e_comp_object_layers_add(eda, cw, NULL, NULL, 0);
+        else if (cw2->layer == cw->layer)
+          {
+             if (above)
+               _e_comp_object_layers_add(eda, cw, cw2, NULL, 0);
+             else if (o == obj)
+               _e_comp_object_layers_add(eda, cw, NULL, NULL, above? 0 : 1);
+             else if (below)
+               _e_comp_object_layers_add(eda, cw, NULL, cw2, 0);
+          }
+        else
+          _e_comp_object_layers_add(eda, cw, NULL, NULL, 1);
+     }
+   else
+     _e_comp_object_layers_add(eda, cw, NULL, NULL, 0);
+}
+
+static void
+_e_comp_intercept_stack_helper(E_Desk_Area *eda, E_Comp_Object *cw, Evas_Object *stack, E_Comp_Object_Stack_Func stack_cb)
+{
+   E_Comp_Object *cw2 = NULL;
+   E_Client *ecstack;
+   short layer;
+   Evas_Object *o = stack;
+   Eina_Bool raising = stack_cb == _e_comp_object_stack_above;
+
+   /* We should consider topmost's layer_pending for subsurface */
+   if ((cw->ec->layer_block) || _e_comp_object_is_pending(cw->ec))
+     {
+        if (_e_comp_object_is_pending(cw->ec))
+          _e_comp_object_layer_update(eda, cw->smart_obj,
+                                     raising? stack : NULL,
+                                     raising? NULL : stack);
+
+        /* obey compositor effects! */
+        if (cw->ec->layer == evas_object_layer_get(cw->smart_obj))
+          evas_object_data_set(cw->smart_obj, "client_restack", (void*)1);
+        stack_cb(cw->smart_obj, stack);
+        if (cw->ec->layer == evas_object_layer_get(cw->smart_obj))
+          evas_object_data_del(cw->smart_obj, "client_restack");
+        return;
+     }
+
+   cw2 = evas_object_data_get(o, "comp_obj");
+
+   /* assume someone knew what they were doing during client init */
+   if (cw->ec->new_client)
+     layer = cw->ec->layer;
+   else if ((cw2) && _e_comp_object_is_pending(cw2->ec))
+     layer = cw2->ec->layer;
+   else
+     layer = evas_object_layer_get(stack);
+   ecstack = e_client_below_get(cw->ec);
+   if (layer != e_comp_canvas_layer_map_to(cw->layer))
+     {
+        evas_object_layer_set(cw->smart_obj, layer);
+        /* we got our layer wrangled, return now! */
+        if (layer != e_comp_canvas_layer_map_to(cw->layer)) return;
+     }
+
+   /* check if we're stacking below another client */
+   while (!cw2)
+     {
+        /* check for non-client layer object */
+        if (!e_util_strcmp(evas_object_name_get(o), "layer_obj"))
+          break;
+        /* find an existing client to use for layering
+         * by walking up the object stack
+         *
+         * this is guaranteed to be pretty quick since we'll either:
+         * - run out of client layers
+         * - find a stacking client
+         */
+        o = evas_object_above_get(o);
+        if ((!o) || (o == cw->smart_obj)) break;
+        if (evas_object_layer_get(o) != layer)
+          {
+             /* reached the top client layer somehow
+              * use top client object
+              */
+             o = eda->layers[e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR)].obj;
+          }
+        if (!o)
+          /* top client layer window hasn't been stacked yet. this probably shouldn't happen?
+           * return here since the top client layer window
+           */
+          {
+             E_Client *ec;
+
+             ec = e_client_top_get();
+             if (ec)
+               o = ec->frame;
+             //else //wat
+          }
+        if (o) cw2 = evas_object_data_get(o, "comp_obj");
+     }
+
+   if (cw2 && cw->layer != cw2->layer)
+     return;
+
+   /* remove existing layers */
+   _e_comp_object_layers_remove(eda, cw);
+   if (cw2)
+     {
+        if (o == stack) //if stacking above, cw2 is above; else cw2 is below
+          _e_comp_object_layers_add(eda, cw, raising ? cw2 : NULL, raising ? NULL : cw2, 0);
+        else if (o == cw->smart_obj) //prepend (lower) if not stacking above
+          _e_comp_object_layers_add(eda, cw, NULL, NULL, !raising);
+        else //if no stacking objects found, either raise or lower
+          _e_comp_object_layers_add(eda, cw, raising ? NULL : cw2, raising ? cw2 : NULL, 0);
+     }
+   else
+     _e_comp_object_layers_add(eda, cw, NULL, NULL, 0);
+
+   /* find new object for stacking if cw2 is on state of layer_pending */
+   if ((cw2) && _e_comp_object_is_pending(cw2->ec))
+     {
+        E_Client *new_stack = NULL, *current_ec = NULL;
+        current_ec = cw2->ec;
+        if (raising)
+          {
+             while ((new_stack = e_client_below_get(current_ec)))
+               {
+                  current_ec = new_stack;
+                  if (new_stack == cw->ec) continue;
+                  if (new_stack->layer != cw2->ec->layer) break;
+                  if (!_e_comp_object_is_pending(new_stack)) break;
+               }
+             if ((new_stack) && (new_stack->layer == cw2->ec->layer))
+               stack = new_stack->frame;
+             else
+               {
+                  /* stack it above layer object */
+                  int below_layer;
+                  below_layer = (cw2->layer <= 0)? 0 : cw2->layer - 1 ;
+                  stack = eda->layers[below_layer].obj;
+               }
+          }
+        else
+          {
+             while ((new_stack = e_client_above_get(current_ec)))
+               {
+                  current_ec = new_stack;
+                  if (new_stack == cw->ec) continue;
+                  if (new_stack->layer != cw2->ec->layer) break;
+                  if (!_e_comp_object_is_pending(new_stack)) break;
+               }
+             if ((new_stack) && (new_stack->layer == cw2->ec->layer))
+               stack = new_stack->frame;
+             else
+               stack = eda->layers[cw2->layer].obj;
+          }
+     }
+
+   /* set restack if stacking has changed */
+   if (cw->ec->new_client || (!ecstack) || (ecstack->frame != o))
+     evas_object_data_set(cw->smart_obj, "client_restack", (void*)1);
+   stack_cb(cw->smart_obj, stack);
+   if (eda->layers[cw->layer].obj)
+     if (evas_object_below_get(cw->smart_obj) == eda->layers[cw->layer].obj)
+       {
+          CRI("STACKING ERROR!!! ec:%p (cw->layer:%d, ec->layer:%d)", cw->ec, cw->layer, cw->ec->layer);
+       }
+   if (cw->ec->new_client || (!ecstack) || (ecstack->frame != o))
+     evas_object_data_del(cw->smart_obj, "client_restack");
+   if (!cw->visible) return;
+   e_comp_render_queue();
+}
 #else
 static Eina_Bool
 _check_desk_area_client_layer_validation(E_Desk_Area_Client_Layer edgc_layer)
@@ -368,8 +632,8 @@ _desk_area_cb_client_get_above(struct wl_listener *listener, void *data)
    unsigned int x;
 
    eda_client = wl_container_of(listener, eda_client, client_get_above);
-   ec = eda_client->ec;
    eda = eda_client->eda;
+   ec = eda_client->ec;
 
    if (EINA_INLIST_GET(ec)->next) //check current layer
      {
@@ -396,9 +660,9 @@ _desk_area_cb_client_get_above(struct wl_listener *listener, void *data)
    /* go up the layers until we find one */
    for (x = e_comp_canvas_layer_map(ec->layer) + 1; x <= e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR); x++)
      {
-        if (!e_comp->layers[x].clients) continue;
+        if (!eda->layers[x].clients) continue;
 
-        EINA_INLIST_FOREACH(e_comp->layers[x].clients, ec2)
+        EINA_INLIST_FOREACH(eda->layers[x].clients, ec2)
           {
              if (ec == ec2)
                {
@@ -431,8 +695,8 @@ _desk_area_cb_client_get_below(struct wl_listener *listener, void *data)
    int cw_layer;
 
    eda_client = wl_container_of(listener, eda_client, client_get_below);
-   ec = eda_client->ec;
    eda = eda_client->eda;
+   ec = eda_client->ec;
 
    if (EINA_INLIST_GET(ec)->prev) //check current layer
      {
@@ -480,9 +744,9 @@ _desk_area_cb_client_get_below(struct wl_listener *listener, void *data)
 
    for (; x >= e_comp_canvas_layer_map(E_LAYER_CLIENT_DESKTOP); x--)
      {
-        if (!e_comp->layers[x].clients) continue;
+        if (!eda->layers[x].clients) continue;
 
-        EINA_INLIST_REVERSE_FOREACH(e_comp->layers[x].clients, ec2)
+        EINA_INLIST_REVERSE_FOREACH(eda->layers[x].clients, ec2)
           {
              if (ec == ec2)
                {
@@ -507,10 +771,12 @@ _desk_area_cb_client_get_visible_above(struct wl_listener *listener, void *data)
 {
    E_Desk_Area_Private_Client *eda_client;
    E_Client_Data_Get_Visible_Above *get_visible_above_data = data;
+   E_Desk_Area *eda;
    E_Client *ec, *ec2;
    unsigned int x;
 
    eda_client = wl_container_of(listener, eda_client, client_get_visible_above);
+   eda = eda_client->eda;
    ec = eda_client->ec;
 
    if (EINA_INLIST_GET(ec)->next) //check current layer
@@ -535,8 +801,8 @@ _desk_area_cb_client_get_visible_above(struct wl_listener *listener, void *data)
    /* go up the layers until we find one */
    for (x = e_comp_canvas_layer_map(ec->layer) + 1; x <= e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR); x++)
      {
-        if (!e_comp->layers[x].clients) continue;
-        EINA_INLIST_FOREACH(e_comp->layers[x].clients, ec2)
+        if (!eda->layers[x].clients) continue;
+        EINA_INLIST_FOREACH(eda->layers[x].clients, ec2)
           {
              if (ec == ec2) continue;
              if ((!e_object_is_del(E_OBJECT(ec2))) &&
@@ -564,8 +830,8 @@ _desk_area_cb_client_get_visible_below(struct wl_listener *listener, void *data)
    int cw_layer;
 
    eda_client = wl_container_of(listener, eda_client, client_get_visible_below);
-   ec = eda_client->ec;
    eda = eda_client->eda;
+   ec = eda_client->ec;
 
    if (EINA_INLIST_GET(ec)->prev) //check current layer
      {
@@ -608,8 +874,8 @@ _desk_area_cb_client_get_visible_below(struct wl_listener *listener, void *data)
 
    for (; x >= e_comp_canvas_layer_map(E_LAYER_CLIENT_DESKTOP); x--)
      {
-        if (!e_comp->layers[x].clients) continue;
-        EINA_INLIST_REVERSE_FOREACH(e_comp->layers[x].clients, ec2)
+        if (!eda->layers[x].clients) continue;
+        EINA_INLIST_REVERSE_FOREACH(eda->layers[x].clients, ec2)
           {
              if (ec == ec2) continue;
              if ((!e_object_is_del(E_OBJECT(ec2))) &&
@@ -628,9 +894,11 @@ static void
 _desk_area_cb_client_subsurface_stack_update(struct wl_listener *listener, void *data)
 {
    E_Desk_Area_Private_Client *eda_client;
+   E_Desk_Area *eda;
    E_Client *ec;
 
    eda_client = wl_container_of(listener, eda_client, client_subsurface_stack_update);
+   eda = eda_client->eda;
    ec = eda_client->ec;
 
    //To update client stack list
@@ -647,14 +915,14 @@ _desk_area_cb_client_subsurface_stack_update(struct wl_listener *listener, void
           {
              //stack above done
              o = evas_object_below_get(ec->frame);
-             e_comp_object_layer_update(ec->frame, o, NULL);
+             _e_comp_object_layer_update(eda, ec->frame, o, NULL);
           }
         else if ((parent->comp_data->sub.below_list) &&
                  (eina_list_data_find(parent->comp_data->sub.below_list, ec)))
           {
              //stack below done
              o = evas_object_above_get(ec->frame);
-             e_comp_object_layer_update(ec->frame, NULL, o);
+             _e_comp_object_layer_update(eda, ec->frame, NULL, o);
           }
      }
 }
@@ -662,11 +930,13 @@ static void
 _desk_area_cb_comp_object_lower(struct wl_listener *listener, void *data)
 {
    E_Desk_Area_Private_Client *eda_client;
+   E_Desk_Area *eda;
    E_Client *ec;
    Evas_Object *obj, *o;
    E_Comp_Object *cw;
 
    eda_client = wl_container_of(listener, eda_client, comp_object_lower);
+   eda = eda_client->eda;
    ec = eda_client->ec;
    obj = ec->frame;
    cw = (E_Comp_Object *)data;
@@ -674,7 +944,7 @@ _desk_area_cb_comp_object_lower(struct wl_listener *listener, void *data)
    if ((cw->ec->layer_block) || (cw->ec->layer_pending))
      {
         if (cw->ec->layer_pending)
-          e_comp_object_layer_update(obj, NULL, obj);
+          _e_comp_object_layer_update(eda, obj, NULL, obj);
 
         _e_comp_object_lower(cw, obj);
         return;
@@ -683,9 +953,9 @@ _desk_area_cb_comp_object_lower(struct wl_listener *listener, void *data)
    if (!EINA_INLIST_GET(cw->ec)->prev) return; //already lowest on layer
 
    o = evas_object_below_get(obj);
-   _e_comp_object_layers_remove(cw);
+   _e_comp_object_layers_remove(eda, cw);
    /* prepend to client list since this client should be the first item now */
-   _e_comp_object_layers_add(cw, NULL, NULL, 1);
+   _e_comp_object_layers_add(eda, cw, NULL, NULL, 1);
    if (evas_object_layer_get(o) != evas_object_layer_get(obj)) return; //already at bottom!
 
    evas_object_data_set(obj, "client_restack", (void*)1);
@@ -701,11 +971,13 @@ static void
 _desk_area_cb_comp_object_raise(struct wl_listener *listener, void *data)
 {
    E_Desk_Area_Private_Client *eda_client;
+   E_Desk_Area *eda;
    E_Client *ec;
    Evas_Object *obj, *o, *op;
    E_Comp_Object *cw;
 
    eda_client = wl_container_of(listener, eda_client, comp_object_raise);
+   eda = eda_client->eda;
    ec = eda_client->ec;
    obj = ec->frame;
    cw = (E_Comp_Object *)data;
@@ -716,7 +988,7 @@ _desk_area_cb_comp_object_raise(struct wl_listener *listener, void *data)
           {
              int obj_layer = evas_object_layer_get(obj);
              if (cw->ec->layer != obj_layer)
-               e_comp_object_layer_update(obj, NULL, NULL);
+               _e_comp_object_layer_update(eda, obj, NULL, NULL);
           }
 
         _e_comp_object_raise(obj);
@@ -727,8 +999,8 @@ _desk_area_cb_comp_object_raise(struct wl_listener *listener, void *data)
    if (evas_object_layer_get(o) != evas_object_layer_get(obj)) return; //already at top!
 
    /* still stack below override below the layer marker */
-   for (op = o = e_comp->layers[cw->layer].obj;
-        o && o != e_comp->layers[cw->layer - 1].obj;
+   for (op = o = eda->layers[cw->layer].obj;
+        o && o != eda->layers[cw->layer - 1].obj;
         op = o, o = evas_object_below_get(o))
      {
         if (evas_object_smart_smart_get(o))
@@ -751,6 +1023,7 @@ static void
 _desk_area_cb_comp_object_set_layer(struct wl_listener *listener, void *data)
 {
    E_Desk_Area_Private_Client *eda_client;
+   E_Desk_Area *eda;
    E_Client *ec;
    Evas_Object *obj;
    E_Comp_Object_Data_Set_Layer *layer_set_data;
@@ -761,6 +1034,7 @@ _desk_area_cb_comp_object_set_layer(struct wl_listener *listener, void *data)
    int oldraise;
 
    eda_client = wl_container_of(listener, eda_client, comp_object_set_layer);
+   eda = eda_client->eda;
    ec = eda_client->ec;
    obj = ec->frame;
    layer_set_data = (E_Comp_Object_Data_Set_Layer *)data;
@@ -809,7 +1083,7 @@ _desk_area_cb_comp_object_set_layer(struct wl_listener *listener, void *data)
                     evas_object_stack_below(obj, ec2->frame);
                }
              else
-               evas_object_stack_below(obj, ec2 ? ec2->frame : e_comp->layers[cw->layer].obj);
+               evas_object_stack_below(obj, ec2 ? ec2->frame : eda->layers[cw->layer].obj);
           }
         return;
      }
@@ -853,15 +1127,15 @@ layer_set:
 
    e_config->transient.raise = oldraise;
 
-   _e_comp_object_layers_remove(cw);
+   _e_comp_object_layers_remove(eda, cw);
    cw->layer = e_comp_canvas_layer_map(layer);
-   _e_comp_object_layers_add(cw, NULL, NULL, 0);
+   _e_comp_object_layers_add(eda, cw, NULL, NULL, 0);
    //if (cw->ec->new_client)
      //INF("CLIENT STACKED %p: %u", cw->ec, layer);
    e_comp_object_layer_set(obj, layer);
-   if (!e_comp->layers[cw->layer].obj) return; //this is a layer marker
-   evas_object_stack_below(obj, e_comp->layers[cw->layer].obj);
-   if (evas_object_below_get(obj) == e_comp->layers[cw->layer].obj)
+   if (!eda->layers[cw->layer].obj) return; //this is a layer marker
+   evas_object_stack_below(obj, eda->layers[cw->layer].obj);
+   if (evas_object_below_get(obj) == eda->layers[cw->layer].obj)
      {
         /* can't stack a client above its own layer marker */
         CRI("STACKING ERROR!!! ec:%p (cw->layer:%d, ec->layer:%d)", cw->ec, cw->layer, cw->ec->layer);
@@ -872,12 +1146,14 @@ static void
 _desk_area_cb_comp_object_stack_above(struct wl_listener *listener, void *data)
 {
    E_Desk_Area_Private_Client *eda_client;
+   E_Desk_Area *eda;
    E_Client *ec;
    Evas_Object *obj, *above;
    E_Comp_Object_Data_Stack_Above *stack_above_data;
    E_Comp_Object *cw;
 
    eda_client = wl_container_of(listener, eda_client, comp_object_stack_above);
+   eda = eda_client->eda;
    ec = eda_client->ec;
    obj = ec->frame;
    stack_above_data = (E_Comp_Object_Data_Stack_Above *)data;
@@ -886,11 +1162,11 @@ _desk_area_cb_comp_object_stack_above(struct wl_listener *listener, void *data)
 
    if (evas_object_below_get(obj) == above)
      {
-        e_comp_object_layer_update(obj, above, NULL);
+        _e_comp_object_layer_update(eda, obj, above, NULL);
         return;
      }
 
-   _e_comp_intercept_stack_helper(cw, above, _e_comp_object_stack_above);
+   _e_comp_intercept_stack_helper(eda, cw, above, _e_comp_object_stack_above);
 
    _e_comp_object_transform_obj_stack_update(obj);
    _e_comp_object_transform_obj_stack_update(above);
@@ -901,12 +1177,14 @@ static void
 _desk_area_cb_comp_object_stack_below(struct wl_listener *listener, void *data)
 {
    E_Desk_Area_Private_Client *eda_client;
+   E_Desk_Area *eda;
    E_Client *ec;
    Evas_Object *obj, *below;
    E_Comp_Object_Data_Stack_Below *stack_below_data;
    E_Comp_Object *cw;
 
    eda_client = wl_container_of(listener, eda_client, comp_object_stack_below);
+   eda = eda_client->eda;
    ec = eda_client->ec;
    obj = ec->frame;
    stack_below_data = (E_Comp_Object_Data_Stack_Below *)data;
@@ -915,11 +1193,11 @@ _desk_area_cb_comp_object_stack_below(struct wl_listener *listener, void *data)
 
    if (evas_object_above_get(obj) == below)
      {
-        e_comp_object_layer_update(obj, NULL, below);
+        _e_comp_object_layer_update(eda, obj, NULL, below);
         return;
      }
 
-   _e_comp_intercept_stack_helper(cw, below, _e_comp_object_stack_below);
+   _e_comp_intercept_stack_helper(eda, cw, below, _e_comp_object_stack_below);
 
    if (evas_object_smart_smart_get(obj))
      _e_comp_object_transform_obj_stack_update(obj);
@@ -1017,7 +1295,7 @@ e_desk_area_new(E_Desk *desk, int id, int x, int y, int w, int h, E_Desk_Area_La
    for (ec_layer = e_comp_canvas_layer_map(E_LAYER_CLIENT_DESKTOP); ec_layer <= e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR); ec_layer++)
      {
 
-        obj = e_comp->layers[ec_layer].obj = evas_object_rectangle_add(e_comp->evas);
+        obj = eda->layers[ec_layer].obj = evas_object_rectangle_add(e_comp->evas);
         evas_object_layer_set(obj, e_comp_canvas_layer_map_to(ec_layer));
         evas_object_name_set(obj, "layer_obj");
      }
@@ -1374,6 +1652,7 @@ e_desk_area_ec_remove(E_Desk_Area *eda, E_Client *ec)
 {
 #ifdef REFACTOR_DESK_AREA
    E_Desk_Area_Private_Client *eda_client;
+   E_Comp_Object *cw;
 
    E_OBJECT_CHECK(eda);
    E_OBJECT_TYPE_CHECK(eda, E_DESK_AREA_TYPE);
@@ -1389,6 +1668,12 @@ e_desk_area_ec_remove(E_Desk_Area *eda, E_Client *ec)
 
    ELOGF("EDA", "CLIENT DEL", ec);
 
+   cw = evas_object_smart_data_get(ec->frame);
+   if (cw)
+     _e_comp_object_layers_remove(eda, cw);
+   else
+     ELOGF("EDA", "No Comp Object. Fix Me~!!", ec);
+
    _e_desk_area_smart_client_del(eda->smart_obj, ec);
 
    eda->clients = eina_list_remove(eda->clients, eda_client);
@@ -2105,9 +2390,9 @@ e_desk_area_top_ec_get(E_Desk_Area *eda)
 
    for (x = e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR); x >= e_comp_canvas_layer_map(E_LAYER_CLIENT_DESKTOP); x--)
      {
-        if (!e_comp->layers[x].clients) continue;
+        if (!eda->layers[x].clients) continue;
 
-        EINA_INLIST_REVERSE_FOREACH(e_comp->layers[x].clients, ec)
+        EINA_INLIST_REVERSE_FOREACH(eda->layers[x].clients, ec)
           if (!e_object_is_del(E_OBJECT(ec)))
             {
                g_rec_mutex_unlock(&e_comp->ec_list_mutex);
@@ -2130,9 +2415,9 @@ e_desk_area_bottom_ec_get(E_Desk_Area *eda)
 
    for (x = e_comp_canvas_layer_map(E_LAYER_CLIENT_DESKTOP); x <= e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR); x++)
      {
-        if (!e_comp->layers[x].clients) continue;
+        if (!eda->layers[x].clients) continue;
 
-        EINA_INLIST_FOREACH(e_comp->layers[x].clients, ec)
+        EINA_INLIST_FOREACH(eda->layers[x].clients, ec)
           if (!e_object_is_del(E_OBJECT(ec)))
             {
                g_rec_mutex_unlock(&e_comp->ec_list_mutex);