From 00690dab17f1e1e8bd28e7579908ae422593ff8e Mon Sep 17 00:00:00 2001 From: Gwanglim Lee Date: Fri, 29 Aug 2014 13:48:01 -0400 Subject: [PATCH] added mobile policy module Summary: mobile policy module provides user interface for small mobile devices like phones. Test Plan: N/A Reviewers: raster, devilhorns, zmike Subscribers: seoz, zmike, cedric Differential Revision: https://phab.enlightenment.org/D817 --- configure.ac | 1 + src/bin/e_module.c | 1 + src/modules/Makefile.mk | 2 + src/modules/Makefile_policy_mobile.mk | 21 + .../policy_mobile/e-module-policy-mobile.edj | Bin 0 -> 17246 bytes src/modules/policy_mobile/e_mod_config.c | 387 +++++++++++ src/modules/policy_mobile/e_mod_main.c | 646 ++++++++++++++++++ src/modules/policy_mobile/e_mod_main.h | 108 +++ src/modules/policy_mobile/e_mod_softkey.c | 171 +++++ 9 files changed, 1337 insertions(+) create mode 100644 src/modules/Makefile_policy_mobile.mk create mode 100644 src/modules/policy_mobile/e-module-policy-mobile.edj create mode 100644 src/modules/policy_mobile/e_mod_config.c create mode 100644 src/modules/policy_mobile/e_mod_main.c create mode 100644 src/modules/policy_mobile/e_mod_main.h create mode 100644 src/modules/policy_mobile/e_mod_softkey.c diff --git a/configure.ac b/configure.ac index c1ceca6bb..f807de672 100644 --- a/configure.ac +++ b/configure.ac @@ -971,6 +971,7 @@ AC_E_OPTIONAL_MODULE([wl_x11], $have_wayland, $wl_x11) AC_E_OPTIONAL_MODULE([wl_fb], $have_wayland, [CHECK_MODULE_WL_FB]) AC_E_OPTIONAL_MODULE([wl_drm], $have_wayland, [CHECK_MODULE_WL_DRM]) #AC_E_OPTIONAL_MODULE([wl_screenshot], true, [CHECK_MODULE_WL_SCREENSHOT]) +AC_E_OPTIONAL_MODULE([policy_mobile], true) HALT="/sbin/shutdown -h now" REBOOT="/sbin/shutdown -r now" diff --git a/src/bin/e_module.c b/src/bin/e_module.c index a864ef879..49b4adc7e 100644 --- a/src/bin/e_module.c +++ b/src/bin/e_module.c @@ -938,6 +938,7 @@ _e_module_whitelist_check(void) "music-control", "appmenu", "packagekit", + "policy_mobile", NULL // end marker }; diff --git a/src/modules/Makefile.mk b/src/modules/Makefile.mk index bc2d69394..5b6bf8b17 100644 --- a/src/modules/Makefile.mk +++ b/src/modules/Makefile.mk @@ -130,3 +130,5 @@ include src/modules/Makefile_wl_fb.mk #if HAVE_WAYLAND_SCREENSHOT #include src/modules/Makefile_wl_screenshot.mk + +include src/modules/Makefile_policy_mobile.mk diff --git a/src/modules/Makefile_policy_mobile.mk b/src/modules/Makefile_policy_mobile.mk new file mode 100644 index 000000000..59ca42222 --- /dev/null +++ b/src/modules/Makefile_policy_mobile.mk @@ -0,0 +1,21 @@ +EXTRA_DIST += src/modules/policy_mobile/e-module-policy-mobile.edj +if USE_MODULE_POLICY_MOBILE +policy_mobiledir = $(MDIR)/policy_mobile +policy_mobile_DATA = src/modules/policy_mobile/e-module-policy-mobile.edj + +policy_mobilepkgdir = $(MDIR)/policy_mobile/$(MODULE_ARCH) +policy_mobilepkg_LTLIBRARIES = src/modules/policy_mobile/module.la + +src_modules_policy_mobile_module_la_LIBADD = $(MOD_LIBS) +src_modules_policy_mobile_module_la_CPPFLAGS = $(MOD_CPPFLAGS) +src_modules_policy_mobile_module_la_LDFLAGS = $(MOD_LDFLAGS) +src_modules_policy_mobile_module_la_SOURCES = \ +src/modules/policy_mobile/e_mod_main.h \ +src/modules/policy_mobile/e_mod_config.c \ +src/modules/policy_mobile/e_mod_softkey.c \ +src/modules/policy_mobile/e_mod_main.c + +PHONIES += policy_mobile install-policy_mobile +policy_mobile: $(policy_mobilepkg_LTLIBRARIES) $(policy_mobile_DATA) +install-policy_mobile: install-policy_mobileDATA install-policy_mobilepkgLTLIBRARIES +endif diff --git a/src/modules/policy_mobile/e-module-policy-mobile.edj b/src/modules/policy_mobile/e-module-policy-mobile.edj new file mode 100644 index 0000000000000000000000000000000000000000..1a1c81cc4cab96377845eb6cfbd3494c02913f77 GIT binary patch literal 17246 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 P(!4aihs}p@<>LPU70~p^ literal 0 HcmV?d00001 diff --git a/src/modules/policy_mobile/e_mod_config.c b/src/modules/policy_mobile/e_mod_config.c new file mode 100644 index 000000000..6df66f049 --- /dev/null +++ b/src/modules/policy_mobile/e_mod_config.c @@ -0,0 +1,387 @@ +#include "e_mod_main.h" + +static void _pol_conf_desk_add(Config *conf, E_Desk *desk); +static void _pol_conf_desk_del(Config *conf, Config_Desk *d); +static Config_Desk *_pol_conf_desk_get(Config *conf, Config_Desk *d); + +static void *_pol_cfd_data_create(E_Config_Dialog *cfd); +static void _pol_cfd_data_free(E_Config_Dialog *cfd EINA_UNUSED, E_Config_Dialog_Data *cfdata); +static int _pol_cfd_data_basic_apply(E_Config_Dialog *cfd EINA_UNUSED, E_Config_Dialog_Data *cfdata); +static void _pol_cfd_desk_list_update(E_Config_Dialog_Data *cfdata, E_Zone *zone); +static void _pol_cfd_hook_zone_change(void *data, Evas_Object *obj); +static Evas_Object *_pol_cfd_data_basic_widgets_create(E_Config_Dialog *cfd EINA_UNUSED, Evas *evas, E_Config_Dialog_Data *cfdata); + +static void +_pol_conf_desk_add(Config *conf, E_Desk *desk) +{ + Config_Desk *d; + + d = E_NEW(Config_Desk, 1); + d->comp_num = desk->zone->comp->num; + d->zone_num = desk->zone->num; + d->x = desk->x; + d->y = desk->y; + d->enable = 1; + + conf->desks = eina_list_append(conf->desks, d); +} + +static void +_pol_conf_desk_del(Config *conf, Config_Desk *d) +{ + conf->desks = eina_list_remove(conf->desks, d); + free(d); +} + +static Config_Desk * +_pol_conf_desk_get(Config *conf, Config_Desk *d) +{ + Eina_List *l; + Config_Desk *d2; + + EINA_LIST_FOREACH(conf->desks, l, d2) + { + if ((d2->comp_num == d->comp_num) && + (d2->zone_num == d->zone_num) && + (d2->x == d->x) && (d2->y == d->y)) + { + return d2; + } + } + + return NULL; +} + +static void * +_pol_cfd_data_create(E_Config_Dialog *cfd) +{ + E_Config_Dialog_Data *cfdata = NULL; + + cfdata = E_NEW(E_Config_Dialog_Data, 1); + cfdata->conf = E_NEW(Config, 1); + cfdata->conf->launcher.title = eina_stringshare_ref(_pol_mod->conf->launcher.title); + cfdata->conf->launcher.clas = eina_stringshare_ref(_pol_mod->conf->launcher.clas); + cfdata->conf->launcher.type = _pol_mod->conf->launcher.type; + cfdata->conf->use_softkey = _pol_mod->conf->use_softkey; + cfdata->conf->softkey_size = _pol_mod->conf->softkey_size; + + _pol_mod->conf_dialog = cfd; + + return cfdata; +} + +static void +_pol_cfd_data_free(E_Config_Dialog *cfd EINA_UNUSED, E_Config_Dialog_Data *cfdata) +{ + _pol_mod->conf_dialog = NULL; + E_FREE_LIST(cfdata->conf->desks, free); + eina_stringshare_del(cfdata->conf->launcher.title); + eina_stringshare_del(cfdata->conf->launcher.clas); + free(cfdata->conf); + free(cfdata); +} + +static int +_pol_cfd_data_basic_apply(E_Config_Dialog *cfd EINA_UNUSED, E_Config_Dialog_Data *cfdata) +{ + E_Comp *comp; + E_Zone *zone; + E_Desk *desk; + Pol_Softkey *softkey; + Pol_Desk *pd; + Config_Desk *d, *d2; + Eina_Bool changed = EINA_FALSE; + const Eina_List *l; + Eina_Inlist *il; + Eina_Iterator *it; + + if (_pol_mod->conf->use_softkey != cfdata->conf->use_softkey) + { + _pol_mod->conf->use_softkey = cfdata->conf->use_softkey; + if (_pol_mod->conf->use_softkey) + { + it = eina_hash_iterator_data_new(hash_pol_desks); + while (eina_iterator_next(it, (void **)&pd)) + { + softkey = e_mod_pol_softkey_get(pd->zone); + if (!softkey) + softkey = e_mod_pol_softkey_add(pd->zone); + if (e_desk_current_get(pd->zone) == pd->desk) + e_mod_pol_softkey_show(softkey); + } + eina_iterator_free(it); + } + else + { + EINA_INLIST_FOREACH_SAFE(_pol_mod->softkeys, il, softkey) + e_mod_pol_softkey_del(softkey); + } + + changed = EINA_TRUE; + } + + if (_pol_mod->conf->softkey_size != cfdata->conf->softkey_size) + { + _pol_mod->conf->softkey_size = cfdata->conf->softkey_size; + if (_pol_mod->conf->use_softkey) + { + EINA_INLIST_FOREACH(_pol_mod->softkeys, softkey) + e_mod_pol_softkey_update(softkey); + } + changed = EINA_TRUE; + } + + EINA_LIST_FOREACH(cfdata->conf->desks, l, d) + { + comp = e_comp_number_get(d->comp_num); + zone = e_comp_zone_number_get(comp, d->zone_num); + desk = e_desk_at_xy_get(zone, d->x, d->y); + if (!desk) continue; + + d2 = _pol_conf_desk_get(_pol_mod->conf, d); + if (d2) + { + /* disable policy for this desktop */ + if (d2->enable != d->enable) + { + pd = eina_hash_find(hash_pol_desks, &desk); + if (pd) e_mod_pol_desk_del(pd); + _pol_conf_desk_del(_pol_mod->conf, d2); + changed = EINA_TRUE; + } + } + else + { + /* apply policy for all clients in this desk, + * and add desk to configuration list and desk hash */ + if (d->enable) + { + e_mod_pol_desk_add(desk); + _pol_conf_desk_add(_pol_mod->conf, desk); + changed = EINA_TRUE; + } + } + } + + if (changed) + e_config_save_queue(); + + return 1; +} + +static void +_pol_cfd_desk_list_update(E_Config_Dialog_Data *cfdata, E_Zone *zone) +{ + Evas_Object *o, *ch; + Evas *evas; + E_Desk *desk; + Config_Desk *d, *d2; + int i, n; + + evas = evas_object_evas_get(cfdata->o_list); + evas_object_del(cfdata->o_desks); + E_FREE_LIST(cfdata->conf->desks, free); + + o = e_widget_list_add(evas, 1, 0); + cfdata->o_desks = o; + + n = zone->desk_y_count * zone->desk_x_count; + for (i = 0; i < n; i++) + { + desk = zone->desks[i]; + + d = E_NEW(Config_Desk, 1); + d->comp_num = zone->comp->num; + d->zone_num = zone->num; + d->x = desk->x; + d->y = desk->y; + d->enable = 0; + + d2 = _pol_conf_desk_get(_pol_mod->conf, d); + if (d2) + d->enable = d2->enable; + + ch = e_widget_check_add(evas, desk->name, &d->enable); + e_widget_list_object_append(o, ch, 1, 1, 0.5); + + cfdata->conf->desks = eina_list_append(cfdata->conf->desks, d); + } + + e_widget_list_object_append(cfdata->o_list, o, 1, 1, 0.5); +} + +static void +_pol_cfd_hook_zone_change(void *data, Evas_Object *obj) +{ + E_Config_Dialog_Data *cfdata; + E_Zone *zone; + int n; + + cfdata = data; + n = e_widget_ilist_selected_get(obj); + zone = e_widget_ilist_nth_data_get(obj, n); + if (zone) + _pol_cfd_desk_list_update(cfdata, zone); +} + +static Evas_Object * +_pol_cfd_data_basic_widgets_create(E_Config_Dialog *cfd EINA_UNUSED, Evas *evas, E_Config_Dialog_Data *cfdata) +{ + Evas_Object *base, *fl, *lb, *lo, *o; + E_Comp *comp; + E_Zone *zone; + Eina_List *l; + + comp = e_comp_get(NULL); + + base = e_widget_list_add(evas, 0, 0); + + fl = e_widget_framelist_add(evas, _("Softkey"), 0); + o = e_widget_check_add(evas, _("Use softkey for navigation among the windows"), + &cfdata->conf->use_softkey); + e_widget_framelist_object_append(fl, o); + o = e_widget_label_add(evas, _("Icon Size")); + e_widget_framelist_object_append(fl, o); + o = e_widget_slider_add(evas, 1, 0, "%1.0f", 32, 256, 1, 0, NULL, + &(cfdata->conf->softkey_size), 150); + e_widget_framelist_object_append(fl, o); + e_widget_list_object_append(base, fl, 1, 1, 0.5); + + fl = e_widget_framelist_add(evas, _("Virtual Desktops"), 0); + lb = e_widget_label_add(evas, _("Enable mobile policy per desktop")); + e_widget_framelist_object_append(fl, lb); + + lo = e_widget_list_add(evas, 0, 1); + cfdata->o_list = lo; + o = e_widget_ilist_add(evas, 0, 0, NULL); + e_widget_ilist_multi_select_set(o, EINA_FALSE); + e_widget_size_min_set(o, 100, 100); + e_widget_on_change_hook_set(o, _pol_cfd_hook_zone_change, cfdata); + EINA_LIST_REVERSE_FOREACH(comp->zones, l, zone) + e_widget_ilist_append(o, NULL, zone->name, NULL, zone, NULL); + e_widget_ilist_go(o); + e_widget_ilist_selected_set(o, 0); + e_widget_list_object_append(lo, o, 1, 1, 0.5); + + /* update virtual desktops of first zone */ + zone = eina_list_data_get(comp->zones); + _pol_cfd_desk_list_update(cfdata, zone); + + e_widget_framelist_object_append(fl, lo); + e_widget_list_object_append(base, fl, 1, 1, 0.5); + + return base; +} + +void +e_mod_pol_conf_init(Mod *mod) +{ + E_Comp *comp; + E_Zone *zone; + E_Desk *desk; + Config *conf; + + mod->conf_desk_edd = E_CONFIG_DD_NEW("Policy_Mobile_Config_Desk", Config_Desk); +#undef T +#undef D +#define T Config_Desk +#define D mod->conf_desk_edd + E_CONFIG_VAL(D, T, comp_num, INT); + E_CONFIG_VAL(D, T, zone_num, UINT); + E_CONFIG_VAL(D, T, x, INT); + E_CONFIG_VAL(D, T, y, INT); + E_CONFIG_VAL(D, T, enable, INT); + + mod->conf_edd = E_CONFIG_DD_NEW("Policy_Mobile_Config", Config); +#undef T +#undef D +#define T Config +#define D mod->conf_edd + E_CONFIG_VAL(D, T, launcher.title, STR); + E_CONFIG_VAL(D, T, launcher.clas, STR); + E_CONFIG_VAL(D, T, launcher.type, UINT); + E_CONFIG_LIST(D, T, desks, mod->conf_desk_edd); + E_CONFIG_VAL(D, T, use_softkey, INT); + E_CONFIG_VAL(D, T, softkey_size, INT); + +#undef T +#undef D + + mod->conf = e_config_domain_load("module.policy-mobile", mod->conf_edd); + if (!mod->conf) + { + conf = E_NEW(Config, 1); + mod->conf = conf; + conf->launcher.title = eina_stringshare_add("Illume Home"); + conf->launcher.clas = eina_stringshare_add("Illume-Home"); + conf->launcher.type = E_WINDOW_TYPE_NORMAL; + conf->use_softkey = 1; + conf->softkey_size = 42; + + comp = e_comp_get(NULL); + zone = e_zone_current_get(comp); + desk = e_desk_current_get(zone); + _pol_conf_desk_add(conf, desk); + } +} + +void +e_mod_pol_conf_shutdown(Mod *mod) +{ + Config *conf; + + if (mod->conf) + { + conf = mod->conf; + E_FREE_LIST(conf->desks, free); + eina_stringshare_del(conf->launcher.title); + eina_stringshare_del(conf->launcher.clas); + free(mod->conf); + } + + E_CONFIG_DD_FREE(mod->conf_desk_edd); + E_CONFIG_DD_FREE(mod->conf_edd); +} + +Config_Desk * +e_mod_pol_conf_desk_get_by_nums(Config *conf, unsigned int comp_num, unsigned int zone_num, int x, int y) +{ + Eina_List *l; + Config_Desk *d2; + + EINA_LIST_FOREACH(conf->desks, l, d2) + { + if ((d2->comp_num == comp_num) && + (d2->zone_num == zone_num) && + (d2->x == x) && (d2->y == y)) + { + return d2; + } + } + + return NULL; +} + +E_Config_Dialog * +e_int_config_pol_mobile(E_Comp *comp, const char *params EINA_UNUSED) +{ + E_Config_Dialog *cfd; + E_Config_Dialog_View *v; + char buf[PATH_MAX]; + + if (e_config_dialog_find("E", "windows/policy-mobile")) + return NULL; + + v = E_NEW(E_Config_Dialog_View, 1); + v->create_cfdata = _pol_cfd_data_create; + v->free_cfdata = _pol_cfd_data_free; + v->basic.apply_cfdata = _pol_cfd_data_basic_apply; + v->basic.create_widgets = _pol_cfd_data_basic_widgets_create; + + snprintf(buf, sizeof(buf), "%s/e-module-policy-mobile.edj", + e_module_dir_get(_pol_mod->module)); + + cfd = e_config_dialog_new(comp, _("Mobile Policy Configuration"), "E", + "windows/policy-mobile", buf, 0, v, NULL); + return cfd; +} diff --git a/src/modules/policy_mobile/e_mod_main.c b/src/modules/policy_mobile/e_mod_main.c new file mode 100644 index 000000000..2d8b86e92 --- /dev/null +++ b/src/modules/policy_mobile/e_mod_main.c @@ -0,0 +1,646 @@ +#include "e_mod_main.h" + +EAPI E_Module_Api e_modapi = { E_MODULE_API_VERSION, "Policy-Mobile" }; + +Mod *_pol_mod = NULL; +Eina_Hash *hash_pol_desks = NULL; +Eina_Hash *hash_pol_clients = NULL; + +static Eina_List *handlers = NULL; +static Eina_List *hooks = NULL; + +static Pol_Client *_pol_client_add(E_Client *ec); +static void _pol_client_del(Pol_Client *pc); +static Eina_Bool _pol_client_normal_check(E_Client *ec); +static void _pol_client_update(Pol_Client *pc); +static void _pol_client_launcher_set(Pol_Client *pc); + +static void _pol_hook_client_eval_post_fetch(void *d EINA_UNUSED, E_Client *ec); +static void _pol_hook_client_desk_set(void *d EINA_UNUSED, E_Client *ec); +static void _pol_cb_desk_data_free(void *data); +static void _pol_cb_client_data_free(void *data); +static Eina_Bool _pol_cb_zone_add(void *data EINA_UNUSED, int type EINA_UNUSED, void *event); +static Eina_Bool _pol_cb_zone_del(void *data EINA_UNUSED, int type EINA_UNUSED, void *event); +static Eina_Bool _pol_cb_zone_move_resize(void *data EINA_UNUSED, int type EINA_UNUSED, void *event); +static Eina_Bool _pol_cb_zone_desk_count_set(void *data EINA_UNUSED, int type EINA_UNUSED, void *event); +static Eina_Bool _pol_cb_desk_show(void *data EINA_UNUSED, int type EINA_UNUSED, void *event); +static Eina_Bool _pol_cb_client_remove(void *data EINA_UNUSED, int type, void *event); + +static void +_pol_client_launcher_set(Pol_Client *pc) +{ + Pol_Client *pc2; + + pc2 = e_mod_pol_client_launcher_get(pc->ec->zone); + if (pc2) return; + + if (pc->ec->netwm.type != _pol_mod->conf->launcher.type) + return; + + if (e_util_strcmp(pc->ec->icccm.class, + _pol_mod->conf->launcher.clas)) + return; + + + if (e_util_strcmp(pc->ec->icccm.title, + _pol_mod->conf->launcher.title)) + { + /* check netwm name instead, because comp_x had ignored + * icccm name when fetching */ + if (e_util_strcmp(pc->ec->netwm.name, + _pol_mod->conf->launcher.title)) + { + return; + } + } + + _pol_mod->launchers = eina_list_append(_pol_mod->launchers, pc); +} + +static Pol_Client * +_pol_client_add(E_Client *ec) +{ + Pol_Client *pc; + Pol_Desk *pd; + + if (e_object_is_del(E_OBJECT(ec))) return NULL; + if (!_pol_client_normal_check(ec)) return NULL; + + pc = eina_hash_find(hash_pol_clients, &ec); + if (pc) return NULL; + + pd = eina_hash_find(hash_pol_desks, &ec->desk); + if (!pd) return NULL; + + pc = E_NEW(Pol_Client, 1); + pc->ec = ec; + +#undef _SET +# define _SET(a) pc->orig.a = ec->a + _SET(borderless); + _SET(fullscreen); + _SET(maximized); + _SET(lock_user_location); + _SET(lock_client_location); + _SET(lock_user_size); + _SET(lock_client_size); + _SET(lock_client_stacking); + _SET(lock_user_shade); + _SET(lock_client_shade); + _SET(lock_user_maximize); + _SET(lock_client_maximize); +#undef _SET + + _pol_client_launcher_set(pc); + + eina_hash_add(hash_pol_clients, &ec, pc); + + _pol_client_update(pc); + + return pc; +} + +static void +_pol_client_del(Pol_Client *pc) +{ + E_Client *ec; + Eina_Bool changed = EINA_FALSE; + + ec = pc->ec; + + if (pc->orig.borderless != ec->borderless) + { + ec->border.changed = 1; + changed = EINA_TRUE; + } + + if ((pc->orig.fullscreen != ec->fullscreen) && + (pc->orig.fullscreen)) + { + ec->need_fullscreen = 1; + changed = EINA_TRUE; + } + + if (pc->orig.maximized != ec->maximized) + { + if (pc->orig.maximized) + ec->changes.need_maximize = 1; + else + ec->changes.need_unmaximize = 1; + changed = EINA_TRUE; + } + +#undef _SET +# define _SET(a) ec->a = pc->orig.a + _SET(borderless); + _SET(fullscreen); + _SET(maximized); + _SET(lock_user_location); + _SET(lock_client_location); + _SET(lock_user_size); + _SET(lock_client_size); + _SET(lock_client_stacking); + _SET(lock_user_shade); + _SET(lock_client_shade); + _SET(lock_user_maximize); + _SET(lock_client_maximize); +#undef _SET + + /* only set it if the border is changed or fullscreen/maximize has changed */ + if (changed) + EC_CHANGED(pc->ec); + + _pol_mod->launchers = eina_list_remove(_pol_mod->launchers, pc); + + eina_hash_del_by_key(hash_pol_clients, &pc->ec); +} + +static Eina_Bool +_pol_client_normal_check(E_Client *ec) +{ + if ((e_client_util_ignored_get(ec)) || + (!ec->pixmap)) + { + return EINA_FALSE; + } + + if ((ec->netwm.type == E_WINDOW_TYPE_NORMAL) || + (ec->netwm.type == E_WINDOW_TYPE_UNKNOWN)) + { + return EINA_TRUE; + } + + return EINA_FALSE; +} + +static void +_pol_client_update(Pol_Client *pc) +{ + E_Client *ec; + + ec = pc->ec; + + if (ec->remember) + { + e_remember_del(ec->remember); + ec->remember = NULL; + } + + /* skip hooks of e_remeber for eval_pre_post_fetch and eval_post_new_client */ + ec->internal_no_remember = 1; + + if (!ec->borderless) + { + ec->borderless = 1; + ec->border.changed = 1; + EC_CHANGED(pc->ec); + } + + if (!ec->maximized) + e_client_maximize(ec, E_MAXIMIZE_EXPAND | E_MAXIMIZE_BOTH); + + /* do not allow client to change these properties */ + ec->lock_user_location = 1; + ec->lock_client_location = 1; + ec->lock_user_size = 1; + ec->lock_client_size = 1; + ec->lock_client_stacking = 1; + ec->lock_user_shade = 1; + ec->lock_client_shade = 1; + ec->lock_user_maximize = 1; + ec->lock_client_maximize = 1; +} + +static void +_pol_hook_client_eval_post_fetch(void *d EINA_UNUSED, E_Client *ec) +{ + Pol_Client *pc; + Pol_Desk *pd; + + if (e_object_is_del(E_OBJECT(ec))) return; + if (!_pol_client_normal_check(ec)) return; + if (ec->new_client) return; + + pd = eina_hash_find(hash_pol_desks, &ec->desk); + if (!pd) return; + + pc = eina_hash_find(hash_pol_clients, &ec); + if (pc) + { + _pol_client_launcher_set(pc); + return; + } + + _pol_client_add(ec); +} + +static void +_pol_hook_client_desk_set(void *d EINA_UNUSED, E_Client *ec) +{ + Pol_Client *pc; + Pol_Desk *pd; + + if (e_object_is_del(E_OBJECT(ec))) return; + if (!_pol_client_normal_check(ec)) return; + + pc = eina_hash_find(hash_pol_clients, &ec); + pd = eina_hash_find(hash_pol_desks, &ec->desk); + + if ((!pc) && (pd)) + _pol_client_add(ec); + else if ((pc) && (!pd)) + _pol_client_del(pc); +} + +static void +_pol_cb_desk_data_free(void *data) +{ + free(data); +} + +static void +_pol_cb_client_data_free(void *data) +{ + free(data); +} + +static Eina_Bool +_pol_cb_zone_add(void *data EINA_UNUSED, int type EINA_UNUSED, void *event) +{ + E_Event_Zone_Add *ev; + E_Zone *zone; + Config_Desk *d; + int i, n; + + ev = event; + zone = ev->zone; + n = zone->desk_y_count * zone->desk_x_count; + for (i = 0; i < n; i++) + { + d = e_mod_pol_conf_desk_get_by_nums(_pol_mod->conf, + zone->comp->num, + zone->num, + zone->desks[i]->x, + zone->desks[i]->y); + if (d) + e_mod_pol_desk_add(zone->desks[i]); + } + + return ECORE_CALLBACK_PASS_ON; +} + +static Eina_Bool +_pol_cb_zone_del(void *data EINA_UNUSED, int type EINA_UNUSED, void *event) +{ + E_Event_Zone_Del *ev; + E_Zone *zone; + Pol_Desk *pd; + int i, n; + + ev = event; + zone = ev->zone; + n = zone->desk_y_count * zone->desk_x_count; + for (i = 0; i < n; i++) + { + pd = eina_hash_find(hash_pol_desks, &zone->desks[i]); + if (pd) e_mod_pol_desk_del(pd); + } + + return ECORE_CALLBACK_PASS_ON; +} + +static Eina_Bool +_pol_cb_zone_move_resize(void *data EINA_UNUSED, int type EINA_UNUSED, void *event) +{ + E_Event_Zone_Move_Resize *ev; + Pol_Softkey *softkey; + + ev = event; + + if (_pol_mod->conf->use_softkey) + { + softkey = e_mod_pol_softkey_get(ev->zone); + e_mod_pol_softkey_update(softkey); + } + return ECORE_CALLBACK_PASS_ON; +} + +static Eina_Bool +_pol_cb_zone_desk_count_set(void *data EINA_UNUSED, int type EINA_UNUSED, void *event) +{ + E_Event_Zone_Desk_Count_Set *ev; + E_Zone *zone; + E_Desk *desk; + Eina_Iterator *it; + Pol_Desk *pd; + Config_Desk *d; + int i, n; + Eina_Bool found; + Eina_List *desks_del = NULL; + + ev = event; + zone = ev->zone; + + /* remove deleted desk from hash */ + it = eina_hash_iterator_data_new(hash_pol_desks); + while (eina_iterator_next(it, (void **)&pd)) + { + if (pd->zone != zone) continue; + + found = EINA_FALSE; + n = zone->desk_y_count * zone->desk_x_count; + for (i = 0; i < n; i++) + { + if (pd->desk == zone->desks[i]) + { + found = EINA_TRUE; + break; + } + } + if (!found) + desks_del = eina_list_append(desks_del, pd->desk); + } + eina_iterator_free(it); + + EINA_LIST_FREE(desks_del, desk) + { + pd = eina_hash_find(hash_pol_desks, &desk); + if (pd) e_mod_pol_desk_del(pd); + } + + /* add newly added desk to hash */ + n = zone->desk_y_count * zone->desk_x_count; + for (i = 0; i < n; i++) + { + d = e_mod_pol_conf_desk_get_by_nums(_pol_mod->conf, + zone->comp->num, + zone->num, + zone->desks[i]->x, + zone->desks[i]->y); + if (d) + e_mod_pol_desk_add(zone->desks[i]); + } + + return ECORE_CALLBACK_PASS_ON; +} + +static Eina_Bool +_pol_cb_desk_show(void *data EINA_UNUSED, int type EINA_UNUSED, void *event) +{ + E_Event_Desk_Show *ev; + Pol_Softkey *softkey; + + ev = event; + + if (_pol_mod->conf->use_softkey) + { + softkey = e_mod_pol_softkey_get(ev->desk->zone); + if (eina_hash_find(hash_pol_desks, &ev->desk)) + e_mod_pol_softkey_show(softkey); + else + e_mod_pol_softkey_hide(softkey); + } + return ECORE_CALLBACK_PASS_ON; +} + +static Eina_Bool +_pol_cb_client_remove(void *data EINA_UNUSED, int type EINA_UNUSED, void *event) +{ + E_Event_Client *ev; + Pol_Client *pc; + + ev = event; + pc = eina_hash_find(hash_pol_clients, &ev->ec); + if (!pc) return ECORE_CALLBACK_PASS_ON; + + eina_hash_del_by_key(hash_pol_clients, &ev->ec); + + return ECORE_CALLBACK_PASS_ON; +} + +void +e_mod_pol_desk_add(E_Desk *desk) +{ + Pol_Desk *pd; + E_Comp *comp; + E_Client *ec; + Pol_Softkey *softkey; + const Eina_List *l; + + pd = eina_hash_find(hash_pol_desks, &desk); + if (pd) return; + + pd = E_NEW(Pol_Desk, 1); + pd->desk = desk; + pd->zone = desk->zone; + + eina_hash_add(hash_pol_desks, &desk, pd); + + /* add clients */ + EINA_LIST_FOREACH(e_comp_list(), l, comp) + E_CLIENT_FOREACH(comp, ec) + { + if (pd->desk == ec->desk) + _pol_client_add(ec); + } + + /* add and show softkey */ + if (_pol_mod->conf->use_softkey) + { + softkey = e_mod_pol_softkey_get(desk->zone); + if (!softkey) + softkey = e_mod_pol_softkey_add(desk->zone); + if (e_desk_current_get(desk->zone) == desk) + e_mod_pol_softkey_show(softkey); + } +} + +void +e_mod_pol_desk_del(Pol_Desk *pd) +{ + Eina_Iterator *it; + Pol_Client *pc; + E_Client *ec; + Eina_List *clients_del = NULL; + Pol_Softkey *softkey; + Eina_Bool keep = EINA_FALSE; + int i, n; + + /* hide and delete softkey */ + if (_pol_mod->conf->use_softkey) + { + softkey = e_mod_pol_softkey_get(pd->zone); + if (e_desk_current_get(pd->zone) == pd->desk) + e_mod_pol_softkey_hide(softkey); + + n = pd->zone->desk_y_count * pd->zone->desk_x_count; + for (i = 0; i < n; i++) + { + if (eina_hash_find(hash_pol_desks, &pd->zone->desks[i])) + { + keep = EINA_TRUE; + break; + } + } + + if (!keep) + e_mod_pol_softkey_del(softkey); + } + + /* remove clients */ + it = eina_hash_iterator_data_new(hash_pol_clients); + while (eina_iterator_next(it, (void **)&pc)) + { + if (pc->ec->desk == pd->desk) + clients_del = eina_list_append(clients_del, pc->ec); + } + eina_iterator_free(it); + + EINA_LIST_FREE(clients_del, ec) + { + pc = eina_hash_find(hash_pol_clients, &ec); + if (pc) _pol_client_del(pc); + } + + eina_hash_del_by_key(hash_pol_desks, &pd->desk); +} + +Pol_Client * +e_mod_pol_client_launcher_get(E_Zone *zone) +{ + Pol_Client *pc; + Eina_List *l; + + EINA_LIST_FOREACH(_pol_mod->launchers, l, pc) + { + if (pc->ec->zone == zone) + return pc; + } + return NULL; +} + +#undef E_CLIENT_HOOK_APPEND +#define E_CLIENT_HOOK_APPEND(l, t, cb, d) \ + do \ + { \ + E_Client_Hook *_h; \ + _h = e_client_hook_add(t, cb, d); \ + assert(_h); \ + l = eina_list_append(l, _h); \ + } \ + while (0) + +EAPI void * +e_modapi_init(E_Module *m) +{ + Mod *mod; + E_Comp *comp; + E_Zone *zone; + Config_Desk *d; + const Eina_List *l, *ll; + int i, n; + char buf[PATH_MAX]; + + mod = E_NEW(Mod, 1); + mod->module = m; + _pol_mod = mod; + + hash_pol_clients = eina_hash_pointer_new(_pol_cb_client_data_free); + hash_pol_desks = eina_hash_pointer_new(_pol_cb_desk_data_free); + + /* initialize configure and config data type */ + snprintf(buf, sizeof(buf), "%s/e-module-policy-mobile.edj", + e_module_dir_get(m)); + + e_configure_registry_category_add("windows", 50, _("Windows"), NULL, + "preferences-system-windows"); + e_configure_registry_item_add("windows/policy-mobile", 150, + _("Mobile Policy"), NULL, buf, + e_int_config_pol_mobile); + + e_mod_pol_conf_init(mod); + + EINA_LIST_FOREACH(e_comp_list(), l, comp) + EINA_LIST_FOREACH(comp->zones, ll, zone) + { + //Eina_Bool home_add = EINA_FALSE; + n = zone->desk_y_count * zone->desk_x_count; + for (i = 0; i < n; i++) + { + d = e_mod_pol_conf_desk_get_by_nums(_pol_mod->conf, + comp->num, + zone->num, + zone->desks[i]->x, + zone->desks[i]->y); + if (d) + { + e_mod_pol_desk_add(zone->desks[i]); + //home_add = EINA_TRUE; + } + } + + /* FIXME: should consider the case that illume-home module + * is not loaded yet and make it configurable. + * and also, this code will be enabled when e_policy stuff lands in e. + */ + //if (home_add) + // e_policy_zone_home_add_request(zone); + } + + E_LIST_HANDLER_APPEND(handlers, E_EVENT_ZONE_ADD, _pol_cb_zone_add, NULL); + E_LIST_HANDLER_APPEND(handlers, E_EVENT_ZONE_DEL, _pol_cb_zone_del, NULL); + E_LIST_HANDLER_APPEND(handlers, E_EVENT_ZONE_MOVE_RESIZE, _pol_cb_zone_move_resize, NULL); + E_LIST_HANDLER_APPEND(handlers, E_EVENT_ZONE_DESK_COUNT_SET, _pol_cb_zone_desk_count_set, NULL); + E_LIST_HANDLER_APPEND(handlers, E_EVENT_DESK_SHOW, _pol_cb_desk_show, NULL); + E_LIST_HANDLER_APPEND(handlers, E_EVENT_CLIENT_REMOVE, _pol_cb_client_remove, NULL); + + E_CLIENT_HOOK_APPEND(hooks, E_CLIENT_HOOK_EVAL_POST_FETCH, + _pol_hook_client_eval_post_fetch, NULL); + E_CLIENT_HOOK_APPEND(hooks, E_CLIENT_HOOK_DESK_SET, + _pol_hook_client_desk_set, NULL); + + return mod; +} + +EAPI int +e_modapi_shutdown(E_Module *m) +{ + Mod *mod = m->data; + Eina_Inlist *l; + Pol_Softkey *softkey; + + eina_list_free(mod->launchers); + EINA_INLIST_FOREACH_SAFE(mod->softkeys, l, softkey) + e_mod_pol_softkey_del(softkey); + E_FREE_LIST(hooks, e_client_hook_del); + E_FREE_LIST(handlers, ecore_event_handler_del); + E_FREE_FUNC(hash_pol_desks, eina_hash_free); + E_FREE_FUNC(hash_pol_clients, eina_hash_free); + + e_configure_registry_item_del("windows/policy-mobile"); + e_configure_registry_category_del("windows"); + + if (mod->conf_dialog) + { + e_object_del(E_OBJECT(mod->conf_dialog)); + mod->conf_dialog = NULL; + } + + e_mod_pol_conf_shutdown(mod); + + E_FREE(mod); + + _pol_mod = NULL; + + return 1; +} + +EAPI int +e_modapi_save(E_Module *m) +{ + Mod *mod = m->data; + e_config_domain_save("module.policy-mobile", + mod->conf_edd, + mod->conf); + return 1; +} diff --git a/src/modules/policy_mobile/e_mod_main.h b/src/modules/policy_mobile/e_mod_main.h new file mode 100644 index 000000000..3e9850876 --- /dev/null +++ b/src/modules/policy_mobile/e_mod_main.h @@ -0,0 +1,108 @@ +#ifndef E_MOD_MAIN_H +#define E_MOD_MAIN_H +#include + +typedef struct _Pol_Desk Pol_Desk; +typedef struct _Pol_Client Pol_Client; +typedef struct _Pol_Softkey Pol_Softkey; +typedef struct _Config_Match Config_Match; +typedef struct _Config_Desk Config_Desk; +typedef struct _Config Config; +typedef struct _Mod Mod; + +struct _Pol_Desk +{ + E_Desk *desk; + E_Zone *zone; +}; + +struct _Pol_Client +{ + E_Client *ec; + struct + { + E_Maximize maximized; + unsigned int fullscreen : 1; + unsigned char borderless : 1; + unsigned int lock_user_location : 1; + unsigned int lock_client_location : 1; + unsigned int lock_user_size : 1; + unsigned int lock_client_size : 1; + unsigned int lock_client_stacking : 1; + unsigned int lock_user_shade : 1; + unsigned int lock_client_shade : 1; + unsigned int lock_user_maximize : 1; + unsigned int lock_client_maximize : 1; + } orig; +}; + +struct _Pol_Softkey +{ + EINA_INLIST; + + E_Zone *zone; + Evas_Object *home; + Evas_Object *back; +}; + +struct _Config_Match +{ + const char *title; /* icccm.title or netwm.name */ + const char *clas; /* icccm.class */ + unsigned int type; /* netwm.type */ +}; + +struct _Config_Desk +{ + unsigned int comp_num; + unsigned int zone_num; + int x, y; + int enable; +}; + +struct _Config +{ + Config_Match launcher; + Eina_List *desks; + int use_softkey; + int softkey_size; +}; + +struct _Mod +{ + E_Module *module; + E_Config_DD *conf_edd; + E_Config_DD *conf_desk_edd; + Config *conf; + E_Config_Dialog *conf_dialog; + Eina_List *launchers; /* launcher window per zone */ + Eina_Inlist *softkeys; /* softkey ui object per zone */ +}; + +struct _E_Config_Dialog_Data +{ + Config *conf; + Evas_Object *o_list; + Evas_Object *o_desks; +}; + +extern Mod *_pol_mod; +extern Eina_Hash *hash_pol_desks; +extern Eina_Hash *hash_pol_clients; + +EINTERN void e_mod_pol_conf_init(Mod *mod); +EINTERN void e_mod_pol_conf_shutdown(Mod *mod); +EINTERN Config_Desk *e_mod_pol_conf_desk_get_by_nums(Config *conf, unsigned int comp_num, unsigned int zone_num, int x, int y); +EINTERN E_Config_Dialog *e_int_config_pol_mobile(E_Comp *comp, const char *params EINA_UNUSED); +EINTERN void e_mod_pol_desk_add(E_Desk *desk); +EINTERN void e_mod_pol_desk_del(Pol_Desk *pd); +EINTERN Pol_Client *e_mod_pol_client_launcher_get(E_Zone *zone); + +EINTERN Pol_Softkey *e_mod_pol_softkey_add(E_Zone *zone); +EINTERN void e_mod_pol_softkey_del(Pol_Softkey *softkey); +EINTERN void e_mod_pol_softkey_show(Pol_Softkey *softkey); +EINTERN void e_mod_pol_softkey_hide(Pol_Softkey *softkey); +EINTERN void e_mod_pol_softkey_update(Pol_Softkey *softkey); +EINTERN Pol_Softkey *e_mod_pol_softkey_get(E_Zone *zone); + +#endif diff --git a/src/modules/policy_mobile/e_mod_softkey.c b/src/modules/policy_mobile/e_mod_softkey.c new file mode 100644 index 000000000..11bca2f7e --- /dev/null +++ b/src/modules/policy_mobile/e_mod_softkey.c @@ -0,0 +1,171 @@ +#include "e_mod_main.h" + +static void _pol_cb_softkey(void *data, Evas_Object *obj EINA_UNUSED, const char *emission, const char *source EINA_UNUSED); +static void _pol_softkey_iconify(E_Zone *zone, Eina_Bool all); +static Evas_Object *_pol_softkey_icon_add(E_Zone *zone, const char *name); +static void _pol_softkey_icon_del(Evas_Object *comp_obj); + +static void +_pol_cb_softkey(void *data, Evas_Object *obj EINA_UNUSED, const char *emission, const char *source EINA_UNUSED) +{ + E_Zone *zone; + Eina_Bool all; + + zone = data; + + if (!e_util_strcmp(emission, "e,action,softkey,home")) + all = EINA_TRUE; + else if (!e_util_strcmp(emission, "e,action,softkey,back")) + all = EINA_FALSE; + else + return; + + _pol_softkey_iconify(zone, all); +} + +static void +_pol_softkey_iconify(E_Zone *zone, Eina_Bool all) +{ + E_Desk *desk; + E_Client *ec; + Pol_Client *launcher; + + desk = e_desk_current_get(zone); + launcher = e_mod_pol_client_launcher_get(zone); + + E_CLIENT_REVERSE_FOREACH(e_comp_get(desk), ec) + { + if (e_client_util_ignored_get(ec)) continue; + if (!e_client_util_desk_visible(ec, desk)) continue; + if (!evas_object_visible_get(ec->frame)) continue; + + if ((launcher) && (launcher->ec == ec)) + return; + + e_client_iconify(ec); + + if (!all) return; + } +} + +static Evas_Object * +_pol_softkey_icon_add(E_Zone *zone, const char *name) +{ + Evas_Object *obj, *comp_obj; + char path[PATH_MAX], group[PATH_MAX]; + + obj = edje_object_add(e_comp_get(NULL)->evas); + + snprintf(group, sizeof(group), "e/modules/policy-mobile/softkey/%s", name); + snprintf(path, sizeof(path), "%s/e-module-policy-mobile.edj", + e_module_dir_get(_pol_mod->module)); + + if (!e_theme_edje_object_set(obj, NULL, group)) + edje_object_file_set(obj, path, group); + + edje_object_signal_callback_add(obj, "e,action,softkey,*", "e", + _pol_cb_softkey, zone); + + /* use TYPE_NONE to disable shadow for softkey object */ + comp_obj = e_comp_object_util_add(obj, E_COMP_OBJECT_TYPE_NONE); + evas_object_layer_set(comp_obj, E_LAYER_POPUP); + + evas_object_data_set(comp_obj, "policy_mobile_obj", obj); + + return comp_obj; +} + +static void +_pol_softkey_icon_del(Evas_Object *comp_obj) +{ + Evas_Object *obj; + + obj = evas_object_data_get(comp_obj, "policy_mobile_obj"); + + edje_object_signal_callback_del(obj, "e,action,softkey,*", + "e", _pol_cb_softkey); + evas_object_hide(comp_obj); + evas_object_del(comp_obj); +} + +Pol_Softkey * +e_mod_pol_softkey_add(E_Zone *zone) +{ + Pol_Softkey *softkey; + + softkey = E_NEW(Pol_Softkey, 1); + + softkey->zone = zone; + softkey->home = _pol_softkey_icon_add(zone, "home"); + softkey->back = _pol_softkey_icon_add(zone, "back"); + + _pol_mod->softkeys = eina_inlist_append(_pol_mod->softkeys, EINA_INLIST_GET(softkey)); + + return softkey; +} + +void +e_mod_pol_softkey_del(Pol_Softkey *softkey) +{ + if (!softkey) return; + + _pol_softkey_icon_del(softkey->home); + _pol_softkey_icon_del(softkey->back); + + _pol_mod->softkeys = eina_inlist_remove(_pol_mod->softkeys, EINA_INLIST_GET(softkey)); + + free(softkey); +} + +void +e_mod_pol_softkey_show(Pol_Softkey *softkey) +{ + if (!softkey) return; + + e_mod_pol_softkey_update(softkey); + + evas_object_show(softkey->home); + evas_object_show(softkey->back); +} + +void +e_mod_pol_softkey_hide(Pol_Softkey *softkey) +{ + if (!softkey) return; + + evas_object_hide(softkey->home); + evas_object_hide(softkey->back); +} + +void +e_mod_pol_softkey_update(Pol_Softkey *softkey) +{ + int x, y, w, h, ow, oh, space; + + if (!softkey) return; + + e_zone_useful_geometry_get(softkey->zone, &x, &y, &w, &h); + + ow = oh = _pol_mod->conf->softkey_size; + + x = x + (w - ow) / 2; + y = h - oh; + space = ow * 4; + + evas_object_geometry_set(softkey->home, x - space, y, ow, oh); + evas_object_geometry_set(softkey->back, x + space, y, ow, oh); +} + +Pol_Softkey * +e_mod_pol_softkey_get(E_Zone *zone) +{ + Pol_Softkey *softkey; + + EINA_INLIST_FOREACH(_pol_mod->softkeys, softkey) + { + if (softkey->zone == zone) + return softkey; + } + + return NULL; +}