src/bin/e_config.h \
src/bin/e_dbusmenu.h \
src/bin/e_desk.h \
-src/bin/e_desk_group.h \
+src/bin/e_desk_area.h \
src/bin/e_dialog.h \
src/bin/e_dnd.h \
src/bin/e_dpms.h \
src/bin/e_config_data.c \
src/bin/e_dbusmenu.c \
src/bin/e_desk.c \
-src/bin/e_desk_group.c \
+src/bin/e_desk_area.c \
src/bin/e_dialog.c \
src/bin/e_dpms.c \
src/bin/e_dnd.c \
ec->transform_core.result.enable = EINA_FALSE;
- e_client_desk_group_set(ec, NULL);
- e_util_transform_del(ec->desk_group.transform);
- ec->desk_group.transform = NULL;
+ e_client_desk_area_set(ec, NULL);
+ e_util_transform_del(ec->desk_area.transform);
+ ec->desk_area.transform = NULL;
_e_client_resize_object_del(ec);
zx = zy = zw = zh = 0;
ec->maximize_override = 1;
- if (ec->desk_group.enable && ec->desk_group.desk_group != NULL)
+ if (ec->desk_area.enable && ec->desk_area.desk_area != NULL)
{
- desk_x = ec->desk_group.desk_group->x;
- desk_y = ec->desk_group.desk_group->y;
- desk_w = ec->desk_group.desk_group->w;
- desk_h = ec->desk_group.desk_group->h;
+ desk_x = ec->desk_area.desk_area->x;
+ desk_y = ec->desk_area.desk_area->y;
+ desk_w = ec->desk_area.desk_area->w;
+ desk_h = ec->desk_area.desk_area->h;
}
else
{
_e_client_hook_call(E_CLIENT_HOOK_DESK_SET, ec);
evas_object_smart_callback_call(ec->frame, "desk_change", ec);
- if (ec->desk->desk_group.enable)
+ if (ec->desk->desk_area.enable)
{
- if (!ec->desk_group.desk_group)
+ if (!ec->desk_area.desk_area)
{
- E_Desk_Group *edg;
- edg = e_desk_desk_group_base_get(ec->desk);
- e_client_desk_group_set(ec, edg);
+ E_Desk_Area *eda;
+ eda = e_desk_desk_area_base_get(ec->desk);
+ e_client_desk_area_set(ec, eda);
}
- e_client_desk_group_enable_set(ec, EINA_TRUE);
+ e_client_desk_area_enable_set(ec, EINA_TRUE);
}
}
return;
}
- if (ec->desk_group.enable && ec->desk_group.desk_group != NULL)
+ if (ec->desk_area.enable && ec->desk_area.desk_area != NULL)
{
- desk_x = ec->desk_group.desk_group->x;
- desk_y = ec->desk_group.desk_group->y;
+ desk_x = ec->desk_area.desk_area->x;
+ desk_y = ec->desk_area.desk_area->y;
}
else
{
if (e_comp_canvas_client_layer_map(layer) == 9999)
return EINA_FALSE; //invalid layer is not allowed
- if (ec->desk_group.enable)
+ if (ec->desk_area.enable)
{
- if (e_client_layer_set_by_desk_group(ec, layer))
+ if (e_client_layer_set_by_desk_area(ec, layer))
{
// restack according to desk group rule
- e_desk_group_ec_rearrange(ec->desk_group.desk_group, ec);
+ e_desk_area_ec_rearrange(ec->desk_area.desk_area, ec);
return EINA_TRUE;
}
}
- ec->desk_group.layer_backup = layer;
+ ec->desk_area.layer_backup = layer;
evas_object_layer_set(ec->frame, layer);
if (ec->layer != layer)
}
static void
-_e_client_desk_group_original_layer_save(E_Client *ec, E_Layer layer)
+_e_client_desk_area_original_layer_save(E_Client *ec, E_Layer layer)
{
E_OBJECT_CHECK(ec);
E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
- ec->desk_group.layer_backup = layer;
+ ec->desk_area.layer_backup = layer;
}
EINTERN Eina_Bool
-e_client_layer_set_by_desk_group(E_Client *ec, E_Layer layer)
+e_client_layer_set_by_desk_area(E_Client *ec, E_Layer layer)
{
- E_Desk_Group *edg;
+ E_Desk_Area *eda;
E_Layer edg_layer;
E_Layer org_layer;
if (!ec) return EINA_FALSE;
if (!ec->frame) return EINA_FALSE;
- if (!ec->desk_group.enable) return EINA_FALSE;
- if (!ec->desk_group.desk_group) return EINA_FALSE;
+ if (!ec->desk_area.enable) return EINA_FALSE;
+ if (!ec->desk_area.desk_area) return EINA_FALSE;
- edg = ec->desk_group.desk_group;
+ eda = ec->desk_area.desk_area;
// save original layer
- _e_client_desk_group_original_layer_save(ec, layer);
+ _e_client_desk_area_original_layer_save(ec, layer);
- // get desk_group layer
- edg_layer = (E_Layer)e_desk_group_layer_get(edg);
- org_layer = e_client_desk_group_original_layer_get(ec);
+ // get desk_area layer
+ edg_layer = (E_Layer)e_desk_area_layer_get(eda);
+ org_layer = e_client_desk_area_original_layer_get(ec);
- ELOGF("EDG", "layer_set by desk_group... layer:%d, org_layer:%d, new_layer:%d", ec, layer, org_layer, edg_layer);
+ ELOGF("EDG", "layer_set by desk_area... layer:%d, org_layer:%d, new_layer:%d", ec, layer, org_layer, edg_layer);
if (org_layer == edg_layer)
{
evas_object_raise(ec->frame);
}
EINTERN void
-e_client_desk_group_original_layer_restore(E_Client *ec)
+e_client_desk_area_original_layer_restore(E_Client *ec)
{
if (!ec) return;
- // Do we need to check ec->desk_group.enable?
- // if ec->desk_group.enable is true, then e_client_layer_set calls
- // e_desk_group_ec_layer_set(). that's too bad. :(
+ // Do we need to check ec->desk_area.enable?
+ // if ec->desk_area.enable is true, then e_client_layer_set calls
+ // e_desk_area_ec_layer_set(). that's too bad. :(
// so, we MUST make a policy for ordering of the desk group layer restore
// and the desk group enable.
- if (ec->desk_group.enable) return;
- e_client_layer_set(ec, ec->desk_group.layer_backup);
+ if (ec->desk_area.enable) return;
+ e_client_layer_set(ec, ec->desk_area.layer_backup);
}
EINTERN E_Layer
-e_client_desk_group_original_layer_get(E_Client *ec)
+e_client_desk_area_original_layer_get(E_Client *ec)
{
if (!ec) return E_LAYER_DESKTOP;
- if (ec->desk_group.enable)
- return ec->desk_group.layer_backup;
+ if (ec->desk_area.enable)
+ return ec->desk_area.layer_backup;
else
return ec->layer;
}
EINTERN Eina_Bool
-e_client_desk_group_client_layer_set(E_Client *ec, E_Desk_Group_Client_Layer edgc_layer)
+e_client_desk_area_client_layer_set(E_Client *ec, E_Desk_Area_Client_Layer edgc_layer)
{
E_OBJECT_CHECK_RETURN(ec, EINA_FALSE);
E_OBJECT_TYPE_CHECK_RETURN(ec, E_CLIENT_TYPE, EINA_FALSE);
- if ((edgc_layer < E_DESK_GROUP_CLIENT_LAYER_DESKTOP) ||
- (edgc_layer >= E_DESK_GROUP_CLIENT_LAYER_MAX))
+ if ((edgc_layer < E_DESK_AREA_CLIENT_LAYER_DESKTOP) ||
+ (edgc_layer >= E_DESK_AREA_CLIENT_LAYER_MAX))
return EINA_FALSE;
- ec->desk_group.edgc_layer = edgc_layer;
+ ec->desk_area.edgc_layer = edgc_layer;
return EINA_TRUE;
}
-EINTERN E_Desk_Group_Client_Layer
-e_client_desk_group_client_layer_get(E_Client *ec)
+EINTERN E_Desk_Area_Client_Layer
+e_client_desk_area_client_layer_get(E_Client *ec)
{
- E_OBJECT_CHECK_RETURN(ec, E_DESK_GROUP_CLIENT_LAYER_DESKTOP);
+ E_OBJECT_CHECK_RETURN(ec, E_DESK_AREA_CLIENT_LAYER_DESKTOP);
- return ec->desk_group.edgc_layer;
+ return ec->desk_area.edgc_layer;
}
EINTERN Eina_Bool
-e_client_desk_group_enable_set(E_Client *ec, Eina_Bool enable)
+e_client_desk_area_enable_set(E_Client *ec, Eina_Bool enable)
{
E_OBJECT_CHECK_RETURN(ec, EINA_FALSE);
E_OBJECT_TYPE_CHECK_RETURN(ec, E_CLIENT_TYPE, EINA_FALSE);
- ec->desk_group.enable = enable;
+ ec->desk_area.enable = enable;
ELOGF("EDG", "Desk group enable set to %d", ec, enable);
if (enable)
{
- if (!ec->desk_group.transform)
+ if (!ec->desk_area.transform)
{
- ec->desk_group.transform = e_util_transform_new();
- e_util_transform_role_set(ec->desk_group.transform, "desk_group");
+ ec->desk_area.transform = e_util_transform_new();
+ e_util_transform_role_set(ec->desk_area.transform, "desk_area");
}
}
else
{
- if (ec->desk_group.transform)
+ if (ec->desk_area.transform)
{
- e_util_transform_del(ec->desk_group.transform);
- ec->desk_group.transform = NULL;
+ e_util_transform_del(ec->desk_area.transform);
+ ec->desk_area.transform = NULL;
}
}
- e_desk_group_ec_update(ec->desk_group.desk_group, ec);
+ e_desk_area_ec_update(ec->desk_area.desk_area, ec);
return EINA_TRUE;
}
E_API Eina_Bool
-e_client_desk_group_set(E_Client *ec, E_Desk_Group *edg)
+e_client_desk_area_set(E_Client *ec, E_Desk_Area *eda)
{
- E_Desk_Group *old_edg;
+ E_Desk_Area *old_edg;
if (!ec) return EINA_FALSE;
-#if 0 // if this is removed.. then below if (edg != old_edg) is removed also...
- if (ec->desk_group.desk_group == edg)
+#if 0 // if this is removed.. then below if (eda != old_edg) is removed also...
+ if (ec->desk_area.desk_area == eda)
return EINA_TRUE;
#endif
- ELOGF("EDG", "Desk Group Set (new:%p, old:%p)", ec, edg, ec->desk_group.desk_group);
- old_edg = ec->desk_group.desk_group;
+ ELOGF("EDG", "Desk Group Set (new:%p, old:%p)", ec, eda, ec->desk_area.desk_area);
+ old_edg = ec->desk_area.desk_area;
if (old_edg)
- e_desk_group_ec_remove(old_edg, ec);
+ e_desk_area_ec_remove(old_edg, ec);
- ec->desk_group.desk_group = edg;
- e_desk_group_ec_add(edg, ec);
+ ec->desk_area.desk_area = eda;
+ e_desk_area_ec_add(eda, ec);
-#if 0 // if this is removed.. then above if (ec->desk_group.desk_group == edg) is removed also...
- if (edg != old_edg)
+#if 0 // if this is removed.. then above if (ec->desk_area.desk_area == eda) is removed also...
+ if (eda != old_edg)
#endif
{
- e_desk_group_ec_update(edg, ec);
- e_desk_group_ec_rearrange(ec->desk_group.desk_group, ec);
+ e_desk_area_ec_update(eda, ec);
+ e_desk_area_ec_rearrange(ec->desk_area.desk_area, ec);
}
return EINA_TRUE;
{
if (!ec) return;
- if (ec->desk_group.enable)
+ if (ec->desk_area.enable)
{
- E_Desk_Group *edg;
- edg = ec->desk_group.desk_group;
- if (edg)
+ E_Desk_Area *eda;
+ eda = ec->desk_area.desk_area;
+ if (eda)
{
- e_desk_group_ec_raise(edg, ec);
+ e_desk_area_ec_raise(eda, ec);
return;
}
}
{
if (!ec) return;
- if (ec->desk_group.enable)
+ if (ec->desk_area.enable)
{
- E_Desk_Group *edg;
- edg = ec->desk_group.desk_group;
- if (edg)
+ E_Desk_Area *eda;
+ eda = ec->desk_area.desk_area;
+ if (eda)
{
- e_desk_group_ec_lower(edg, ec);
+ e_desk_area_ec_lower(eda, ec);
return;
}
}
if (!above) return;
if (!above->frame) return;
- if (ec->desk_group.enable)
+ if (ec->desk_area.enable)
{
- E_Desk_Group *edg;
- edg = ec->desk_group.desk_group;
- if (edg)
+ E_Desk_Area *eda;
+ eda = ec->desk_area.desk_area;
+ if (eda)
{
- e_desk_group_ec_stack_above(edg, ec, above);
+ e_desk_area_ec_stack_above(eda, ec, above);
return;
}
}
if (!below) return;
if (!below->frame) return;
- if (ec->desk_group.enable)
+ if (ec->desk_area.enable)
{
- E_Desk_Group *edg;
- edg = ec->desk_group.desk_group;
- if (edg)
+ E_Desk_Area *eda;
+ eda = ec->desk_area.desk_area;
+ if (eda)
{
- e_desk_group_ec_stack_below(edg, ec, below);
+ e_desk_area_ec_stack_below(eda, ec, below);
return;
}
}
struct
{
Eina_Bool enable;
- E_Desk_Group *desk_group;
- E_Desk_Group_Client_Layer edgc_layer; // used by desk_group mode
- E_Layer layer_backup; // original layer (used by no desk_group mode)
+ E_Desk_Area *desk_area;
+ E_Desk_Area_Client_Layer edgc_layer; // used by desk_area mode
+ E_Layer layer_backup; // original layer (used by no desk_area mode)
E_Util_Transform *transform;
- } desk_group;
+ } desk_area;
Eina_Bool transient_for_always_on_top;
Eina_Bool belong_to_parent;
*/
E_API E_Layer e_client_layer_get(E_Client *ec);
-EINTERN Eina_Bool e_client_layer_set_by_desk_group(E_Client *ec, E_Layer layer);
-EINTERN void e_client_desk_group_original_layer_restore(E_Client *ec);
-EINTERN E_Layer e_client_desk_group_original_layer_get(E_Client *ec);
-EINTERN Eina_Bool e_client_desk_group_client_layer_set(E_Client *ec, E_Desk_Group_Client_Layer edgc_layer);
-EINTERN E_Desk_Group_Client_Layer e_client_desk_group_client_layer_get(E_Client *ec);
-EINTERN Eina_Bool e_client_desk_group_enable_set(E_Client *ec, Eina_Bool enable);
+EINTERN Eina_Bool e_client_layer_set_by_desk_area(E_Client *ec, E_Layer layer);
+EINTERN void e_client_desk_area_original_layer_restore(E_Client *ec);
+EINTERN E_Layer e_client_desk_area_original_layer_get(E_Client *ec);
+EINTERN Eina_Bool e_client_desk_area_client_layer_set(E_Client *ec, E_Desk_Area_Client_Layer edgc_layer);
+EINTERN E_Desk_Area_Client_Layer e_client_desk_area_client_layer_get(E_Client *ec);
+EINTERN Eina_Bool e_client_desk_area_enable_set(E_Client *ec, Eina_Bool enable);
-E_API Eina_Bool e_client_desk_group_set(E_Client *ec, E_Desk_Group *edg);
+E_API Eina_Bool e_client_desk_area_set(E_Client *ec, E_Desk_Area *eda);
E_API void e_client_raise(E_Client *ec);
E_API void e_client_lower(E_Client *ec);
E_CONFIG_VAL(D, T, cursor_configured_output_resolution.h, INT);
E_CONFIG_VAL(D, T, global_object_not_provide.launch_effect, UCHAR);
E_CONFIG_VAL(D, T, use_thread_max_cpu, UCHAR);
- E_CONFIG_VAL(D, T, use_desk_group, UCHAR);
+ E_CONFIG_VAL(D, T, use_desk_area, UCHAR);
E_CONFIG_VAL(D, T, desk_zoom_effect.enable, UCHAR);
E_CONFIG_VAL(D, T, desk_zoom_effect.duration, DOUBLE);
E_CONFIG_VAL(D, T, fake_output_resolution.use, UCHAR);
E_CONFIG_LIMIT(e_config->configured_output_resolution.use, 0, 1);
E_CONFIG_LIMIT(e_config->global_object_not_provide.launch_effect, 0, 1);
E_CONFIG_LIMIT(e_config->use_thread_max_cpu, 0, 1);
- E_CONFIG_LIMIT(e_config->use_desk_group, 0, 1);
+ E_CONFIG_LIMIT(e_config->use_desk_area, 0, 1);
E_CONFIG_LIMIT(e_config->desk_zoom_effect.enable, 0, 1);
E_CONFIG_LIMIT(e_config->desk_zoom_effect.duration, 0.0, 10.0);
E_CONFIG_LIMIT(e_config->fake_output_resolution.use, 0, 1);
} global_object_not_provide;
Eina_Bool use_thread_max_cpu; //set cpu count to ecore thread max
- Eina_Bool use_desk_group;
+ Eina_Bool use_desk_area;
struct
{
static Eina_Inlist *_e_desk_hooks[] =
{
- [E_DESK_HOOK_DESK_GROUP_ENABLE] = NULL,
- [E_DESK_HOOK_DESK_GROUP_DISABLE] = NULL,
- [E_DESK_HOOK_DESK_GROUP_ACTIVE_CHANGE] = NULL,
+ [E_DESK_HOOK_DESK_AREA_ENABLE] = NULL,
+ [E_DESK_HOOK_DESK_AREA_DISABLE] = NULL,
+ [E_DESK_HOOK_DESK_AREA_ACTIVE_CHANGE] = NULL,
};
static void _e_desk_free(E_Desk *desk);
static void _e_desk_object_zoom(Evas_Object *obj, double zoomx, double zoomy, Evas_Coord cx, Evas_Coord cy);
static void _e_desk_client_zoom(E_Client *ec, double zoomx, double zoomy, Evas_Coord cx, Evas_Coord cy);
-static Eina_Bool _e_desk_desk_group_base_new(E_Desk *desk);
+static Eina_Bool _e_desk_desk_area_base_new(E_Desk *desk);
static void _e_desk_hooks_clean(void);
static Eina_Bool _e_desk_hook_call(E_Desk_Hook_Point hookpoint, E_Desk *desk);
if (!ok)
desk->window_profile = eina_stringshare_ref(e_config->desktop_default_window_profile);
- // new a base e_desk_group
- _e_desk_desk_group_base_new(desk);
+ // new a base e_desk_area
+ _e_desk_desk_area_base_new(desk);
return desk;
}
_e_desk_free(E_Desk *desk)
{
Eina_List *l;
- E_Desk_Group *edg;
+ E_Desk_Area *eda;
- if (e_config->use_desk_group)
+ if (e_config->use_desk_area)
{
- for (int i=E_DESK_GROUP_LAYER_COUNT-1; i>=0; i--)
+ for (int i=E_DESK_AREA_LAYER_COUNT-1; i>=0; i--)
{
- EINA_LIST_FOREACH(desk->desk_group.list[i], l, edg)
+ EINA_LIST_FOREACH(desk->desk_area.list[i], l, eda)
{
- e_desk_group_del(edg);
+ e_desk_area_del(eda);
}
- eina_list_free(desk->desk_group.list[i]);
- desk->desk_group.list[i] = NULL;
+ eina_list_free(desk->desk_area.list[i]);
+ desk->desk_area.list[i] = NULL;
}
- desk->desk_group.base = NULL;
- desk->desk_group.active = NULL;
+ desk->desk_area.base = NULL;
+ desk->desk_area.active = NULL;
}
E_FREE_FUNC(desk->smart_obj, evas_object_del);
}
static unsigned int
-_e_desk_desk_group_layer_map(E_Desk_Group_Layer layer)
+_e_desk_desk_area_layer_map(E_Desk_Area_Layer layer)
{
switch (layer)
{
- case E_DESK_GROUP_LAYER_BACKGROUND: return 0;
- case E_DESK_GROUP_LAYER_NORMAL_BELOW: return 1;
- case E_DESK_GROUP_LAYER_NORMAL: return 2;
- case E_DESK_GROUP_LAYER_NORMAL_ABOVE: return 3;
- case E_DESK_GROUP_LAYER_NOTIFICATION_LOW: return 4;
- case E_DESK_GROUP_LAYER_NOTIFICATION_NORMAL: return 5;
- case E_DESK_GROUP_LAYER_NOTIFICATION_HIGH: return 6;
- case E_DESK_GROUP_LAYER_NOTIFICATION_TOP: return 7;
- case E_DESK_GROUP_LAYER_SYSTEM: return 8;
+ case E_DESK_AREA_LAYER_BACKGROUND: return 0;
+ case E_DESK_AREA_LAYER_NORMAL_BELOW: return 1;
+ case E_DESK_AREA_LAYER_NORMAL: return 2;
+ case E_DESK_AREA_LAYER_NORMAL_ABOVE: return 3;
+ case E_DESK_AREA_LAYER_NOTIFICATION_LOW: return 4;
+ case E_DESK_AREA_LAYER_NOTIFICATION_NORMAL: return 5;
+ case E_DESK_AREA_LAYER_NOTIFICATION_HIGH: return 6;
+ case E_DESK_AREA_LAYER_NOTIFICATION_TOP: return 7;
+ case E_DESK_AREA_LAYER_SYSTEM: return 8;
default: return 0;
}
}
-E_API E_Desk_Group *
-e_desk_desk_group_add(E_Desk *desk, int x, int y, int w, int h, E_Desk_Group_Layer layer)
+E_API E_Desk_Area *
+e_desk_desk_area_add(E_Desk *desk, int x, int y, int w, int h, E_Desk_Area_Layer layer)
{
- E_Desk_Group *edg;
+ E_Desk_Area *eda;
int id;
unsigned int list_id;
- if (!e_config->use_desk_group) return NULL;
+ if (!e_config->use_desk_area) return NULL;
E_OBJECT_CHECK_RETURN(desk, NULL);
E_OBJECT_TYPE_CHECK_RETURN(desk, E_DESK_TYPE, NULL);
- id = desk->desk_group.id;
+ id = desk->desk_area.id;
- edg = e_desk_group_new(desk, id, x, y, w, h, layer);
- if (!edg)
+ eda = e_desk_area_new(desk, id, x, y, w, h, layer);
+ if (!eda)
{
return NULL;
}
- list_id = _e_desk_desk_group_layer_map(layer);
- desk->desk_group.list[list_id] = eina_list_prepend(desk->desk_group.list[list_id], edg);
- desk->desk_group.id++;
+ list_id = _e_desk_desk_area_layer_map(layer);
+ desk->desk_area.list[list_id] = eina_list_prepend(desk->desk_area.list[list_id], eda);
+ desk->desk_area.id++;
- return edg;
+ return eda;
}
E_API void
-e_desk_desk_group_del(E_Desk *desk, E_Desk_Group *edg)
+e_desk_desk_area_del(E_Desk *desk, E_Desk_Area *eda)
{
unsigned int list_id;
E_OBJECT_CHECK(desk);
E_OBJECT_TYPE_CHECK(desk, E_DESK_TYPE);
- if (!e_config->use_desk_group) return;
+ if (!e_config->use_desk_area) return;
- if (!edg) return;
+ if (!eda) return;
- list_id = _e_desk_desk_group_layer_map(edg->layer);
- desk->desk_group.list[list_id] = eina_list_remove(desk->desk_group.list[list_id], edg);
+ list_id = _e_desk_desk_area_layer_map(eda->layer);
+ desk->desk_area.list[list_id] = eina_list_remove(desk->desk_area.list[list_id], eda);
}
-E_API E_Desk_Group *
-e_desk_desk_group_get_by_id(E_Desk *desk, int id)
+E_API E_Desk_Area *
+e_desk_desk_area_get_by_id(E_Desk *desk, int id)
{
- E_Desk_Group *edg = NULL;
+ E_Desk_Area *eda = NULL;
Eina_List *l;
E_OBJECT_CHECK_RETURN(desk, NULL);
E_OBJECT_TYPE_CHECK_RETURN(desk, E_DESK_TYPE, NULL);
- for (int i=0; i<E_DESK_GROUP_LAYER_COUNT; i++)
+ for (int i=0; i<E_DESK_AREA_LAYER_COUNT; i++)
{
- EINA_LIST_FOREACH(desk->desk_group.list[i], l, edg)
+ EINA_LIST_FOREACH(desk->desk_area.list[i], l, eda)
{
- if (edg->id == id)
- return edg;
+ if (eda->id == id)
+ return eda;
}
}
}
static Eina_Bool
-_e_desk_desk_group_base_new(E_Desk *desk)
+_e_desk_desk_area_base_new(E_Desk *desk)
{
if (!desk) return EINA_FALSE;
- if (!e_config->use_desk_group) return EINA_FALSE;
+ if (!e_config->use_desk_area) return EINA_FALSE;
- if (!desk->desk_group.base)
+ if (!desk->desk_area.base)
{
- // Add a base e_desk_group
- desk->desk_group.base = e_desk_desk_group_add(desk, desk->geom.x, desk->geom.y, desk->geom.w, desk->geom.h, E_DESK_GROUP_LAYER_NORMAL);
+ // Add a base e_desk_area
+ desk->desk_area.base = e_desk_desk_area_add(desk, desk->geom.x, desk->geom.y, desk->geom.w, desk->geom.h, E_DESK_AREA_LAYER_NORMAL);
}
- if (!desk->desk_group.base)
+ if (!desk->desk_area.base)
return EINA_FALSE;
else
return EINA_TRUE;
}
-E_API E_Desk_Group *
-e_desk_desk_group_base_get(E_Desk *desk)
+E_API E_Desk_Area *
+e_desk_desk_area_base_get(E_Desk *desk)
{
E_OBJECT_CHECK_RETURN(desk, NULL);
E_OBJECT_TYPE_CHECK_RETURN(desk, E_DESK_TYPE, NULL);
- if (!e_config->use_desk_group) return NULL;
+ if (!e_config->use_desk_area) return NULL;
- return desk->desk_group.base;
+ return desk->desk_area.base;
}
EINTERN void
-e_desk_desk_group_active_set(E_Desk *desk, E_Desk_Group *edg)
+e_desk_desk_area_active_set(E_Desk *desk, E_Desk_Area *eda)
{
E_OBJECT_CHECK(desk);
E_OBJECT_TYPE_CHECK(desk, E_DESK_TYPE);
- if (!e_config->use_desk_group) return;
- if (desk->desk_group.active == edg) return;
+ if (!e_config->use_desk_area) return;
+ if (desk->desk_area.active == eda) return;
- desk->desk_group.active = edg;
+ desk->desk_area.active = eda;
- _e_desk_hook_call(E_DESK_HOOK_DESK_GROUP_ACTIVE_CHANGE, desk);
+ _e_desk_hook_call(E_DESK_HOOK_DESK_AREA_ACTIVE_CHANGE, desk);
}
-E_API E_Desk_Group *
-e_desk_desk_group_active_get(E_Desk *desk)
+E_API E_Desk_Area *
+e_desk_desk_area_active_get(E_Desk *desk)
{
E_OBJECT_CHECK_RETURN(desk, NULL);
E_OBJECT_TYPE_CHECK_RETURN(desk, E_DESK_TYPE, NULL);
- if (!e_config->use_desk_group) return NULL;
+ if (!e_config->use_desk_area) return NULL;
- return desk->desk_group.active;
+ return desk->desk_area.active;
}
static void
-_e_desk_desk_group_check_ec_in_desk_group(E_Desk *desk)
+_e_desk_desk_area_check_ec_in_desk_area(E_Desk *desk)
{
E_Client *ec;
Eina_List *ec_list = NULL;
{
if (ec->desk != desk) continue;
if (e_object_is_del(E_OBJECT(ec))) continue;
- if (ec->desk_group.desk_group) continue;
+ if (ec->desk_area.desk_area) continue;
ec_list = eina_list_append(ec_list, ec);
}
EINA_LIST_FREE(ec_list, ec)
- e_client_desk_group_set(ec, desk->desk_group.base);
+ e_client_desk_area_set(ec, desk->desk_area.base);
}
E_API Eina_Bool
-e_desk_desk_group_enable(E_Desk *desk)
+e_desk_desk_area_enable(E_Desk *desk)
{
- E_Desk_Group *edg = NULL;
+ E_Desk_Area *eda = NULL;
Eina_List *l;
- if (!e_config->use_desk_group) return EINA_FALSE;
+ if (!e_config->use_desk_area) return EINA_FALSE;
E_OBJECT_CHECK_RETURN(desk, EINA_FALSE);
E_OBJECT_TYPE_CHECK_RETURN(desk, E_DESK_TYPE, EINA_FALSE);
- ELOGF("EDG", "Enable Desk_Group...", NULL);
- if (desk->desk_group.enable) return EINA_TRUE;
- desk->desk_group.enable = EINA_TRUE;
+ ELOGF("EDG", "Enable Desk_Area...", NULL);
+ if (desk->desk_area.enable) return EINA_TRUE;
+ desk->desk_area.enable = EINA_TRUE;
- _e_desk_hook_call(E_DESK_HOOK_DESK_GROUP_ENABLE, desk);
+ _e_desk_hook_call(E_DESK_HOOK_DESK_AREA_ENABLE, desk);
// check all ec is included in desk group
- _e_desk_desk_group_check_ec_in_desk_group(desk);
+ _e_desk_desk_area_check_ec_in_desk_area(desk);
- for (int i=0; i<E_DESK_GROUP_LAYER_COUNT; i++)
+ for (int i=0; i<E_DESK_AREA_LAYER_COUNT; i++)
{
- EINA_LIST_REVERSE_FOREACH(desk->desk_group.list[i], l, edg)
+ EINA_LIST_REVERSE_FOREACH(desk->desk_area.list[i], l, eda)
{
- e_desk_group_enable_set(edg, EINA_TRUE);
+ e_desk_area_enable_set(eda, EINA_TRUE);
}
}
}
E_API Eina_Bool
-e_desk_desk_group_disable(E_Desk *desk)
+e_desk_desk_area_disable(E_Desk *desk)
{
- E_Desk_Group *edg = NULL;
+ E_Desk_Area *eda = NULL;
Eina_List *l;
- if (!e_config->use_desk_group) return EINA_FALSE;
+ if (!e_config->use_desk_area) return EINA_FALSE;
E_OBJECT_CHECK_RETURN(desk, EINA_FALSE);
E_OBJECT_TYPE_CHECK_RETURN(desk, E_DESK_TYPE, EINA_FALSE);
- ELOGF("EDG", "Disable Desk_Group...", NULL);
- if (!desk->desk_group.enable) return EINA_TRUE;
- desk->desk_group.enable = EINA_FALSE;
+ ELOGF("EDG", "Disable Desk_Area...", NULL);
+ if (!desk->desk_area.enable) return EINA_TRUE;
+ desk->desk_area.enable = EINA_FALSE;
- _e_desk_hook_call(E_DESK_HOOK_DESK_GROUP_DISABLE, desk);
+ _e_desk_hook_call(E_DESK_HOOK_DESK_AREA_DISABLE, desk);
- for (int i=0; i<E_DESK_GROUP_LAYER_COUNT; i++)
+ for (int i=0; i<E_DESK_AREA_LAYER_COUNT; i++)
{
- EINA_LIST_REVERSE_FOREACH(desk->desk_group.list[i], l, edg)
+ EINA_LIST_REVERSE_FOREACH(desk->desk_area.list[i], l, eda)
{
- e_desk_group_enable_set(edg, EINA_FALSE);
+ e_desk_area_enable_set(eda, EINA_FALSE);
}
}
return EINA_TRUE;
}
EINTERN void
-e_desk_desk_group_raise(E_Desk *desk, E_Desk_Group *edg)
+e_desk_desk_area_raise(E_Desk *desk, E_Desk_Area *eda)
{
unsigned int list_id;
- if (!e_config->use_desk_group) return;
+ if (!e_config->use_desk_area) return;
E_OBJECT_CHECK(desk);
E_OBJECT_TYPE_CHECK(desk, E_DESK_TYPE);
- if (!edg) return;
+ if (!eda) return;
- ELOGF("EDG", "Raise Desk_Group... edg:%p", NULL, edg);
+ ELOGF("EDG", "Raise Desk_Area... eda:%p", NULL, eda);
- list_id = _e_desk_desk_group_layer_map(edg->layer);
- desk->desk_group.list[list_id] = eina_list_remove(desk->desk_group.list[list_id], edg);
- desk->desk_group.list[list_id] = eina_list_prepend(desk->desk_group.list[list_id], edg);
+ list_id = _e_desk_desk_area_layer_map(eda->layer);
+ desk->desk_area.list[list_id] = eina_list_remove(desk->desk_area.list[list_id], eda);
+ desk->desk_area.list[list_id] = eina_list_prepend(desk->desk_area.list[list_id], eda);
- e_desk_group_raise(edg);
+ e_desk_area_raise(eda);
}
EINTERN void
-e_desk_desk_group_lower(E_Desk *desk, E_Desk_Group *edg)
+e_desk_desk_area_lower(E_Desk *desk, E_Desk_Area *eda)
{
unsigned int list_id;
- if (!e_config->use_desk_group) return;
+ if (!e_config->use_desk_area) return;
E_OBJECT_CHECK(desk);
E_OBJECT_TYPE_CHECK(desk, E_DESK_TYPE);
- if (!edg) return;
+ if (!eda) return;
- ELOGF("EDG", "Lower Desk_Group...", NULL);
+ ELOGF("EDG", "Lower Desk_Area...", NULL);
- list_id = _e_desk_desk_group_layer_map(edg->layer);
- desk->desk_group.list[list_id] = eina_list_remove(desk->desk_group.list[list_id], edg);
- desk->desk_group.list[list_id] = eina_list_append(desk->desk_group.list[list_id], edg);
+ list_id = _e_desk_desk_area_layer_map(eda->layer);
+ desk->desk_area.list[list_id] = eina_list_remove(desk->desk_area.list[list_id], eda);
+ desk->desk_area.list[list_id] = eina_list_append(desk->desk_area.list[list_id], eda);
- e_desk_group_lower(edg);
+ e_desk_area_lower(eda);
}
-// get above E_Desk_Group in the same edg layer
-EINTERN E_Desk_Group *
-e_desk_desk_group_above_get(E_Desk *desk, E_Desk_Group *edg)
+// get above E_Desk_Area in the same eda layer
+EINTERN E_Desk_Area *
+e_desk_desk_area_above_get(E_Desk *desk, E_Desk_Area *eda)
{
Eina_List *l = NULL;
- E_Desk_Group *above = NULL;
- E_Desk_Group *temp = NULL;
+ E_Desk_Area *above = NULL;
+ E_Desk_Area *temp = NULL;
unsigned int list_id;
if (!desk) return NULL;
- if (!edg) return NULL;
+ if (!eda) return NULL;
- list_id = _e_desk_desk_group_layer_map(edg->layer);
- EINA_LIST_FOREACH(desk->desk_group.list[list_id], l, temp)
+ list_id = _e_desk_desk_area_layer_map(eda->layer);
+ EINA_LIST_FOREACH(desk->desk_area.list[list_id], l, temp)
{
- if (temp != edg)
+ if (temp != eda)
above = temp;
else
break;
}
- ELOGF("EDG", "Get Above E_Desk_Group:%p... current:%p", NULL, above, edg);
+ ELOGF("EDG", "Get Above E_Desk_Area:%p... current:%p", NULL, above, eda);
return above;
}
-// get below E_Desk_Group in the same edg layer
-EINTERN E_Desk_Group *
-e_desk_desk_group_below_get(E_Desk *desk, E_Desk_Group *edg)
+// get below E_Desk_Area in the same eda layer
+EINTERN E_Desk_Area *
+e_desk_desk_area_below_get(E_Desk *desk, E_Desk_Area *eda)
{
Eina_List *l = NULL;
- E_Desk_Group *below = NULL;
- E_Desk_Group *temp = NULL;
+ E_Desk_Area *below = NULL;
+ E_Desk_Area *temp = NULL;
unsigned int list_id;
if (!desk) return NULL;
- if (!edg) return NULL;
+ if (!eda) return NULL;
- list_id = _e_desk_desk_group_layer_map(edg->layer);
- EINA_LIST_REVERSE_FOREACH(desk->desk_group.list[list_id], l, temp)
+ list_id = _e_desk_desk_area_layer_map(eda->layer);
+ EINA_LIST_REVERSE_FOREACH(desk->desk_area.list[list_id], l, temp)
{
- if (temp != edg)
+ if (temp != eda)
below = temp;
else
break;
}
- ELOGF("EDG", "Get Below E_Desk_Group:%p... current:%p", NULL, below, edg);
+ ELOGF("EDG", "Get Below E_Desk_Area:%p... current:%p", NULL, below, eda);
return below;
}
}
EINTERN void
-e_desk_desk_group_info_print(E_Desk *desk)
+e_desk_desk_area_info_print(E_Desk *desk)
{
- E_Desk_Group *edg = NULL;
+ E_Desk_Area *eda = NULL;
Eina_List *l;
E_OBJECT_CHECK(desk);
E_OBJECT_TYPE_CHECK(desk, E_DESK_TYPE);
- for (int i=E_DESK_GROUP_LAYER_COUNT-1; i>=0; i--)
+ for (int i=E_DESK_AREA_LAYER_COUNT-1; i>=0; i--)
{
- EINA_LIST_FOREACH(desk->desk_group.list[i], l, edg)
+ EINA_LIST_FOREACH(desk->desk_area.list[i], l, eda)
{
- e_desk_group_info_print(edg);
+ e_desk_area_info_print(eda);
}
}
}
_e_desk_splitscreen_region_cb_assign_appid(struct wl_client *client,
struct wl_resource *resource, const char *appid)
{
- E_Desk_Group *edg;
+ E_Desk_Area *eda;
char *appid_tmp;
- if (!(edg = wl_resource_get_user_data(resource))) return;
+ if (!(eda = wl_resource_get_user_data(resource))) return;
appid_tmp = strdup(appid);
- // call the E_DESK_GROUP_HOOK_ASSIGN_APPID hook
- if (!e_desk_group_hook_call(edg, E_DESK_GROUP_HOOK_SET_APPID, (void *)appid_tmp))
+ // call the E_DESK_AREA_HOOK_ASSIGN_APPID hook
+ if (!e_desk_area_hook_call(eda, E_DESK_AREA_HOOK_SET_APPID, (void *)appid_tmp))
{
ERR("e_desk_zoom_set: fail get eout");
return;
_e_desk_splitscreen_region_cb_resource_destroy(struct wl_resource *resource)
{
E_Desk *desk;
- E_Desk_Group *edg;
+ E_Desk_Area *eda;
- if (!(edg = wl_resource_get_user_data(resource))) return;
- if (!edg->desk) return;
+ if (!(eda = wl_resource_get_user_data(resource))) return;
+ if (!eda->desk) return;
- desk = edg->desk;
+ desk = eda->desk;
desk->ss_region_resources =
eina_list_remove(desk->ss_region_resources, resource);
e_desk_splitscreen_regions_all_generate(E_Desk *desk, struct wl_client *client,
struct wl_resource *ss_res, uint32_t id)
{
- E_Desk_Group *edg;
+ E_Desk_Area *eda;
struct wl_resource *ss_region_res;
Eina_List *l;
int i;
E_OBJECT_CHECK_RETURN(desk, EINA_FALSE);
E_OBJECT_TYPE_CHECK_RETURN(desk, E_DESK_TYPE, EINA_FALSE);
- for (i = (E_DESK_GROUP_LAYER_COUNT - 1); i >= 0; i--)
+ for (i = (E_DESK_AREA_LAYER_COUNT - 1); i >= 0; i--)
{
- EINA_LIST_FOREACH(desk->desk_group.list[i], l, edg)
+ EINA_LIST_FOREACH(desk->desk_area.list[i], l, eda)
{
- if (edg->name == NULL)
+ if (eda->name == NULL)
{
- // The edg->name can be Ientification of the desk group.
+ // The eda->name can be Ientification of the desk group.
continue;
}
ss_region_res = wl_resource_create(client,
}
wl_resource_set_implementation(ss_region_res,
- &_e_desk_splitscreen_region_interface, edg,
+ &_e_desk_splitscreen_region_interface, eda,
_e_desk_splitscreen_region_cb_resource_destroy);
desk->ss_region_resources = eina_list_append(
wtz_splitscreen_send_region(ss_res, ss_region_res);
// send the name of the split_screen_region
- wtz_splitscreen_region_send_name(ss_region_res, edg->name);
+ wtz_splitscreen_region_send_name(ss_region_res, eda->name);
// send the geometry of the split_screen_region
- wtz_splitscreen_region_send_geometry(ss_region_res, edg->x, edg->y, edg->w, edg->h);
+ wtz_splitscreen_region_send_geometry(ss_region_res, eda->x, eda->y, eda->w, eda->h);
}
}
typedef void (*E_Desk_Flip_Cb)(void *data, E_Desk *desk, int dx, int dy, Eina_Bool show);
-typedef enum _E_Desk_Group_Layer
+typedef enum _E_Desk_Area_Layer
{
- E_DESK_GROUP_LAYER_BACKGROUND = 0, //E_LAYER_DESKTOP
- E_DESK_GROUP_LAYER_NORMAL_BELOW = 150, //E_LAYER_CLIENT_BELOW
- E_DESK_GROUP_LAYER_NORMAL = 200, //E_LAYER_CLIENT_NORMAL,
- E_DESK_GROUP_LAYER_NORMAL_ABOVE = 250, //E_LAYER_CLIENT_ABOVE,
- E_DESK_GROUP_LAYER_NOTIFICATION_LOW = 650, //E_LAYER_CLIENT_NOTIFICATION_LOW,
- E_DESK_GROUP_LAYER_NOTIFICATION_NORMAL = 700, //E_LAYER_CLIENT_NOTIFICATION_NORMAL,
- E_DESK_GROUP_LAYER_NOTIFICATION_HIGH = 750, //E_LAYER_CLIENT_NOTIFICATION_HIGH,
- E_DESK_GROUP_LAYER_NOTIFICATION_TOP = 800, //E_LAYER_CLIENT_NOTIFICATION_TOP,
- E_DESK_GROUP_LAYER_SYSTEM = 900, //E_LAYER_CLIENT_ALERT,
-} E_Desk_Group_Layer;
-#define E_DESK_GROUP_LAYER_COUNT 9
+ E_DESK_AREA_LAYER_BACKGROUND = 0, //E_LAYER_DESKTOP
+ E_DESK_AREA_LAYER_NORMAL_BELOW = 150, //E_LAYER_CLIENT_BELOW
+ E_DESK_AREA_LAYER_NORMAL = 200, //E_LAYER_CLIENT_NORMAL,
+ E_DESK_AREA_LAYER_NORMAL_ABOVE = 250, //E_LAYER_CLIENT_ABOVE,
+ E_DESK_AREA_LAYER_NOTIFICATION_LOW = 650, //E_LAYER_CLIENT_NOTIFICATION_LOW,
+ E_DESK_AREA_LAYER_NOTIFICATION_NORMAL = 700, //E_LAYER_CLIENT_NOTIFICATION_NORMAL,
+ E_DESK_AREA_LAYER_NOTIFICATION_HIGH = 750, //E_LAYER_CLIENT_NOTIFICATION_HIGH,
+ E_DESK_AREA_LAYER_NOTIFICATION_TOP = 800, //E_LAYER_CLIENT_NOTIFICATION_TOP,
+ E_DESK_AREA_LAYER_SYSTEM = 900, //E_LAYER_CLIENT_ALERT,
+} E_Desk_Area_Layer;
+#define E_DESK_AREA_LAYER_COUNT 9
#else
#ifndef E_DESK_H
typedef enum _E_Desk_Hook_Point
{
- E_DESK_HOOK_DESK_GROUP_ENABLE,
- E_DESK_HOOK_DESK_GROUP_DISABLE,
- E_DESK_HOOK_DESK_GROUP_ACTIVE_CHANGE,
+ E_DESK_HOOK_DESK_AREA_ENABLE,
+ E_DESK_HOOK_DESK_AREA_DISABLE,
+ E_DESK_HOOK_DESK_AREA_ACTIVE_CHANGE,
E_DESK_HOOK_LAST
} E_Desk_Hook_Point;
{
Eina_Bool enable;
int id;
- Eina_List *list[E_DESK_GROUP_LAYER_COUNT];
- E_Desk_Group *base;
- E_Desk_Group *active;
- } desk_group;
+ Eina_List *list[E_DESK_AREA_LAYER_COUNT];
+ E_Desk_Area *base;
+ E_Desk_Area *active;
+ } desk_area;
Eina_List *iconified_list;
Eina_List *ss_region_resources; // splitscreen_region resourses
EINTERN void e_desk_client_zoom_apply(E_Desk *desk, E_Client *ec);
-E_API E_Desk_Group *e_desk_desk_group_add(E_Desk *desk, int x, int y, int w, int h, E_Desk_Group_Layer layer);
-E_API void e_desk_desk_group_del(E_Desk *desk, E_Desk_Group *edg);
-E_API E_Desk_Group *e_desk_desk_group_get_by_id(E_Desk *desk, int id);
-E_API E_Desk_Group *e_desk_desk_group_base_get(E_Desk *desk);
-EINTERN void e_desk_desk_group_active_set(E_Desk *desk, E_Desk_Group *edg);
-E_API E_Desk_Group *e_desk_desk_group_active_get(E_Desk *desk);
-E_API Eina_Bool e_desk_desk_group_enable(E_Desk *desk);
-E_API Eina_Bool e_desk_desk_group_disable(E_Desk *desk);
-EINTERN void e_desk_desk_group_raise(E_Desk *desk, E_Desk_Group *edg);
-EINTERN void e_desk_desk_group_lower(E_Desk *desk, E_Desk_Group *edg);
-EINTERN E_Desk_Group *e_desk_desk_group_above_get(E_Desk *desk, E_Desk_Group *edg);
-EINTERN E_Desk_Group *e_desk_desk_group_below_get(E_Desk *desk, E_Desk_Group *edg);
+E_API E_Desk_Area *e_desk_desk_area_add(E_Desk *desk, int x, int y, int w, int h, E_Desk_Area_Layer layer);
+E_API void e_desk_desk_area_del(E_Desk *desk, E_Desk_Area *eda);
+E_API E_Desk_Area *e_desk_desk_area_get_by_id(E_Desk *desk, int id);
+E_API E_Desk_Area *e_desk_desk_area_base_get(E_Desk *desk);
+EINTERN void e_desk_desk_area_active_set(E_Desk *desk, E_Desk_Area *eda);
+E_API E_Desk_Area *e_desk_desk_area_active_get(E_Desk *desk);
+E_API Eina_Bool e_desk_desk_area_enable(E_Desk *desk);
+E_API Eina_Bool e_desk_desk_area_disable(E_Desk *desk);
+EINTERN void e_desk_desk_area_raise(E_Desk *desk, E_Desk_Area *eda);
+EINTERN void e_desk_desk_area_lower(E_Desk *desk, E_Desk_Area *eda);
+EINTERN E_Desk_Area *e_desk_desk_area_above_get(E_Desk *desk, E_Desk_Area *eda);
+EINTERN E_Desk_Area *e_desk_desk_area_below_get(E_Desk *desk, E_Desk_Area *eda);
E_API E_Desk_Hook *e_desk_hook_add(E_Desk_Hook_Point hookpoint, E_Desk_Hook_Cb func, const void *data);
E_API void e_desk_hook_del(E_Desk_Hook *dh);
-EINTERN void e_desk_desk_group_info_print(E_Desk *desk);
+EINTERN void e_desk_desk_area_info_print(E_Desk *desk);
EINTERN Eina_Bool e_desk_zoom_is_animating(E_Desk *desk);
E_API void e_desk_visible_client_iconify_all(E_Desk *desk);
--- /dev/null
+#include "e.h"
+
+static int _e_desk_area_hooks_delete = 0;
+static int _e_desk_area_hooks_walking = 0;
+
+static Eina_Inlist *_e_desk_area_hooks[] =
+{
+ [E_DESK_AREA_HOOK_SET_APPID] = NULL,
+};
+
+struct _E_Desk_Area_Hook
+{
+ EINA_INLIST;
+ E_Desk_Area_Hook_Point hookpoint;
+ E_Desk_Area_Hook_Cb func;
+ void *data;
+ unsigned char delete_me : 1;
+};
+
+static void _e_desk_area_hooks_clean(void);
+static Eina_Bool _e_desk_area_hook_call(E_Desk_Area_Hook_Point hookpoint, E_Desk_Area *desk_area, void *appid);
+
+static Eina_Bool
+_check_desk_area_client_layer_validation(E_Desk_Area_Client_Layer edgc_layer)
+{
+ if ((edgc_layer >= E_DESK_AREA_CLIENT_LAYER_DESKTOP) &&
+ (edgc_layer < E_DESK_AREA_CLIENT_LAYER_MAX))
+ return EINA_TRUE;
+ else
+ return EINA_FALSE;
+}
+
+static void
+_e_desk_area_ec_prepend(E_Desk_Area *eda, E_Client *ec)
+{
+ E_Desk_Area_Client_Layer edgc_layer;
+
+ edgc_layer = e_client_desk_area_client_layer_get(ec);
+ if (!_check_desk_area_client_layer_validation(edgc_layer)) return;
+
+ eda->ec_lists[edgc_layer] = eina_list_remove(eda->ec_lists[edgc_layer], ec);
+ eda->ec_lists[edgc_layer] = eina_list_prepend(eda->ec_lists[edgc_layer], ec);
+
+ e_client_desk_area_client_layer_set(ec, edgc_layer);
+}
+
+static void
+_e_desk_area_ec_append(E_Desk_Area *eda, E_Client *ec)
+{
+ E_Desk_Area_Client_Layer edgc_layer;
+
+ edgc_layer = e_client_desk_area_client_layer_get(ec);
+ if (!_check_desk_area_client_layer_validation(edgc_layer)) return;
+
+ eda->ec_lists[edgc_layer] = eina_list_remove(eda->ec_lists[edgc_layer], ec);
+ eda->ec_lists[edgc_layer] = eina_list_append(eda->ec_lists[edgc_layer], ec);
+
+ e_client_desk_area_client_layer_set(ec, edgc_layer);
+}
+
+static void
+_e_desk_area_ec_prepend_relative(E_Desk_Area *eda, E_Client *ec, E_Client *above)
+{
+ E_Desk_Area_Client_Layer edgc_layer;
+ E_Desk_Area_Client_Layer above_edgc_layer;
+
+ // update eda's ec_list order
+ edgc_layer = e_client_desk_area_client_layer_get(ec);
+ if (!_check_desk_area_client_layer_validation(edgc_layer)) return;
+ above_edgc_layer = e_client_desk_area_client_layer_get(above);
+ if (!_check_desk_area_client_layer_validation(above_edgc_layer)) return;
+
+ ELOGF("EDG", "STACK_ABOVE... eda:%p. layer:%d, above(win:%zx, ec:%p, layer:%d)", ec, eda, edgc_layer, e_client_util_win_get(above), above, above_edgc_layer);
+
+ if (edgc_layer == above_edgc_layer)
+ {
+ eda->ec_lists[edgc_layer] = eina_list_remove(eda->ec_lists[edgc_layer], ec);
+ eda->ec_lists[edgc_layer] = eina_list_prepend_relative(eda->ec_lists[edgc_layer], ec, above);
+ }
+ else
+ {
+ eda->ec_lists[edgc_layer] = eina_list_remove(eda->ec_lists[edgc_layer], ec);
+ eda->ec_lists[above_edgc_layer] = eina_list_prepend_relative(eda->ec_lists[above_edgc_layer], ec, above);
+ }
+
+ e_client_desk_area_client_layer_set(ec, above_edgc_layer);
+}
+
+static void
+_e_desk_area_ec_append_relative(E_Desk_Area *eda, E_Client *ec, E_Client *below)
+{
+ E_Desk_Area_Client_Layer edgc_layer;
+ E_Desk_Area_Client_Layer below_edgc_layer;
+
+ // update eda's ec_list order
+ edgc_layer = e_client_desk_area_client_layer_get(ec);
+ if (!_check_desk_area_client_layer_validation(edgc_layer)) return;
+ below_edgc_layer = e_client_desk_area_client_layer_get(below);
+ if (!_check_desk_area_client_layer_validation(below_edgc_layer)) return;
+
+ ELOGF("EDG", "STACK_BELOW... eda:%p. layer:%d, below(win:%zx, ec:%p, layer:%d)", ec, eda, edgc_layer, e_client_util_win_get(below), below, below_edgc_layer);
+
+ if (edgc_layer == below_edgc_layer)
+ {
+ eda->ec_lists[edgc_layer] = eina_list_remove(eda->ec_lists[edgc_layer], ec);
+ eda->ec_lists[edgc_layer] = eina_list_append_relative(eda->ec_lists[edgc_layer], ec, below);
+ }
+ else
+ {
+ eda->ec_lists[edgc_layer] = eina_list_remove(eda->ec_lists[edgc_layer], ec);
+ eda->ec_lists[below_edgc_layer] = eina_list_append_relative(eda->ec_lists[below_edgc_layer], ec, below);
+ }
+
+ e_client_desk_area_client_layer_set(ec, below_edgc_layer);
+}
+
+static void
+_e_desk_geometry_info_set(E_Desk_Area *eda, int x, int y, int w, int h)
+{
+ E_Desk *desk;
+
+ if (!eda) return;
+ if (!eda->desk) return;
+
+ desk = eda->desk;
+
+ eda->x = x;
+ eda->y = y;
+ eda->w = w;
+ eda->h = h;
+
+ eda->scale_w = (double)w / (double)desk->geom.w;
+ eda->scale_h = (double)h / (double)desk->geom.h;
+}
+
+static void
+_e_desk_area_active_change(E_Desk_Area *eda, E_Desk *desk)
+{
+ E_Desk_Area *prev_active_edg;
+
+ if (!desk) return;
+
+ prev_active_edg = e_desk_desk_area_active_get(desk);
+ if (prev_active_edg == eda) return;
+
+ // 1. reset current active eda info
+ if (prev_active_edg)
+ prev_active_edg->active = EINA_FALSE;
+
+ // 2. set new active eda info
+ if (eda)
+ {
+ eda->active = EINA_TRUE;
+ e_desk_desk_area_active_set(desk, eda);
+ }
+ else
+ {
+ e_desk_desk_area_active_set(desk, NULL);
+ }
+}
+
+static void
+_e_desk_area_cb_hook_subsurface_create(void *data, E_Client *ec)
+{
+ EINA_SAFETY_ON_NULL_RETURN(ec);
+
+ if (ec->desk_area.transform)
+ {
+ e_client_transform_core_remove(ec, ec->desk_area.transform);
+ }
+}
+
+EINTERN int
+e_desk_area_init(void)
+{
+ return 1;
+}
+
+EINTERN int
+e_desk_area_shutdown(void)
+{
+ return 1;
+}
+
+EINTERN E_Desk_Area *
+e_desk_area_new(E_Desk *desk, int id, int x, int y, int w, int h, E_Desk_Area_Layer layer)
+{
+ E_Desk_Area *eda;
+
+ E_OBJECT_CHECK_RETURN(desk, NULL);
+ E_OBJECT_TYPE_CHECK_RETURN(desk, E_DESK_TYPE, NULL);
+
+ eda = E_NEW(E_Desk_Area, 1);
+ if (!eda) return NULL;
+
+ eda->desk = desk;
+ eda->id = id;
+
+ _e_desk_geometry_info_set(eda, x, y, w, h);
+
+ eda->layer = layer;
+
+ eda->hook_subsurf_create = e_comp_wl_hook_add(E_COMP_WL_HOOK_SUBSURFACE_CREATE,
+ _e_desk_area_cb_hook_subsurface_create,
+ NULL);
+
+ return eda;
+}
+
+EINTERN void
+e_desk_area_del(E_Desk_Area *eda)
+{
+ if (!eda) return;
+
+ for (int i=0; i<E_DESK_AREA_CLIENT_LAYER_MAX; i++)
+ {
+ eina_list_free(eda->ec_lists[i]);
+ }
+
+ if (eda->active)
+ _e_desk_area_active_change(NULL, eda->desk);
+
+ E_FREE_FUNC(eda->hook_subsurf_create, e_comp_wl_hook_del);
+
+ E_FREE(eda);
+}
+
+void _e_desk_area_ec_geometry_apply(E_Desk_Area *eda, E_Client *ec)
+{
+ E_Maximize max;
+ E_Util_Transform *transform;
+
+ if (e_comp_wl_subsurface_check(ec))
+ return;
+
+ transform = ec->desk_area.transform;
+
+ if (eda->transform_enabled)
+ {
+ if (!transform) return;
+
+ e_util_transform_move(transform, eda->x, eda->y, 0);
+ e_util_transform_scale(transform, eda->scale_w, eda->scale_h, 1.0);
+ e_client_transform_core_add(ec, transform);
+
+ e_client_transform_core_update(ec);
+ }
+ else
+ {
+ if (transform)
+ {
+ e_util_transform_move(transform, 0, 0, 0);
+ e_util_transform_scale(transform, 1.0, 1.0, 1.0);
+ e_client_transform_core_remove(ec, transform);
+
+ e_client_transform_core_update(ec);
+ }
+
+ max = ec->maximized;
+ ec->maximized = E_MAXIMIZE_NONE;
+ e_client_maximize(ec, max);
+ }
+}
+
+void _e_desk_area_ec_geometry_restore(E_Desk_Area *eda, E_Client *ec)
+{
+ e_client_transform_core_update(ec);
+}
+
+void _e_desk_area_enable(E_Desk_Area *eda)
+{
+ int i;
+ E_Client *ec;
+ Eina_List *l;
+ Eina_List *list;
+
+ if (!eda) return;
+
+ for (i=0; i<E_DESK_AREA_CLIENT_LAYER_MAX; i++)
+ {
+ list = eina_list_clone(eda->ec_lists[i]);
+ EINA_LIST_REVERSE_FOREACH(list, l, ec)
+ {
+ e_client_desk_area_enable_set(ec, EINA_TRUE);
+ }
+ eina_list_free(list);
+ list = NULL;
+ }
+}
+
+void _e_desk_area_disable(E_Desk_Area *eda)
+{
+ int i;
+ E_Client *ec;
+ Eina_List *l = NULL;
+ Eina_List *list = NULL;
+
+ for (i=0; i<E_DESK_AREA_CLIENT_LAYER_MAX; i++)
+ {
+ list = eina_list_clone(eda->ec_lists[i]);
+ EINA_LIST_REVERSE_FOREACH(list, l, ec)
+ {
+ // unset ec's desk_area enable flag
+ e_client_desk_area_enable_set(ec, EINA_FALSE);
+ // restore original ec->layer
+ e_client_desk_area_original_layer_restore(ec);
+ // restore ec's original geometry (changing real geometry or using transform)
+ _e_desk_area_ec_geometry_restore(eda, ec);
+
+ e_client_desk_area_set(ec, NULL);
+ }
+ eina_list_free(list);
+ list = NULL;
+
+ eina_list_free(eda->ec_lists[i]);
+ eda->ec_lists[i] = NULL;
+ }
+}
+
+EINTERN Eina_Bool
+e_desk_area_enable_set(E_Desk_Area *eda, Eina_Bool enable)
+{
+ if (!eda) return EINA_FALSE;
+
+ eda->enable = enable;
+ if (enable)
+ {
+ _e_desk_area_enable(eda);
+ }
+ else
+ {
+ _e_desk_area_disable(eda);
+ }
+
+ return EINA_TRUE;
+}
+
+E_API Eina_Bool
+e_desk_area_geometry_set(E_Desk_Area *eda, int x, int y, int w, int h)
+{
+ if (!eda) return EINA_FALSE;
+
+ _e_desk_geometry_info_set(eda, x, y, w, h);
+
+ return EINA_TRUE;
+}
+
+E_API Eina_Bool
+e_desk_area_geometry_get(E_Desk_Area *eda, int *x, int *y, int *w, int *h)
+{
+ if (!eda) return EINA_FALSE;
+
+ if (x) *x = eda->x;
+ if (y) *y = eda->y;
+ if (w) *w = eda->w;
+ if (h) *h = eda->h;
+
+ return EINA_TRUE;
+}
+
+EINTERN Eina_Bool
+e_desk_area_layer_set(E_Desk_Area *eda, E_Desk_Area_Layer layer)
+{
+ if (!eda) return EINA_FALSE;
+
+ eda->layer = layer;
+ return EINA_TRUE;
+}
+
+E_API E_Desk_Area_Layer
+e_desk_area_layer_get(E_Desk_Area *eda)
+{
+ if (!eda) return E_DESK_AREA_LAYER_NORMAL;
+
+ return eda->layer;
+}
+
+E_API void
+e_desk_area_activate(E_Desk_Area *eda)
+{
+ if (!eda) return;
+ if (!eda->desk) return;
+
+ e_desk_area_raise(eda);
+ _e_desk_area_active_change(eda, eda->desk);
+}
+
+E_API Eina_Bool
+e_desk_area_is_activate(E_Desk_Area *eda)
+{
+ if (!eda) return EINA_FALSE;
+ return eda->active;
+}
+
+E_API void
+e_desk_area_raise(E_Desk_Area *eda)
+{
+ int i;
+ E_Client *ec;
+ Eina_List *l = NULL;
+ Eina_List *ll = NULL;
+
+ if (!eda) return;
+
+ for (i=0; i<E_DESK_AREA_CLIENT_LAYER_MAX; i++)
+ {
+ EINA_LIST_REVERSE_FOREACH_SAFE(eda->ec_lists[i], l, ll, ec)
+ {
+ evas_object_raise(ec->frame);
+ }
+ }
+}
+
+E_API void
+e_desk_area_lower(E_Desk_Area *eda)
+{
+ int i;
+ E_Client *ec;
+ Eina_List *l = NULL;
+ Eina_List *ll = NULL;
+
+ if (!eda) return;
+
+ for (i=E_DESK_AREA_CLIENT_LAYER_MAX-1; i>=0; i--)
+ {
+ //EINA_LIST_FOREACH(eda->ec_lists[i], l, ec)
+ EINA_LIST_FOREACH_SAFE(eda->ec_lists[i], l, ll, ec)
+ {
+ evas_object_lower(ec->frame);
+ }
+ }
+}
+
+
+static E_Desk_Area_Client_Layer
+_e_desk_area_client_layer_convert_from_layer(E_Layer layer)
+{
+ E_Desk_Area_Client_Layer edg_layer;
+
+ if (layer <= E_LAYER_CLIENT_DESKTOP)
+ edg_layer = E_DESK_AREA_CLIENT_LAYER_DESKTOP;
+ else if (layer <= E_LAYER_CLIENT_BELOW)
+ edg_layer = E_DESK_AREA_CLIENT_LAYER_BELOW;
+ else if (layer <= E_LAYER_CLIENT_NORMAL)
+ edg_layer = E_DESK_AREA_CLIENT_LAYER_NORMAL;
+ else if (layer <= E_LAYER_CLIENT_ABOVE)
+ edg_layer = E_DESK_AREA_CLIENT_LAYER_ABOVE;
+ else if (layer <= E_LAYER_CLIENT_NOTIFICATION_LOW)
+ edg_layer = E_DESK_AREA_CLIENT_LAYER_NOTIFICATION_LOW;
+ else if (layer <= E_LAYER_CLIENT_NOTIFICATION_NORMAL)
+ edg_layer = E_DESK_AREA_CLIENT_LAYER_NOTIFICATION_NORMAL;
+ else if (layer <= E_LAYER_CLIENT_NOTIFICATION_HIGH)
+ edg_layer = E_DESK_AREA_CLIENT_LAYER_NOTIFICATION_HIGH;
+ else if (layer <= E_LAYER_CLIENT_NOTIFICATION_TOP)
+ edg_layer = E_DESK_AREA_CLIENT_LAYER_NOTIFICATION_TOP;
+ else
+ edg_layer = E_DESK_AREA_CLIENT_LAYER_ALERT;
+
+ return edg_layer;
+}
+
+E_API Eina_Bool
+e_desk_area_ec_add(E_Desk_Area *eda, E_Client *ec)
+{
+ E_Desk_Area_Client_Layer edgc_layer;
+ E_Layer layer;
+
+ if (!eda) return EINA_FALSE;
+ if (!ec) return EINA_FALSE;
+
+
+ layer = e_client_desk_area_original_layer_get(ec);
+ edgc_layer = _e_desk_area_client_layer_convert_from_layer(layer);
+
+ eda->ec_lists[edgc_layer] = eina_list_prepend(eda->ec_lists[edgc_layer], ec);
+
+ e_client_desk_area_client_layer_set(ec, edgc_layer);
+
+ return EINA_TRUE;
+}
+
+E_API void
+e_desk_area_ec_remove(E_Desk_Area *eda, E_Client *ec)
+{
+ E_Desk_Area_Client_Layer edgc_layer;
+
+ if (!eda) return;
+ if (!ec) return;
+
+ edgc_layer = e_client_desk_area_client_layer_get(ec);
+ if (!_check_desk_area_client_layer_validation(edgc_layer)) return;
+
+ eda->ec_lists[edgc_layer] = eina_list_remove(eda->ec_lists[edgc_layer], ec);
+}
+
+static E_Client *
+_find_above_ec_in_same_edgc_layer(E_Desk_Area *eda, E_Client *ec)
+{
+ Eina_List *l;
+ E_Client *above = NULL;
+ E_Client *temp = NULL;
+ E_Desk_Area_Client_Layer edgc_layer;
+ Eina_Bool find = EINA_FALSE;
+
+ edgc_layer = e_client_desk_area_client_layer_get(ec);
+ if (!_check_desk_area_client_layer_validation(edgc_layer)) return NULL;
+
+ EINA_LIST_REVERSE_FOREACH(eda->ec_lists[edgc_layer], l, temp)
+ {
+ if (find)
+ {
+ above = temp;
+ break;
+ }
+
+ if (temp == ec)
+ {
+ find = EINA_TRUE;
+ }
+ }
+
+ // TODO: do we need check below->frame???
+
+ return above;
+}
+
+static E_Client *
+_find_bottom_ec_in_above_edgc_layer(E_Desk_Area *eda, E_Client *ec)
+{
+ Eina_List *l;
+ E_Client *bottom = NULL;
+ E_Desk_Area_Client_Layer edgc_layer;
+ int i;
+
+ edgc_layer = e_client_desk_area_client_layer_get(ec);
+ if (!_check_desk_area_client_layer_validation(edgc_layer)) return NULL;
+
+ for (i = edgc_layer+1; i < E_DESK_AREA_CLIENT_LAYER_MAX; i++)
+ {
+ EINA_LIST_REVERSE_FOREACH(eda->ec_lists[i], l, bottom)
+ {
+ // TODO: do we need check below->frame???
+ if (bottom)
+ return bottom;
+ }
+ }
+
+ return NULL;
+}
+
+static E_Client *
+_find_bottom_ec_in_above_edg(E_Desk_Area *eda)
+{
+ E_Desk_Area *above_edg = NULL;
+ E_Client *bottom = NULL;
+ Eina_List *l;
+ int i;
+
+ above_edg = e_desk_desk_area_above_get(eda->desk, eda);
+ while (above_edg)
+ {
+ for (i=E_DESK_AREA_CLIENT_LAYER_DESKTOP; i<E_DESK_AREA_CLIENT_LAYER_MAX; i++)
+ {
+ EINA_LIST_REVERSE_FOREACH(above_edg->ec_lists[i], l, bottom)
+ {
+ if (bottom)
+ goto find_bottom;
+ }
+ }
+
+ bottom = NULL;
+ above_edg = e_desk_desk_area_above_get(above_edg->desk, above_edg);
+ }
+
+find_bottom:
+ return bottom;
+}
+
+static E_Client *
+_find_below_ec_in_same_edgc_layer(E_Desk_Area *eda, E_Client *ec)
+{
+ Eina_List *l;
+ E_Client *below = NULL;
+ E_Client *temp = NULL;
+ E_Desk_Area_Client_Layer edgc_layer;
+ Eina_Bool find = EINA_FALSE;
+
+ edgc_layer = e_client_desk_area_client_layer_get(ec);
+ if (!_check_desk_area_client_layer_validation(edgc_layer)) return NULL;
+
+ EINA_LIST_FOREACH(eda->ec_lists[edgc_layer], l, temp)
+ {
+ if (find)
+ {
+ below = temp;
+ break;
+ }
+
+ if (temp == ec)
+ {
+ find = EINA_TRUE;
+ }
+ }
+
+ // TODO: do we need check below->frame???
+
+ return below;
+}
+
+static E_Client *
+_find_top_ec_in_below_edgc_layer(E_Desk_Area *eda, E_Client *ec)
+{
+ Eina_List *l;
+ E_Client *top = NULL;
+ E_Desk_Area_Client_Layer edgc_layer;
+ int i;
+
+ edgc_layer = e_client_desk_area_client_layer_get(ec);
+ if (!_check_desk_area_client_layer_validation(edgc_layer)) return NULL;
+
+ for (i = edgc_layer-1; i >= E_DESK_AREA_CLIENT_LAYER_DESKTOP; i--)
+ {
+ EINA_LIST_FOREACH(eda->ec_lists[i], l, top)
+ {
+ // TODO: do we need check top->frame???
+ if (top)
+ return top;
+ }
+ }
+
+ return NULL;
+}
+
+static E_Client *
+_find_top_ec_in_below_edg(E_Desk_Area *eda)
+{
+ E_Desk_Area *below_edg = NULL;
+ E_Client *top = NULL;
+ Eina_List *l;
+ int i;
+
+ below_edg = e_desk_desk_area_below_get(eda->desk, eda);
+ while (below_edg)
+ {
+ for (i=E_DESK_AREA_CLIENT_LAYER_MAX-1; i>=E_DESK_AREA_CLIENT_LAYER_DESKTOP; i--)
+ {
+ EINA_LIST_FOREACH(below_edg->ec_lists[i], l, top)
+ {
+ if (top)
+ goto find_top;
+ }
+ }
+
+ top = NULL;
+ below_edg = e_desk_desk_area_below_get(below_edg->desk, below_edg);
+ }
+
+find_top:
+ return top;
+}
+
+EINTERN void
+e_desk_area_ec_raise(E_Desk_Area *eda, E_Client *ec)
+{
+ E_Client *below = NULL;
+ E_Client *above = NULL;
+
+ if (!eda) return;
+ if (!ec) return;
+
+ ELOGF("EDG", "RAISE... eda:%p", ec, eda);
+
+ _e_desk_area_ec_prepend(eda, ec);
+
+ // 1. find below ec in same edgc layer in same eda
+ below = _find_below_ec_in_same_edgc_layer(eda, ec);
+ if (below) goto find_below;
+
+ // 2. find above ec in same edgc layer in same eda
+ above = _find_above_ec_in_same_edgc_layer(eda, ec);
+ if (above) goto find_above;
+
+ // 3. find bottom ec in above edgc layer in same eda
+ above = _find_bottom_ec_in_above_edgc_layer(eda, ec);
+ if (above) goto find_above;
+
+ // 4. find bottom ec in above eda
+ above = _find_bottom_ec_in_above_edg(eda);
+ if (above) goto find_above;
+
+ // 5. if not found, just evas_object_raise
+ ELOGF("EDG", "RAISE... call evas_object_raise", ec);
+ evas_object_raise(ec->frame);
+ return;
+
+find_below:
+ if (below)
+ {
+ ELOGF("EDG", "STACK_ABOVE... below(win:0x%08zx, ec:%p)", ec, e_client_util_win_get(below), below);
+ if (below->frame)
+ {
+ ELOGF("EDG", "STACK_ABOVE... call evas_object_stack_above", ec);
+ evas_object_stack_above(ec->frame, below->frame);
+ }
+ }
+ return;
+
+find_above:
+ if (above)
+ {
+ ELOGF("EDG", "STACK_BELOW... above(win:0x%08zx, ec:%p)", ec, e_client_util_win_get(above), above);
+ if (above->frame)
+ {
+ ELOGF("EDG", "STACK_BELOW... call evas_object_stack_below", ec);
+ evas_object_stack_below(ec->frame, above->frame);
+ }
+ }
+ return;
+}
+
+EINTERN void
+e_desk_area_ec_lower(E_Desk_Area *eda, E_Client *ec)
+{
+ E_Client *above = NULL;
+ E_Client *below = NULL;
+
+ if (!eda) return;
+ if (!ec) return;
+
+ ELOGF("EDG", "LOWER... eda:%p", ec, eda);
+
+ _e_desk_area_ec_append(eda, ec);
+
+ // 1. find above ec in same edgc layer in same eda
+ above = _find_above_ec_in_same_edgc_layer(eda, ec);
+ if (above) goto find_above;
+
+ // 2. find below ec in same edgc layer in same eda
+ below = _find_below_ec_in_same_edgc_layer(eda, ec);
+ if (below) goto find_below;
+
+ // 3. find top ec in below edgc layer in same eda
+ below = _find_top_ec_in_below_edgc_layer(eda, ec);
+ if (below) goto find_below;
+
+ // 4. find top ec in below eda
+ below = _find_top_ec_in_below_edg(eda);
+ if (below) goto find_below;
+
+ // 5. if not found, just evas_object_raise
+ ELOGF("EDG", "LOWER... call evas_object_raise", ec);
+ evas_object_lower(ec->frame);
+ return;
+
+find_below:
+ if (below)
+ {
+ ELOGF("EDG", "STACK_ABOVE... below(win:0x%08zx, ec:%p)", ec, e_client_util_win_get(below), below);
+ if (below->frame)
+ {
+ ELOGF("EDG", "STACK_ABOVE... call evas_object_stack_above", ec);
+ evas_object_stack_above(ec->frame, below->frame);
+ }
+ }
+ return;
+
+find_above:
+ if (above)
+ {
+ ELOGF("EDG", "STACK_BELOW... above(win:0x%08zx, ec:%p)", ec, e_client_util_win_get(above), above);
+ if (above->frame)
+ {
+ ELOGF("EDG", "STACK_BELOW... call evas_object_stack_below", ec);
+ evas_object_stack_below(ec->frame, above->frame);
+ }
+ }
+ return;
+}
+
+EINTERN void
+e_desk_area_ec_stack_above(E_Desk_Area *eda, E_Client *ec, E_Client *above)
+{
+ if (!eda) return;
+ if (!ec) return;
+ if (!ec->frame) return;
+ if (!above) return;
+ if (!above->frame) return;
+
+ _e_desk_area_ec_prepend_relative(eda, ec, above);
+
+ evas_object_stack_above(ec->frame, above->frame);
+}
+
+EINTERN void
+e_desk_area_ec_stack_below(E_Desk_Area *eda, E_Client *ec, E_Client *below)
+{
+ if (!eda) return;
+ if (!ec) return;
+ if (!ec->frame) return;
+ if (!below) return;
+ if (!below->frame) return;
+
+ _e_desk_area_ec_append_relative(eda, ec, below);
+
+ evas_object_stack_below(ec->frame, below->frame);
+}
+
+EINTERN void
+e_desk_area_ec_layer_set(E_Desk_Area *eda, E_Client *ec, E_Layer layer)
+{
+ E_Desk_Area_Client_Layer edg_layer;
+
+ if (!eda) return;
+ if (!ec) return;
+
+ // save original layer
+
+ edg_layer = eda->layer;
+ evas_object_layer_set(ec->frame, edg_layer);
+}
+
+static void
+_e_desk_area_ec_restack(E_Desk_Area *eda, E_Client *ec)
+{
+ E_Client *above = NULL, *below = NULL;
+
+ // 1. find below ec in same edgc layer in same eda
+ below = _find_below_ec_in_same_edgc_layer(eda, ec);
+ if (below) goto find_below;
+
+ // 2. find above ec in same edgc layer in same eda
+ above = _find_above_ec_in_same_edgc_layer(eda, ec);
+ if (above) goto find_above;
+
+ // 3. find bottom ec in above edgc layer in same eda
+ above = _find_bottom_ec_in_above_edgc_layer(eda, ec);
+ if (above) goto find_above;
+
+ // 4. find bottom ec in above eda
+ above = _find_bottom_ec_in_above_edg(eda);
+ if (above) goto find_above;
+
+ // 5. if not found, just evas_object_raise
+ ELOGF("EDG", "RESTACK raise... call evas_object_raise", ec);
+ evas_object_raise(ec->frame);
+ return;
+
+find_below:
+ if (below)
+ {
+ ELOGF("EDG", "STACK_ABOVE... below(win:0x%08zx, ec:%p)", ec, e_client_util_win_get(below), below);
+ if (below->frame)
+ {
+ ELOGF("EDG", "STACK_ABOVE... call evas_object_stack_above", ec);
+ evas_object_stack_above(ec->frame, below->frame);
+ }
+ }
+ return;
+
+find_above:
+ if (above)
+ {
+ ELOGF("EDG", "STACK_BELOW... above(win:0x%08zx, ec:%p)", ec, e_client_util_win_get(above), above);
+ if (above->frame)
+ {
+ ELOGF("EDG", "STACK_BELOW... call evas_object_stack_below", ec);
+ evas_object_stack_below(ec->frame, above->frame);
+ }
+ }
+ return;
+}
+
+EINTERN void
+e_desk_area_ec_rearrange(E_Desk_Area *eda, E_Client *ec)
+{
+ E_Layer layer;
+ E_Desk_Area_Client_Layer edgc_layer, prev_edgc_layer;
+
+ ELOGF("EDG", "RE-ARRANGE... eda:%p", ec, eda);
+
+ if (!eda) return;
+ if (!ec) return;
+
+ prev_edgc_layer = e_client_desk_area_client_layer_get(ec);
+ if (!_check_desk_area_client_layer_validation(prev_edgc_layer)) return;
+
+ eda->ec_lists[prev_edgc_layer] = eina_list_remove(eda->ec_lists[prev_edgc_layer], ec);
+
+ layer = e_client_desk_area_original_layer_get(ec);
+ edgc_layer = _e_desk_area_client_layer_convert_from_layer(layer);
+ eda->ec_lists[edgc_layer] = eina_list_prepend(eda->ec_lists[edgc_layer], ec);
+
+ e_client_desk_area_client_layer_set(ec, edgc_layer);
+
+ _e_desk_area_ec_restack(eda, ec);
+}
+
+EINTERN void
+e_desk_area_ec_stack_change(E_Desk_Area *eda, E_Client *ec)
+{
+}
+
+E_API void
+e_desk_area_ec_update(E_Desk_Area *eda, E_Client *ec)
+{
+ E_Layer layer;
+
+ if (!eda) return;
+ if (!ec) return;
+
+ layer = e_client_desk_area_original_layer_get(ec);
+
+ // update stack
+ e_client_layer_set_by_desk_area(ec, layer);
+
+ // update geometry
+ _e_desk_area_ec_geometry_apply(eda, ec);
+}
+
+E_API void
+e_desk_area_all_ec_update(E_Desk_Area *eda)
+{
+ int i;
+ E_Client *ec;
+ Eina_List *l;
+ Eina_List *list;
+
+ if (!eda) return;
+
+ for (i=0; i<E_DESK_AREA_CLIENT_LAYER_MAX; i++)
+ {
+ list = eina_list_clone(eda->ec_lists[i]);
+
+ EINA_LIST_REVERSE_FOREACH(list, l, ec)
+ {
+ e_desk_area_ec_update(eda, ec);
+ }
+
+ eina_list_free(list);
+ list = NULL;
+ }
+}
+
+E_API Eina_List *
+e_desk_area_ec_list_get(E_Desk_Area *eda)
+{
+ if (!eda) return NULL;
+
+ return NULL;
+}
+
+E_API void
+e_desk_area_transform_enable_set(E_Desk_Area *eda, Eina_Bool enable)
+{
+ if (!eda) return;
+
+ eda->transform_enabled = enable;
+}
+
+E_API Eina_Bool
+e_desk_area_transform_enable_get(E_Desk_Area *eda)
+{
+ if (!eda) return EINA_FALSE;
+
+ return eda->transform_enabled;
+}
+
+
+// for debug
+EINTERN void
+e_desk_area_info_print(E_Desk_Area *eda)
+{
+ Eina_List *l;
+ E_Client *ec;
+
+ if (!eda) return;
+
+ ELOGF("EDG_INFO", "===========================================", NULL);
+ ELOGF("EDG_INFO", "E_Desk_Area(%p), ID(%d), Geo(%d,%d,%d,%d), Layer:%d", NULL, eda, eda->id, eda->x, eda->y, eda->w, eda->h, eda->layer);
+ ELOGF("EDG_INFO", "-------------------------------------------", NULL);
+ for (int i=E_DESK_AREA_CLIENT_LAYER_MAX-1; i>=0; i--)
+ {
+ EINA_LIST_FOREACH(eda->ec_lists[i], l, ec)
+ {
+ ELOGF("EDG_INFO", "EDG_Layer[%d] Win:0x%08zx, EC:%p, frame:%p, ec->layer:%d, org_layer:%d, name:%s", NULL, i, e_client_util_win_get(ec), ec, ec->frame, ec->layer, ec->desk_area.layer_backup, ec->icccm.title ? ec->icccm.title:"NO NAME");
+ }
+ }
+ ELOGF("EDG_INFO", "===========================================", NULL);
+}
+
+static void
+_e_desk_area_hooks_clean(void)
+{
+ Eina_Inlist *l;
+ E_Desk_Area_Hook *dgh;
+ unsigned int x;
+
+ for (x = 0; x < E_DESK_AREA_HOOK_LAST; x++)
+ EINA_INLIST_FOREACH_SAFE(_e_desk_area_hooks[x], l, dgh)
+ {
+ if (!dgh->delete_me) continue;
+ _e_desk_area_hooks[x] = eina_inlist_remove(_e_desk_area_hooks[x], EINA_INLIST_GET(dgh));
+ free(dgh);
+ }
+
+ _e_desk_area_hooks_delete = 0;
+}
+
+static Eina_Bool
+_e_desk_area_hook_call(E_Desk_Area_Hook_Point hookpoint, E_Desk_Area *desk_area, void *data)
+{
+ E_Desk_Area_Hook *dgh;
+
+ e_object_ref(E_OBJECT(desk_area));
+ _e_desk_area_hooks_walking++;
+ EINA_INLIST_FOREACH(_e_desk_area_hooks[hookpoint], dgh)
+ {
+ if (dgh->delete_me) continue;
+ dgh->func(dgh->data, desk_area, data);
+ }
+ _e_desk_area_hooks_walking--;
+ if ((_e_desk_area_hooks_walking == 0) && (_e_desk_area_hooks_delete > 0))
+ _e_desk_area_hooks_clean();
+
+ return !!e_object_unref(E_OBJECT(desk_area));
+}
+
+EINTERN Eina_Bool
+e_desk_area_hook_call(E_Desk_Area *eda, E_Desk_Area_Hook_Point hookpoint, void *data)
+{
+ return _e_desk_area_hook_call(hookpoint, eda, data);
+}
+
+E_API E_Desk_Area_Hook *
+e_desk_area_hook_add(E_Desk_Area_Hook_Point hookpoint,
+ E_Desk_Area_Hook_Cb func, const void *data)
+{
+ E_Desk_Area_Hook *dgh;
+
+ EINA_SAFETY_ON_TRUE_RETURN_VAL(hookpoint >= E_DESK_AREA_HOOK_LAST, NULL);
+ dgh = E_NEW(E_Desk_Area_Hook, 1);
+ if (!dgh) return NULL;
+
+ dgh->hookpoint = hookpoint;
+ dgh->func = func;
+ dgh->data = (void*)data;
+
+ _e_desk_area_hooks[hookpoint] =
+ eina_inlist_append(_e_desk_area_hooks[hookpoint], EINA_INLIST_GET(dgh));
+
+ return dgh;
+}
+
+E_API void
+e_desk_area_hook_del(E_Desk_Area_Hook * dgh)
+{
+ dgh->delete_me = 1;
+
+ if (_e_desk_area_hooks_walking == 0)
+ {
+ _e_desk_area_hooks[dgh->hookpoint] =
+ eina_inlist_remove(_e_desk_area_hooks[dgh->hookpoint], EINA_INLIST_GET(dgh));
+ free(dgh);
+ }
+ else
+ _e_desk_area_hooks_delete++;
+}
\ No newline at end of file
--- /dev/null
+#ifdef E_TYPEDEFS
+
+typedef struct _E_Desk_Area E_Desk_Area;
+typedef struct _E_Event_Desk_Area E_Event_Desk_Area;
+
+typedef enum _E_Desk_Area_Client_Layer
+{
+ E_DESK_AREA_CLIENT_LAYER_DESKTOP,
+ E_DESK_AREA_CLIENT_LAYER_BELOW,
+ E_DESK_AREA_CLIENT_LAYER_NORMAL,
+ E_DESK_AREA_CLIENT_LAYER_ABOVE,
+ E_DESK_AREA_CLIENT_LAYER_NOTIFICATION_LOW,
+ E_DESK_AREA_CLIENT_LAYER_NOTIFICATION_NORMAL,
+ E_DESK_AREA_CLIENT_LAYER_NOTIFICATION_HIGH,
+ E_DESK_AREA_CLIENT_LAYER_NOTIFICATION_TOP,
+ E_DESK_AREA_CLIENT_LAYER_ALERT,
+ E_DESK_AREA_CLIENT_LAYER_MAX,
+} E_Desk_Area_Client_Layer;
+
+#else
+#ifndef E_DESK_AREA_H
+#define E_DESK_AREA_H
+
+typedef struct _E_Desk_Area_Hook E_Desk_Area_Hook;
+
+typedef enum _E_Desk_Area_Hook_Point
+{
+ E_DESK_AREA_HOOK_SET_APPID,
+ E_DESK_AREA_HOOK_LAST
+} E_Desk_Area_Hook_Point;
+
+typedef void (*E_Desk_Area_Hook_Cb)(void *data, E_Desk_Area *desk_area, void *hook_data);
+
+struct _E_Desk_Area
+{
+ E_Object e_obj_inherit;
+
+ E_Desk *desk;
+ int id;
+ E_Desk_Area_Layer layer;
+ Eina_Stringshare *name;
+
+ int x, y, w, h;
+ double scale_w, scale_h;
+
+ unsigned char enable : 1;
+ unsigned char visible : 1;
+ unsigned char active : 1;
+ unsigned char transform_enabled : 1;
+ Eina_List *ec_lists[E_DESK_AREA_CLIENT_LAYER_MAX];
+
+ Eina_List *handlers;
+
+ E_Comp_Wl_Hook *hook_subsurf_create;
+};
+
+struct _E_Event_Desk_Area
+{
+ E_Desk_Area *eda;
+};
+
+EINTERN int e_desk_area_init(void);
+EINTERN int e_desk_area_shutdown(void);
+
+EINTERN E_Desk_Area *e_desk_area_new(E_Desk *desk, int id, int x, int y, int w, int h, E_Desk_Area_Layer layer);
+EINTERN void e_desk_area_del(E_Desk_Area *eda);
+
+EINTERN Eina_Bool e_desk_area_enable_set(E_Desk_Area *eda, Eina_Bool enable);
+
+E_API Eina_Bool e_desk_area_geometry_set(E_Desk_Area *eda, int x, int y, int w, int h);
+E_API Eina_Bool e_desk_area_geometry_get(E_Desk_Area *eda, int *x, int *y, int *w, int *h);
+
+EINTERN Eina_Bool e_desk_area_layer_set(E_Desk_Area *eda, E_Desk_Area_Layer layer);
+E_API E_Desk_Area_Layer e_desk_area_layer_get(E_Desk_Area *eda);
+
+E_API void e_desk_area_activate(E_Desk_Area *eda);
+E_API Eina_Bool e_desk_area_is_activate(E_Desk_Area *eda);
+
+E_API void e_desk_area_raise(E_Desk_Area *eda);
+E_API void e_desk_area_lower(E_Desk_Area *eda);
+
+
+E_API Eina_Bool e_desk_area_ec_add(E_Desk_Area *eda, E_Client *ec);
+E_API void e_desk_area_ec_remove(E_Desk_Area *eda, E_Client *ec);
+EINTERN void e_desk_area_ec_raise(E_Desk_Area *eda, E_Client *ec);
+EINTERN void e_desk_area_ec_lower(E_Desk_Area *eda, E_Client *ec);
+EINTERN void e_desk_area_ec_stack_above(E_Desk_Area *eda, E_Client *ec, E_Client *above);
+EINTERN void e_desk_area_ec_stack_below(E_Desk_Area *eda, E_Client *ec, E_Client *below);
+EINTERN void e_desk_area_ec_layer_set(E_Desk_Area *eda, E_Client *ec, E_Layer layer);
+EINTERN void e_desk_area_ec_rearrange(E_Desk_Area *eda, E_Client *ec);
+EINTERN void e_desk_area_ec_stack_change(E_Desk_Area *eda, E_Client *ec);
+
+E_API void e_desk_area_ec_update(E_Desk_Area *eda, E_Client *ec);
+E_API void e_desk_area_all_ec_update(E_Desk_Area *eda);
+
+E_API Eina_List *e_desk_area_ec_list_get(E_Desk_Area *eda);
+
+E_API void e_desk_area_transform_enable_set(E_Desk_Area *eda, Eina_Bool enable);
+E_API Eina_Bool e_desk_area_transform_enable_get(E_Desk_Area *eda);
+
+// for debug
+EINTERN void e_desk_area_info_print(E_Desk_Area *eda);
+
+EINTERN Eina_Bool e_desk_area_hook_call(E_Desk_Area *eda, E_Desk_Area_Hook_Point hookpoint, void *data);
+E_API E_Desk_Area_Hook *e_desk_area_hook_add(E_Desk_Area_Hook_Point hookpoint, E_Desk_Area_Hook_Cb func, const void *data);
+E_API void e_desk_area_hook_del(E_Desk_Area_Hook *dgh);
+
+extern E_API int E_EVENT_DESK_AREA_CHANGE;
+
+#endif
+#endif
+++ /dev/null
-#include "e.h"
-
-static int _e_desk_group_hooks_delete = 0;
-static int _e_desk_group_hooks_walking = 0;
-
-static Eina_Inlist *_e_desk_group_hooks[] =
-{
- [E_DESK_GROUP_HOOK_SET_APPID] = NULL,
-};
-
-struct _E_Desk_Group_Hook
-{
- EINA_INLIST;
- E_Desk_Group_Hook_Point hookpoint;
- E_Desk_Group_Hook_Cb func;
- void *data;
- unsigned char delete_me : 1;
-};
-
-static void _e_desk_group_hooks_clean(void);
-static Eina_Bool _e_desk_group_hook_call(E_Desk_Group_Hook_Point hookpoint, E_Desk_Group *desk_group, void *appid);
-
-static Eina_Bool
-_check_desk_group_client_layer_validation(E_Desk_Group_Client_Layer edgc_layer)
-{
- if ((edgc_layer >= E_DESK_GROUP_CLIENT_LAYER_DESKTOP) &&
- (edgc_layer < E_DESK_GROUP_CLIENT_LAYER_MAX))
- return EINA_TRUE;
- else
- return EINA_FALSE;
-}
-
-static void
-_e_desk_group_ec_prepend(E_Desk_Group *edg, E_Client *ec)
-{
- E_Desk_Group_Client_Layer edgc_layer;
-
- edgc_layer = e_client_desk_group_client_layer_get(ec);
- if (!_check_desk_group_client_layer_validation(edgc_layer)) return;
-
- edg->ec_lists[edgc_layer] = eina_list_remove(edg->ec_lists[edgc_layer], ec);
- edg->ec_lists[edgc_layer] = eina_list_prepend(edg->ec_lists[edgc_layer], ec);
-
- e_client_desk_group_client_layer_set(ec, edgc_layer);
-}
-
-static void
-_e_desk_group_ec_append(E_Desk_Group *edg, E_Client *ec)
-{
- E_Desk_Group_Client_Layer edgc_layer;
-
- edgc_layer = e_client_desk_group_client_layer_get(ec);
- if (!_check_desk_group_client_layer_validation(edgc_layer)) return;
-
- edg->ec_lists[edgc_layer] = eina_list_remove(edg->ec_lists[edgc_layer], ec);
- edg->ec_lists[edgc_layer] = eina_list_append(edg->ec_lists[edgc_layer], ec);
-
- e_client_desk_group_client_layer_set(ec, edgc_layer);
-}
-
-static void
-_e_desk_group_ec_prepend_relative(E_Desk_Group *edg, E_Client *ec, E_Client *above)
-{
- E_Desk_Group_Client_Layer edgc_layer;
- E_Desk_Group_Client_Layer above_edgc_layer;
-
- // update edg's ec_list order
- edgc_layer = e_client_desk_group_client_layer_get(ec);
- if (!_check_desk_group_client_layer_validation(edgc_layer)) return;
- above_edgc_layer = e_client_desk_group_client_layer_get(above);
- if (!_check_desk_group_client_layer_validation(above_edgc_layer)) return;
-
- ELOGF("EDG", "STACK_ABOVE... edg:%p. layer:%d, above(win:%zx, ec:%p, layer:%d)", ec, edg, edgc_layer, e_client_util_win_get(above), above, above_edgc_layer);
-
- if (edgc_layer == above_edgc_layer)
- {
- edg->ec_lists[edgc_layer] = eina_list_remove(edg->ec_lists[edgc_layer], ec);
- edg->ec_lists[edgc_layer] = eina_list_prepend_relative(edg->ec_lists[edgc_layer], ec, above);
- }
- else
- {
- edg->ec_lists[edgc_layer] = eina_list_remove(edg->ec_lists[edgc_layer], ec);
- edg->ec_lists[above_edgc_layer] = eina_list_prepend_relative(edg->ec_lists[above_edgc_layer], ec, above);
- }
-
- e_client_desk_group_client_layer_set(ec, above_edgc_layer);
-}
-
-static void
-_e_desk_group_ec_append_relative(E_Desk_Group *edg, E_Client *ec, E_Client *below)
-{
- E_Desk_Group_Client_Layer edgc_layer;
- E_Desk_Group_Client_Layer below_edgc_layer;
-
- // update edg's ec_list order
- edgc_layer = e_client_desk_group_client_layer_get(ec);
- if (!_check_desk_group_client_layer_validation(edgc_layer)) return;
- below_edgc_layer = e_client_desk_group_client_layer_get(below);
- if (!_check_desk_group_client_layer_validation(below_edgc_layer)) return;
-
- ELOGF("EDG", "STACK_BELOW... edg:%p. layer:%d, below(win:%zx, ec:%p, layer:%d)", ec, edg, edgc_layer, e_client_util_win_get(below), below, below_edgc_layer);
-
- if (edgc_layer == below_edgc_layer)
- {
- edg->ec_lists[edgc_layer] = eina_list_remove(edg->ec_lists[edgc_layer], ec);
- edg->ec_lists[edgc_layer] = eina_list_append_relative(edg->ec_lists[edgc_layer], ec, below);
- }
- else
- {
- edg->ec_lists[edgc_layer] = eina_list_remove(edg->ec_lists[edgc_layer], ec);
- edg->ec_lists[below_edgc_layer] = eina_list_append_relative(edg->ec_lists[below_edgc_layer], ec, below);
- }
-
- e_client_desk_group_client_layer_set(ec, below_edgc_layer);
-}
-
-static void
-_e_desk_geometry_info_set(E_Desk_Group *edg, int x, int y, int w, int h)
-{
- E_Desk *desk;
-
- if (!edg) return;
- if (!edg->desk) return;
-
- desk = edg->desk;
-
- edg->x = x;
- edg->y = y;
- edg->w = w;
- edg->h = h;
-
- edg->scale_w = (double)w / (double)desk->geom.w;
- edg->scale_h = (double)h / (double)desk->geom.h;
-}
-
-static void
-_e_desk_group_active_change(E_Desk_Group *edg, E_Desk *desk)
-{
- E_Desk_Group *prev_active_edg;
-
- if (!desk) return;
-
- prev_active_edg = e_desk_desk_group_active_get(desk);
- if (prev_active_edg == edg) return;
-
- // 1. reset current active edg info
- if (prev_active_edg)
- prev_active_edg->active = EINA_FALSE;
-
- // 2. set new active edg info
- if (edg)
- {
- edg->active = EINA_TRUE;
- e_desk_desk_group_active_set(desk, edg);
- }
- else
- {
- e_desk_desk_group_active_set(desk, NULL);
- }
-}
-
-static void
-_e_desk_group_cb_hook_subsurface_create(void *data, E_Client *ec)
-{
- EINA_SAFETY_ON_NULL_RETURN(ec);
-
- if (ec->desk_group.transform)
- {
- e_client_transform_core_remove(ec, ec->desk_group.transform);
- }
-}
-
-EINTERN int
-e_desk_group_init(void)
-{
- return 1;
-}
-
-EINTERN int
-e_desk_group_shutdown(void)
-{
- return 1;
-}
-
-EINTERN E_Desk_Group *
-e_desk_group_new(E_Desk *desk, int id, int x, int y, int w, int h, E_Desk_Group_Layer layer)
-{
- E_Desk_Group *edg;
-
- E_OBJECT_CHECK_RETURN(desk, NULL);
- E_OBJECT_TYPE_CHECK_RETURN(desk, E_DESK_TYPE, NULL);
-
- edg = E_NEW(E_Desk_Group, 1);
- if (!edg) return NULL;
-
- edg->desk = desk;
- edg->id = id;
-
- _e_desk_geometry_info_set(edg, x, y, w, h);
-
- edg->layer = layer;
-
- edg->hook_subsurf_create = e_comp_wl_hook_add(E_COMP_WL_HOOK_SUBSURFACE_CREATE,
- _e_desk_group_cb_hook_subsurface_create,
- NULL);
-
- return edg;
-}
-
-EINTERN void
-e_desk_group_del(E_Desk_Group *edg)
-{
- if (!edg) return;
-
- for (int i=0; i<E_DESK_GROUP_CLIENT_LAYER_MAX; i++)
- {
- eina_list_free(edg->ec_lists[i]);
- }
-
- if (edg->active)
- _e_desk_group_active_change(NULL, edg->desk);
-
- E_FREE_FUNC(edg->hook_subsurf_create, e_comp_wl_hook_del);
-
- E_FREE(edg);
-}
-
-void _e_desk_group_ec_geometry_apply(E_Desk_Group *edg, E_Client *ec)
-{
- E_Maximize max;
- E_Util_Transform *transform;
-
- if (e_comp_wl_subsurface_check(ec))
- return;
-
- transform = ec->desk_group.transform;
-
- if (edg->transform_enabled)
- {
- if (!transform) return;
-
- e_util_transform_move(transform, edg->x, edg->y, 0);
- e_util_transform_scale(transform, edg->scale_w, edg->scale_h, 1.0);
- e_client_transform_core_add(ec, transform);
-
- e_client_transform_core_update(ec);
- }
- else
- {
- if (transform)
- {
- e_util_transform_move(transform, 0, 0, 0);
- e_util_transform_scale(transform, 1.0, 1.0, 1.0);
- e_client_transform_core_remove(ec, transform);
-
- e_client_transform_core_update(ec);
- }
-
- max = ec->maximized;
- ec->maximized = E_MAXIMIZE_NONE;
- e_client_maximize(ec, max);
- }
-}
-
-void _e_desk_group_ec_geometry_restore(E_Desk_Group *edg, E_Client *ec)
-{
- e_client_transform_core_update(ec);
-}
-
-void _e_desk_group_enable(E_Desk_Group *edg)
-{
- int i;
- E_Client *ec;
- Eina_List *l;
- Eina_List *list;
-
- if (!edg) return;
-
- for (i=0; i<E_DESK_GROUP_CLIENT_LAYER_MAX; i++)
- {
- list = eina_list_clone(edg->ec_lists[i]);
- EINA_LIST_REVERSE_FOREACH(list, l, ec)
- {
- e_client_desk_group_enable_set(ec, EINA_TRUE);
- }
- eina_list_free(list);
- list = NULL;
- }
-}
-
-void _e_desk_group_disable(E_Desk_Group *edg)
-{
- int i;
- E_Client *ec;
- Eina_List *l = NULL;
- Eina_List *list = NULL;
-
- for (i=0; i<E_DESK_GROUP_CLIENT_LAYER_MAX; i++)
- {
- list = eina_list_clone(edg->ec_lists[i]);
- EINA_LIST_REVERSE_FOREACH(list, l, ec)
- {
- // unset ec's desk_group enable flag
- e_client_desk_group_enable_set(ec, EINA_FALSE);
- // restore original ec->layer
- e_client_desk_group_original_layer_restore(ec);
- // restore ec's original geometry (changing real geometry or using transform)
- _e_desk_group_ec_geometry_restore(edg, ec);
-
- e_client_desk_group_set(ec, NULL);
- }
- eina_list_free(list);
- list = NULL;
-
- eina_list_free(edg->ec_lists[i]);
- edg->ec_lists[i] = NULL;
- }
-}
-
-EINTERN Eina_Bool
-e_desk_group_enable_set(E_Desk_Group *edg, Eina_Bool enable)
-{
- if (!edg) return EINA_FALSE;
-
- edg->enable = enable;
- if (enable)
- {
- _e_desk_group_enable(edg);
- }
- else
- {
- _e_desk_group_disable(edg);
- }
-
- return EINA_TRUE;
-}
-
-E_API Eina_Bool
-e_desk_group_geometry_set(E_Desk_Group *edg, int x, int y, int w, int h)
-{
- if (!edg) return EINA_FALSE;
-
- _e_desk_geometry_info_set(edg, x, y, w, h);
-
- return EINA_TRUE;
-}
-
-E_API Eina_Bool
-e_desk_group_geometry_get(E_Desk_Group *edg, int *x, int *y, int *w, int *h)
-{
- if (!edg) return EINA_FALSE;
-
- if (x) *x = edg->x;
- if (y) *y = edg->y;
- if (w) *w = edg->w;
- if (h) *h = edg->h;
-
- return EINA_TRUE;
-}
-
-EINTERN Eina_Bool
-e_desk_group_layer_set(E_Desk_Group *edg, E_Desk_Group_Layer layer)
-{
- if (!edg) return EINA_FALSE;
-
- edg->layer = layer;
- return EINA_TRUE;
-}
-
-E_API E_Desk_Group_Layer
-e_desk_group_layer_get(E_Desk_Group *edg)
-{
- if (!edg) return E_DESK_GROUP_LAYER_NORMAL;
-
- return edg->layer;
-}
-
-E_API void
-e_desk_group_activate(E_Desk_Group *edg)
-{
- if (!edg) return;
- if (!edg->desk) return;
-
- e_desk_group_raise(edg);
- _e_desk_group_active_change(edg, edg->desk);
-}
-
-E_API Eina_Bool
-e_desk_group_is_activate(E_Desk_Group *edg)
-{
- if (!edg) return EINA_FALSE;
- return edg->active;
-}
-
-E_API void
-e_desk_group_raise(E_Desk_Group *edg)
-{
- int i;
- E_Client *ec;
- Eina_List *l = NULL;
- Eina_List *ll = NULL;
-
- if (!edg) return;
-
- for (i=0; i<E_DESK_GROUP_CLIENT_LAYER_MAX; i++)
- {
- EINA_LIST_REVERSE_FOREACH_SAFE(edg->ec_lists[i], l, ll, ec)
- {
- evas_object_raise(ec->frame);
- }
- }
-}
-
-E_API void
-e_desk_group_lower(E_Desk_Group *edg)
-{
- int i;
- E_Client *ec;
- Eina_List *l = NULL;
- Eina_List *ll = NULL;
-
- if (!edg) return;
-
- for (i=E_DESK_GROUP_CLIENT_LAYER_MAX-1; i>=0; i--)
- {
- //EINA_LIST_FOREACH(edg->ec_lists[i], l, ec)
- EINA_LIST_FOREACH_SAFE(edg->ec_lists[i], l, ll, ec)
- {
- evas_object_lower(ec->frame);
- }
- }
-}
-
-
-static E_Desk_Group_Client_Layer
-_e_desk_group_client_layer_convert_from_layer(E_Layer layer)
-{
- E_Desk_Group_Client_Layer edg_layer;
-
- if (layer <= E_LAYER_CLIENT_DESKTOP)
- edg_layer = E_DESK_GROUP_CLIENT_LAYER_DESKTOP;
- else if (layer <= E_LAYER_CLIENT_BELOW)
- edg_layer = E_DESK_GROUP_CLIENT_LAYER_BELOW;
- else if (layer <= E_LAYER_CLIENT_NORMAL)
- edg_layer = E_DESK_GROUP_CLIENT_LAYER_NORMAL;
- else if (layer <= E_LAYER_CLIENT_ABOVE)
- edg_layer = E_DESK_GROUP_CLIENT_LAYER_ABOVE;
- else if (layer <= E_LAYER_CLIENT_NOTIFICATION_LOW)
- edg_layer = E_DESK_GROUP_CLIENT_LAYER_NOTIFICATION_LOW;
- else if (layer <= E_LAYER_CLIENT_NOTIFICATION_NORMAL)
- edg_layer = E_DESK_GROUP_CLIENT_LAYER_NOTIFICATION_NORMAL;
- else if (layer <= E_LAYER_CLIENT_NOTIFICATION_HIGH)
- edg_layer = E_DESK_GROUP_CLIENT_LAYER_NOTIFICATION_HIGH;
- else if (layer <= E_LAYER_CLIENT_NOTIFICATION_TOP)
- edg_layer = E_DESK_GROUP_CLIENT_LAYER_NOTIFICATION_TOP;
- else
- edg_layer = E_DESK_GROUP_CLIENT_LAYER_ALERT;
-
- return edg_layer;
-}
-
-E_API Eina_Bool
-e_desk_group_ec_add(E_Desk_Group *edg, E_Client *ec)
-{
- E_Desk_Group_Client_Layer edgc_layer;
- E_Layer layer;
-
- if (!edg) return EINA_FALSE;
- if (!ec) return EINA_FALSE;
-
-
- layer = e_client_desk_group_original_layer_get(ec);
- edgc_layer = _e_desk_group_client_layer_convert_from_layer(layer);
-
- edg->ec_lists[edgc_layer] = eina_list_prepend(edg->ec_lists[edgc_layer], ec);
-
- e_client_desk_group_client_layer_set(ec, edgc_layer);
-
- return EINA_TRUE;
-}
-
-E_API void
-e_desk_group_ec_remove(E_Desk_Group *edg, E_Client *ec)
-{
- E_Desk_Group_Client_Layer edgc_layer;
-
- if (!edg) return;
- if (!ec) return;
-
- edgc_layer = e_client_desk_group_client_layer_get(ec);
- if (!_check_desk_group_client_layer_validation(edgc_layer)) return;
-
- edg->ec_lists[edgc_layer] = eina_list_remove(edg->ec_lists[edgc_layer], ec);
-}
-
-static E_Client *
-_find_above_ec_in_same_edgc_layer(E_Desk_Group *edg, E_Client *ec)
-{
- Eina_List *l;
- E_Client *above = NULL;
- E_Client *temp = NULL;
- E_Desk_Group_Client_Layer edgc_layer;
- Eina_Bool find = EINA_FALSE;
-
- edgc_layer = e_client_desk_group_client_layer_get(ec);
- if (!_check_desk_group_client_layer_validation(edgc_layer)) return NULL;
-
- EINA_LIST_REVERSE_FOREACH(edg->ec_lists[edgc_layer], l, temp)
- {
- if (find)
- {
- above = temp;
- break;
- }
-
- if (temp == ec)
- {
- find = EINA_TRUE;
- }
- }
-
- // TODO: do we need check below->frame???
-
- return above;
-}
-
-static E_Client *
-_find_bottom_ec_in_above_edgc_layer(E_Desk_Group *edg, E_Client *ec)
-{
- Eina_List *l;
- E_Client *bottom = NULL;
- E_Desk_Group_Client_Layer edgc_layer;
- int i;
-
- edgc_layer = e_client_desk_group_client_layer_get(ec);
- if (!_check_desk_group_client_layer_validation(edgc_layer)) return NULL;
-
- for (i = edgc_layer+1; i < E_DESK_GROUP_CLIENT_LAYER_MAX; i++)
- {
- EINA_LIST_REVERSE_FOREACH(edg->ec_lists[i], l, bottom)
- {
- // TODO: do we need check below->frame???
- if (bottom)
- return bottom;
- }
- }
-
- return NULL;
-}
-
-static E_Client *
-_find_bottom_ec_in_above_edg(E_Desk_Group *edg)
-{
- E_Desk_Group *above_edg = NULL;
- E_Client *bottom = NULL;
- Eina_List *l;
- int i;
-
- above_edg = e_desk_desk_group_above_get(edg->desk, edg);
- while (above_edg)
- {
- for (i=E_DESK_GROUP_CLIENT_LAYER_DESKTOP; i<E_DESK_GROUP_CLIENT_LAYER_MAX; i++)
- {
- EINA_LIST_REVERSE_FOREACH(above_edg->ec_lists[i], l, bottom)
- {
- if (bottom)
- goto find_bottom;
- }
- }
-
- bottom = NULL;
- above_edg = e_desk_desk_group_above_get(above_edg->desk, above_edg);
- }
-
-find_bottom:
- return bottom;
-}
-
-static E_Client *
-_find_below_ec_in_same_edgc_layer(E_Desk_Group *edg, E_Client *ec)
-{
- Eina_List *l;
- E_Client *below = NULL;
- E_Client *temp = NULL;
- E_Desk_Group_Client_Layer edgc_layer;
- Eina_Bool find = EINA_FALSE;
-
- edgc_layer = e_client_desk_group_client_layer_get(ec);
- if (!_check_desk_group_client_layer_validation(edgc_layer)) return NULL;
-
- EINA_LIST_FOREACH(edg->ec_lists[edgc_layer], l, temp)
- {
- if (find)
- {
- below = temp;
- break;
- }
-
- if (temp == ec)
- {
- find = EINA_TRUE;
- }
- }
-
- // TODO: do we need check below->frame???
-
- return below;
-}
-
-static E_Client *
-_find_top_ec_in_below_edgc_layer(E_Desk_Group *edg, E_Client *ec)
-{
- Eina_List *l;
- E_Client *top = NULL;
- E_Desk_Group_Client_Layer edgc_layer;
- int i;
-
- edgc_layer = e_client_desk_group_client_layer_get(ec);
- if (!_check_desk_group_client_layer_validation(edgc_layer)) return NULL;
-
- for (i = edgc_layer-1; i >= E_DESK_GROUP_CLIENT_LAYER_DESKTOP; i--)
- {
- EINA_LIST_FOREACH(edg->ec_lists[i], l, top)
- {
- // TODO: do we need check top->frame???
- if (top)
- return top;
- }
- }
-
- return NULL;
-}
-
-static E_Client *
-_find_top_ec_in_below_edg(E_Desk_Group *edg)
-{
- E_Desk_Group *below_edg = NULL;
- E_Client *top = NULL;
- Eina_List *l;
- int i;
-
- below_edg = e_desk_desk_group_below_get(edg->desk, edg);
- while (below_edg)
- {
- for (i=E_DESK_GROUP_CLIENT_LAYER_MAX-1; i>=E_DESK_GROUP_CLIENT_LAYER_DESKTOP; i--)
- {
- EINA_LIST_FOREACH(below_edg->ec_lists[i], l, top)
- {
- if (top)
- goto find_top;
- }
- }
-
- top = NULL;
- below_edg = e_desk_desk_group_below_get(below_edg->desk, below_edg);
- }
-
-find_top:
- return top;
-}
-
-EINTERN void
-e_desk_group_ec_raise(E_Desk_Group *edg, E_Client *ec)
-{
- E_Client *below = NULL;
- E_Client *above = NULL;
-
- if (!edg) return;
- if (!ec) return;
-
- ELOGF("EDG", "RAISE... edg:%p", ec, edg);
-
- _e_desk_group_ec_prepend(edg, ec);
-
- // 1. find below ec in same edgc layer in same edg
- below = _find_below_ec_in_same_edgc_layer(edg, ec);
- if (below) goto find_below;
-
- // 2. find above ec in same edgc layer in same edg
- above = _find_above_ec_in_same_edgc_layer(edg, ec);
- if (above) goto find_above;
-
- // 3. find bottom ec in above edgc layer in same edg
- above = _find_bottom_ec_in_above_edgc_layer(edg, ec);
- if (above) goto find_above;
-
- // 4. find bottom ec in above edg
- above = _find_bottom_ec_in_above_edg(edg);
- if (above) goto find_above;
-
- // 5. if not found, just evas_object_raise
- ELOGF("EDG", "RAISE... call evas_object_raise", ec);
- evas_object_raise(ec->frame);
- return;
-
-find_below:
- if (below)
- {
- ELOGF("EDG", "STACK_ABOVE... below(win:0x%08zx, ec:%p)", ec, e_client_util_win_get(below), below);
- if (below->frame)
- {
- ELOGF("EDG", "STACK_ABOVE... call evas_object_stack_above", ec);
- evas_object_stack_above(ec->frame, below->frame);
- }
- }
- return;
-
-find_above:
- if (above)
- {
- ELOGF("EDG", "STACK_BELOW... above(win:0x%08zx, ec:%p)", ec, e_client_util_win_get(above), above);
- if (above->frame)
- {
- ELOGF("EDG", "STACK_BELOW... call evas_object_stack_below", ec);
- evas_object_stack_below(ec->frame, above->frame);
- }
- }
- return;
-}
-
-EINTERN void
-e_desk_group_ec_lower(E_Desk_Group *edg, E_Client *ec)
-{
- E_Client *above = NULL;
- E_Client *below = NULL;
-
- if (!edg) return;
- if (!ec) return;
-
- ELOGF("EDG", "LOWER... edg:%p", ec, edg);
-
- _e_desk_group_ec_append(edg, ec);
-
- // 1. find above ec in same edgc layer in same edg
- above = _find_above_ec_in_same_edgc_layer(edg, ec);
- if (above) goto find_above;
-
- // 2. find below ec in same edgc layer in same edg
- below = _find_below_ec_in_same_edgc_layer(edg, ec);
- if (below) goto find_below;
-
- // 3. find top ec in below edgc layer in same edg
- below = _find_top_ec_in_below_edgc_layer(edg, ec);
- if (below) goto find_below;
-
- // 4. find top ec in below edg
- below = _find_top_ec_in_below_edg(edg);
- if (below) goto find_below;
-
- // 5. if not found, just evas_object_raise
- ELOGF("EDG", "LOWER... call evas_object_raise", ec);
- evas_object_lower(ec->frame);
- return;
-
-find_below:
- if (below)
- {
- ELOGF("EDG", "STACK_ABOVE... below(win:0x%08zx, ec:%p)", ec, e_client_util_win_get(below), below);
- if (below->frame)
- {
- ELOGF("EDG", "STACK_ABOVE... call evas_object_stack_above", ec);
- evas_object_stack_above(ec->frame, below->frame);
- }
- }
- return;
-
-find_above:
- if (above)
- {
- ELOGF("EDG", "STACK_BELOW... above(win:0x%08zx, ec:%p)", ec, e_client_util_win_get(above), above);
- if (above->frame)
- {
- ELOGF("EDG", "STACK_BELOW... call evas_object_stack_below", ec);
- evas_object_stack_below(ec->frame, above->frame);
- }
- }
- return;
-}
-
-EINTERN void
-e_desk_group_ec_stack_above(E_Desk_Group *edg, E_Client *ec, E_Client *above)
-{
- if (!edg) return;
- if (!ec) return;
- if (!ec->frame) return;
- if (!above) return;
- if (!above->frame) return;
-
- _e_desk_group_ec_prepend_relative(edg, ec, above);
-
- evas_object_stack_above(ec->frame, above->frame);
-}
-
-EINTERN void
-e_desk_group_ec_stack_below(E_Desk_Group *edg, E_Client *ec, E_Client *below)
-{
- if (!edg) return;
- if (!ec) return;
- if (!ec->frame) return;
- if (!below) return;
- if (!below->frame) return;
-
- _e_desk_group_ec_append_relative(edg, ec, below);
-
- evas_object_stack_below(ec->frame, below->frame);
-}
-
-EINTERN void
-e_desk_group_ec_layer_set(E_Desk_Group *edg, E_Client *ec, E_Layer layer)
-{
- E_Desk_Group_Client_Layer edg_layer;
-
- if (!edg) return;
- if (!ec) return;
-
- // save original layer
-
- edg_layer = edg->layer;
- evas_object_layer_set(ec->frame, edg_layer);
-}
-
-static void
-_e_desk_group_ec_restack(E_Desk_Group *edg, E_Client *ec)
-{
- E_Client *above = NULL, *below = NULL;
-
- // 1. find below ec in same edgc layer in same edg
- below = _find_below_ec_in_same_edgc_layer(edg, ec);
- if (below) goto find_below;
-
- // 2. find above ec in same edgc layer in same edg
- above = _find_above_ec_in_same_edgc_layer(edg, ec);
- if (above) goto find_above;
-
- // 3. find bottom ec in above edgc layer in same edg
- above = _find_bottom_ec_in_above_edgc_layer(edg, ec);
- if (above) goto find_above;
-
- // 4. find bottom ec in above edg
- above = _find_bottom_ec_in_above_edg(edg);
- if (above) goto find_above;
-
- // 5. if not found, just evas_object_raise
- ELOGF("EDG", "RESTACK raise... call evas_object_raise", ec);
- evas_object_raise(ec->frame);
- return;
-
-find_below:
- if (below)
- {
- ELOGF("EDG", "STACK_ABOVE... below(win:0x%08zx, ec:%p)", ec, e_client_util_win_get(below), below);
- if (below->frame)
- {
- ELOGF("EDG", "STACK_ABOVE... call evas_object_stack_above", ec);
- evas_object_stack_above(ec->frame, below->frame);
- }
- }
- return;
-
-find_above:
- if (above)
- {
- ELOGF("EDG", "STACK_BELOW... above(win:0x%08zx, ec:%p)", ec, e_client_util_win_get(above), above);
- if (above->frame)
- {
- ELOGF("EDG", "STACK_BELOW... call evas_object_stack_below", ec);
- evas_object_stack_below(ec->frame, above->frame);
- }
- }
- return;
-}
-
-EINTERN void
-e_desk_group_ec_rearrange(E_Desk_Group *edg, E_Client *ec)
-{
- E_Layer layer;
- E_Desk_Group_Client_Layer edgc_layer, prev_edgc_layer;
-
- ELOGF("EDG", "RE-ARRANGE... edg:%p", ec, edg);
-
- if (!edg) return;
- if (!ec) return;
-
- prev_edgc_layer = e_client_desk_group_client_layer_get(ec);
- if (!_check_desk_group_client_layer_validation(prev_edgc_layer)) return;
-
- edg->ec_lists[prev_edgc_layer] = eina_list_remove(edg->ec_lists[prev_edgc_layer], ec);
-
- layer = e_client_desk_group_original_layer_get(ec);
- edgc_layer = _e_desk_group_client_layer_convert_from_layer(layer);
- edg->ec_lists[edgc_layer] = eina_list_prepend(edg->ec_lists[edgc_layer], ec);
-
- e_client_desk_group_client_layer_set(ec, edgc_layer);
-
- _e_desk_group_ec_restack(edg, ec);
-}
-
-EINTERN void
-e_desk_group_ec_stack_change(E_Desk_Group *edg, E_Client *ec)
-{
-}
-
-E_API void
-e_desk_group_ec_update(E_Desk_Group *edg, E_Client *ec)
-{
- E_Layer layer;
-
- if (!edg) return;
- if (!ec) return;
-
- layer = e_client_desk_group_original_layer_get(ec);
-
- // update stack
- e_client_layer_set_by_desk_group(ec, layer);
-
- // update geometry
- _e_desk_group_ec_geometry_apply(edg, ec);
-}
-
-E_API void
-e_desk_group_all_ec_update(E_Desk_Group *edg)
-{
- int i;
- E_Client *ec;
- Eina_List *l;
- Eina_List *list;
-
- if (!edg) return;
-
- for (i=0; i<E_DESK_GROUP_CLIENT_LAYER_MAX; i++)
- {
- list = eina_list_clone(edg->ec_lists[i]);
-
- EINA_LIST_REVERSE_FOREACH(list, l, ec)
- {
- e_desk_group_ec_update(edg, ec);
- }
-
- eina_list_free(list);
- list = NULL;
- }
-}
-
-E_API Eina_List *
-e_desk_group_ec_list_get(E_Desk_Group *edg)
-{
- if (!edg) return NULL;
-
- return NULL;
-}
-
-E_API void
-e_desk_group_transform_enable_set(E_Desk_Group *edg, Eina_Bool enable)
-{
- if (!edg) return;
-
- edg->transform_enabled = enable;
-}
-
-E_API Eina_Bool
-e_desk_group_transform_enable_get(E_Desk_Group *edg)
-{
- if (!edg) return EINA_FALSE;
-
- return edg->transform_enabled;
-}
-
-
-// for debug
-EINTERN void
-e_desk_group_info_print(E_Desk_Group *edg)
-{
- Eina_List *l;
- E_Client *ec;
-
- if (!edg) return;
-
- ELOGF("EDG_INFO", "===========================================", NULL);
- ELOGF("EDG_INFO", "E_Desk_Group(%p), ID(%d), Geo(%d,%d,%d,%d), Layer:%d", NULL, edg, edg->id, edg->x, edg->y, edg->w, edg->h, edg->layer);
- ELOGF("EDG_INFO", "-------------------------------------------", NULL);
- for (int i=E_DESK_GROUP_CLIENT_LAYER_MAX-1; i>=0; i--)
- {
- EINA_LIST_FOREACH(edg->ec_lists[i], l, ec)
- {
- ELOGF("EDG_INFO", "EDG_Layer[%d] Win:0x%08zx, EC:%p, frame:%p, ec->layer:%d, org_layer:%d, name:%s", NULL, i, e_client_util_win_get(ec), ec, ec->frame, ec->layer, ec->desk_group.layer_backup, ec->icccm.title ? ec->icccm.title:"NO NAME");
- }
- }
- ELOGF("EDG_INFO", "===========================================", NULL);
-}
-
-static void
-_e_desk_group_hooks_clean(void)
-{
- Eina_Inlist *l;
- E_Desk_Group_Hook *dgh;
- unsigned int x;
-
- for (x = 0; x < E_DESK_GROUP_HOOK_LAST; x++)
- EINA_INLIST_FOREACH_SAFE(_e_desk_group_hooks[x], l, dgh)
- {
- if (!dgh->delete_me) continue;
- _e_desk_group_hooks[x] = eina_inlist_remove(_e_desk_group_hooks[x], EINA_INLIST_GET(dgh));
- free(dgh);
- }
-
- _e_desk_group_hooks_delete = 0;
-}
-
-static Eina_Bool
-_e_desk_group_hook_call(E_Desk_Group_Hook_Point hookpoint, E_Desk_Group *desk_group, void *data)
-{
- E_Desk_Group_Hook *dgh;
-
- e_object_ref(E_OBJECT(desk_group));
- _e_desk_group_hooks_walking++;
- EINA_INLIST_FOREACH(_e_desk_group_hooks[hookpoint], dgh)
- {
- if (dgh->delete_me) continue;
- dgh->func(dgh->data, desk_group, data);
- }
- _e_desk_group_hooks_walking--;
- if ((_e_desk_group_hooks_walking == 0) && (_e_desk_group_hooks_delete > 0))
- _e_desk_group_hooks_clean();
-
- return !!e_object_unref(E_OBJECT(desk_group));
-}
-
-EINTERN Eina_Bool
-e_desk_group_hook_call(E_Desk_Group *edg, E_Desk_Group_Hook_Point hookpoint, void *data)
-{
- return _e_desk_group_hook_call(hookpoint, edg, data);
-}
-
-E_API E_Desk_Group_Hook *
-e_desk_group_hook_add(E_Desk_Group_Hook_Point hookpoint,
- E_Desk_Group_Hook_Cb func, const void *data)
-{
- E_Desk_Group_Hook *dgh;
-
- EINA_SAFETY_ON_TRUE_RETURN_VAL(hookpoint >= E_DESK_GROUP_HOOK_LAST, NULL);
- dgh = E_NEW(E_Desk_Group_Hook, 1);
- if (!dgh) return NULL;
-
- dgh->hookpoint = hookpoint;
- dgh->func = func;
- dgh->data = (void*)data;
-
- _e_desk_group_hooks[hookpoint] =
- eina_inlist_append(_e_desk_group_hooks[hookpoint], EINA_INLIST_GET(dgh));
-
- return dgh;
-}
-
-E_API void
-e_desk_group_hook_del(E_Desk_Group_Hook * dgh)
-{
- dgh->delete_me = 1;
-
- if (_e_desk_group_hooks_walking == 0)
- {
- _e_desk_group_hooks[dgh->hookpoint] =
- eina_inlist_remove(_e_desk_group_hooks[dgh->hookpoint], EINA_INLIST_GET(dgh));
- free(dgh);
- }
- else
- _e_desk_group_hooks_delete++;
-}
\ No newline at end of file
+++ /dev/null
-#ifdef E_TYPEDEFS
-
-typedef struct _E_Desk_Group E_Desk_Group;
-typedef struct _E_Event_Desk_Group E_Event_Desk_Group;
-
-typedef enum _E_Desk_Group_Client_Layer
-{
- E_DESK_GROUP_CLIENT_LAYER_DESKTOP,
- E_DESK_GROUP_CLIENT_LAYER_BELOW,
- E_DESK_GROUP_CLIENT_LAYER_NORMAL,
- E_DESK_GROUP_CLIENT_LAYER_ABOVE,
- E_DESK_GROUP_CLIENT_LAYER_NOTIFICATION_LOW,
- E_DESK_GROUP_CLIENT_LAYER_NOTIFICATION_NORMAL,
- E_DESK_GROUP_CLIENT_LAYER_NOTIFICATION_HIGH,
- E_DESK_GROUP_CLIENT_LAYER_NOTIFICATION_TOP,
- E_DESK_GROUP_CLIENT_LAYER_ALERT,
- E_DESK_GROUP_CLIENT_LAYER_MAX,
-} E_Desk_Group_Client_Layer;
-
-#else
-#ifndef E_DESK_GROUP_H
-#define E_DESK_GROUP_H
-
-typedef struct _E_Desk_Group_Hook E_Desk_Group_Hook;
-
-typedef enum _E_Desk_Group_Hook_Point
-{
- E_DESK_GROUP_HOOK_SET_APPID,
- E_DESK_GROUP_HOOK_LAST
-} E_Desk_Group_Hook_Point;
-
-typedef void (*E_Desk_Group_Hook_Cb)(void *data, E_Desk_Group *desk_group, void *hook_data);
-
-struct _E_Desk_Group
-{
- E_Object e_obj_inherit;
-
- E_Desk *desk;
- int id;
- E_Desk_Group_Layer layer;
- Eina_Stringshare *name;
-
- int x, y, w, h;
- double scale_w, scale_h;
-
- unsigned char enable : 1;
- unsigned char visible : 1;
- unsigned char active : 1;
- unsigned char transform_enabled : 1;
- Eina_List *ec_lists[E_DESK_GROUP_CLIENT_LAYER_MAX];
-
- Eina_List *handlers;
-
- E_Comp_Wl_Hook *hook_subsurf_create;
-};
-
-struct _E_Event_Desk_Group
-{
- E_Desk_Group *edg;
-};
-
-EINTERN int e_desk_group_init(void);
-EINTERN int e_desk_group_shutdown(void);
-
-EINTERN E_Desk_Group *e_desk_group_new(E_Desk *desk, int id, int x, int y, int w, int h, E_Desk_Group_Layer layer);
-EINTERN void e_desk_group_del(E_Desk_Group *edg);
-
-EINTERN Eina_Bool e_desk_group_enable_set(E_Desk_Group *edg, Eina_Bool enable);
-
-E_API Eina_Bool e_desk_group_geometry_set(E_Desk_Group *edg, int x, int y, int w, int h);
-E_API Eina_Bool e_desk_group_geometry_get(E_Desk_Group *edg, int *x, int *y, int *w, int *h);
-
-EINTERN Eina_Bool e_desk_group_layer_set(E_Desk_Group *edg, E_Desk_Group_Layer layer);
-E_API E_Desk_Group_Layer e_desk_group_layer_get(E_Desk_Group *edg);
-
-E_API void e_desk_group_activate(E_Desk_Group *edg);
-E_API Eina_Bool e_desk_group_is_activate(E_Desk_Group *edg);
-
-E_API void e_desk_group_raise(E_Desk_Group *edg);
-E_API void e_desk_group_lower(E_Desk_Group *edg);
-
-
-E_API Eina_Bool e_desk_group_ec_add(E_Desk_Group *edg, E_Client *ec);
-E_API void e_desk_group_ec_remove(E_Desk_Group *edg, E_Client *ec);
-EINTERN void e_desk_group_ec_raise(E_Desk_Group *edg, E_Client *ec);
-EINTERN void e_desk_group_ec_lower(E_Desk_Group *edg, E_Client *ec);
-EINTERN void e_desk_group_ec_stack_above(E_Desk_Group *edg, E_Client *ec, E_Client *above);
-EINTERN void e_desk_group_ec_stack_below(E_Desk_Group *edg, E_Client *ec, E_Client *below);
-EINTERN void e_desk_group_ec_layer_set(E_Desk_Group *edg, E_Client *ec, E_Layer layer);
-EINTERN void e_desk_group_ec_rearrange(E_Desk_Group *edg, E_Client *ec);
-EINTERN void e_desk_group_ec_stack_change(E_Desk_Group *edg, E_Client *ec);
-
-E_API void e_desk_group_ec_update(E_Desk_Group *edg, E_Client *ec);
-E_API void e_desk_group_all_ec_update(E_Desk_Group *edg);
-
-E_API Eina_List *e_desk_group_ec_list_get(E_Desk_Group *edg);
-
-E_API void e_desk_group_transform_enable_set(E_Desk_Group *edg, Eina_Bool enable);
-E_API Eina_Bool e_desk_group_transform_enable_get(E_Desk_Group *edg);
-
-// for debug
-EINTERN void e_desk_group_info_print(E_Desk_Group *edg);
-
-EINTERN Eina_Bool e_desk_group_hook_call(E_Desk_Group *edg, E_Desk_Group_Hook_Point hookpoint, void *data);
-E_API E_Desk_Group_Hook *e_desk_group_hook_add(E_Desk_Group_Hook_Point hookpoint, E_Desk_Group_Hook_Cb func, const void *data);
-E_API void e_desk_group_hook_del(E_Desk_Group_Hook *dgh);
-
-extern E_API int E_EVENT_DESK_GROUP_CHANGE;
-
-#endif
-#endif
#include "e_comp_wl_video.h"
#include "e_comp_wl_video_buffer.h"
#include "e_msg.h"
-#include "e_desk_group.h"
+#include "e_desk_area.h"
#include "e_comp_wl_capture.h"
#include "e_comp_wl_tizen_hwc.h"
#include "e_comp_wl_renderer.h"
}
static void
-_e_info_client_proc_desk_group(int argc, char **argv)
+_e_info_client_proc_desk_area(int argc, char **argv)
{
const int offset = 2, base_cmd_len = 1;
Eina_Bool res = EINA_FALSE;
if (eina_streq(argv[offset], "info"))
{
- res = _e_info_client_eldbus_message("desk_group_info", NULL);
+ res = _e_info_client_eldbus_message("desk_area_info", NULL);
}
else if (eina_streq(argv[offset], "enable"))
{
if (enable == 1 || enable == 0)
{
- res = _e_info_client_eldbus_message_with_args("desk_group_enable", NULL, "i", enable);
+ res = _e_info_client_eldbus_message_with_args("desk_area_enable", NULL, "i", enable);
}
}
else if (eina_streq(argv[offset], "make_sub1"))
h = atoi(argv[offset + base_cmd_len + 3]);
layer = atoi(argv[offset + base_cmd_len + 4]);
- res = _e_info_client_eldbus_message_with_args("desk_group_new_sub1", NULL, "iiiii", x, y, w, h, layer);
+ res = _e_info_client_eldbus_message_with_args("desk_area_new_sub1", NULL, "iiiii", x, y, w, h, layer);
}
else if (eina_streq(argv[offset], "make_sub2"))
{
h = atoi(argv[offset + base_cmd_len + 3]);
layer = atoi(argv[offset + base_cmd_len + 4]);
- res = _e_info_client_eldbus_message_with_args("desk_group_new_sub2", NULL, "iiiii", x, y, w, h, layer);
+ res = _e_info_client_eldbus_message_with_args("desk_area_new_sub2", NULL, "iiiii", x, y, w, h, layer);
}
else if (eina_streq(argv[offset], "remove_sub1"))
{
uint32_t id = 1;
- res = _e_info_client_eldbus_message_with_args("desk_group_remove_sub", NULL, "i", id);
+ res = _e_info_client_eldbus_message_with_args("desk_area_remove_sub", NULL, "i", id);
}
else if (eina_streq(argv[offset], "remove_sub2"))
{
uint32_t id = 2;
- res = _e_info_client_eldbus_message_with_args("desk_group_remove_sub", NULL, "i", id);
+ res = _e_info_client_eldbus_message_with_args("desk_area_remove_sub", NULL, "i", id);
}
else if (eina_streq(argv[offset], "raise_base"))
{
if (raise == 1 || raise == 0)
{
- res = _e_info_client_eldbus_message_with_args("desk_group_base_raise", NULL, "i", raise);
+ res = _e_info_client_eldbus_message_with_args("desk_area_base_raise", NULL, "i", raise);
}
}
else if (eina_streq(argv[offset], "raise_sub1"))
if (raise == 1 || raise == 0)
{
- res = _e_info_client_eldbus_message_with_args("desk_group_sub1_raise", NULL, "i", raise);
+ res = _e_info_client_eldbus_message_with_args("desk_area_sub1_raise", NULL, "i", raise);
}
}
else if (eina_streq(argv[offset], "raise_sub2"))
if (raise == 1 || raise == 0)
{
- res = _e_info_client_eldbus_message_with_args("desk_group_sub2_raise", NULL, "i", raise);
+ res = _e_info_client_eldbus_message_with_args("desk_area_sub2_raise", NULL, "i", raise);
}
}
else if (eina_streq(argv[offset], "check_stack"))
{
- res = _e_info_client_eldbus_message("desk_group_check_stack", NULL);
+ res = _e_info_client_eldbus_message("desk_area_check_stack", NULL);
}
else
return;
arg_err:
- printf("Usage: enlightenment_info -desk_group -h\n");
+ printf("Usage: enlightenment_info -desk_area -h\n");
}
static void
_e_info_client_proc_apply_filter
},
{
- "desk_group",
- USAGE_DESK_GROUP,
+ "desk_area",
+ USAGE_DESK_AREA,
"Get information or Enable/Disable functionality for desk group",
- _e_info_client_proc_desk_group
+ _e_info_client_proc_desk_area
},
{
"gcov",
return reply;
}
-static E_Desk_Group *_edg_sub1 = NULL;
-static E_Desk_Group *_edg_sub2 = NULL;
+static E_Desk_Area *_edg_sub1 = NULL;
+static E_Desk_Area *_edg_sub2 = NULL;
static Eldbus_Message *
-_e_info_server_cb_desk_group_info(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+_e_info_server_cb_desk_area_info(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
{
Eldbus_Message *reply = eldbus_message_method_return_new(msg);
E_Zone *zone;
zone = e_zone_current_get();
desk = e_desk_current_get(zone);
- e_desk_desk_group_info_print(desk);
+ e_desk_desk_area_info_print(desk);
return reply;
}
static Eldbus_Message *
-_e_info_server_cb_desk_group_enable(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+_e_info_server_cb_desk_area_enable(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
{
Eldbus_Message *reply = eldbus_message_method_return_new(msg);
uint32_t enable;
if (enable == 1)
{
- e_desk_desk_group_enable(e_desk_current_get(e_zone_current_get()));
+ e_desk_desk_area_enable(e_desk_current_get(e_zone_current_get()));
}
else if (enable == 0)
{
- e_desk_desk_group_disable(e_desk_current_get(e_zone_current_get()));
+ e_desk_desk_area_disable(e_desk_current_get(e_zone_current_get()));
}
return reply;
}
-static void _desk_group_new(int sub_edg_id, int x, int y, int w, int h, int layer)
+static void _desk_area_new(int sub_edg_id, int x, int y, int w, int h, int layer)
{
E_Zone *zone;
E_Desk *desk;
- E_Desk_Group_Layer edg_layer;
+ E_Desk_Area_Layer edg_layer;
zone = e_zone_current_get();
desk = e_desk_current_get(zone);
switch (layer)
{
- case 0: edg_layer = E_DESK_GROUP_LAYER_BACKGROUND; break;
- case 1: edg_layer = E_DESK_GROUP_LAYER_NORMAL_BELOW; break;
- case 2: edg_layer = E_DESK_GROUP_LAYER_NORMAL; break;
- case 3: edg_layer = E_DESK_GROUP_LAYER_NORMAL_ABOVE; break;
- case 4: edg_layer = E_DESK_GROUP_LAYER_NOTIFICATION_LOW; break;
- case 5: edg_layer = E_DESK_GROUP_LAYER_NOTIFICATION_NORMAL; break;
- case 6: edg_layer = E_DESK_GROUP_LAYER_NOTIFICATION_HIGH; break;
- default: edg_layer = E_DESK_GROUP_LAYER_NORMAL; break;
+ case 0: edg_layer = E_DESK_AREA_LAYER_BACKGROUND; break;
+ case 1: edg_layer = E_DESK_AREA_LAYER_NORMAL_BELOW; break;
+ case 2: edg_layer = E_DESK_AREA_LAYER_NORMAL; break;
+ case 3: edg_layer = E_DESK_AREA_LAYER_NORMAL_ABOVE; break;
+ case 4: edg_layer = E_DESK_AREA_LAYER_NOTIFICATION_LOW; break;
+ case 5: edg_layer = E_DESK_AREA_LAYER_NOTIFICATION_NORMAL; break;
+ case 6: edg_layer = E_DESK_AREA_LAYER_NOTIFICATION_HIGH; break;
+ default: edg_layer = E_DESK_AREA_LAYER_NORMAL; break;
}
if (sub_edg_id == 1)
{
if (!_edg_sub1)
- _edg_sub1 = e_desk_desk_group_add(desk, x, y, w, h, edg_layer);
+ _edg_sub1 = e_desk_desk_area_add(desk, x, y, w, h, edg_layer);
else
{
- e_desk_group_geometry_set(_edg_sub1, x, y, w, h);
- e_desk_group_layer_set(_edg_sub1, edg_layer);
+ e_desk_area_geometry_set(_edg_sub1, x, y, w, h);
+ e_desk_area_layer_set(_edg_sub1, edg_layer);
}
}
else if (sub_edg_id == 2)
{
if (!_edg_sub2)
- _edg_sub2 = e_desk_desk_group_add(desk, x, y, w, h, edg_layer);
+ _edg_sub2 = e_desk_desk_area_add(desk, x, y, w, h, edg_layer);
else
{
- e_desk_group_geometry_set(_edg_sub2, x, y, w, h);
- e_desk_group_layer_set(_edg_sub2, edg_layer);
+ e_desk_area_geometry_set(_edg_sub2, x, y, w, h);
+ e_desk_area_layer_set(_edg_sub2, edg_layer);
}
}
}
static Eldbus_Message *
-_e_info_server_cb_desk_group_new_sub1(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+_e_info_server_cb_desk_area_new_sub1(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
{
Eldbus_Message *reply = eldbus_message_method_return_new(msg);
E_Client *ec;
return reply;
}
- _desk_group_new(1, x, y, w, h, layer);
+ _desk_area_new(1, x, y, w, h, layer);
E_CLIENT_REVERSE_FOREACH(ec)
{
EINA_LIST_REVERSE_FOREACH(ec_list, l, ec)
{
- e_client_desk_group_set(ec, _edg_sub1);
+ e_client_desk_area_set(ec, _edg_sub1);
}
- //e_desk_group_all_ec_update(_edg_sub1);
+ //e_desk_area_all_ec_update(_edg_sub1);
return reply;
}
static Eldbus_Message *
-_e_info_server_cb_desk_group_new_sub2(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+_e_info_server_cb_desk_area_new_sub2(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
{
Eldbus_Message *reply = eldbus_message_method_return_new(msg);
int x, y, w, h;
return reply;
}
- _desk_group_new(2, x, y, w, h, layer);
+ _desk_area_new(2, x, y, w, h, layer);
E_CLIENT_FOREACH(ec)
{
if (e_policy_client_is_home_screen(ec))
- e_client_desk_group_set(ec, _edg_sub2);
+ e_client_desk_area_set(ec, _edg_sub2);
else if (e_policy_client_is_quickpanel(ec))
- e_client_desk_group_set(ec, _edg_sub2);
+ e_client_desk_area_set(ec, _edg_sub2);
}
return reply;
}
static Eldbus_Message *
-_e_info_server_cb_desk_group_remove_sub(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+_e_info_server_cb_desk_area_remove_sub(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
{
Eldbus_Message *reply = eldbus_message_method_return_new(msg);
uint32_t sub_edg_id;
if (sub_edg_id == 1)
{
- e_desk_desk_group_del(desk, _edg_sub1);
+ e_desk_desk_area_del(desk, _edg_sub1);
_edg_sub1 = NULL;
}
else if (sub_edg_id == 2)
{
- e_desk_desk_group_del(desk, _edg_sub2);
+ e_desk_desk_area_del(desk, _edg_sub2);
_edg_sub2 = NULL;
}
}
static void
-_desk_group_raise(E_Desk_Group *edg, uint32_t raise)
+_desk_area_raise(E_Desk_Area *eda, uint32_t raise)
{
E_Zone *zone;
E_Desk *desk;
desk = e_desk_current_get(zone);
if (!desk) return;
- if (!edg)
- edg = desk->desk_group.base;
+ if (!eda)
+ eda = desk->desk_area.base;
- if (edg)
+ if (eda)
{
if (raise == 1)
{
- //e_desk_group_raise(edg);
- e_desk_desk_group_raise(edg->desk, edg);
+ //e_desk_area_raise(eda);
+ e_desk_desk_area_raise(eda->desk, eda);
}
else if (raise == 0)
{
- //e_desk_group_lower(edg);
- e_desk_desk_group_lower(edg->desk, edg);
+ //e_desk_area_lower(eda);
+ e_desk_desk_area_lower(eda->desk, eda);
}
}
}
static Eldbus_Message *
-_e_info_server_cb_desk_group_base_raise(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+_e_info_server_cb_desk_area_base_raise(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
{
Eldbus_Message *reply = eldbus_message_method_return_new(msg);
uint32_t raise;
return reply;
}
- _desk_group_raise(NULL, raise);
+ _desk_area_raise(NULL, raise);
return reply;
}
static Eldbus_Message *
-_e_info_server_cb_desk_group_sub1_raise(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+_e_info_server_cb_desk_area_sub1_raise(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
{
Eldbus_Message *reply = eldbus_message_method_return_new(msg);
uint32_t raise;
}
if (_edg_sub1)
- _desk_group_raise(_edg_sub1, raise);
+ _desk_area_raise(_edg_sub1, raise);
return reply;
}
static Eldbus_Message *
-_e_info_server_cb_desk_group_sub2_raise(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+_e_info_server_cb_desk_area_sub2_raise(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
{
Eldbus_Message *reply = eldbus_message_method_return_new(msg);
uint32_t raise;
}
if (_edg_sub2)
- _desk_group_raise(_edg_sub2, raise);
+ _desk_area_raise(_edg_sub2, raise);
return reply;
}
static Eldbus_Message *
-_e_info_server_cb_desk_group_check_stack(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
+_e_info_server_cb_desk_area_check_stack(const Eldbus_Service_Interface *iface EINA_UNUSED, const Eldbus_Message *msg)
{
Eldbus_Message *reply = eldbus_message_method_return_new(msg);
E_Zone *zone;
E_Desk *desk;
- E_Desk_Group *edg = NULL;
+ E_Desk_Area *eda = NULL;
Eina_List *l;
Eina_List *ll;
Eina_List *edg_ecs_list = NULL;
desk = e_desk_current_get(zone);
if (!desk)
{
- ELOGF("EDG_TEST", "No current Desk_Group at a current Zoen... return", NULL);
+ ELOGF("EDG_TEST", "No current Desk_Area at a current Zoen... return", NULL);
return reply;
}
- if (!desk->desk_group.enable)
+ if (!desk->desk_area.enable)
{
- ELOGF("EDG_TEST", "Desk_Group is not enable... return", NULL);
+ ELOGF("EDG_TEST", "Desk_Area is not enable... return", NULL);
return reply;
}
- for (i=E_DESK_GROUP_LAYER_COUNT-1; i>=0; i--)
+ for (i=E_DESK_AREA_LAYER_COUNT-1; i>=0; i--)
{
- EINA_LIST_FOREACH(desk->desk_group.list[i], l, edg)
+ EINA_LIST_FOREACH(desk->desk_area.list[i], l, eda)
{
- for (j=E_DESK_GROUP_CLIENT_LAYER_MAX-1; j>=0; j--)
+ for (j=E_DESK_AREA_CLIENT_LAYER_MAX-1; j>=0; j--)
{
- EINA_LIST_FOREACH(edg->ec_lists[j], ll, edg_ec)
+ EINA_LIST_FOREACH(eda->ec_lists[j], ll, edg_ec)
{
edg_ecs_list = eina_list_append(edg_ecs_list, edg_ec);
}
{ "desktop_geometry_set", ELDBUS_ARGS({"iiii", "Geometry"}), NULL, _e_info_server_cb_desktop_geometry_set, 0},
{ "desktop_window_control", ELDBUS_ARGS({"i", "Window Control option"}), NULL, _e_info_server_cb_desktop_window_control, 0},
{ "desk_zoom", ELDBUS_ARGS({"ddii", "Zoom"}), NULL, _e_info_server_cb_desk_zoom, 0},
- { "desk_group_info", NULL, NULL, _e_info_server_cb_desk_group_info, 0},
- { "desk_group_enable", ELDBUS_ARGS({"i", "enable"}), NULL, _e_info_server_cb_desk_group_enable, 0},
- { "desk_group_new_sub1", ELDBUS_ARGS({"iiiii", "geometry"}), NULL, _e_info_server_cb_desk_group_new_sub1, 0},
- { "desk_group_new_sub2", ELDBUS_ARGS({"iiiii", "geometry"}), NULL, _e_info_server_cb_desk_group_new_sub2, 0},
- { "desk_group_remove_sub", ELDBUS_ARGS({"i", "sub_id"}), NULL, _e_info_server_cb_desk_group_remove_sub, 0},
- { "desk_group_base_raise", ELDBUS_ARGS({"i", "raise"}), NULL, _e_info_server_cb_desk_group_base_raise, 0},
- { "desk_group_sub1_raise", ELDBUS_ARGS({"i", "raise"}), NULL, _e_info_server_cb_desk_group_sub1_raise, 0},
- { "desk_group_sub2_raise", ELDBUS_ARGS({"i", "raise"}), NULL, _e_info_server_cb_desk_group_sub2_raise, 0},
- { "desk_group_check_stack", NULL, NULL, _e_info_server_cb_desk_group_check_stack, 0},
+ { "desk_area_info", NULL, NULL, _e_info_server_cb_desk_area_info, 0},
+ { "desk_area_enable", ELDBUS_ARGS({"i", "enable"}), NULL, _e_info_server_cb_desk_area_enable, 0},
+ { "desk_area_new_sub1", ELDBUS_ARGS({"iiiii", "geometry"}), NULL, _e_info_server_cb_desk_area_new_sub1, 0},
+ { "desk_area_new_sub2", ELDBUS_ARGS({"iiiii", "geometry"}), NULL, _e_info_server_cb_desk_area_new_sub2, 0},
+ { "desk_area_remove_sub", ELDBUS_ARGS({"i", "sub_id"}), NULL, _e_info_server_cb_desk_area_remove_sub, 0},
+ { "desk_area_base_raise", ELDBUS_ARGS({"i", "raise"}), NULL, _e_info_server_cb_desk_area_base_raise, 0},
+ { "desk_area_sub1_raise", ELDBUS_ARGS({"i", "raise"}), NULL, _e_info_server_cb_desk_area_sub1_raise, 0},
+ { "desk_area_sub2_raise", ELDBUS_ARGS({"i", "raise"}), NULL, _e_info_server_cb_desk_area_sub2_raise, 0},
+ { "desk_area_check_stack", NULL, NULL, _e_info_server_cb_desk_area_check_stack, 0},
{ "frender", ELDBUS_ARGS({"i", "frender"}), ELDBUS_ARGS({"s", "force_render_result"}), _e_info_server_cb_force_render, 0},
{ "screen_rotation_pre", ELDBUS_ARGS({"i", "value"}), NULL, _e_info_server_cb_screen_rotation_pre, 0},
{ "screen_rotation", ELDBUS_ARGS({"i", "value"}), NULL, _e_info_server_cb_screen_rotation, 0},
/* -------------------------------------------------------------------------- */
/* DESK GROUP */
/* -------------------------------------------------------------------------- */
-#define USAGE_DESK_GROUP \
+#define USAGE_DESK_AREA \
"[Option..] [DIR]\n" \
"\tinfo : print desk group information\n" \
- "\tenable [1:enable, 0:disable] : enable/disable desk_group\n" \
- "\tmake_sub1 [x][y][w][h][layer 0:bg, 1:below, 2:normal, 3:above, 4~6:noti] : make sub1 desk_group\n" \
- "\tmake_sub2 [x][y][w][h][layer 0:bg, 1:below, 2:normal, 3:above, 4~6:noti] : make sub2 desk_group\n" \
- "\tremove_sub1 : remove sub1 desk_group\n" \
- "\tremove_sub2 : remove sub2 desk_group\n" \
- "\traise_base [1:raise, 0:lower] : raise/lower base desk_group\n" \
- "\traise_sub1 [1:raise, 0:lower] : raise/lower sub1 desk_group\n" \
- "\traise_sub2 [1:raise, 0:lower] : raise/lower sub2 desk_group\n" \
+ "\tenable [1:enable, 0:disable] : enable/disable desk_area\n" \
+ "\tmake_sub1 [x][y][w][h][layer 0:bg, 1:below, 2:normal, 3:above, 4~6:noti] : make sub1 desk_area\n" \
+ "\tmake_sub2 [x][y][w][h][layer 0:bg, 1:below, 2:normal, 3:above, 4~6:noti] : make sub2 desk_area\n" \
+ "\tremove_sub1 : remove sub1 desk_area\n" \
+ "\tremove_sub2 : remove sub2 desk_area\n" \
+ "\traise_base [1:raise, 0:lower] : raise/lower base desk_area\n" \
+ "\traise_sub1 [1:raise, 0:lower] : raise/lower sub1 desk_area\n" \
+ "\traise_sub2 [1:raise, 0:lower] : raise/lower sub2 desk_area\n" \
"\tcheck_stack : check stack\n" \
"Example:\n" \
- "\twinfo -desk_group info\n" \
- "\twinfo -desk_group enable 1\n" \
- "\twinfo -desk_group make_sub1 240 480 480 800 2\n" \
- "\twinfo -desk_group make_sub2 310 80 320 480 2\n" \
- "\twinfo -desk_group remove_sub1\n" \
- "\twinfo -desk_group remove_sub2\n" \
- "\twinfo -desk_group raise_base 1\n" \
- "\twinfo -desk_group raise_sub1 1\n" \
- "\twinfo -desk_group raise_sub2 0\n" \
- "\twinfo -desk_group check_stack\n"
+ "\twinfo -desk_area info\n" \
+ "\twinfo -desk_area enable 1\n" \
+ "\twinfo -desk_area make_sub1 240 480 480 800 2\n" \
+ "\twinfo -desk_area make_sub2 310 80 320 480 2\n" \
+ "\twinfo -desk_area remove_sub1\n" \
+ "\twinfo -desk_area remove_sub2\n" \
+ "\twinfo -desk_area raise_base 1\n" \
+ "\twinfo -desk_area raise_sub1 1\n" \
+ "\twinfo -desk_area raise_sub2 0\n" \
+ "\twinfo -desk_area check_stack\n"
/* -------------------------------------------------------------------------- */
/* BASIC_OPERATION_GENERATE */
return;
}
- if (ec->desk_group.enable)
+ if (ec->desk_area.enable)
{
E_Layer layer;
E_Layer parent_layer;
- layer = e_client_desk_group_original_layer_get(ec);
- parent_layer = e_client_desk_group_original_layer_get(ec->parent);
+ layer = e_client_desk_area_original_layer_get(ec);
+ parent_layer = e_client_desk_area_original_layer_get(ec->parent);
if (parent_layer != layer)
{
EINA_LIST_FOREACH(ec->transients, l, child)
{
if (!child) continue;
- child->saved.layer = e_client_desk_group_original_layer_get(child);
+ child->saved.layer = e_client_desk_area_original_layer_get(child);
}
}
if (parent)
{
- if (ec->desk_group.desk_group && parent->desk_group.desk_group)
+ if (ec->desk_area.desk_area && parent->desk_area.desk_area)
{
- if (ec->desk_group.desk_group != parent->desk_group.desk_group)
+ if (ec->desk_area.desk_area != parent->desk_area.desk_area)
{
- e_client_desk_group_set(ec, parent->desk_group.desk_group);
+ e_client_desk_area_set(ec, parent->desk_area.desk_area);
}
}
}
default: ly = E_LAYER_CLIENT_NOTIFICATION_LOW; break;
}
- if (e_config->use_desk_group)
- cur_ly = e_client_desk_group_original_layer_get(ec);
+ if (e_config->use_desk_area)
+ cur_ly = e_client_desk_area_original_layer_get(ec);
else
cur_ly = e_client_layer_get(ec);
&_e_zone_splitscreen_interface, zone,
_e_zone_splitscreen_cb_resource_destroy);
- // The splitscreen_regions are the e_desk_groups associated with this
+ // The splitscreen_regions are the e_desk_areas associated with this
// E_Zone(E_Desk) and these are already created by the e20 module with the
// specifc policy. So e20 sends the splitscreen_regions associated with each
- // e_desk_group.
+ // e_desk_area.
desk = e_desk_current_get(zone);
if (!e_desk_splitscreen_regions_all_generate(desk, client, ss_res, id))
{
e_client_window_role_set(ec, "lockscreen");
// set lockscreen layer
- if (e_config->use_desk_group)
- layer = e_client_desk_group_original_layer_get(ec);
+ if (e_config->use_desk_area)
+ layer = e_client_desk_area_original_layer_get(ec);
else
layer = e_client_layer_get(ec);
}
// set quickpanel layer
- if (e_config->use_desk_group)
- layer = e_client_desk_group_original_layer_get(ec);
+ if (e_config->use_desk_area)
+ layer = e_client_desk_area_original_layer_get(ec);
else
layer = e_client_layer_get(ec);
ELOGF("SCRSAVER","Set Client", ec);
// set screensaver layer
- if (e_config->use_desk_group)
- layer = e_client_desk_group_original_layer_get(ec);
+ if (e_config->use_desk_area)
+ layer = e_client_desk_area_original_layer_get(ec);
else
layer = e_client_layer_get(ec);
e_client_hook_add(E_CLIENT_HOOK_DEL, _volume_hook_client_del, NULL);
// set volume layer
- if (e_config->use_desk_group)
- layer = e_client_desk_group_original_layer_get(ec);
+ if (e_config->use_desk_area)
+ layer = e_client_desk_area_original_layer_get(ec);
else
layer = e_client_layer_get(ec);
projects / platform / upstream / enlightenment.git / commitdiff