#ifdef CONTAINER_POLICY
#include "e_policy_zone_intern.h"
+#include "e_policy_desk_intern.h"
#endif
static Eina_List *handlers;
E_Tizen_Screen *tizen_screen;
#ifdef CONTAINER_POLICY
E_Policy_Zone *policy_zone;
+ e_policy_desk_init();
#endif
TRACE_DS_BEGIN(COMP_CANVAS:INIT);
#include "e_desk_intern.h"
+#include "e_zone_intern.h"
#include "e_desk_area_intern.h"
#include "e_client_intern.h"
+
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
+
+#include <libds-tizen/screen.h>
+
+#ifdef CONTAINER_POLICY
+#else
#include "e_utils_intern.h"
#include "e_comp_wl_subsurface_intern.h"
#include "e_output_intern.h"
-#include "e_zone_intern.h"
#include "e_config_intern.h"
#include "e_policy_wl_intern.h"
#include "e_policy_intern.h"
#include "e_display_intern.h"
-#include "e_view_intern.h"
-#include "e_view_client_intern.h"
-
-#include <libds-tizen/screen.h>
+#endif
/* E_Desk is a child object of E_Zone. A desk is essentially a background
* and an associated set of client windows. Each zone can have an arbitrary
*/
typedef struct _E_Desk_Private E_Desk_Private;
+#ifdef CONTAINER_POLICY
+#else
typedef struct _E_Desk_Private_Client E_Desk_Private_Client;
+#endif
+
+#ifdef CONTAINER_POLICY
+#else
typedef struct _E_Desk_Smart_Data E_Desk_Smart_Data;
+#endif
#define DESK_EC_DATA_KEY "E_Desk_Client"
#define PRI(desk) ((E_Desk_Private *)e_object_data_get(E_OBJECT(desk)))
+
#define API_ENTRY \
EINA_SAFETY_ON_NULL_RETURN(desk); \
E_Desk_Private *priv = PRI(desk); \
EINA_SAFETY_ON_NULL_RETURN(priv);
+#ifdef CONTAINER_POLICY
+#else
+
#define E_DESK_SMART_DATA_GET(obj, ptr) \
E_Desk_Smart_Data *ptr = evas_object_smart_data_get(obj);
#define E_DESK_SMART_DATA_GET_OR_RETURN(obj, ptr) \
E_DESK_SMART_DATA_GET(obj, ptr); \
if (!ptr) return
+#endif
+#ifdef CONTAINER_POLICY
+#else
typedef enum _E_Desk_Zoom_Animating_Type
{
E_DESK_ZOOM_ANIMATING_TYPE_NONE,
E_DESK_ZOOM_ANIMATING_TYPE_ENABLE,
E_DESK_ZOOM_ANIMATING_TYPE_DISABLE,
} E_Desk_Zoom_Animating_Type;
+#endif
struct _E_Desk_Private
{
struct
{
struct wl_signal client_add;
+#ifdef CONTAINER_POLICY
+ struct wl_signal client_del;
+#endif
struct wl_signal desk_area_enable;
struct wl_signal desk_area_disable;
struct wl_signal desk_area_active_change;
+#ifdef CONTAINER_POLICY
+ struct wl_signal desk_new;
+ struct wl_signal desk_free;
+ struct wl_signal top_visible_get;
+ struct wl_signal name_set;
+ struct wl_signal name_add;
+ struct wl_signal name_del;
+ struct wl_signal name_update;
+ struct wl_signal desk_show;
+ struct wl_signal desk_deskshow;
+ struct wl_signal geometry_set;
+ struct wl_signal zoom_set;
+ struct wl_signal zoom_get;
+ struct wl_signal zoom_get_center_coordinate;
+ struct wl_signal zoom_unset;
+ struct wl_signal smart_member_add;
+ struct wl_signal smart_member_del;
+ struct wl_signal client_zoom_skip_set;
+ struct wl_signal client_zoom_skip_unset;
+ struct wl_signal client_zoom_apply;
+ struct wl_signal zoom_is_animating;
+ struct wl_signal visible_client_iconify_all;
+ struct wl_signal visible_client_restore_all;
+ struct wl_signal client_iconified_list_remove;
+ struct wl_signal client_iconified_list_remove_all;
+#endif
} events;
};
+
+#ifdef CONTAINER_POLICY
+#else
struct _E_Desk_Private_Client
{
E_Desk *desk;
E_Desk_Zoom_Animating_Type animating_type;
} zoom;
};
+#endif
+#ifdef CONTAINER_POLICY
+#else
static int _e_desk_hooks_delete = 0;
static int _e_desk_hooks_walking = 0;
[E_DESK_HOOK_SPLIT_DESK_ACTIVATE] = NULL,
[E_DESK_HOOK_SPLIT_DESK_DEACTIVATE] = NULL,
};
+#endif
static void _e_desk_free(E_Desk *desk);
+#ifdef CONTAINER_POLICY
+#else
static void _e_desk_event_desk_show_free(void *data, void *ev);
static void _e_desk_event_desk_before_show_free(void *data, void *ev);
static void _e_desk_event_desk_after_show_free(void *data, void *ev);
static void _e_desk_show_begin(E_Desk *desk, int dx, int dy);
static void _e_desk_hide_begin(E_Desk *desk, int dx, int dy);
static void _e_desk_event_desk_geometry_change_free(void *data, void *ev);
-
static void _e_desk_smart_init(E_Desk *desk);
static void _e_desk_smart_add(Evas_Object *obj);
static void _e_desk_smart_del(Evas_Object *obj);
static void _e_desk_hooks_clean(void);
static Eina_Bool _e_desk_hook_call(E_Desk_Hook_Point hookpoint, E_Desk *desk);
+#endif
+#ifdef CONTAINER_POLICY
+#else
EVAS_SMART_SUBCLASS_NEW(E_DESK_SMART_OBJ_TYPE, _e_desk,
Evas_Smart_Class, Evas_Smart_Class,
evas_object_smart_clipped_class_get, NULL)
+#endif
EINTERN int E_EVENT_DESK_SHOW = 0;
EINTERN int E_EVENT_DESK_BEFORE_SHOW = 0;
priv->desk = desk;
wl_signal_init(&priv->events.client_add);
+ wl_signal_init(&priv->events.client_del);
wl_signal_init(&priv->events.desk_area_enable);
wl_signal_init(&priv->events.desk_area_disable);
wl_signal_init(&priv->events.desk_area_active_change);
+#ifdef CONTAINER_POLICY
+ wl_signal_init(&priv->events.desk_new);
+ wl_signal_init(&priv->events.desk_free);
+ wl_signal_init(&priv->events.top_visible_get);
+ wl_signal_init(&priv->events.name_set);
+ wl_signal_init(&priv->events.name_add);
+ wl_signal_init(&priv->events.name_del);
+ wl_signal_init(&priv->events.name_update);
+ wl_signal_init(&priv->events.desk_show);
+ wl_signal_init(&priv->events.desk_deskshow);
+ wl_signal_init(&priv->events.geometry_set);
+ wl_signal_init(&priv->events.zoom_set);
+ wl_signal_init(&priv->events.zoom_get);
+ wl_signal_init(&priv->events.zoom_get_center_coordinate);
+ wl_signal_init(&priv->events.zoom_unset);
+ wl_signal_init(&priv->events.smart_member_add);
+ wl_signal_init(&priv->events.smart_member_del);
+ wl_signal_init(&priv->events.client_zoom_skip_set);
+ wl_signal_init(&priv->events.client_zoom_skip_unset);
+ wl_signal_init(&priv->events.client_zoom_apply);
+ wl_signal_init(&priv->events.zoom_is_animating);
+ wl_signal_init(&priv->events.visible_client_iconify_all);
+ wl_signal_init(&priv->events.visible_client_restore_all);
+ wl_signal_init(&priv->events.client_iconified_list_remove);
+ wl_signal_init(&priv->events.client_iconified_list_remove_all);
+#endif
e_object_data_set(E_OBJECT(desk), priv);
free(priv);
}
+#ifdef CONTAINER_POLICY
+#else
static void
_e_desk_event_simple_free(void *d EINA_UNUSED, E_Event_Desk *event)
{
ecore_event_add(type, ev, (Ecore_End_Cb)_e_desk_event_simple_free, NULL);
}
+#endif
EINTERN int
e_desk_init(void)
e_desk_new(E_Zone *zone, int x, int y)
{
E_Desk *desk;
+#ifdef CONTAINER_POLICY
+#else
Eina_List *l;
E_Config_Desktop_Name *cfname;
char name[40];
int ok = 0;
+#endif
static int desk_id = 0;
E_OBJECT_CHECK_RETURN(zone, NULL);
desk->y = y;
desk->id = desk_id++;
+#ifdef CONTAINER_POLICY
+ wl_signal_emit(&PRI(desk)->events.desk_new, desk);
+#else
/* init smart object */
_e_desk_smart_init(desk);
e_object_del(E_OBJECT(desk));
return NULL;
}
+#endif
return desk;
}
EINTERN E_Client *
e_desk_client_top_visible_get(E_Desk *desk)
{
+#ifdef CONTAINER_POLICY
+ E_Desk_Data_Top_Visible_Get top_visible_data = {0,};
+ top_visible_data.desk = desk;
+#else
E_Client *ec;
+#endif
E_OBJECT_CHECK_RETURN(desk, NULL);
E_OBJECT_TYPE_CHECK_RETURN(desk, E_DESK_TYPE, NULL);
+#ifdef CONTAINER_POLICY
+ wl_signal_emit(&PRI(desk)->events.top_visible_get, &top_visible_data);
+ return top_visible_data.visible_ec;
+#else
E_CLIENT_REVERSE_FOREACH(ec)
if (e_desk_has_ec(desk, ec) && e_view_client_visible_get(e_client_view_get(ec))) return ec;
return NULL;
+#endif
}
EINTERN void
eina_stringshare_replace(&desk->name, name);
+#ifdef CONTAINER_POLICY
+ wl_signal_emit(&PRI(desk)->events.name_set, NULL);
+#else
_e_desk_event_simple_add(desk, E_EVENT_DESK_NAME_CHANGE);
+#endif
}
EINTERN void
e_desk_name_add(int zone, int desk_x, int desk_y, const char *name)
{
+#ifdef CONTAINER_POLICY
+ E_Desk_Data_Name name_data = {0,};
+ E_Zone *zone_ptr;
+ E_Desk *desk;
+ name_data.name = name;
+ name_data.desk_x = desk_x;
+ name_data.desk_y = desk_y;
+
+ zone_ptr = e_zone_get_by_id(zone);
+ // TODO: should we consider it as policy?
+ desk = e_desk_at_xy_get(zone_ptr, desk_x, desk_y);
+
+ if (!desk)
+ {
+ ERR("Desk at %d, %d is NULL...", desk_x, desk_y);
+ return;
+ }
+
+ wl_signal_emit(&PRI(desk)->events.name_add, &name_data);
+#else
E_Config_Desktop_Name *cfname;
e_desk_name_del(zone, desk_x, desk_y);
if (name) cfname->name = eina_stringshare_add(name);
else cfname->name = NULL;
e_config->desktop_names = eina_list_append(e_config->desktop_names, cfname);
+#endif
}
EINTERN void
e_desk_name_del(int zone, int desk_x, int desk_y)
{
+#ifdef CONTAINER_POLICY
+ E_Desk_Data_Name name_data = {0,};
+ E_Zone *zone_ptr;
+ E_Desk *desk;
+ name_data.desk_x = desk_x;
+ name_data.desk_y = desk_y;
+
+ zone_ptr = e_zone_get_by_id(zone);
+ // TODO: should we consider it as policy?
+ desk = e_desk_at_xy_get(zone_ptr, desk_x, desk_y);
+
+ if (!desk)
+ {
+ ERR("Desk at %d, %d is NULL...", desk_x, desk_y);
+ return;
+ }
+
+ wl_signal_emit(&PRI(desk)->events.name_del, &name_data);
+#else
Eina_List *l = NULL;
E_Config_Desktop_Name *cfname = NULL;
break;
}
}
+#endif
}
EINTERN void
e_desk_name_update(void)
{
+#ifdef CONTAINER_POLICY
+ E_Desk *desk = e_desk_current_get(e_zone_current_get());
+ if (!desk) return;
+
+ wl_signal_emit(&PRI(desk)->events.name_update, NULL);
+#else
const Eina_List *z, *l;
E_Zone *zone;
E_Desk *desk;
}
}
}
+#endif
}
EINTERN void
e_desk_show(E_Desk *desk)
{
+#ifdef CONTAINER_POLICY
+#else
E_Event_Desk_Show *ev = NULL;
E_Event_Desk_Before_Show *eev = NULL;
E_Event_Desk_After_Show *eeev = NULL;
int dx = 0, dy = 0;
Ecore_Event *eev_ecore_event = NULL;
Ecore_Event *ev_ecore_event = NULL;
+#endif
E_OBJECT_CHECK(desk);
E_OBJECT_TYPE_CHECK(desk, E_DESK_TYPE);
if (desk->visible) return;
+#ifdef CONTAINER_POLICY
+ wl_signal_emit(&PRI(desk)->events.desk_show, NULL);
+#else
desk2 = e_desk_at_xy_get(desk->zone, desk->zone->desk_x_current, desk->zone->desk_y_current);
if ((!starting) && (!desk2->visible)) return;
eev = E_NEW(E_Event_Desk_Before_Show, 1);
e_object_unref(E_OBJECT(eev->desk));
free(eev);
}
+#endif
}
EINTERN void
e_desk_deskshow(E_Zone *zone)
{
- E_Client *ec;
E_Desk *desk;
E_OBJECT_CHECK(zone);
desk = e_desk_current_get(zone);
EINA_SAFETY_ON_NULL_RETURN(desk);
+#ifdef CONTAINER_POLICY
+ // TODO: Should we move it to zone?
+ wl_signal_emit(&PRI(desk)->events.desk_show, NULL);
+#else
if (desk->deskshow_toggle)
{
/* uniconify raises windows and changes stacking order
desk->deskshow_toggle = !desk->deskshow_toggle;
_e_desk_event_simple_add(desk, E_EVENT_DESK_DESKSHOW);
+#endif
}
+#ifdef CONTAINER_POLICY
+#else
EINTERN void
e_desk_row_add(E_Zone *zone)
{
{
E_OBJECT_CHECK_RETURN(zone, NULL);
E_OBJECT_TYPE_CHECK_RETURN(zone, E_ZONE_TYPE, NULL);
-
+
E_Desk *desk = e_desk_at_xy_get(zone, zone->desk_x_current, zone->desk_y_current);
return desk;
}
EINTERN E_Desk *
e_desk_at_pos_get(E_Zone *zone, int pos)
{
- int x, y;
-
E_OBJECT_CHECK_RETURN(zone, NULL);
E_OBJECT_TYPE_CHECK_RETURN(zone, E_ZONE_TYPE, NULL);
+ int x, y;
+
y = pos / zone->desk_x_count;
x = pos - (y * zone->desk_x_count);
return zone->desks[x + (y * zone->desk_x_count)];
}
+#endif
EINTERN void
e_desk_xy_get(E_Desk *desk, int *x, int *y)
if (y) *y = desk->y;
}
+#ifdef CONTAINER_POLICY
+#else
EINTERN void
e_desk_next(E_Zone *zone)
{
E_OBJECT_CHECK(zone);
E_OBJECT_TYPE_CHECK(zone, E_ZONE_TYPE);
+ // FIXME: desk not available
+
if ((zone->desk_x_count < 2) && (zone->desk_y_count < 2))
return;
E_OBJECT_CHECK(zone);
E_OBJECT_TYPE_CHECK(zone, E_ZONE_TYPE);
+ // FIXME: desk not available
+
if ((zone->desk_x_count < 2) && (zone->desk_y_count < 2))
return;
E_Zone *zone;
unsigned int count = 0;
+ // FIXME: desk not available
+
EINA_LIST_FOREACH(e_comp->zones, l, zone)
{
int cx = 0, cy = 0;
}
return count;
}
+#endif
+#ifdef CONTAINER_POLICY
+#else
static void
_e_desk_client_data_del(E_Desk *desk, E_Client *ec)
{
e_desk_visible_client_iconified_list_remove_all(desk);
}
}
+#endif
EINTERN void
e_desk_client_add(E_Desk *desk, E_Client *ec)
{
+#ifdef CONTAINER_POLICY
+#else
E_Desk_Area *eda;
E_Desk_Private_Client *desk_client;
+#endif
E_OBJECT_CHECK(desk);
E_OBJECT_TYPE_CHECK(desk, E_DESK_TYPE);
if (e_desk_has_ec(desk, ec)) return;
+#ifdef CONTAINER_POLICY
+ wl_signal_emit(&PRI(desk)->events.client_add, ec);
+#else
ELOGF("DESK", "CLIENT ADD. desk:%p", ec, desk);
desk_client = E_NEW(E_Desk_Private_Client, 1);
wl_signal_emit(&PRI(desk)->events.client_add, desk);
_e_desk_hook_call(E_DESK_HOOK_CLIENT_ADD, desk);
+#endif
}
+#ifdef CONTAINER_POLICY
+#else
static E_Desk_Private_Client *
_e_desk_private_client_get(E_Client *ec)
{
return wl_container_of(listener, desk_client, client_destroy);
}
+#endif
E_API void
e_desk_client_del(E_Desk *desk, E_Client *ec)
{
+#ifdef CONTAINER_POLICY
+#else
E_Desk_Private_Client *desk_client;
E_Desk_Area *eda;
+#endif
E_OBJECT_CHECK(desk);
E_OBJECT_TYPE_CHECK(desk, E_DESK_TYPE);
if (!e_desk_has_ec(desk, ec)) return;
+#ifdef CONTAINER_POLICY
+ wl_signal_emit(&PRI(desk)->events.client_del, ec);
+#else
+
ELOGF("DESK", "CLIENT REMOVE. desk:%p", ec, desk);
desk_client = _e_desk_private_client_get(ec);
e_desk_area_ec_remove(eda, ec);
_e_desk_private_client_del(desk_client);
+#endif
}
E_API void
e_desk_geometry_set(E_Desk *desk, int x, int y, int w, int h)
{
+#ifdef CONTAINER_POLICY
+ E_Desk_Data_Geometry geom_data = {0,};
+#else
E_Client *ec;
E_Maximize max;
Eina_List *l = NULL, *ll = NULL;
E_Event_Desk_Geometry_Change *ev = NULL;
int cx, cy, dx, dy;
+#endif
E_OBJECT_CHECK(desk);
E_OBJECT_TYPE_CHECK(desk, E_DESK_TYPE);
+#ifdef CONTAINER_POLICY
+#else
E_DESK_SMART_DATA_GET_OR_RETURN(desk->smart_obj, sd);
+#endif
if ((desk->geom.x == x) && (desk->geom.y == y) &&
(desk->geom.w == w) && (desk->geom.h == h))
return;
+#ifdef CONTAINER_POLICY
+ EINA_RECTANGLE_SET(&desk->geom, x, y, w, h);
+
+ geom_data.x = x;
+ geom_data.y = y;
+ geom_data.w = w;
+ geom_data.h = h;
+ wl_signal_emit(&PRI(desk)->events.geometry_set, &geom_data);
+#else
dx = x - desk->geom.x;
dy = y - desk->geom.y;
EINA_RECTANGLE_SET(&desk->geom, x, y, w, h);
}
e_comp_render_queue();
+#endif
}
if (h) *h = desk->geom.h;
}
+#ifdef CONTAINER_POLICY
+#else
static Eina_Bool
_e_desk_zoom_animate_cb(void *data, double pos)
{
return ECORE_CALLBACK_PASS_ON;
}
+#endif
E_API void
e_desk_zoom_set(E_Desk *desk, double zoomx, double zoomy, int cx, int cy)
{
+#ifdef CONTAINER_POLICY
+ E_Desk_Data_Zoom zoom_data = {0,};
+#else
E_Client *ec;
Eina_List *l;
E_Zone *zone = NULL;
E_Output *eout = NULL;
+#endif
E_OBJECT_CHECK(desk);
E_OBJECT_TYPE_CHECK(desk, E_DESK_TYPE);
+#ifdef CONTAINER_POLICY
+ zoom_data.zoomx = zoomx;
+ zoom_data.zoomy = zoomy;
+ zoom_data.cx = cx;
+ zoom_data.cy = cy;
+
+ wl_signal_emit(&PRI(desk)->events.zoom_set, &zoom_data);
+#else
ELOGF("DESK", "ZOOM SET. desk:%p, zoom ratio(%f,%f) cpos(%d,%d)", NULL, desk, zoomx, zoomy, cx, cy);
if (e_config->use_pp_zoom)
end:
_e_desk_event_simple_add(desk, E_EVENT_DESK_ZOOM_SET);
+#endif
}
E_API Eina_Bool
e_desk_zoom_get(E_Desk *desk, double *zoomx, double *zoomy, int *cx, int *cy)
{
+#ifdef CONTAINER_POLICY
+ E_Desk_Data_Zoom zoom_data = {0,};
+#else
E_Zone *zone = NULL;
E_Output *eout = NULL;
Eina_Bool res = EINA_FALSE;
+#endif
E_OBJECT_CHECK_RETURN(desk, EINA_FALSE);
E_OBJECT_TYPE_CHECK_RETURN(desk, E_DESK_TYPE, EINA_FALSE);
+#ifdef CONTAINER_POLICY
+ wl_signal_emit(&PRI(desk)->events.zoom_get, &zoom_data);
+
+ if (zoom_data.result)
+ {
+ if (zoomx) *zoomx = zoom_data.zoomx;
+ if (zoomy) *zoomy = zoom_data.zoomy;
+ if (cx) *cx = zoom_data.cx;
+ if (cy) *cy = zoom_data.cy;
+ }
+ return zoom_data.result;
+#else
if (e_config->use_pp_zoom)
{
if (e_display_pp_support())
if (cy) *cy = sd->zoom.cord_y;
return EINA_TRUE;
+#endif
}
EINTERN Eina_Bool
e_desk_zoom_get_center_coordinate(E_Desk *desk, double zoomx, double zoomy, int rectx, int recty, int *cx, int *cy)
{
+#ifdef CONTAINER_POLICY
+ E_Desk_Data_Zoom zoom_data = {0,};
+#else
E_Zone *zone = NULL;
E_Output *eout = NULL;
int w, h;
int zoomw, zoomh;
+#endif
E_OBJECT_CHECK_RETURN(desk, EINA_FALSE);
E_OBJECT_TYPE_CHECK_RETURN(desk, E_DESK_TYPE, EINA_FALSE);
+#ifdef CONTAINER_POLICY
+ zoom_data.zoomx = zoomx;
+ zoom_data.zoomy = zoomy;
+ zoom_data.rectx = rectx;
+ zoom_data.recty = recty;
+
+ wl_signal_emit(&PRI(desk)->events.zoom_get_center_coordinate, &zoom_data);
+
+ if (zoom_data.result)
+ {
+ if (cx) *cx = zoom_data.cx;
+ if (cy) *cy = zoom_data.cy;
+ }
+ return zoom_data.result;
+#else
zone = desk->zone;
eout = e_output_find(zone->output_id);
*cy = (int)((zoomy * (double)recty) / (zoomy - 1.0));
return EINA_TRUE;
+ #endif
}
E_API void
e_desk_zoom_unset(E_Desk *desk)
{
+#ifdef CONTAINER_POLICY
+#else
E_Client *ec;
Eina_List *l;
E_Zone *zone = NULL;
E_Output *eout = NULL;
+#endif
E_OBJECT_CHECK(desk);
E_OBJECT_TYPE_CHECK(desk, E_DESK_TYPE);
+#ifdef CONTAINER_POLICY
+ wl_signal_emit(&PRI(desk)->events.zoom_unset, NULL);
+#else
ELOGF("DESK", "ZOOM UNSET. desk:%p", NULL, desk);
if (e_config->use_pp_zoom)
end:
_e_desk_event_simple_add(desk, E_EVENT_DESK_ZOOM_UNSET);
+#endif
}
E_API void
E_OBJECT_CHECK(desk);
E_OBJECT_TYPE_CHECK(desk, E_DESK_TYPE);
+#ifdef CONTAINER_POLICY
+ wl_signal_emit(&PRI(desk)->events.smart_member_add, obj);
+#else
evas_object_smart_member_add(obj, desk->smart_obj);
+#endif
}
E_API void
e_desk_smart_member_del(Evas_Object *obj)
{
+#ifdef CONTAINER_POLICY
+ E_Desk *desk;
+ desk = e_desk_current_get(e_zone_current_get());
+ if (!desk) return;
+
+ wl_signal_emit(&PRI(desk)->events.smart_member_del, obj);
+#else
evas_object_smart_member_del(obj);
+#endif
}
E_API Eina_Bool
e_desk_client_zoom_skip_set(E_Desk * desk, E_Client * ec)
{
+#ifdef CONTAINER_POLICY
+ E_Desk_Data_Client_Zoom client_zoom_data = {0,};
+#else
E_Desk *ec_desk;
+#endif
if (!desk) return EINA_FALSE;
if (!ec) return EINA_FALSE;
+#ifdef CONTAINER_POLICY
+ client_zoom_data.ec = ec;
+ wl_signal_emit(&PRI(desk)->events.client_zoom_skip_set, &client_zoom_data);
+
+ return client_zoom_data.result;
+#else
+ // TODO: Need to check the ec_desk?
ec_desk = e_zone_desk_find_by_ec(desk->zone, ec);
if (!ec_desk) return EINA_FALSE;
desk_client->skip_zoom = EINA_TRUE;
return EINA_TRUE;
+#endif
}
E_API Eina_Bool
e_desk_client_zoom_skip_unset(E_Desk *desk, E_Client *ec)
{
+#ifdef CONTAINER_POLICY
+ E_Desk_Data_Client_Zoom client_zoom_data = {0,};
+#else
E_Desk *ec_desk;
+#endif
if (!desk) return EINA_FALSE;
if (!ec) return EINA_FALSE;
+#ifdef CONTAINER_POLICY
+ client_zoom_data.ec = ec;
+ wl_signal_emit(&PRI(desk)->events.client_zoom_skip_unset, &client_zoom_data);
+
+ return client_zoom_data.result;
+#else
ec_desk = e_zone_desk_find_by_ec(desk->zone, ec);
if (!ec_desk) return EINA_FALSE;
_e_desk_smart_client_add(desk->smart_obj, ec);
return EINA_TRUE;
+#endif
}
EINTERN void
e_desk_client_zoom_apply(E_Desk *desk, E_Client *ec)
{
+#ifdef CONTAINER_POLICY
+ E_Desk_Data_Client_Zoom client_zoom_data = {0,};
+#endif
E_OBJECT_CHECK(desk);
E_OBJECT_TYPE_CHECK(desk, E_DESK_TYPE);
E_OBJECT_CHECK(ec);
E_OBJECT_TYPE_CHECK(ec, E_CLIENT_TYPE);
+#ifdef CONTAINER_POLICY
+ client_zoom_data.ec = ec;
+ wl_signal_emit(&PRI(desk)->events.client_zoom_apply, &client_zoom_data);
+#else
E_DESK_SMART_DATA_GET_OR_RETURN(desk->smart_obj, sd);
if (!eina_list_data_find(sd->clients, ec))
return;
sd->zoom.ratio_x, sd->zoom.ratio_y,
sd->zoom.cord_x, sd->zoom.cord_y);
}
+#endif
}
EINTERN Eina_Bool
e_desk_zoom_is_animating(E_Desk *desk)
{
+#ifdef CONTAINER_POLICY
+ E_Desk_Data_Zoom zoom_data = {0,};
+ wl_signal_emit(&PRI(desk)->events.zoom_is_animating, &zoom_data);
+
+ return zoom_data.result;
+#else
E_DESK_SMART_DATA_GET(desk->smart_obj, sd);
if (!sd) return EINA_FALSE;
if (!e_config->desk_zoom_effect.enable) return EINA_FALSE;
return !!sd->zoom.animator;
+#endif
}
E_API void
e_desk_visible_client_iconify_all(E_Desk *desk)
{
+#ifdef CONTAINER_POLICY
+#else
E_Client *ec;
Eina_List *l;
+#endif
if (!desk) return;
+#ifdef CONTAINER_POLICY
+ wl_signal_emit(&PRI(desk)->events.visible_client_iconify_all, NULL);
+#else
ELOGF("DESK", "ICONIFY ALL VISIBLE WINDOW", NULL);
E_CLIENT_REVERSE_FOREACH(ec)
{
e_policy_wl_iconify_state_change_send(ec, 1);
e_client_iconify(ec);
}
+#endif
}
E_API void
e_desk_visible_client_restore_all(E_Desk *desk)
{
+#ifdef CONTAINER_POLICY
+#else
E_Client *ec;
Eina_List *restore_list;
Eina_List *l;
+#endif
if (!desk) return;
if (!desk->iconified_list) return;
+#ifdef CONTAINER_POLICY
+ wl_signal_emit(&PRI(desk)->events.visible_client_restore_all, NULL);
+#else
ELOGF("DESK", "RESTORE ALL VISIBLE WINDOW", NULL);
restore_list = eina_list_clone(desk->iconified_list);
e_client_uniconify(ec);
}
eina_list_free(restore_list);
+#endif
}
E_API void
if (!desk || !ec) return;
if (!desk->iconified_list) return;
+#ifdef CONTAINER_POLICY
+ wl_signal_emit(&PRI(desk)->events.client_iconified_list_remove, &ec);
+#else
ELOGF("DESK", "Remove from iconified list", ec);
desk->iconified_list = eina_list_remove(desk->iconified_list, ec);
+#endif
}
E_API void
if (!desk) return;
if (!desk->iconified_list) return;
+#ifdef CONTAINER_POLICY
+ wl_signal_emit(&PRI(desk)->events.client_iconified_list_remove_all, NULL);
+#else
ELOGF("DESK", "Remove iconified list all", NULL);
eina_list_free(desk->iconified_list);
desk->iconified_list = NULL;
+#endif
}
E_API Eina_List *
static void
_e_desk_free(E_Desk *desk)
{
+#ifdef CONTAINER_POLICY
+#else
Eina_List *l;
E_Desk_Area *eda;
+#endif
+#ifdef CONTAINER_POLICY
+ wl_signal_emit(&PRI(desk)->events.desk_free, desk);
+#else
for (int i=E_DESK_AREA_LAYER_COUNT-1; i>=0; i--)
{
EINA_LIST_FOREACH(desk->desk_area.list[i], l, eda)
eina_stringshare_del(desk->name);
desk->name = NULL;
E_FREE_LIST(desk->handlers, ecore_event_handler_del);
-
+#endif
_e_desk_private_finish(desk);
free(desk);
}
+
+#ifdef CONTAINER_POLICY
+#else
+// use event_simple_free
static void
_e_desk_event_desk_show_free(void *data EINA_UNUSED, void *event)
{
free(ev);
}
+// use event_simple_free
static void
_e_desk_event_desk_before_show_free(void *data EINA_UNUSED, void *event)
{
free(ev);
}
+// use event_simple_free
static void
_e_desk_event_desk_after_show_free(void *data EINA_UNUSED, void *event)
{
free(ev);
}
+// use event_simple_free
static void
_e_desk_event_desk_geometry_change_free(void *data EINA_UNUSED, void *event)
{
e_object_unref(E_OBJECT(ev->desk));
E_FREE(ev);
}
+#endif
+#ifdef CONTAINER_POLICY
+#else
static Eina_Bool
_e_desk_transition_setup(E_Client *ec, int dx, int dy, int state)
{
ec->hidden = 1;
e_view_client_hide(e_client_view_get(ec));
}
+#endif
+#ifdef CONTAINER_POLICY
+#else
static void
_e_desk_show_begin(E_Desk *desk, int dx, int dy)
{
e_client_comp_hidden_set(ec, EINA_TRUE);
}
}
+#endif
+#ifdef CONTAINER_POLICY
+#else
static void
_e_desk_smart_init(E_Desk *desk)
{
sd->zoom.cord_x = 0;
sd->zoom.cord_y = 0;
}
+#endif
+#ifdef CONTAINER_POLICY
+#else
static Eina_Bool
_e_desk_smart_client_cb_resize(void *data, int type, void *event)
{
sc->member_add = _e_desk_smart_member_add;
sc->member_del = _e_desk_smart_member_del;
}
+#endif
+#ifdef CONTAINER_POLICY
+#else
static void
_e_desk_smart_client_add(Evas_Object *obj, E_Client *ec)
{
e_view_client_render(e_client_view_get(ec));
}
}
+#endif
static unsigned int
_e_desk_desk_area_layer_map(E_Desk_Area_Layer layer)
desk->desk_area.active = eda;
wl_signal_emit(&PRI(desk)->events.desk_area_active_change, desk);
+#ifdef CONTAINER_POLICY
+#else
_e_desk_hook_call(E_DESK_HOOK_DESK_AREA_ACTIVE_CHANGE, desk);
+#endif
}
EINTERN E_Desk_Area *
return below;
}
+#ifdef CONTAINER_POLICY
+#else
static void
_e_desk_hooks_clean(void)
{
return !!e_object_unref(E_OBJECT(desk));
}
+#endif
+#ifdef CONTAINER_POLICY
+#else
E_API E_Desk_Hook *
e_desk_hook_add(E_Desk_Hook_Point hookpoint, E_Desk_Hook_Cb func, const void *data)
{
}
}
}
+#endif
EINTERN Eina_Bool
e_desk_has_ec(E_Desk *desk, E_Client *ec)
wl_signal_add(&priv->events.client_add, listener);
}
+EINTERN void
+e_desk_client_del_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.client_del, listener);
+}
+
EINTERN void
e_desk_desk_area_enable_listener_add(E_Desk *desk, struct wl_listener *listener)
{
API_ENTRY;
wl_signal_add(&priv->events.desk_area_active_change, listener);
}
+
+#ifdef CONTAINER_POLICY
+EINTERN void
+e_desk_desk_new_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.desk_new, listener);
+}
+
+EINTERN void
+e_desk_desk_free_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.desk_free, listener);
+}
+
+EINTERN void
+e_desk_top_visible_get_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.top_visible_get, listener);
+}
+
+EINTERN void
+e_desk_name_set_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.name_set, listener);
+}
+
+EINTERN void
+e_desk_name_add_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.name_add, listener);
+}
+
+EINTERN void
+e_desk_name_del_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.name_del, listener);
+}
+
+EINTERN void
+e_desk_name_update_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.name_update, listener);
+}
+
+EINTERN void
+e_desk_desk_show_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.desk_show, listener);
+}
+
+EINTERN void
+e_desk_desk_deskshow_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.desk_deskshow, listener);
+}
+
+EINTERN void
+e_desk_geometry_set_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.geometry_set, listener);
+}
+
+EINTERN void
+e_desk_zoom_set_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.zoom_set, listener);
+}
+
+EINTERN void
+e_desk_zoom_get_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.zoom_get, listener);
+}
+
+EINTERN void
+e_desk_zoom_get_center_coordinate_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.zoom_get_center_coordinate, listener);
+}
+
+EINTERN void
+e_desk_zoom_unset_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.zoom_unset, listener);
+}
+
+EINTERN void
+e_desk_smart_member_add_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.smart_member_add, listener);
+}
+
+EINTERN void
+e_desk_smart_member_del_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.smart_member_del, listener);
+}
+
+EINTERN void
+e_desk_client_zoom_skip_set_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.client_zoom_skip_set, listener);
+}
+
+EINTERN void
+e_desk_client_zoom_skip_unset_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.client_zoom_skip_unset, listener);
+}
+
+EINTERN void
+e_desk_client_zoom_apply_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.client_zoom_apply, listener);
+}
+
+EINTERN void
+e_desk_zoom_is_animating_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.zoom_is_animating, listener);
+}
+
+EINTERN void
+e_desk_visible_client_iconify_all_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.visible_client_iconify_all, listener);
+}
+
+EINTERN void
+e_desk_visible_client_restore_all_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.visible_client_restore_all, listener);
+}
+
+EINTERN void
+e_desk_client_iconified_list_remove_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.client_iconified_list_remove, listener);
+}
+
+EINTERN void
+e_desk_client_iconified_list_remove_all_listener_add(E_Desk *desk, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.client_iconified_list_remove_all, listener);
+}
+#endif
E_Client *ec;
unsigned int x;
- g_rec_mutex_lock(&e_comp->ec_list_mutex);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(eda, NULL);
+
+ e_comp_ec_list_lock();;
for (x = e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR); x >= e_comp_canvas_layer_map(E_LAYER_CLIENT_DESKTOP); x--)
{
E_Client *ec;
unsigned int x;
- g_rec_mutex_lock(&e_comp->ec_list_mutex);
+ EINA_SAFETY_ON_NULL_RETURN_VAL(eda, NULL);
+
+ e_comp_ec_list_lock();;
for (x = e_comp_canvas_layer_map(E_LAYER_CLIENT_DESKTOP); x <= e_comp_canvas_layer_map(E_LAYER_CLIENT_CURSOR); x++)
{
#include <wayland-server.h>
#include <libds-tizen/screen.h>
+#ifdef CONTAINER_POLICY
+typedef struct _E_Desk_Data_Top_Visible_Get
+{
+ E_Desk *desk;
+ E_Client *visible_ec;
+} E_Desk_Data_Top_Visible_Get;
+
+typedef struct _E_Desk_Data_Name
+{
+ const char *name;
+ int desk_x, desk_y;
+} E_Desk_Data_Name;
+
+typedef struct _E_Desk_Data_Desk_Control
+{
+ E_Zone *zone;
+} E_Desk_Data_Desk_Control;
+
+typedef struct _E_Desk_Data_Geometry
+{
+ int x, y, w, h;
+} E_Desk_Data_Geometry;
+
+typedef struct _E_Desk_Data_Zoom
+{
+ double zoomx, zoomy;
+ int cx, cy;
+ int rectx, recty;
+ Eina_Bool result;
+} E_Desk_Data_Zoom;
+
+typedef struct _E_Desk_Data_Client_Zoom
+{
+ E_Client *ec;
+ Eina_Bool result;
+} E_Desk_Data_Client_Zoom;
+
+#endif
+
extern EINTERN int E_EVENT_DESK_SHOW;
extern EINTERN int E_EVENT_DESK_BEFORE_SHOW;
extern EINTERN int E_EVENT_DESK_AFTER_SHOW;
EINTERN void e_desk_show(E_Desk *desk);
EINTERN void e_desk_deskshow(E_Zone *zone);
EINTERN E_Client *e_desk_client_top_visible_get(E_Desk *desk);
+#ifdef CONTAINER_POLICY
+#else
EINTERN E_Desk *e_desk_at_xy_get(E_Zone *zone, int x, int y);
EINTERN E_Desk *e_desk_at_pos_get(E_Zone *zone, int pos);
+#endif
EINTERN void e_desk_xy_get(E_Desk *desk, int *x, int *y);
+#ifdef CONTAINER_POLICY
+#else
EINTERN void e_desk_next(E_Zone *zone);
EINTERN void e_desk_prev(E_Zone *zone);
EINTERN void e_desk_row_add(E_Zone *zone);
EINTERN void e_desk_row_remove(E_Zone *zone);
EINTERN void e_desk_col_add(E_Zone *zone);
EINTERN void e_desk_col_remove(E_Zone *zone);
+#endif
EINTERN Eina_Bool e_desk_has_ec(E_Desk *desk, E_Client *ec);
EINTERN E_Client *e_desk_top_ec_get(E_Desk *desk);
EINTERN E_Client *e_desk_bottom_ec_get(E_Desk *desk);
// listeners
EINTERN void e_desk_client_add_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_client_del_listener_add(E_Desk *desk, struct wl_listener *listener);
EINTERN void e_desk_desk_area_enable_listener_add(E_Desk *desk, struct wl_listener *listener);
EINTERN void e_desk_desk_area_disable_listener_add(E_Desk *desk, struct wl_listener *listener);
EINTERN void e_desk_desk_area_active_change_listener_add(E_Desk *desk, struct wl_listener *listener);
+#ifdef CONTAINER_POLICY
+EINTERN void e_desk_desk_new_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_desk_free_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_top_visible_get_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_name_set_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_name_add_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_name_del_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_name_update_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_desk_show_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_desk_deskshow_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_geometry_set_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_zoom_set_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_zoom_get_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_zoom_get_center_coordinate_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_zoom_unset_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_smart_member_add_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_smart_member_del_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_client_zoom_skip_set_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_client_zoom_skip_unset_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_client_zoom_apply_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_zoom_is_animating_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_visible_client_iconify_all_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_visible_client_restore_all_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_client_iconified_list_remove_listener_add(E_Desk *desk, struct wl_listener *listener);
+EINTERN void e_desk_client_iconified_list_remove_all_listener_add(E_Desk *desk, struct wl_listener *listener);
+#endif
#endif
#include "e_desk_intern.h"
#include "e_comp_intern.h"
+#include "e_focus_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
+
+#ifdef CONTAINER_POLICY
+#else
#include "e_actions_intern.h"
#include "e_appinfo_intern.h"
#include "e_bindings_intern.h"
#include "e_place_intern.h"
#include "e_policy_intern.h"
#include "e_maximize_intern.h"
-#include "e_focus_intern.h"
#include "e_policy_visibility_intern.h"
#include "e_comp_object_intern.h"
#include "e_comp_canvas_intern.h"
#include "e_comp_input_intern.h"
#include "e_input_thread_client_intern.h"
-#include "e_view_intern.h"
-#include "e_view_client_intern.h"
+#endif
#define ZONE_EC_DATA_KEY "E_Zone_Client"
struct wl_signal useful_geometry_get;
struct wl_signal bg_mouse_down;
struct wl_signal bg_mouse_up;
+ struct wl_signal desk_row_add;
+ struct wl_signal desk_row_remove;
+ struct wl_signal desk_col_add;
+ struct wl_signal desk_col_remove;
+ struct wl_signal desk_current_get;
+ struct wl_signal desk_at_xy_get;
+ struct wl_signal desk_at_pos_get;
+ struct wl_signal desk_next;
+ struct wl_signal desk_prev;
+ struct wl_signal desk_count;
#endif
struct wl_signal client_add;
#ifdef CONTAINER_POLICY
wl_signal_init(&priv->events.useful_geometry_get);
wl_signal_init(&priv->events.bg_mouse_down);
wl_signal_init(&priv->events.bg_mouse_up);
+ wl_signal_init(&priv->events.desk_row_add);
+ wl_signal_init(&priv->events.desk_row_remove);
+ wl_signal_init(&priv->events.desk_col_add);
+ wl_signal_init(&priv->events.desk_col_remove);
+ wl_signal_init(&priv->events.desk_current_get);
+ wl_signal_init(&priv->events.desk_at_xy_get);
+ wl_signal_init(&priv->events.desk_at_pos_get);
+ wl_signal_init(&priv->events.desk_next);
+ wl_signal_init(&priv->events.desk_prev);
+ wl_signal_init(&priv->events.desk_count);
#endif
wl_signal_init(&priv->events.client_add);
#ifdef CONTAINER_POLICY
wl_signal_add(&priv->events.focus_reset, listener);
}
#endif
+
+
+
+#ifdef CONTAINER_POLICY
+EINTERN void
+e_desk_row_add(E_Zone *zone)
+{
+ E_Desk_Data_Desk_Control data = {0,};
+
+ data.zone = zone;
+ wl_signal_emit(&PRI(zone)->events.desk_row_add, &data);
+}
+
+EINTERN void
+e_desk_row_remove(E_Zone *zone)
+{
+ E_Desk_Data_Desk_Control data = {0,};
+
+ data.zone = zone;
+ wl_signal_emit(&PRI(zone)->events.desk_row_remove, &data);
+}
+
+EINTERN void
+e_desk_col_add(E_Zone *zone)
+{
+ E_Desk_Data_Desk_Control data = {0,};
+
+ data.zone = zone;
+ wl_signal_emit(&PRI(zone)->events.desk_col_add, &data);
+}
+
+EINTERN void
+e_desk_col_remove(E_Zone *zone)
+{
+ E_Desk_Data_Desk_Control data = {0,};
+
+ data.zone = zone;
+ wl_signal_emit(&PRI(zone)->events.desk_col_remove, &data);
+}
+
+E_API E_Desk *
+e_desk_current_get(E_Zone *zone)
+{
+ E_Zone_Data_Desk_Get data = {0,};
+
+ E_OBJECT_CHECK_RETURN(zone, NULL);
+ E_OBJECT_TYPE_CHECK_RETURN(zone, E_ZONE_TYPE, NULL);
+
+ data.zone = zone;
+ wl_signal_emit(&PRI(zone)->events.desk_current_get, &data);
+
+ return data.desk;
+}
+
+EINTERN E_Desk *
+e_desk_at_xy_get(E_Zone *zone, int x, int y)
+{
+ E_Zone_Data_Desk_Get data = {0,};
+
+ E_OBJECT_CHECK_RETURN(zone, NULL);
+ E_OBJECT_TYPE_CHECK_RETURN(zone, E_ZONE_TYPE, NULL);
+
+ data.zone = zone;
+ data.x = x;
+ data.y = y;
+
+ wl_signal_emit(&PRI(zone)->events.desk_at_xy_get, &data);
+
+ return data.desk;
+}
+
+EINTERN E_Desk *
+e_desk_at_pos_get(E_Zone *zone, int pos)
+{
+ E_Zone_Data_Desk_Get data = {0,};
+
+ E_OBJECT_CHECK_RETURN(zone, NULL);
+ E_OBJECT_TYPE_CHECK_RETURN(zone, E_ZONE_TYPE, NULL);
+
+ data.zone = zone;
+ data.pos = pos;
+
+ wl_signal_emit(&PRI(zone)->events.desk_at_pos_get, &data);
+
+ return data.desk;
+}
+
+EINTERN void
+e_desk_next(E_Zone *zone)
+{
+ E_OBJECT_CHECK(zone);
+ E_OBJECT_TYPE_CHECK(zone, E_ZONE_TYPE);
+
+ wl_signal_emit(&PRI(zone)->events.desk_next, NULL);
+}
+
+EINTERN void
+e_desk_prev(E_Zone *zone)
+{
+ E_OBJECT_CHECK(zone);
+ E_OBJECT_TYPE_CHECK(zone, E_ZONE_TYPE);
+
+ wl_signal_emit(&PRI(zone)->events.desk_prev, NULL);
+}
+
+EINTERN unsigned int
+e_desks_count(void)
+{
+ Eina_List *l, *comp_zone_list;
+ E_Zone *zone;
+ unsigned int count = 0;
+
+ if (!(comp_zone_list = e_comp_zone_list_get())) return 0;
+
+ EINA_LIST_FOREACH(comp_zone_list, l, zone)
+ {
+ E_Zone_Data_Desk_Count data = {0,};
+ wl_signal_emit(&PRI(zone)->events.desk_count, &data);
+ count += data.count;
+ }
+
+ return count;
+}
+
+EINTERN void
+e_zone_desk_row_add_listener_add(E_Zone *zone, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.desk_row_add, listener);
+}
+
+EINTERN void
+e_zone_desk_row_remove_listener_add(E_Zone *zone, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.desk_row_remove, listener);
+}
+
+EINTERN void
+e_zone_desk_col_add_listener_add(E_Zone *zone, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.desk_col_add, listener);
+}
+
+EINTERN void
+e_zone_desk_col_remove_listener_add(E_Zone *zone, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.desk_col_remove, listener);
+}
+
+EINTERN void
+e_zone_desk_current_get_listener_add(E_Zone *zone, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.desk_current_get, listener);
+}
+
+EINTERN void
+e_zone_desk_at_xy_get_listener_add(E_Zone *zone, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.desk_at_xy_get, listener);
+}
+
+EINTERN void
+e_zone_desk_at_pos_get_listener_add(E_Zone *zone, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.desk_at_pos_get, listener);
+}
+
+EINTERN void
+e_zone_desk_next_listener_add(E_Zone *zone, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.desk_next, listener);
+}
+
+EINTERN void
+e_zone_desk_prev_listener_add(E_Zone *zone, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.desk_prev, listener);
+}
+
+EINTERN void
+e_zone_desk_count_listener_add(E_Zone *zone, struct wl_listener *listener)
+{
+ API_ENTRY;
+ wl_signal_add(&priv->events.desk_count, listener);
+}
+
+#endif
\ No newline at end of file
} E_Zone_Data_Useful_Geometry;
#endif
+#ifdef CONTAINER_POLICY
+typedef struct _E_Zone_Data_Desk_Get
+{
+ E_Zone *zone;
+ int x, y;
+ int pos;
+ E_Desk *desk;
+}E_Zone_Data_Desk_Get;
+
+typedef struct _E_Zone_Data_Desk_Count
+{
+ unsigned int count;
+} E_Zone_Data_Desk_Count;
+
+#endif
+
EINTERN int e_zone_init(void);
EINTERN int e_zone_shutdown(void);
EINTERN void e_zone_focus_reset_listener_add(E_Zone *zone, struct wl_listener *listener);
#endif
+#ifdef CONTAINER_POLICY
+EINTERN void e_desk_row_add(E_Zone *zone);
+EINTERN void e_desk_row_remove(E_Zone *zone);
+EINTERN void e_desk_col_add(E_Zone *zone);
+EINTERN void e_desk_col_remove(E_Zone *zone);
+EINTERN E_Desk *e_desk_at_xy_get(E_Zone *zone, int x, int y);
+EINTERN E_Desk *e_desk_at_pos_get(E_Zone *zone, int pos);
+EINTERN void e_desk_next(E_Zone *zone);
+EINTERN void e_desk_prev(E_Zone *zone);
+
+EINTERN void e_zone_desk_row_add_listener_add(E_Zone *zone, struct wl_listener *listener);
+EINTERN void e_zone_desk_row_remove_listener_add(E_Zone *zone, struct wl_listener *listener);
+EINTERN void e_zone_desk_col_add_listener_add(E_Zone *zone, struct wl_listener *listener);
+EINTERN void e_zone_desk_col_remove_listener_add(E_Zone *zone, struct wl_listener *listener);
+EINTERN void e_zone_desk_current_get_listener_add(E_Zone *zone, struct wl_listener *listener);
+EINTERN void e_zone_desk_at_xy_get_listener_add(E_Zone *zone, struct wl_listener *listener);
+EINTERN void e_zone_desk_at_pos_get_listener_add(E_Zone *zone, struct wl_listener *listener);
+EINTERN void e_zone_desk_next_listener_add(E_Zone *zone, struct wl_listener *listener);
+EINTERN void e_zone_desk_prev_listener_add(E_Zone *zone, struct wl_listener *listener);
+EINTERN void e_zone_desk_count_listener_add(E_Zone *zone, struct wl_listener *listener);
+#endif
+
#endif
#endif
E_Policy *e_policy = NULL;
+#ifdef CONTAINER_POLICY
+#else
Eina_Hash *hash_policy_desks = NULL;
+#endif
Eina_Hash *hash_policy_clients = NULL;
E_Policy_System_Info e_policy_system_info =
{
static void _e_policy_cb_hook_pixmap_del(void *data EINA_UNUSED, E_Pixmap *cp);
static void _e_policy_cb_hook_pixmap_unusable(void *data EINA_UNUSED, E_Pixmap *cp);
+#ifdef CONTAINER_POLICY
+#else
static void _e_policy_cb_desk_data_free(void *data);
+#endif
static void _e_policy_cb_client_data_free(void *data);
static Eina_Bool _e_policy_cb_zone_add(void *data EINA_UNUSED, int type EINA_UNUSED, void *event);
static Eina_Bool _e_policy_cb_zone_del(void *data EINA_UNUSED, int type EINA_UNUSED, void *event);
if (ec->internal) goto delete_hook;
if (ec->new_client) goto delete_hook;
+#ifdef CONTAINER_POLICY
+ pd = e_policy_desk_get(desk);
+#else
pd = eina_hash_find(hash_policy_desks, &desk);
+#endif
if (pd)
_e_policy_client_maximize_policy_apply(pc);
else
if (!_e_policy_client_normal_check(ec)) return;
+#ifdef CONTAINER_POLICY
+ pd = e_policy_desk_get(desk);
+#else
pd = eina_hash_find(hash_policy_desks, &desk);
+#endif
if (!pd) return;
pc = eina_hash_find(hash_policy_clients, &ec);
e_policy_client_unmap(ec);
}
+#ifdef CONTAINER_POLICY
+#else
static void
_e_policy_cb_desk_data_free(void *data)
{
free(data);
}
+#endif
static void
_e_policy_cb_client_data_free(void *data)
zone->desks[i]->x,
zone->desks[i]->y);
if (d)
- e_policy_desk_add(zone->desks[i]);
+ {
+ e_policy_desk_add(zone->desks[i]);
+ e_desk_show(zone->desks[i]);
+ }
}
else
- e_policy_desk_add(zone->desks[i]);
+ {
+ e_policy_desk_add(zone->desks[i]);
+ e_desk_show(zone->desks[i]);
+ }
}
/* add and show softkey */
n = zone->desk_y_count * zone->desk_x_count;
for (i = 0; i < n; i++)
{
+#ifdef CONTAINER_POLICY
+ pd = e_policy_desk_get(zone->desks[i]);
+#else
pd = eina_hash_find(hash_policy_desks, &zone->desks[i]);
+#endif
if (pd) e_policy_desk_del(pd);
}
E_Event_Zone_Desk_Count_Set *ev;
E_Zone *zone;
E_Desk *desk;
+#ifdef CONTAINER_POLICY
+#else
Eina_Iterator *it;
+ Eina_Bool found;
+#endif
E_Policy_Desk *pd;
E_Config_Policy_Desk *d;
int i, n;
- Eina_Bool found;
Eina_List *desks_del = NULL;
ev = event;
zone = ev->zone;
/* remove deleted desk from hash */
+#ifdef CONTAINER_POLICY
+ n = zone->desk_y_count * zone->desk_x_count;
+ for (i = 0; i < n; i++)
+ {
+ pd = e_policy_desk_get(zone->desks[i]);
+ if (!pd)
+ {
+ desks_del = eina_list_append(desks_del, zone->desks[i]);
+ break;
+ }
+ }
+#else
it = eina_hash_iterator_data_new(hash_policy_desks);
while (eina_iterator_next(it, (void **)&pd))
{
desks_del = eina_list_append(desks_del, pd->desk);
}
eina_iterator_free(it);
+#endif
EINA_LIST_FREE(desks_del, desk)
{
+#ifdef CONTAINER_POLICY
+ pd = e_policy_desk_get(desk);
+#else
pd = eina_hash_find(hash_policy_desks, &desk);
+#endif
if (pd) e_policy_desk_del(pd);
}
zone->desks[i]->x,
zone->desks[i]->y);
if (d)
- e_policy_desk_add(zone->desks[i]);
+ {
+ e_policy_desk_add(zone->desks[i]);
+ e_desk_show(zone->desks[i]);
+ }
}
else
- e_policy_desk_add(zone->desks[i]);
+ {
+ e_policy_desk_add(zone->desks[i]);
+ e_desk_show(zone->desks[i]);
+ }
}
return ECORE_CALLBACK_PASS_ON;
softkey = e_policy_softkey_get(ev->desk->zone);
if (!softkey)
softkey = e_policy_softkey_add(ev->desk->zone);
-
+#ifdef CONTAINER_POLICY
+ if (e_policy_desk_get(ev->desk))
+#else
if (eina_hash_find(hash_policy_desks, &ev->desk))
+#endif
e_policy_softkey_show(softkey);
else
e_policy_softkey_hide(softkey);
return ECORE_CALLBACK_RENEW;
}
+#ifdef CONTAINER_POLICY
+#else
EINTERN void
e_policy_desk_add(E_Desk *desk)
{
E_Client *ec;
E_Policy_Client *pc;
+ ELOGF("JUNSEOK", "\tdesk add, desk:%p", NULL, desk);
+
pd = eina_hash_find(hash_policy_desks, &desk);
- if (pd) return;
+ if (pd)
+ {
+ ELOGF("JUNSEOK", "\t\talready added desk:%p, returned", NULL, desk);
+ return;
+ }
pd = E_NEW(E_Policy_Desk, 1);
if (!pd) return;
eina_hash_del_by_key(hash_policy_desks, &pd->desk);
}
+#endif
EINTERN E_Policy_Client *
e_policy_client_launcher_get(E_Zone *zone)
desk = e_zone_desk_find_by_ec(pc->zone, ec);
EINA_SAFETY_ON_NULL_RETURN_VAL(desk, EINA_FALSE);
+#ifdef CONTAINER_POLICY
+ pd = e_policy_desk_get(desk);
+#else
pd = eina_hash_find(hash_policy_desks, &desk);
+#endif
if (!pd) return EINA_FALSE;
if (pc->flt_policy_state)
return _e_policy_client_maximize_policy_apply(pc);
}
+#ifdef CONTAINER_POLICY
+EINTERN Eina_Bool
+e_policy_client_maximize_policy_apply(E_Policy_Client *pc)
+{
+ EINA_SAFETY_ON_NULL_RETURN_VAL(pc, EINA_FALSE);
+
+ return _e_policy_client_maximize_policy_apply(pc);
+}
+
+EINTERN void
+e_policy_client_maximize_policy_cancel(E_Policy_Client *pc)
+{
+ EINA_SAFETY_ON_NULL_RETURN(pc);
+
+ _e_policy_client_maximize_policy_cancel(pc);
+}
+#endif
+
EINTERN void
e_policy_keyboard_layout_apply(E_Client *ec EINA_UNUSED)
{
return pc;
}
+#ifdef CONTAINER_POLICY
+EINTERN E_Policy_Client *
+e_policy_client_get(E_Client *ec)
+{
+ E_Policy_Client *pc;
+
+ if (e_object_is_del(E_OBJECT(ec))) return NULL;
+
+ pc = eina_hash_find(hash_policy_clients, &ec);
+ if (pc) return pc;
+ return NULL;
+}
+#endif
+
EINTERN int
e_policy_init(void)
{
e_policy = pol;
hash_policy_clients = eina_hash_pointer_new(_e_policy_cb_client_data_free);
+#ifdef CONTAINER_POLICY
+#else
hash_policy_desks = eina_hash_pointer_new(_e_policy_cb_desk_data_free);
+#endif
E_EVENT_POLICY_QUICKPANEL_VISIBLE_STATE_CHANGE = ecore_event_type_new();
E_FREE_LIST(hooks_ec, e_client_hook_del);
E_FREE_LIST(handlers, ecore_event_handler_del);
+#ifdef CONTAINER_POLICY
+#else
E_FREE_FUNC(hash_policy_desks, eina_hash_free);
+#endif
E_FREE_FUNC(hash_policy_clients, eina_hash_free);
e_policy_stack_shutdown();
#include "e_policy_desk_intern.h"
#ifdef CONTAINER_POLICY
+#include "e_policy_intern.h"
+#include "e_policy_softkey_intern.h"
+#include "e_desk_area_intern.h"
+#include "e_client_intern.h"
+#include "e_utils_intern.h"
+#include "e_comp_wl_subsurface_intern.h"
+#include "e_output_intern.h"
+#include "e_zone_intern.h"
+#include "e_config_intern.h"
+#include "e_policy_wl_intern.h"
+#include "e_display_intern.h"
+#include "e_view_intern.h"
+#include "e_view_client_intern.h"
+#define DESK_EC_DATA_KEY "E_Desk_Client"
+typedef struct _E_Policy_Desk_Private_Client E_Policy_Desk_Private_Client;
+typedef struct _E_Policy_Desk_Smart_Data E_Policy_Desk_Smart_Data;
+
+#define E_POLICY_DESK_SMART_DATA_GET(obj, ptr) \
+ E_Policy_Desk_Smart_Data *ptr = evas_object_smart_data_get(obj);
+
+#define E_POLICY_DESK_SMART_DATA_GET_OR_RETURN(obj, ptr) \
+ E_POLICY_DESK_SMART_DATA_GET(obj, ptr); \
+if (!ptr) return
+
+EVAS_SMART_SUBCLASS_NEW(E_POLICY_DESK_SMART_OBJ_TYPE, _e_policy_desk,
+ Evas_Smart_Class, Evas_Smart_Class,
+ evas_object_smart_clipped_class_get, NULL)
+
+ typedef enum _E_Policy_Desk_Zoom_Animating_Type
+{
+ E_POLICY_DESK_ZOOM_ANIMATING_TYPE_NONE,
+ E_POLICY_DESK_ZOOM_ANIMATING_TYPE_ENABLE,
+ E_POLICY_DESK_ZOOM_ANIMATING_TYPE_DISABLE,
+} E_Policy_Desk_Zoom_Animating_Type;
+
+struct _E_Policy_Desk
+{
+ E_Desk *desk;
+ E_Zone *zone;
+
+ struct wl_listener desk_new;
+ struct wl_listener desk_free;
+ struct wl_listener top_visible_get;
+ struct wl_listener name_set;
+ struct wl_listener name_add;
+ struct wl_listener name_del;
+ struct wl_listener name_update;
+ struct wl_listener desk_show;
+ struct wl_listener desk_deskshow;
+ struct wl_listener desk_client_add;
+ struct wl_listener desk_client_del;
+ struct wl_listener geometry_set;
+ struct wl_listener zoom_set;
+ struct wl_listener zoom_get;
+ struct wl_listener zoom_get_center_coordinate;
+ struct wl_listener zoom_unset;
+ struct wl_listener smart_member_add;
+ struct wl_listener smart_member_del;
+ struct wl_listener client_zoom_skip_set;
+ struct wl_listener client_zoom_skip_unset;
+ struct wl_listener client_zoom_apply;
+ struct wl_listener zoom_is_animating;
+ struct wl_listener visible_client_iconify_all;
+ struct wl_listener visible_client_restore_all;
+ struct wl_listener client_iconified_list_remove;
+ struct wl_listener client_iconified_list_remove_all;
+};
+
+struct _E_Policy_Desk_Private_Client
+{
+ E_Desk *desk;
+ E_Client *ec;
+ Eina_Bool skip_zoom;
+
+ // client listeners
+ struct wl_listener client_destroy;
+ struct wl_listener client_activate_done;
+};
+
+struct _E_Policy_Desk_Smart_Data
+{
+ Evas_Object_Smart_Clipped_Data base;
+ Eina_List *clients;
+ Eina_List *handlers;
+
+ struct
+ {
+ double ratio_x, ratio_y;
+ int cord_x, cord_y;
+ double prev_ratio_x, prev_ratio_y;
+ int prev_cord_x, prev_cord_y;
+ Eina_Bool enabled;
+ Ecore_Animator *animator;
+ E_Policy_Desk_Zoom_Animating_Type animating_type;
+ } zoom;
+};
+
+Eina_Hash *hash_policy_desks = NULL;
+static int _e_policy_desk_hooks_delete = 0;
+static int _e_policy_desk_hooks_walking = 0;
+
+static Eina_Inlist *_e_policy_desk_hooks[] =
+{
+ [E_DESK_HOOK_CLIENT_ADD] = NULL,
+ [E_DESK_HOOK_DESK_AREA_ENABLE] = NULL,
+ [E_DESK_HOOK_DESK_AREA_DISABLE] = NULL,
+ [E_DESK_HOOK_DESK_AREA_ACTIVE_CHANGE] = NULL,
+ [E_DESK_HOOK_SPLIT_DESK_ACTIVATE] = NULL,
+ [E_DESK_HOOK_SPLIT_DESK_DEACTIVATE] = NULL,
+};
+
+
+static void _e_policy_desk_object_zoom(Evas_Object *obj, double zoomx, double zoomy, Evas_Coord cx, Evas_Coord cy);
+static void _e_policy_desk_client_zoom(E_Client *ec, double zoomx, double zoomy, Evas_Coord cx, Evas_Coord cy);
+
+static void _e_policy_desk_cb_client_destroy(struct wl_listener *listener, void *data);
+static void _e_policy_desk_cb_client_activate_done(struct wl_listener *listener, void *data);
+
+
+
+static void
+_e_policy_desk_cb_desk_data_free(void *data)
+{
+ free(data);
+}
+
+static void
+_e_policy_desk_event_desk_geometry_change_free(void *d EINA_UNUSED, void *event)
+{
+ E_Event_Desk_Geometry_Change *ev;
+
+ ev = (E_Event_Desk_Geometry_Change *) event;
+ e_object_unref(E_OBJECT(ev->desk));
+ free(ev);
+}
+
+static void
+_e_policy_desk_event_simple_free(void *d EINA_UNUSED, void *event)
+{
+ E_Event_Desk *ev;
+
+ ev = (E_Event_Desk *) event;
+ e_object_unref(E_OBJECT(ev->desk));
+ free(ev);
+}
+
+static Ecore_Event *
+_e_policy_desk_event_simple_add(E_Desk *desk, int type)
+{
+ E_Event_Desk *ev;
+
+ ev = E_NEW(E_Event_Desk, 1);
+ if (!ev) return NULL;
+ ev->desk = desk;
+ e_object_ref(E_OBJECT(desk));
+ return ecore_event_add(type, ev, _e_policy_desk_event_simple_free, NULL);
+}
+
+static void
+_e_policy_desk_hooks_clean(void)
+{
+ Eina_Inlist *l;
+ E_Desk_Hook *dh;
+ unsigned int x;
+
+ for (x = 0; x < E_DESK_HOOK_LAST; x++)
+ EINA_INLIST_FOREACH_SAFE(_e_policy_desk_hooks[x], l, dh)
+ {
+ if (!dh->delete_me) continue;
+ _e_policy_desk_hooks[x] = eina_inlist_remove(_e_policy_desk_hooks[x], EINA_INLIST_GET(dh));
+ free(dh);
+ }
+
+ _e_policy_desk_hooks_delete = 0;
+}
+
+static Eina_Bool
+_e_policy_desk_hook_call(E_Desk_Hook_Point hookpoint, E_Desk *desk)
+{
+ E_Desk_Hook *dh;
+
+ e_object_ref(E_OBJECT(desk));
+ _e_policy_desk_hooks_walking++;
+ EINA_INLIST_FOREACH(_e_policy_desk_hooks[hookpoint], dh)
+ {
+ if (dh->delete_me) continue;
+ dh->func(dh->data, desk);
+ }
+ _e_policy_desk_hooks_walking--;
+ if ((_e_policy_desk_hooks_walking == 0) && (_e_policy_desk_hooks_delete > 0))
+ _e_policy_desk_hooks_clean();
+
+ return !!e_object_unref(E_OBJECT(desk));
+}
+
+E_API E_Desk_Hook *
+e_desk_hook_add(E_Desk_Hook_Point hookpoint, E_Desk_Hook_Cb func, const void *data)
+{
+ E_Desk_Hook *dh;
+
+ EINA_SAFETY_ON_TRUE_RETURN_VAL(hookpoint >= E_DESK_HOOK_LAST, NULL);
+ dh = E_NEW(E_Desk_Hook, 1);
+ if (!dh) return NULL;
+
+ dh->hookpoint = hookpoint;
+ dh->func = func;
+ dh->data = (void*)data;
+
+ _e_policy_desk_hooks[hookpoint] = eina_inlist_append(_e_policy_desk_hooks[hookpoint], EINA_INLIST_GET(dh));
+ return dh;
+}
+
+E_API void
+e_desk_hook_del(E_Desk_Hook * dh)
+{
+ dh->delete_me = 1;
+ if (_e_policy_desk_hooks_walking == 0)
+ {
+ _e_policy_desk_hooks[dh->hookpoint] = eina_inlist_remove(_e_policy_desk_hooks[dh->hookpoint], EINA_INLIST_GET(dh));
+ free(dh);
+ }
+ else
+ _e_policy_desk_hooks_delete++;
+}
+
+EINTERN void
+e_desk_desk_area_info_print(E_Desk *desk)
+{
+ 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_AREA_LAYER_COUNT-1; i>=0; i--)
+ {
+ EINA_LIST_FOREACH(desk->desk_area.list[i], l, eda)
+ {
+ e_desk_area_info_print(eda);
+ }
+ }
+}
+
+
+static void
+_e_policy_desk_client_data_del(E_Desk *desk, E_Client *ec)
+{
+ e_view_data_del(e_view_client_view_get(e_client_view_get(ec)), DESK_EC_DATA_KEY);
+}
+
+static void
+_e_policy_desk_client_data_set(E_Desk *desk, E_Client *ec)
+{
+ E_Desk *data;
+
+ data = e_view_data_get(e_view_client_view_get(e_client_view_get(ec)), DESK_EC_DATA_KEY);
+ if (data)
+ {
+ if (data == desk)
+ {
+ ELOGF("E_DESK", "EC is already added to desk_id:%d", ec, desk->id);
+ return;
+ }
+
+ _e_policy_desk_client_data_del(desk, ec);
+ }
+
+ e_view_data_set(e_view_client_view_get(e_client_view_get(ec)), DESK_EC_DATA_KEY, desk);
+}
+
+static void
+_e_policy_desk_smart_init(E_Desk *desk)
+{
+ E_Zone *zone;
+
+ zone = desk->zone;
+
+ desk->smart_obj = evas_object_smart_add(e_comp_evas_get(), _e_policy_desk_smart_class_new());
+ e_desk_geometry_set(desk, zone->x, zone->y, zone->w, zone->h);
+
+ E_POLICY_DESK_SMART_DATA_GET_OR_RETURN(desk->smart_obj, sd);
+
+ sd->zoom.ratio_x = 1.0;
+ sd->zoom.ratio_y = 1.0;
+ sd->zoom.cord_x = 0;
+ sd->zoom.cord_y = 0;
+}
+
+static void
+_e_policy_desk_smart_client_add(Evas_Object *obj, E_Client *ec)
+{
+ Evas_Object *parent = NULL;
+ E_Desk *ec_desk;
+
+ E_POLICY_DESK_SMART_DATA_GET_OR_RETURN(obj, sd);
+
+ ec_desk = e_comp_desk_find_by_ec(ec);
+ if (!ec_desk) return;
+
+ // if ec is a member of e_desk, don't add it in data.
+ parent = evas_object_smart_parent_get(ec->frame);
+ if (parent && (parent == ec_desk->smart_obj)) return;
+
+ if (eina_list_data_find(sd->clients, ec))
+ return;
+
+ sd->clients = eina_list_append(sd->clients, ec);
+ evas_object_smart_changed(obj);
+}
+
+static void
+_e_policy_desk_smart_client_del(Evas_Object *obj, E_Client *ec)
+{
+ E_POLICY_DESK_SMART_DATA_GET_OR_RETURN(obj, sd);
+
+ if (!eina_list_data_find(sd->clients, ec))
+ return;
+
+ if (sd->zoom.enabled)
+ _e_policy_desk_client_zoom(ec, 1.0, 1.0, 0, 0);
+
+ sd->clients = eina_list_remove(sd->clients, ec);
+ evas_object_smart_changed(obj);
+}
+
+
+static void
+_e_policy_desk_client_set(E_Desk *desk, E_Client *ec)
+{
+ ec->desk = desk; // FIXME: This line must be deleted.
+
+ if (!ec->new_client)
+ {
+ if (e_client_view_get(ec))
+ {
+ e_view_client_effect_unclip(e_client_view_get(ec));
+ e_view_client_effect_set(e_client_view_get(ec), NULL);
+ }
+ if (desk->visible || ec->sticky)
+ {
+ if ((!ec->hidden) && (!ec->iconic))
+ e_view_client_show(e_client_view_get(ec));
+ }
+ else
+ {
+ ec->hidden = 1;
+ e_view_client_hide(e_client_view_get(ec));
+ }
+ }
+
+ e_client_comp_hidden_set(ec, (!desk->visible) && (!ec->sticky));
+
+ if (e_config->transient.desktop)
+ {
+ E_Client *child;
+ const Eina_List *l;
+
+ EINA_LIST_FOREACH(ec->transients, l, child)
+ e_desk_client_add(desk, child);
+ }
+}
+
+static E_Policy_Desk_Private_Client *
+_e_policy_desk_private_client_get(E_Client *ec)
+{
+ E_Policy_Desk_Private_Client *desk_client;
+ struct wl_listener *listener;
+
+ listener = e_client_destroy_listener_get(ec, _e_policy_desk_cb_client_destroy);
+ if (!listener) return NULL;
+
+ return wl_container_of(listener, desk_client, client_destroy);
+}
+
+static void
+_e_policy_desk_private_client_del(E_Policy_Desk_Private_Client *desk_client)
+{
+ E_Desk *desk = desk_client->desk;
+ E_Client *ec = desk_client->ec;
+
+ _e_policy_desk_smart_client_del(desk->smart_obj, ec);
+ _e_policy_desk_client_data_del(desk, ec);
+
+ wl_list_remove(&desk_client->client_activate_done.link);
+ wl_list_remove(&desk_client->client_destroy.link);
+
+ E_FREE(desk_client);
+}
+
+
+
+static Eina_Bool
+_e_policy_desk_transition_setup(E_Client *ec, int dx, int dy, int state)
+{
+ e_view_client_effect_set(e_client_view_get(ec), "none");
+
+ return EINA_FALSE;
+}
+
+static void
+_e_policy_desk_show_end(void *data, E_View_Client *client, const char *emission, const char *source)
+{
+ E_Client *ec = data;
+ E_Zone *ec_zone;
+ E_Desk *ec_desk;
+
+ ec_zone = e_comp_zone_find_by_ec(ec);
+ ec_desk = e_zone_desk_find_by_ec(ec_zone, ec);
+ if (ec_desk)
+ ec_desk->animate_count--;
+
+ e_client_comp_hidden_set(ec, 0);
+ e_view_client_effect_unclip(e_client_view_get(ec));
+ ec->hidden = 0;
+ if (!ec->visible)
+ e_view_client_show(e_client_view_get(ec));
+
+ if (ec_desk != e_desk_current_get(ec_zone)) return;
+}
+
+static void
+_e_policy_desk_hide_end(void *data, E_View_Client *client, const char *emission, const char *source)
+{
+ E_Client *ec = data;
+ E_Desk *ec_desk;
+
+ ec_desk = e_comp_desk_find_by_ec(ec);
+ if (ec_desk)
+ ec_desk->animate_count--;
+ ec->hidden = 1;
+ e_view_client_hide(e_client_view_get(ec));
+}
+
+static void
+_e_policy_desk_show_begin(E_Desk *desk, int dx, int dy)
+{
+ E_Client *ec;
+
+ if (dx < 0) dx = -1;
+ if (dx > 0) dx = 1;
+ if (dy < 0) dy = -1;
+ if (dy > 0) dy = 1;
+
+ desk->animate_count = 0;
+ E_CLIENT_FOREACH(ec)
+ {
+ if (e_client_util_ignored_get(ec) || (!e_zone_has_ec(desk->zone, ec)) || (ec->iconic)) continue;
+ if (ec->moving)
+ {
+ e_desk_client_add(desk, ec);
+ e_view_client_show(e_client_view_get(ec));
+ continue;
+ }
+ if ((!e_desk_has_ec(desk, ec)) || (ec->sticky)) continue;
+ if ((!starting) && (!ec->new_client) && _e_policy_desk_transition_setup(ec, dx, dy, 1))
+ {
+ e_view_client_effect_stop(e_client_view_get(ec), _e_policy_desk_hide_end);
+ e_view_client_effect_start(e_client_view_get(ec), _e_policy_desk_show_end, ec);
+ desk->animate_count++;
+ }
+ else
+ ec->hidden = 0;
+
+ e_client_comp_hidden_set(ec, ec->hidden);
+ e_view_client_show(e_client_view_get(ec));
+ }
+}
+
+static void
+_e_policy_desk_hide_begin(E_Desk *desk, int dx, int dy)
+{
+ E_Client *ec;
+
+ if (dx < 0) dx = -1;
+ if (dx > 0) dx = 1;
+ if (dy < 0) dy = -1;
+ if (dy > 0) dy = 1;
+
+ desk->animate_count = 0;
+ E_CLIENT_FOREACH(ec)
+ {
+ if (e_client_util_ignored_get(ec)) continue;
+ if ((!e_zone_has_ec(desk->zone, ec)) || (ec->iconic)) continue;
+ if (ec->moving) continue;
+ if ((!e_desk_has_ec(desk, ec)) || (ec->sticky)) continue;
+ if ((!starting) && (!ec->new_client) && _e_policy_desk_transition_setup(ec, -dx, -dy, 0))
+ {
+ e_view_client_effect_stop(e_client_view_get(ec), _e_policy_desk_show_end);
+ e_view_client_effect_start(e_client_view_get(ec), _e_policy_desk_hide_end, ec);
+ desk->animate_count++;
+ }
+ else
+ {
+ ec->hidden = 1;
+ e_view_client_show(e_client_view_get(ec));
+ ec->changes.visible = 0;
+ e_view_client_hide(e_client_view_get(ec));
+ }
+ e_client_comp_hidden_set(ec, EINA_TRUE);
+ }
+}
+
+static void
+_e_policy_desk_object_zoom(Evas_Object *obj, double zoomx, double zoomy, Evas_Coord cx, Evas_Coord cy)
+{
+ E_Map *map;
+
+ if (!obj) return;
+ if ((zoomx == 1.0) && (zoomy == 1.0))
+ {
+ e_comp_object_map_enable_set(obj, EINA_FALSE);
+ e_comp_object_map_set(obj, NULL);
+ return;
+ }
+
+ map = e_map_new();
+ e_map_util_points_populate_from_object(map, obj);
+ e_map_util_zoom(map, zoomx, zoomy, cx, cy);
+ e_comp_object_map_set(obj, map);
+ e_comp_object_map_enable_set(obj, EINA_TRUE);
+ e_map_free(map);
+}
+
+static void
+_e_policy_desk_client_subsurf_create(void *data, E_Client *subc)
+{
+ E_Client *ec, *parent;
+ ec = data;
+
+ if (ec != subc) return;
+
+ if (ec->desk_zoom.transform)
+ {
+ e_client_transform_core_remove(ec, ec->desk_zoom.transform);
+ E_FREE_FUNC(ec->desk_zoom.transform, e_util_transform_del);
+ }
+
+ parent = e_comp_wl_topmost_parent_get(ec);
+ if (parent)
+ {
+ parent->transform_core.changed = EINA_TRUE;
+ e_client_transform_core_update(parent);
+ }
+}
+
+static void
+_e_policy_desk_client_deskzoom_set(E_Client *ec, double zoomx, double zoomy, Evas_Coord cx, Evas_Coord cy)
+{
+ if (e_comp_wl_subsurface_check(ec)) return;
+
+ if ((zoomx == 1.0) && (zoomy == 1.0))
+ {
+ if (ec->desk_zoom.transform)
+ e_client_transform_core_remove(ec, ec->desk_zoom.transform);
+ e_client_transform_core_update(ec);
+ return;
+ }
+
+ if (!ec->desk_zoom.transform)
+ {
+ ec->desk_zoom.transform = e_util_transform_new();
+ e_util_transform_role_set(ec->desk_zoom.transform, "desk_zoom");
+
+ if (!ec->desk_zoom.hook_subsurf_create)
+ {
+ ec->desk_zoom.hook_subsurf_create =
+ e_comp_wl_hook_add(E_COMP_WL_HOOK_SUBSURFACE_CREATE,
+ _e_policy_desk_client_subsurf_create, ec);
+ }
+ }
+
+ e_util_transform_zoom_set(ec->desk_zoom.transform, zoomx, zoomy, cx, cy);
+ e_client_transform_core_add(ec, ec->desk_zoom.transform);
+
+ e_client_transform_core_update(ec);
+}
+
+static void
+_e_policy_desk_client_zoom(E_Client *ec, double zoomx, double zoomy, Evas_Coord cx, Evas_Coord cy)
+{
+ if (e_object_is_del(E_OBJECT(ec))) return;
+ if (ec->is_cursor) return;
+
+ E_Policy_Desk_Private_Client *desk_client = _e_policy_desk_private_client_get(ec);
+ EINA_SAFETY_ON_NULL_RETURN(desk_client);
+
+ if (desk_client->skip_zoom)
+ return;
+
+ if ((zoomx == 1.0) && (zoomy == 1.0))
+ e_client_desk_zoom_enable_set(ec, EINA_FALSE);
+ else
+ e_client_desk_zoom_enable_set(ec, EINA_TRUE);
+
+ _e_policy_desk_client_deskzoom_set(ec, zoomx, zoomy, cx, cy);
+
+ if (e_view_client_visible_get(e_client_view_get(ec)))
+ {
+ // force update
+ e_view_client_damage(e_client_view_get(ec), 0, 0, ec->w, ec->h);
+ e_view_client_dirty(e_client_view_get(ec));
+ e_view_client_render(e_client_view_get(ec));
+ }
+}
+
+static Eina_Bool
+_e_policy_desk_smart_client_cb_resize(void *data, int type, void *event)
+{
+ E_Event_Client *ev;
+ E_Policy_Desk_Smart_Data *sd;
+ E_Client *ec = NULL;
+
+ if (!data) goto end;
+ if (!event) goto end;
+
+ ev = event;
+ sd = data;
+ ec = ev->ec;
+ if (!ec) goto end;
+
+ if (!eina_list_data_find(sd->clients, ec))
+ goto end;
+
+ if (sd->zoom.animator)
+ goto end;
+
+ if (sd->zoom.enabled)
+ _e_policy_desk_client_zoom(ec,
+ sd->zoom.ratio_x, sd->zoom.ratio_y,
+ sd->zoom.cord_x, sd->zoom.cord_y);
+end:
+ return ECORE_CALLBACK_PASS_ON;
+}
+
+static void
+_e_policy_desk_smart_add(Evas_Object *obj)
+{
+ EVAS_SMART_DATA_ALLOC(obj, E_Policy_Desk_Smart_Data);
+
+ /* to apply zoom transformation whenever the client's size is changed. */
+ E_LIST_HANDLER_APPEND(priv->handlers, E_EVENT_CLIENT_RESIZE, _e_policy_desk_smart_client_cb_resize, priv);
+
+ /* FIXME hard coded, it will be laid upper than unpacked clients */
+ evas_object_layer_set(obj, E_LAYER_DESK_OBJECT);
+
+ _e_policy_desk_parent_sc->add(obj);
+}
+
+static void
+_e_policy_desk_smart_del(Evas_Object *obj)
+{
+ _e_policy_desk_parent_sc->del(obj);
+
+ E_POLICY_DESK_SMART_DATA_GET_OR_RETURN(obj, sd);
+
+ E_FREE_LIST(sd->handlers, ecore_event_handler_del);
+ eina_list_free(sd->clients);
+ free(sd);
+
+ evas_object_smart_data_set(obj, NULL);
+}
+
+static void
+_e_policy_desk_smart_member_add(Evas_Object *obj, Evas_Object *child)
+{
+ E_Client *ec;
+ E_Desk *ec_desk;
+
+ _e_policy_desk_parent_sc->member_add(obj, child);
+
+ ec = evas_object_data_get(child, "E_Client");
+ if (ec)
+ {
+ ec_desk = e_comp_desk_find_by_ec(ec);
+ if (ec_desk)
+ e_desk_client_del(ec_desk, ec);
+ }
+}
+
+static void
+_e_policy_desk_smart_member_del(Evas_Object *obj, Evas_Object *child)
+{
+ E_Client *ec = NULL;
+ Evas_Object *parent = NULL;
+ E_Zone*ec_zone;
+ E_Desk *ec_desk;
+
+ _e_policy_desk_parent_sc->member_del(obj, child);
+
+ // if quickpanel packed into mover smart obj, _e_policy_desk_smart_member_del is called
+ // but parent is still e_desk, because mover's parent is the same e_desk
+ // than don't add ec on the sd->clists
+ parent = evas_object_smart_parent_get(child);
+ if (parent && (parent == obj)) return;
+
+ ec = evas_object_data_get(child, "E_Client");
+ if (ec)
+ {
+ ec_zone = e_comp_zone_find_by_ec(ec);
+ ec_desk = e_zone_desk_find_by_ec(ec_zone, ec);
+ if (ec_desk)
+ _e_policy_desk_smart_client_add(ec_desk->smart_obj, ec);
+ }
+}
+
+static void
+_e_policy_desk_smart_set_user(Evas_Smart_Class *sc)
+{
+ sc->add = _e_policy_desk_smart_add;
+ sc->del = _e_policy_desk_smart_del;
+ sc->member_add = _e_policy_desk_smart_member_add;
+ sc->member_del = _e_policy_desk_smart_member_del;
+}
+#if 0
+static void
+_e_policy_desk_cb_desk_new(struct wl_listener *listener, void *data)
+{
+ E_Policy_Desk *pd;
+ E_Zone *zone;
+ E_Desk *desk;
+ Eina_List *l;
+ E_Config_Desktop_Name *cfname;
+ char name[40];
+ int ok = 0;
+
+ pd = wl_container_of(listener, pd, desk_new);
+ desk = data;
+ zone = desk->zone;
+
+ ELOGF("POL_DESK", "Desk NEW. desk:%p", NULL, desk);
+
+ /* init smart object */
+ _e_policy_desk_smart_init(desk);
+
+ /* Get current desktop's name */
+ EINA_LIST_FOREACH(e_config->desktop_names, l, cfname)
+ {
+ if ((cfname->zone >= 0) &&
+ ((int)zone->num != cfname->zone)) continue;
+ if ((cfname->desk_x != desk->x) || (cfname->desk_y != desk->y))
+ continue;
+ desk->name = eina_stringshare_ref(cfname->name);
+ ok = 1;
+ break;
+ }
+
+ if (!ok)
+ {
+ snprintf(name, sizeof(name), _(e_config->desktop_default_name), desk->x, desk->y);
+ desk->name = eina_stringshare_add(name);
+ }
+
+ // new 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_area.base)
+ {
+ e_object_del(E_OBJECT(desk));
+ return;
+ }
+}
+#endif
+
+static void
+_e_policy_desk_cb_desk_free(struct wl_listener *listener, void *data)
+{
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+ Eina_List *l;
+ E_Desk_Area *eda;
+
+ pd = wl_container_of(listener, pd, desk_free);
+ desk = data;
+
+ ELOGF("POL_DESK", "Desk FREE. desk:%p", NULL, desk);
+
+ for (int i=E_DESK_AREA_LAYER_COUNT-1; i>=0; i--)
+ {
+ EINA_LIST_FOREACH(desk->desk_area.list[i], l, eda)
+ {
+ e_object_del(E_OBJECT(eda));
+ }
+ eina_list_free(desk->desk_area.list[i]);
+ desk->desk_area.list[i] = NULL;
+ }
+
+ e_desk_desk_area_del(desk, desk->desk_area.base);
+ desk->desk_area.base = NULL;
+ desk->desk_area.active = NULL;
+
+
+ E_FREE_FUNC(desk->smart_obj, evas_object_del);
+ eina_stringshare_del(desk->name);
+ desk->name = NULL;
+ E_FREE_LIST(desk->handlers, ecore_event_handler_del);
+}
+
+static void
+_e_policy_desk_cb_top_visible_get(struct wl_listener *listener, void *data)
+{
+ E_Desk_Data_Top_Visible_Get *top_visible_data;
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+ E_Client *ec;
+
+ pd = wl_container_of(listener, pd, top_visible_get);
+ top_visible_data = data;
+ desk = top_visible_data->desk;
+
+ E_CLIENT_REVERSE_FOREACH(ec)
+ if (e_desk_has_ec(desk, ec) && e_view_client_visible_get(e_client_view_get(ec)))
+ {
+ top_visible_data->visible_ec = ec;
+ return;
+ }
+
+ top_visible_data->visible_ec = NULL;
+ return;
+}
+
+static void
+_e_policy_desk_cb_name_set(struct wl_listener *listener, void *data)
+{
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+
+ pd = wl_container_of(listener, pd, name_set);
+ desk = pd->desk;
+
+ _e_policy_desk_event_simple_add(desk, E_EVENT_DESK_NAME_CHANGE);
+}
+
+static void
+_e_policy_desk_cb_name_add(struct wl_listener *listener, void *data)
+{
+ E_Desk_Data_Name *name_data;
+ E_Policy_Desk *pd;
+ int zone;
+ int desk_x, desk_y;
+ const char *name;
+ E_Config_Desktop_Name *cfname;
+
+ pd = wl_container_of(listener, pd, name_add);
+ name_data = data;
+ zone = pd->zone->id;
+ desk_x = name_data->desk_x;
+ desk_y = name_data->desk_y;
+ name = name_data->name;
+
+ e_desk_name_del(zone, desk_x, desk_y);
+
+ cfname = E_NEW(E_Config_Desktop_Name, 1);
+ if (!cfname) return;
+ cfname->zone = zone;
+ cfname->desk_x = desk_x;
+ cfname->desk_y = desk_y;
+ if (name) cfname->name = eina_stringshare_add(name);
+ else cfname->name = NULL;
+ e_config->desktop_names = eina_list_append(e_config->desktop_names, cfname);
+}
+
+static void
+_e_policy_desk_cb_name_del(struct wl_listener *listener, void *data)
+{
+ E_Desk_Data_Name *name_data;
+ E_Policy_Desk *pd;
+ int zone;
+ int desk_x, desk_y;
+ E_Config_Desktop_Name *cfname;
+ Eina_List *l = NULL;
+
+ pd = wl_container_of(listener, pd, name_del);
+ name_data = data;
+ zone = pd->zone->id;
+ desk_x = name_data->desk_x;
+ desk_y = name_data->desk_y;
+
+ EINA_LIST_FOREACH(e_config->desktop_names, l, cfname)
+ {
+ if ((cfname->zone == zone) &&
+ (cfname->desk_x == desk_x) && (cfname->desk_y == desk_y))
+ {
+ e_config->desktop_names =
+ eina_list_remove_list(e_config->desktop_names, l);
+ if (cfname->name) eina_stringshare_del(cfname->name);
+ E_FREE(cfname);
+ break;
+ }
+ }
+
+}
+
+static void
+_e_policy_desk_cb_name_update(struct wl_listener *listener, void *data)
+{
+ const Eina_List *z, *l;
+ Eina_List *comp_zone_list;
+ E_Zone *zone;
+ E_Desk *desk;
+ E_Config_Desktop_Name *cfname;
+ int d_x, d_y, ok;
+ char name[40];
+
+ if (!(comp_zone_list = e_comp_zone_list_get())) return;
+
+ EINA_LIST_FOREACH(comp_zone_list, z, zone)
+ {
+ for (d_x = 0; d_x < zone->desk_x_count; d_x++)
+ {
+ for (d_y = 0; d_y < zone->desk_y_count; d_y++)
+ {
+ desk = zone->desks[d_x + zone->desk_x_count * d_y];
+ ok = 0;
+
+ EINA_LIST_FOREACH(e_config->desktop_names, l, cfname)
+ {
+ if ((cfname->zone >= 0) &&
+ ((int)zone->num != cfname->zone)) continue;
+ if ((cfname->desk_x != d_x) ||
+ (cfname->desk_y != d_y)) continue;
+ e_desk_name_set(desk, cfname->name);
+ ok = 1;
+ break;
+ }
+
+ if (!ok)
+ {
+ snprintf(name, sizeof(name),
+ _(e_config->desktop_default_name),
+ d_x, d_y);
+ e_desk_name_set(desk, name);
+ }
+ }
+ }
+ }
+}
+
+static void
+_e_policy_desk_cb_desk_show(struct wl_listener *listener, void *data)
+{
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+ Edje_Message_Float_Set *msg = NULL;
+ E_Desk *desk2 = NULL;
+ int dx = 0, dy = 0;
+ Ecore_Event *eev_ecore_event = NULL;
+ Ecore_Event *ev_ecore_event = NULL;
+
+ pd = wl_container_of(listener, pd, desk_show);
+ desk = pd->desk;
+
+ desk2 = e_desk_at_xy_get(desk->zone, desk->zone->desk_x_current, desk->zone->desk_y_current);
+ if ((!starting) && (!desk2->visible) && (desk != desk2)) return;
+
+ eev_ecore_event = _e_policy_desk_event_simple_add(desk, E_EVENT_DESK_BEFORE_SHOW);
+ if (!eev_ecore_event) goto error;
+
+ if (desk2->visible)
+ {
+ desk2->visible = 0;
+ if ((!dx) && (!dy))
+ {
+ dx = desk->x - desk2->x;
+ dy = desk->y - desk2->y;
+ }
+ _e_policy_desk_hide_begin(desk2, dx, dy);
+ if (desk2->smart_obj)
+ evas_object_hide(desk2->smart_obj);
+ }
+
+ desk->zone->desk_x_prev = desk->zone->desk_x_current;
+ desk->zone->desk_y_prev = desk->zone->desk_y_current;
+ desk->zone->desk_x_current = desk->x;
+ desk->zone->desk_y_current = desk->y;
+ desk->visible = 1;
+
+ msg = alloca(sizeof(Edje_Message_Float_Set) + (4 * sizeof(double)));
+ msg->count = 5;
+ msg->val[0] = 0.0;
+ msg->val[1] = desk->x;
+ msg->val[2] = desk->zone->desk_x_count;
+ msg->val[3] = desk->y;
+ msg->val[4] = desk->zone->desk_y_count;
+
+ _e_policy_desk_show_begin(desk, dx, dy);
+ if (desk->smart_obj)
+ evas_object_show(desk->smart_obj);
+
+ ev_ecore_event = _e_policy_desk_event_simple_add(desk, E_EVENT_DESK_SHOW);
+ if (!ev_ecore_event) goto error;
+
+ _e_policy_desk_event_simple_add(e_desk_current_get(desk->zone), E_EVENT_DESK_AFTER_SHOW);
+
+ return;
+
+error:
+ if (eev_ecore_event) ecore_event_del(eev_ecore_event);
+}
+
+static void
+_e_policy_desk_cb_desk_deskshow(struct wl_listener *listener, void *data)
+{
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+ E_Client *ec;
+
+ pd = wl_container_of(listener, pd, desk_deskshow);
+ desk = pd->desk;
+
+ if (desk->deskshow_toggle)
+ {
+ /* uniconify raises windows and changes stacking order
+ * go top-down to avoid skipping windows
+ */
+ E_CLIENT_REVERSE_FOREACH(ec)
+ {
+ if (e_client_util_ignored_get(ec)) continue;
+ if (!e_desk_has_ec(desk, ec)) continue;
+ if (ec->deskshow)
+ {
+ ec->deskshow = 0;
+ e_client_uniconify(ec);
+ }
+ }
+ }
+ else
+ {
+ /*
+ * iconify raises, so we have to start from the bottom so we are going forward
+ */
+ E_CLIENT_FOREACH(ec)
+ {
+ if (e_client_util_ignored_get(ec)) continue;
+ if (!e_desk_has_ec(desk, ec)) continue;
+ if (ec->iconic) continue;
+ if (ec->netwm.state.skip_taskbar) continue;
+ if (ec->user_skip_winlist) continue;
+ ec->deskshow = 1;
+ e_client_iconify(ec);
+ }
+ }
+ desk->deskshow_toggle = !desk->deskshow_toggle;
+
+ _e_policy_desk_event_simple_add(desk, E_EVENT_DESK_DESKSHOW);
+}
+
+static void
+_e_policy_desk_cb_desk_client_add(struct wl_listener *listener, void *data)
+{
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+ E_Client *ec;
+ E_Policy_Desk_Private_Client *desk_client;
+ E_Desk_Area *eda;
+
+ pd = wl_container_of(listener, pd, desk_client_add);
+ desk = pd->desk;
+ ec = (E_Client *) data;
+
+ ELOGF("POL_DESK", "CLIENT ADD. desk:%p", ec, desk);
+
+ desk_client = E_NEW(E_Policy_Desk_Private_Client, 1);
+ EINA_SAFETY_ON_NULL_RETURN(desk_client);
+
+ desk_client->desk = desk;
+ desk_client->ec = ec;
+
+ // e_client listeners
+ desk_client->client_destroy.notify = _e_policy_desk_cb_client_destroy;
+ e_client_destroy_listener_add(ec, &desk_client->client_destroy);
+ desk_client->client_activate_done.notify = _e_policy_desk_cb_client_activate_done;
+ e_client_activate_done_listener_add(ec, &desk_client->client_activate_done);
+
+ _e_policy_desk_client_set(desk, ec);
+ _e_policy_desk_client_data_set(desk, ec);
+
+ eda = e_desk_desk_area_base_get(desk);
+ e_desk_area_ec_add(eda, ec);
+
+ _e_policy_desk_smart_client_add(desk->smart_obj, ec);
+
+ _e_policy_desk_hook_call(E_DESK_HOOK_CLIENT_ADD, desk);
+}
+
+static void
+_e_policy_desk_cb_desk_client_del(struct wl_listener *listener, void *data)
+{
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+ E_Client *ec;
+ E_Policy_Desk_Private_Client *desk_client;
+ E_Desk_Area *eda;
+
+ pd = wl_container_of(listener, pd, desk_client_del);
+ desk = pd->desk;
+ ec = (E_Client *) data;
+
+ ELOGF("POL_DESK", "CLIENT REMOVE. desk:%p", ec, desk);
+
+ desk_client = _e_policy_desk_private_client_get(ec);
+ EINA_SAFETY_ON_NULL_RETURN(desk_client);
+
+ eda = e_desk_desk_area_find_by_ec(desk, ec);
+ EINA_SAFETY_ON_NULL_RETURN(eda);
+
+ e_desk_area_ec_remove(eda, ec);
+
+ _e_policy_desk_private_client_del(desk_client);
+}
+
+static void
+_e_policy_desk_cb_desk_geometry_set(struct wl_listener *listener, void *data)
+{
+ E_Desk_Data_Geometry *geom_data;
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+ E_Client *ec;
+ E_Maximize max;
+ Eina_List *l = NULL, *ll = NULL;
+ Evas_Object *m;
+ E_Event_Desk_Geometry_Change *ev = NULL;
+ int x, y, w, h;
+ int cx, cy, dx, dy;
+
+ pd = wl_container_of(listener, pd, geometry_set);
+ desk = pd->desk;
+ geom_data = (E_Desk_Data_Geometry *) data;
+ x = geom_data->x;
+ y = geom_data->y;
+ w = geom_data->w;
+ h = geom_data->h;
+
+ E_POLICY_DESK_SMART_DATA_GET_OR_RETURN(desk->smart_obj, sd);
+
+ dx = x - desk->geom.x;
+ dy = y - desk->geom.y;
+
+ EINA_LIST_FOREACH(sd->clients, l, ec)
+ {
+ if (e_object_is_del(E_OBJECT(ec))) continue;
+
+ /* even if the desktop geometry is chagned, the system partial windows such as virtual
+ * keyboard and clipboard should be placed at the bottom of the desktop. */
+ /* QUICK FIX */
+ if (e_policy_client_is_keyboard(ec))
+ {
+ continue;
+ }
+ else if (e_comp_wl_subsurface_check(ec))
+ {
+ continue;
+ }
+ else if (ec->maximized)
+ {
+ max = ec->maximized;
+ ec->maximized = E_MAXIMIZE_NONE;
+ e_client_maximize(ec, max);
+ }
+ else
+ {
+ e_client_geometry_get(ec, &cx, &cy, NULL, NULL);
+ e_client_util_move_without_frame(ec, cx + dx, cy + dy);
+ }
+ }
+
+ // E Client as an member of smart object is not changed even though parent obj is changed
+ // Workaround : update max geometry if ec is a member of desk->smart_obj
+ EINA_LIST_FOREACH(evas_object_smart_members_get(desk->smart_obj), ll, m)
+ {
+ ec = evas_object_data_get(m, "E_Client");
+ if (ec && ec->maximized)
+ {
+ if (e_object_is_del(E_OBJECT(ec))) continue;
+ max = ec->maximized;
+ ec->maximized = E_MAXIMIZE_NONE;
+ e_client_maximize(ec, max);
+ }
+ }
+
+ // apply geometry on smart obj
+ evas_object_geometry_set(desk->smart_obj, x, y, w, h);
+
+ ev = E_NEW(E_Event_Desk_Geometry_Change, 1);
+ if (ev)
+ {
+ ev->desk = desk;
+ ev->x = x;
+ ev->y = y;
+ ev->w = w;
+ ev->h = h;
+ e_object_ref(E_OBJECT(desk));
+ ecore_event_add(E_EVENT_DESK_GEOMETRY_CHANGE, ev, _e_policy_desk_event_desk_geometry_change_free, NULL);
+ }
+
+ e_comp_render_queue();
+}
+
+static Eina_Bool
+_e_policy_desk_zoom_animate_cb(void *data, double pos)
+{
+ E_Desk *desk;
+ E_Client *ec;
+ Eina_List *l;
+ int cx, cy;
+ double zoomx, zoomy;
+ double progress;
+ double diff_x, diff_y;
+ double cBez[4] = {0.3, 0.0, 0.15, 1.0};
+
+ desk = (E_Desk*)data;
+ if (!desk) return ECORE_CALLBACK_CANCEL;
+
+ E_POLICY_DESK_SMART_DATA_GET_OR_RETURN(desk->smart_obj, sd) ECORE_CALLBACK_CANCEL;
+
+ progress = ecore_animator_pos_map_n(pos, ECORE_POS_MAP_CUBIC_BEZIER, 4, cBez);
+
+ diff_x = sd->zoom.prev_ratio_x - sd->zoom.ratio_x;
+ diff_y = sd->zoom.prev_ratio_y - sd->zoom.ratio_y;
+
+ zoomx = sd->zoom.ratio_x + (diff_x * (1-progress));
+ zoomy = sd->zoom.ratio_y + (diff_y * (1-progress));
+ cx = sd->zoom.cord_x;
+ cy = sd->zoom.cord_y;
+
+ EINA_LIST_FOREACH(sd->clients, l, ec)
+ {
+ if ((e_client_visibility_get(ec) == E_VISIBILITY_UNOBSCURED) ||
+ (e_comp_wl_subsurface_check(ec)))
+ _e_policy_desk_client_zoom(ec, zoomx, zoomy, cx, cy);
+ }
+
+ if (pos >= 1.0)
+ {
+ EINA_LIST_FOREACH(sd->clients, l, ec)
+ {
+ _e_policy_desk_client_zoom(ec, zoomx, zoomy, cx, cy);
+ }
+
+ if ((sd->zoom.ratio_x != 1.0) ||
+ (sd->zoom.ratio_y != 1.0))
+ {
+ // Zoom enable done
+ sd->zoom.enabled = EINA_TRUE;
+ }
+
+ sd->zoom.animating_type = E_POLICY_DESK_ZOOM_ANIMATING_TYPE_NONE;
+ sd->zoom.animator = NULL;
+ }
+
+ return ECORE_CALLBACK_PASS_ON;
+}
+
+static void
+_e_policy_desk_cb_desk_zoom_set(struct wl_listener *listener, void *data)
+{
+ E_Desk_Data_Zoom *zoom_data;
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+ E_Client *ec;
+ Eina_List *l;
+ E_Zone *zone = NULL;
+ E_Output *eout = NULL;
+ double zoomx, zoomy;
+ int cx, cy;
+
+ pd = wl_container_of(listener, pd, zoom_set);
+ desk = pd->desk;
+ zoom_data = (E_Desk_Data_Zoom *) data;
+
+ zoomx = zoom_data->zoomx;
+ zoomy = zoom_data->zoomy;
+ cx = zoom_data->cx;
+ cy = zoom_data->cy;
+
+ ELOGF("POL_DESK", "ZOOM SET. desk:%p, zoom ratio(%f,%f) cpos(%d,%d)", NULL, desk, zoomx, zoomy, cx, cy);
+
+ if (e_config->use_pp_zoom)
+ {
+ if (e_display_pp_support())
+ {
+ zone = desk->zone;
+ eout = e_output_find(zone->output_id);
+ if (!eout)
+ {
+ ERR("e_desk_zoom_set: fail get eout");
+ goto end;
+ }
+ if (!e_output_zoom_set(eout, zoomx, zoomy, cx, cy))
+ ERR("e_desk_zoom_set: fail zoom set");
+ else
+ DBG("e_desk_zoom_set: zoomx:%f, zoomy:%f, x:%d, y:%d", zoomx, zoomy, cx, cy);
+
+ goto end;
+ }
+ }
+
+ E_POLICY_DESK_SMART_DATA_GET_OR_RETURN(desk->smart_obj, sd);
+
+ if ((sd->zoom.ratio_x != zoomx) || (sd->zoom.ratio_y != zoomy) ||
+ (sd->zoom.cord_x != cx) || (sd->zoom.cord_y != cy))
+ {
+ sd->zoom.prev_ratio_x = sd->zoom.ratio_x;
+ sd->zoom.prev_ratio_y = sd->zoom.ratio_y;
+ sd->zoom.prev_cord_x = sd->zoom.cord_x;
+ sd->zoom.prev_cord_y = sd->zoom.cord_y;
+
+ sd->zoom.ratio_x = zoomx;
+ sd->zoom.ratio_y = zoomy;
+ sd->zoom.cord_x = cx;
+ sd->zoom.cord_y = cy;
+
+ if (e_config->desk_zoom_effect.enable)
+ {
+ if (sd->zoom.animator)
+ {
+ ecore_animator_del(sd->zoom.animator);
+ sd->zoom.animator = NULL;
+ }
+
+ sd->zoom.animating_type = E_POLICY_DESK_ZOOM_ANIMATING_TYPE_ENABLE;
+ sd->zoom.animator = ecore_animator_timeline_add(e_config->desk_zoom_effect.duration,
+ _e_policy_desk_zoom_animate_cb, desk);
+ _e_policy_desk_object_zoom(desk->smart_obj, zoomx, zoomy, cx, cy);
+ }
+ else
+ {
+ _e_policy_desk_object_zoom(desk->smart_obj, zoomx, zoomy, cx, cy);
+ EINA_LIST_FOREACH(sd->clients, l, ec)
+ {
+ _e_policy_desk_client_zoom(ec, zoomx, zoomy, cx, cy);
+ }
+ }
+ }
+
+ if (!sd->zoom.enabled)
+ {
+ /* if desk_zoom_effect is enabled,
+ then sd->zoom.enabled will be set after finishing effect */
+ if (!e_config->desk_zoom_effect.enable)
+ sd->zoom.enabled = EINA_TRUE;
+
+ /*
+ * NOTE: evas_object_map_enable_set is called in _e_policy_desk_client_zoom()
+ */
+ /*
+ * evas_object_map_enable_set(desk->smart_obj, EINA_TRUE);
+ * EINA_LIST_FOREACH(sd->clients, l, ec)
+ * evas_object_map_enable_set(ec->frame, EINA_TRUE);
+ */
+ }
+
+end:
+ _e_policy_desk_event_simple_add(desk, E_EVENT_DESK_ZOOM_SET);
+}
+
+static void
+_e_policy_desk_cb_desk_zoom_get(struct wl_listener *listener, void *data)
+{
+ E_Desk_Data_Zoom *zoom_data;
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+ E_Zone *zone = NULL;
+ E_Output *eout = NULL;
+ Eina_Bool res = EINA_FALSE;
+ double zoomx = 0, zoomy = 0;
+ int cx = 0, cy = 0;
+
+ pd = wl_container_of(listener, pd, zoom_get);
+ desk = pd->desk;
+ zoom_data = (E_Desk_Data_Zoom *) data;
+ zoom_data->result = EINA_FALSE;
+
+ if (e_config->use_pp_zoom)
+ {
+ if (e_display_pp_support())
+ {
+ zone = desk->zone;
+ eout = e_output_find(zone->output_id);
+ if (!eout)
+ {
+ ERR("e_desk_zoom_set: fail get eout");
+ return;
+ }
+
+ res = e_output_zoom_get(eout, &zoomx, &zoomy, &cx, &cy);
+ zoom_data->zoomx = zoomx;
+ zoom_data->zoomy = zoomy;
+ zoom_data->cx = cx;
+ zoom_data->cy = cy;
+ zoom_data->result = res;
+ return;
+ }
+ }
+
+ E_POLICY_DESK_SMART_DATA_GET(desk->smart_obj, sd);
+ if (!sd)
+ {
+ zoom_data->result = EINA_FALSE;
+ return;
+ }
+
+ zoom_data->zoomx = sd->zoom.ratio_x;
+ zoom_data->zoomy = sd->zoom.ratio_y;
+ zoom_data->cx = sd->zoom.cord_x;
+ zoom_data->cy = sd->zoom.cord_y;
+ zoom_data->result = EINA_TRUE;
+}
+
+static void
+_e_policy_desk_cb_desk_zoom_get_center_coordinate(struct wl_listener *listener, void *data)
+{
+ E_Desk_Data_Zoom *zoom_data;
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+ E_Zone *zone = NULL;
+ E_Output *eout = NULL;
+ double zoomx, zoomy;
+ int rectx, recty;
+ int w, h;
+ int zoomw, zoomh;
+
+ pd = wl_container_of(listener, pd, zoom_get_center_coordinate);
+ desk = pd->desk;
+ zoom_data = (E_Desk_Data_Zoom *) data;
+ zoom_data->result = EINA_FALSE;
+ zoomx = zoom_data->zoomx;
+ zoomy = zoom_data->zoomy;
+ rectx = zoom_data->rectx;
+ recty = zoom_data->recty;
+
+ zone = desk->zone;
+ eout = e_output_find(zone->output_id);
+
+ e_output_size_get(eout, &w, &h);
+
+ zoomw = w / zoomx;
+ zoomh = h / zoomy;
+
+ if (e_config->use_pp_zoom)
+ {
+ if (zoomx == 1 || rectx < 0 || zoomw + rectx >= w)
+ {
+ zoom_data->result = EINA_FALSE;
+ return;
+ }
+
+ if (zoomy == 1 || recty < 0 || zoomh + recty >= h)
+ {
+ zoom_data->result = EINA_FALSE;
+ return;
+ }
+ }
+ else
+ {
+ if (zoomx == 1 || zoomy == 1)
+ {
+ zoom_data->result = EINA_FALSE;
+ return;
+ }
+ }
+
+ if (rectx == 0)
+ zoom_data->cx = 0;
+ else
+ zoom_data->cx = (int)((zoomx * (double)rectx) / (zoomx - 1.0));
+
+ if (recty == 0)
+ zoom_data->cy = 0;
+ else
+ zoom_data->cy = (int)((zoomy * (double)recty) / (zoomy - 1.0));
+
+ zoom_data->result = EINA_TRUE;
+}
+
+static void
+_e_policy_desk_cb_desk_zoom_unset(struct wl_listener *listener, void *data)
+{
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+ E_Client *ec;
+ Eina_List *l;
+ E_Zone *zone = NULL;
+ E_Output *eout = NULL;
+
+ pd = wl_container_of(listener, pd, zoom_unset);
+ desk = pd->desk;
+
+ ELOGF("POL_DESK", "ZOOM UNSET. desk:%p", NULL, desk);
+
+ if (e_config->use_pp_zoom)
+ {
+ if (e_display_pp_support())
+ {
+ zone = desk->zone;
+ eout = e_output_find(zone->output_id);
+ if (!eout)
+ {
+ ERR("e_desk_zoom_unset: fail get eout");
+ goto end;
+ }
+
+ e_output_zoom_unset(eout);
+ DBG("e_desk_zoom_unset");
+
+ goto end;
+ }
+ }
+
+ E_POLICY_DESK_SMART_DATA_GET_OR_RETURN(desk->smart_obj, sd);
+
+ if (!sd->zoom.enabled)
+ {
+ if (sd->zoom.animating_type != E_POLICY_DESK_ZOOM_ANIMATING_TYPE_ENABLE)
+ {
+ goto end;
+ }
+ }
+
+ sd->zoom.prev_ratio_x = sd->zoom.ratio_x;
+ sd->zoom.prev_ratio_y = sd->zoom.ratio_y;
+ sd->zoom.prev_cord_x = sd->zoom.cord_x;
+ sd->zoom.prev_cord_y = sd->zoom.cord_y;
+
+ sd->zoom.ratio_x = 1.0;
+ sd->zoom.ratio_y = 1.0;
+ sd->zoom.cord_x = 0;
+ sd->zoom.cord_y = 0;
+ sd->zoom.enabled = EINA_FALSE;
+
+ if (e_config->desk_zoom_effect.enable)
+ {
+ if (sd->zoom.animator)
+ {
+ ecore_animator_del(sd->zoom.animator);
+ sd->zoom.animator = NULL;
+ }
+
+ sd->zoom.animating_type = E_POLICY_DESK_ZOOM_ANIMATING_TYPE_DISABLE;
+ sd->zoom.animator = ecore_animator_timeline_add(e_config->desk_zoom_effect.duration,
+ _e_policy_desk_zoom_animate_cb, desk);
+ _e_policy_desk_object_zoom(desk->smart_obj, sd->zoom.ratio_x, sd->zoom.ratio_y,
+ sd->zoom.cord_x, sd->zoom.cord_y);
+ }
+ else
+ {
+ _e_policy_desk_object_zoom(desk->smart_obj, sd->zoom.ratio_x, sd->zoom.ratio_y,
+ sd->zoom.cord_x, sd->zoom.cord_y);
+ /*
+ * NOTE: evas_object_map_enable_set is called in _e_policy_desk_client_zoom()
+ */
+ /*
+ * evas_object_map_enable_set(desk->smart_obj, EINA_FALSE);
+ */
+ EINA_LIST_FOREACH(sd->clients, l, ec)
+ {
+ /* NOTE Is it really necessary?
+ * Why isn't it enough to just call evas_object_map_enable_set(false)? */
+ _e_policy_desk_client_zoom(ec, sd->zoom.ratio_x, sd->zoom.ratio_y,
+ sd->zoom.cord_x, sd->zoom.cord_y);
+ //evas_object_map_enable_set(ec->frame, EINA_FALSE);
+ }
+ }
+
+end:
+ _e_policy_desk_event_simple_add(desk, E_EVENT_DESK_ZOOM_UNSET);
+}
+
+static void
+_e_policy_desk_cb_smart_member_add(struct wl_listener *listener, void *data)
+{
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+ Evas_Object *new_member;
+
+ pd = wl_container_of(listener, pd, smart_member_add);
+ desk = pd->desk;
+ new_member = (Evas_Object *) data;
+
+ evas_object_smart_member_add(new_member, desk->smart_obj);
+}
+
+static void
+_e_policy_desk_cb_smart_member_del(struct wl_listener *listener, void *data)
+{
+ E_Policy_Desk *pd;
+ Evas_Object *obj;
+
+ pd = wl_container_of(listener, pd, smart_member_del);
+ obj = (Evas_Object *) data;
+
+ evas_object_smart_member_del(obj);
+}
+
+static void
+_e_policy_desk_cb_client_zoom_skip_set(struct wl_listener *listener, void *data)
+{
+ E_Desk_Data_Client_Zoom *zoom_data;
+ E_Policy_Desk *pd;
+ E_Desk *desk, *ec_desk;
+ E_Client *ec;
+
+ pd = wl_container_of(listener, pd, client_zoom_skip_set);
+ desk = pd->desk;
+ zoom_data = (E_Desk_Data_Client_Zoom *) data;
+ ec = zoom_data->ec;
+ zoom_data->result = EINA_FALSE;
+
+ // TODO: Need to check the ec_desk?
+ ec_desk = e_zone_desk_find_by_ec(desk->zone, ec);
+ if (!ec_desk) return;
+
+ ELOGF("POL_DESK", "Client zoom skip set. desk:%p, ec_desk:%p)", ec, desk, ec_desk);
+
+ if (!e_desk_has_ec(desk, ec)) return;
+
+ E_Policy_Desk_Private_Client *desk_client = _e_policy_desk_private_client_get(ec);
+ if (desk_client)
+ desk_client->skip_zoom = EINA_TRUE;
+
+ zoom_data->result = EINA_TRUE;
+ return;
+}
+
+static void
+_e_policy_desk_cb_client_zoom_skip_unset(struct wl_listener *listener, void *data)
+{
+ E_Desk_Data_Client_Zoom *zoom_data;
+ E_Policy_Desk *pd;
+ E_Desk *desk, *ec_desk;
+ E_Client *ec;
+
+ pd = wl_container_of(listener, pd, client_zoom_skip_unset);
+ desk = pd->desk;
+ zoom_data = (E_Desk_Data_Client_Zoom *) data;
+ ec = zoom_data->ec;
+ zoom_data->result = EINA_FALSE;
+
+ ec_desk = e_zone_desk_find_by_ec(desk->zone, ec);
+ if (!ec_desk) return;
+
+ ELOGF("DESK", "Client zoom skip set. desk:%p, ec_desk:%p)", ec, desk, ec_desk);
+
+ if (!e_desk_has_ec(desk, ec)) return;
+
+ E_Policy_Desk_Private_Client *desk_client = _e_policy_desk_private_client_get(ec);
+ if (desk_client)
+ desk_client->skip_zoom = EINA_FALSE;
+
+ _e_policy_desk_smart_client_add(desk->smart_obj, ec);
+
+ zoom_data->result = EINA_TRUE;
+ return;
+}
+
+static void
+_e_policy_desk_cb_client_zoom_apply(struct wl_listener *listener, void *data)
+{
+ E_Desk_Data_Client_Zoom *zoom_data;
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+ E_Client *ec;
+
+ pd = wl_container_of(listener, pd, client_zoom_apply);
+ desk = pd->desk;
+ zoom_data = (E_Desk_Data_Client_Zoom *) data;
+ ec = zoom_data->ec;
+
+ E_POLICY_DESK_SMART_DATA_GET_OR_RETURN(desk->smart_obj, sd);
+ if (!eina_list_data_find(sd->clients, ec))
+ return;
+
+ if (sd->zoom.enabled)
+ {
+ _e_policy_desk_client_zoom(ec,
+ sd->zoom.ratio_x, sd->zoom.ratio_y,
+ sd->zoom.cord_x, sd->zoom.cord_y);
+ }
+}
+
+static void
+_e_policy_desk_cb_zoom_is_animating(struct wl_listener *listener, void *data)
+{
+ E_Desk_Data_Client_Zoom *zoom_data;
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+
+ pd = wl_container_of(listener, pd, zoom_is_animating);
+ desk = pd->desk;
+ zoom_data = (E_Desk_Data_Client_Zoom *) data;
+ zoom_data->result = EINA_FALSE;
+
+ E_POLICY_DESK_SMART_DATA_GET(desk->smart_obj, sd);
+ if (!sd) return;
+
+ if (!e_config->desk_zoom_effect.enable) return;
+
+ zoom_data->result = !!sd->zoom.animator;
+ return;
+}
+
+static void
+_e_policy_desk_cb_visible_client_iconify_all(struct wl_listener *listener, void *data)
+{
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+ E_Client *ec;
+ Eina_List *l;
+
+ pd = wl_container_of(listener, pd, visible_client_iconify_all);
+ desk = pd->desk;
+
+ ELOGF("POL_DESK", "ICONIFY ALL VISIBLE WINDOW", NULL);
+ E_CLIENT_REVERSE_FOREACH(ec)
+ {
+ if (!e_desk_has_ec(desk, ec)) continue;
+ if (e_object_is_del(E_OBJECT(ec))) continue;
+ if (!ec->visible) continue;
+ if (ec->netwm.type == E_WINDOW_TYPE_DESKTOP) continue;
+ if (e_client_desk_iconify_skip_get(ec)) continue;
+ if (e_client_visibility_get(ec) == E_VISIBILITY_UNKNOWN) continue;
+ if (e_client_visibility_get(ec) != E_VISIBILITY_UNOBSCURED)
+ {
+ if (e_client_is_iconified_by_client(ec))
+ continue;
+ }
+
+ ELOGF("POL_DESK", "Add to iconified list...", ec);
+ desk->iconified_list = eina_list_remove(desk->iconified_list, ec);
+ desk->iconified_list = eina_list_append(desk->iconified_list, ec);
+ }
+
+ // bottom to top
+ EINA_LIST_REVERSE_FOREACH(desk->iconified_list, l, ec)
+ {
+ e_client_iconified_type_set(ec, E_ICONIFIED_TYPE_DESK_ICONIFY_BY_CLIENT);
+ e_policy_wl_iconify_state_change_send(ec, 1);
+ e_client_iconify(ec);
+ }
+}
+
+static void
+_e_policy_desk_cb_visible_client_restore_all(struct wl_listener *listener, void *data)
+{
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+ E_Client *ec;
+ Eina_List *restore_list;
+ Eina_List *l;
+
+ pd = wl_container_of(listener, pd, visible_client_restore_all);
+ desk = pd->desk;
+
+ ELOGF("POL_DESK", "RESTORE ALL VISIBLE WINDOW", NULL);
+
+ restore_list = eina_list_clone(desk->iconified_list);
+
+ eina_list_free(desk->iconified_list);
+ desk->iconified_list = NULL;
+
+ // bottom to top
+ EINA_LIST_REVERSE_FOREACH(restore_list, l, ec)
+ {
+ ELOGF("POL_DESK", "Restore from iconified list...", ec);
+ e_client_iconified_type_set(ec, E_ICONIFIED_TYPE_NONE);
+ e_policy_wl_iconify_state_change_send(ec, 0);
+ e_client_uniconify(ec);
+ }
+ eina_list_free(restore_list);
+}
+
+static void
+_e_policy_desk_cb_client_iconified_list_remove(struct wl_listener *listener, void *data)
+{
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+ E_Client *ec;
+
+ pd = wl_container_of(listener, pd, client_iconified_list_remove);
+ desk = pd->desk;
+ ec = (E_Client *) data;
+
+ ELOGF("POL_DESK", "Remove from iconified list", NULL);
+ desk->iconified_list = eina_list_remove(desk->iconified_list, ec);
+}
+
+static void
+_e_policy_desk_cb_client_iconified_list_remove_all(struct wl_listener *listener, void *data)
+{
+ E_Policy_Desk *pd;
+ E_Desk *desk;
+
+ pd = wl_container_of(listener, pd, client_iconified_list_remove_all);
+ desk = pd->desk;
+
+ ELOGF("POL_DESK", "Remove iconified list all", NULL);
+ eina_list_free(desk->iconified_list);
+ desk->iconified_list = NULL;
+}
+
+static void
+_e_policy_desk_cb_client_destroy(struct wl_listener *listener, void *data)
+{
+ E_Policy_Desk_Private_Client *desk_client;
+ E_Desk *desk;
+ E_Client *ec;
+
+ desk_client = wl_container_of(listener, desk_client, client_destroy);
+ desk = desk_client->desk;
+ ec = desk_client->ec;
+
+ ELOGF("POL_DESK", "CLIENT DESTROY. desk:%p", ec, desk);
+
+ _e_policy_desk_private_client_del(desk_client);
+}
+
+static void
+_e_policy_desk_cb_client_activate_done(struct wl_listener *listener, void *data)
+{
+ E_Policy_Desk_Private_Client *desk_client;
+ E_Desk *desk;
+ E_Client *ec;
+
+ desk_client = wl_container_of(listener, desk_client, client_activate_done);
+ desk = desk_client->desk;
+ ec = desk_client->ec;
+
+ ELOGF("POL_DESK", "CLIENT ACTIVATE DONE. desk:%p", ec, desk);
+
+ if ((!ec->iconic) && (!ec->sticky))
+ {
+ e_desk_show(desk);
+ }
+
+ if (!e_client_desk_iconify_skip_get(ec))
+ {
+ e_desk_visible_client_iconified_list_remove_all(desk);
+ }
+}
+
+EINTERN void
+e_policy_desk_add(E_Desk *desk)
+{
+ E_Policy_Desk *pd;
+ E_Client *ec;
+ E_Policy_Client *pc;
+
+ E_Zone *zone;
+ Eina_List *l;
+ E_Config_Desktop_Name *cfname;
+ char name[40];
+ int ok = 0;
+
+ pd = eina_hash_find(hash_policy_desks, &desk);
+ if (pd) return;
+
+ zone = desk->zone;
+
+ /* init smart object */
+ _e_policy_desk_smart_init(desk);
+
+ /* Get current desktop's name */
+ EINA_LIST_FOREACH(e_config->desktop_names, l, cfname)
+ {
+ if ((cfname->zone >= 0) &&
+ ((int)zone->num != cfname->zone)) continue;
+ if ((cfname->desk_x != desk->x) || (cfname->desk_y != desk->y))
+ continue;
+ desk->name = eina_stringshare_ref(cfname->name);
+ ok = 1;
+ break;
+ }
+
+ if (!ok)
+ {
+ snprintf(name, sizeof(name), _(e_config->desktop_default_name), desk->x, desk->y);
+ desk->name = eina_stringshare_add(name);
+ }
+
+ // new 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_area.base)
+ {
+ e_object_del(E_OBJECT(desk));
+ return;
+ }
+
+ pd = E_NEW(E_Policy_Desk, 1);
+ if (!pd) return;
+
+ ELOGF("POL_DESK", "Policy desk NEW. desk:%p, policy desk:%p", NULL, desk, pd);
+
+ pd->desk = desk;
+ pd->zone = desk->zone;
+
+ eina_hash_add(hash_policy_desks, &desk, pd);
+
+ /* add clients */
+ E_CLIENT_FOREACH(ec)
+ {
+ if (e_desk_has_ec(pd->desk, ec))
+ {
+ pc = e_policy_client_get(ec);
+ e_policy_client_maximize_policy_apply(pc);
+ }
+ }
+
+ //pd->desk_new.notify = _e_policy_desk_cb_desk_new;
+ //e_desk_desk_new_listener_add(pd->desk, &pd->desk_new);
+ pd->desk_free.notify = _e_policy_desk_cb_desk_free;
+ e_desk_desk_free_listener_add(pd->desk, &pd->desk_free);
+ pd->top_visible_get.notify = _e_policy_desk_cb_top_visible_get;
+ e_desk_top_visible_get_listener_add(pd->desk, &pd->top_visible_get);
+ pd->name_set.notify = _e_policy_desk_cb_name_set;
+ e_desk_name_set_listener_add(pd->desk, &pd->name_set);
+ pd->name_add.notify = _e_policy_desk_cb_name_add;
+ e_desk_name_add_listener_add(pd->desk, &pd->name_add);
+ pd->name_del.notify = _e_policy_desk_cb_name_del;
+ e_desk_name_del_listener_add(pd->desk, &pd->name_del);
+ pd->name_update.notify = _e_policy_desk_cb_name_update;
+ e_desk_name_update_listener_add(pd->desk, &pd->name_update);
+ pd->desk_show.notify = _e_policy_desk_cb_desk_show;
+ e_desk_desk_show_listener_add(pd->desk, &pd->desk_show);
+ pd->desk_deskshow.notify = _e_policy_desk_cb_desk_deskshow;
+ e_desk_desk_deskshow_listener_add(pd->desk, &pd->desk_deskshow);
+ pd->desk_client_add.notify = _e_policy_desk_cb_desk_client_add;
+ e_desk_client_add_listener_add(pd->desk, &pd->desk_client_add);
+ pd->desk_client_del.notify = _e_policy_desk_cb_desk_client_del;
+ e_desk_client_del_listener_add(pd->desk, &pd->desk_client_del);
+ pd->geometry_set.notify = _e_policy_desk_cb_desk_geometry_set;
+ e_desk_geometry_set_listener_add(pd->desk, &pd->geometry_set);
+ pd->zoom_set.notify = _e_policy_desk_cb_desk_zoom_set;
+ e_desk_zoom_set_listener_add(pd->desk, &pd->zoom_set);
+ pd->zoom_get.notify = _e_policy_desk_cb_desk_zoom_get;
+ e_desk_zoom_get_listener_add(pd->desk, &pd->zoom_get);
+ pd->zoom_get_center_coordinate.notify = _e_policy_desk_cb_desk_zoom_get_center_coordinate;
+ e_desk_zoom_get_center_coordinate_listener_add(pd->desk, &pd->zoom_get_center_coordinate);
+ pd->zoom_unset.notify = _e_policy_desk_cb_desk_zoom_unset;
+ e_desk_zoom_unset_listener_add(pd->desk, &pd->zoom_unset);
+ pd->smart_member_add.notify = _e_policy_desk_cb_smart_member_add;
+ e_desk_smart_member_add_listener_add(pd->desk, &pd->smart_member_add);
+ pd->smart_member_del.notify = _e_policy_desk_cb_smart_member_del;
+ e_desk_smart_member_del_listener_add(pd->desk, &pd->smart_member_del);
+ pd->client_zoom_skip_set.notify = _e_policy_desk_cb_client_zoom_skip_set;
+ e_desk_client_zoom_skip_set_listener_add(pd->desk, &pd->client_zoom_skip_set);
+ pd->client_zoom_skip_unset.notify = _e_policy_desk_cb_client_zoom_skip_unset;
+ e_desk_client_zoom_skip_unset_listener_add(pd->desk, &pd->client_zoom_skip_unset);
+ pd->client_zoom_apply.notify = _e_policy_desk_cb_client_zoom_apply;
+ e_desk_client_zoom_apply_listener_add(pd->desk, &pd->client_zoom_apply);
+ pd->zoom_is_animating.notify = _e_policy_desk_cb_zoom_is_animating;
+ e_desk_zoom_is_animating_listener_add(pd->desk, &pd->zoom_is_animating);
+ pd->visible_client_iconify_all.notify = _e_policy_desk_cb_visible_client_iconify_all;
+ e_desk_visible_client_iconify_all_listener_add(pd->desk, &pd->visible_client_iconify_all);
+ pd->visible_client_restore_all.notify = _e_policy_desk_cb_visible_client_restore_all;
+ e_desk_visible_client_restore_all_listener_add(pd->desk, &pd->visible_client_restore_all);
+ pd->client_iconified_list_remove.notify = _e_policy_desk_cb_client_iconified_list_remove;
+ e_desk_client_iconified_list_remove_listener_add(pd->desk, &pd->client_iconified_list_remove);
+ pd->client_iconified_list_remove_all.notify = _e_policy_desk_cb_client_iconified_list_remove_all;
+ e_desk_client_iconified_list_remove_all_listener_add(pd->desk, &pd->client_iconified_list_remove_all);
+}
+
+EINTERN void
+e_policy_desk_del(E_Policy_Desk *pd)
+{
+ E_Policy_Client *pc;
+ E_Client *ec;
+ E_Policy_Softkey *softkey;
+
+ /* hide and delete softkey */
+ if (e_config->use_softkey)
+ {
+ softkey = e_policy_softkey_get(pd->zone);
+ if (e_desk_current_get(pd->zone) == pd->desk)
+ e_policy_softkey_hide(softkey);
+ }
+
+ /* remove clients */
+ E_CLIENT_FOREACH(ec)
+ {
+ pc = e_policy_client_get(ec);
+ if (pc)
+ {
+ if (e_desk_has_ec(pd->desk, ec))
+ {
+ e_policy_client_maximize_policy_cancel(pc);
+ }
+ }
+ }
+
+ eina_hash_del_by_key(hash_policy_desks, &pd->desk);
+}
+
+EINTERN E_Policy_Desk *
+e_policy_desk_get(E_Desk *desk)
+{
+ EINA_SAFETY_ON_NULL_RETURN_VAL(desk, NULL);
+
+ return eina_hash_find(hash_policy_desks, &desk);
+}
+
+EINTERN void
+e_policy_desk_init(void)
+{
+ hash_policy_desks = eina_hash_pointer_new(_e_policy_desk_cb_desk_data_free);
+}
+
+EINTERN void
+e_policy_desk_shutdown(void)
+{
+ E_FREE_FUNC(hash_policy_desks, eina_hash_free);
+}
#endif
#include "e_intern.h"
#include "e_desk_intern.h"
+#ifdef CONTAINER_POLICY
+#define E_POLICY_DESK_SMART_OBJ_TYPE "E_Desk_Smart_Object"
+#endif
+
typedef struct _E_Policy_Desk E_Policy_Desk;
#ifdef CONTAINER_POLICY
-struct _E_Policy_Desk
-{
- E_Desk *desk;
- E_Zone *zone;
-};
+
+EINTERN void e_policy_desk_add(E_Desk *desk);
+EINTERN void e_policy_desk_del(E_Policy_Desk *pd);
+EINTERN E_Policy_Desk *e_policy_desk_get(E_Desk *desk);
+EINTERN void e_policy_desk_init(void);
+EINTERN void e_policy_desk_shutdown(void);
+
#endif
#endif
EINTERN void e_policy_deferred_job(void);
EINTERN void e_policy_animatable_lock(E_Client *ec, E_Policy_Animatable_Lock animatable, Eina_Bool set);
+#ifdef CONTAINER_POLICY
+#else
EINTERN void e_policy_desk_add(E_Desk *desk);
EINTERN void e_policy_desk_del(E_Policy_Desk *pd);
+#endif
EINTERN E_Policy_Client *e_policy_client_add(E_Client *ec);
+#ifdef CONTAINER_POLICY
+EINTERN E_Policy_Client *e_policy_client_get(E_Client *ec);
+#endif
EINTERN Eina_Bool e_policy_client_is_conformant(E_Client *ec);
EINTERN Eina_Bool e_policy_client_is_volume_tv(E_Client *ec);
EINTERN Eina_Bool e_policy_client_is_noti(E_Client *ec);
EINTERN void e_policy_client_iconic_state_change_send(E_Client *ec, int iconic);
EINTERN void e_policy_client_unmap(E_Client *ec);
EINTERN Eina_Bool e_policy_client_maximize(E_Client *ec);
+#ifdef CONTAINER_POLICY
+EINTERN Eina_Bool e_policy_client_maximize_policy_apply(E_Policy_Client *pc);
+EINTERN void e_policy_client_maximize_policy_cancel(E_Policy_Client *pc);
+#endif
EINTERN E_Policy_Client *e_policy_client_launcher_get(E_Zone *zone);
EINTERN void e_policy_client_buffer_flush_cancel(E_Client *ec);
struct wl_listener bg_mouse_down;
struct wl_listener bg_mouse_up;
struct wl_listener focus_focused_ec_changed;
+ struct wl_listener desk_row_add;
+ struct wl_listener desk_row_remove;
+ struct wl_listener desk_col_add;
+ struct wl_listener desk_col_remove;
+ struct wl_listener desk_current_get;
+ struct wl_listener desk_at_xy_get;
+ struct wl_listener desk_at_pos_get;
+ struct wl_listener desk_next;
+ struct wl_listener desk_prev;
+ struct wl_listener desk_count;
struct
{
return;
}
+
+static void
+_e_policy_zone_cb_desk_row_add(struct wl_listener *listener, void *data)
+{
+ E_Desk_Data_Desk_Control *desk_control_data;
+ E_Policy_Zone *policy_zone;
+ E_Zone *zone;
+
+ policy_zone = wl_container_of(listener, policy_zone, desk_row_add);
+ desk_control_data = (E_Desk_Data_Desk_Control *) data;
+ zone = desk_control_data->zone;
+
+ e_zone_desk_count_set(zone, zone->desk_x_count, zone->desk_y_count + 1);
+}
+
+static void
+_e_policy_zone_cb_desk_row_remove(struct wl_listener *listener, void *data)
+{
+ E_Desk_Data_Desk_Control *desk_control_data;
+ E_Policy_Zone *policy_zone;
+ E_Zone *zone;
+
+ policy_zone = wl_container_of(listener, policy_zone, desk_row_remove);
+ desk_control_data = (E_Desk_Data_Desk_Control *) data;
+ zone = desk_control_data->zone;
+
+ e_zone_desk_count_set(zone, zone->desk_x_count, zone->desk_y_count - 1);
+}
+
+static void
+_e_policy_zone_cb_desk_col_add(struct wl_listener *listener, void *data)
+{
+ E_Desk_Data_Desk_Control *desk_control_data;
+ E_Policy_Zone *policy_zone;
+ E_Zone *zone;
+
+ policy_zone = wl_container_of(listener, policy_zone, desk_col_add);
+ desk_control_data = (E_Desk_Data_Desk_Control *) data;
+ zone = desk_control_data->zone;
+
+ e_zone_desk_count_set(zone, zone->desk_x_count + 1, zone->desk_y_count);
+}
+
+static void
+_e_policy_zone_cb_desk_col_remove(struct wl_listener *listener, void *data)
+{
+ E_Desk_Data_Desk_Control *desk_control_data;
+ E_Policy_Zone *policy_zone;
+ E_Zone *zone;
+
+ policy_zone = wl_container_of(listener, policy_zone, desk_col_remove);
+ desk_control_data = (E_Desk_Data_Desk_Control *) data;
+ zone = desk_control_data->zone;
+
+ e_zone_desk_count_set(zone, zone->desk_x_count - 1, zone->desk_y_count);
+}
+
+static void
+_e_policy_zone_cb_desk_current_get(struct wl_listener *listener, void *data)
+{
+ E_Zone_Data_Desk_Get *desk_get_data;
+ E_Policy_Zone *policy_zone;
+ E_Zone *zone;
+
+ policy_zone = wl_container_of(listener, policy_zone, desk_current_get);
+ desk_get_data = (E_Zone_Data_Desk_Get *) data;
+ zone = desk_get_data->zone;
+
+ desk_get_data->desk = e_desk_at_xy_get(zone, zone->desk_x_current, zone->desk_y_current);
+}
+
+static void
+_e_policy_zone_cb_desk_at_xy_get(struct wl_listener *listener, void *data)
+{
+ E_Zone_Data_Desk_Get *desk_get_data;
+ E_Policy_Zone *policy_zone;
+ E_Zone *zone;
+ int x, y;
+
+ policy_zone = wl_container_of(listener, policy_zone, desk_at_xy_get);
+ desk_get_data = (E_Zone_Data_Desk_Get *) data;
+ zone = desk_get_data->zone;
+ x = desk_get_data->x;
+ y = desk_get_data->y;
+
+ if ((x >= zone->desk_x_count) || (y >= zone->desk_y_count))
+ {
+ desk_get_data->desk = NULL;
+ return;
+ }
+ else if ((x < 0) || (y < 0))
+ {
+ desk_get_data->desk = NULL;
+ return;
+ }
+
+ if (!zone->desks)
+ {
+ desk_get_data->desk = NULL;
+ return;
+ }
+
+ desk_get_data->desk = zone->desks[x + (y * zone->desk_x_count)];
+}
+
+static void
+_e_policy_zone_cb_desk_at_pos_get(struct wl_listener *listener, void *data)
+{
+ E_Zone_Data_Desk_Get *desk_get_data;
+ E_Policy_Zone *policy_zone;
+ E_Zone *zone;
+ int x, y, pos;
+
+ policy_zone = wl_container_of(listener, policy_zone, desk_at_pos_get);
+ desk_get_data = (E_Zone_Data_Desk_Get *) data;
+ zone = desk_get_data->zone;
+ pos = desk_get_data->pos;
+
+ y = pos / zone->desk_x_count;
+ x = pos - (y * zone->desk_x_count);
+
+ if ((x >= zone->desk_x_count) || (y >= zone->desk_y_count))
+ {
+ desk_get_data->desk = NULL;
+ return;
+ }
+
+ desk_get_data->desk = zone->desks[x + (y * zone->desk_x_count)];
+}
+
+static void
+_e_policy_zone_cb_desk_next(struct wl_listener *listener, void *data)
+{
+ E_Policy_Zone *policy_zone;
+ E_Zone *zone;
+ int x, y;
+
+ policy_zone = wl_container_of(listener, policy_zone, desk_next);
+ zone = policy_zone->zone;
+
+ if ((zone->desk_x_count < 2) && (zone->desk_y_count < 2))
+ return;
+
+ x = zone->desk_x_current;
+ y = zone->desk_y_current;
+
+ x++;
+ if (x >= zone->desk_x_count)
+ {
+ x = 0;
+ y++;
+ if (y >= zone->desk_y_count) y = 0;
+ }
+
+ e_desk_show(e_desk_at_xy_get(zone, x, y));
+}
+
+static void
+_e_policy_zone_cb_desk_prev(struct wl_listener *listener, void *data)
+{
+ E_Policy_Zone *policy_zone;
+ E_Zone *zone;
+ int x, y;
+
+ policy_zone = wl_container_of(listener, policy_zone, desk_prev);
+ zone = policy_zone->zone;
+
+ if ((zone->desk_x_count < 2) && (zone->desk_y_count < 2))
+ return;
+
+ x = zone->desk_x_current;
+ y = zone->desk_y_current;
+
+ x--;
+ if (x < 0)
+ {
+ x = zone->desk_x_count - 1;
+ y--;
+ if (y < 0) y = zone->desk_y_count - 1;
+ }
+ e_desk_show(e_desk_at_xy_get(zone, x, y));
+}
+
+static void
+_e_policy_zone_cb_desk_count(struct wl_listener *listener, void *data)
+{
+ E_Zone_Data_Desk_Count *count_data;
+ E_Policy_Zone *policy_zone;
+ E_Zone *zone;
+ int cx, cy;
+
+ policy_zone = wl_container_of(listener, policy_zone, desk_count);
+ count_data = data;
+ zone = policy_zone->zone;
+
+ e_zone_desk_count_get(zone, &cx, &cy);
+ count_data->count = cx * cy;
+}
+
+
#ifdef EC_IS_NOT_VISIBLE
# undef EC_IS_NOT_VISIBLE
#endif
zone->desks[i]->x,
zone->desks[i]->y);
if (d)
- e_policy_desk_add(zone->desks[i]);
+ {
+ e_policy_desk_add(zone->desks[i]);
+ e_desk_show(zone->desks[i]);
+ }
}
else
- e_policy_desk_add(zone->desks[i]);
+ {
+ e_policy_desk_add(zone->desks[i]);
+ e_desk_show(zone->desks[i]);
+ }
}
// TODO: adjust each focus poicy to each zone.
policy_zone->bg_mouse_up.notify = _e_policy_zone_cb_bg_mouse_up;
e_zone_bg_mouse_up_listener_add(zone, &policy_zone->bg_mouse_up);
+ policy_zone->desk_row_add.notify = _e_policy_zone_cb_desk_row_add;
+ e_zone_desk_row_add_listener_add(policy_zone->zone, &policy_zone->desk_row_add);
+ policy_zone->desk_row_remove.notify = _e_policy_zone_cb_desk_row_remove;
+ e_zone_desk_row_remove_listener_add(policy_zone->zone, &policy_zone->desk_row_remove);
+ policy_zone->desk_col_add.notify = _e_policy_zone_cb_desk_col_add;
+ e_zone_desk_col_add_listener_add(policy_zone->zone, &policy_zone->desk_col_add);
+ policy_zone->desk_col_remove.notify = _e_policy_zone_cb_desk_col_remove;
+ e_zone_desk_col_remove_listener_add(policy_zone->zone, &policy_zone->desk_col_remove);
+ policy_zone->desk_current_get.notify = _e_policy_zone_cb_desk_current_get;
+ e_zone_desk_current_get_listener_add(policy_zone->zone, &policy_zone->desk_current_get);
+ policy_zone->desk_at_xy_get.notify = _e_policy_zone_cb_desk_at_xy_get;
+ e_zone_desk_at_xy_get_listener_add(policy_zone->zone, &policy_zone->desk_at_xy_get);
+ policy_zone->desk_at_pos_get.notify = _e_policy_zone_cb_desk_at_pos_get;
+ e_zone_desk_at_pos_get_listener_add(policy_zone->zone, &policy_zone->desk_at_pos_get);
+ policy_zone->desk_next.notify = _e_policy_zone_cb_desk_next;
+ e_zone_desk_next_listener_add(policy_zone->zone, &policy_zone->desk_next);
+ policy_zone->desk_prev.notify = _e_policy_zone_cb_desk_prev;
+ e_zone_desk_prev_listener_add(policy_zone->zone, &policy_zone->desk_prev);
+ policy_zone->desk_count.notify = _e_policy_zone_cb_desk_count;
+ e_zone_desk_count_listener_add(policy_zone->zone, &policy_zone->desk_count);
+
policy_zone->focus_focused_ec_changed.notify = _policy_zone_cb_focus_focused_ec_changed;
e_focus_focused_ec_changed_listener_add(zone->focus, &policy_zone->focus_focused_ec_changed);
#include <e_client.h>
#define E_DESK_TYPE 0xE0b01005
+#ifdef CONTAINER_POLICY
+#else
#define E_DESK_SMART_OBJ_TYPE "E_Desk_Smart_Object"
+#endif
#define E_DESK_AREA_LAYER_COUNT 9
typedef struct _E_Desk_Hook E_Desk_Hook;
projects / platform / upstream / enlightenment.git / commitdiff