return DBUS_HANDLER_RESULT_HANDLED;
}
-static int _ug_client_dbus_listen_signal(void *data)
-{
- DBusError error;
- char rule[128];
-
- if (ug_dbus_signal_handler_initialized)
- return 0;
-
- dbus_threads_init_default();
-
- dbus_error_init(&error);
- bus = dbus_bus_get_private(DBUS_BUS_SYSTEM, &error);
- if (!bus) {
- LOGW("Failed to connect to the D-BUS daemon: %s", error.message);
- dbus_error_free(&error);
- return -1;
- }
- dbus_connection_setup_with_g_main(bus, NULL);
-
- snprintf(rule, 128,
- "path='%s',type='signal',interface='%s'", "/aul/dbus_handler",
- "org.tizen.aul.signal");
- /* listening to messages */
- dbus_bus_add_match(bus, rule, &error);
- if (dbus_error_is_set(&error)) {
- LOGW("Fail to rule set: %s", error.message);
- dbus_error_free(&error);
- return -1;
- }
-
- if (dbus_connection_add_filter(bus,
- _ug_client_dbus_signal_filter, data, NULL) == FALSE) {
- LOGW("dbus conntaction add fileter fail");
- return -1;
- }
-
- LOGD("bus : %p / filter func pointer : %p", bus , _ug_client_dbus_signal_filter);
-
- ug_dbus_signal_handler_initialized = 1;
-
- return 0;
-}
-
static void _ug_client_dbus_signal_handler_fini(void *data)
{
DBusError error;
return 0;
}
-static int svc_cb(void *data)
-{
- LOGD("svc_cb called");
- return 0;
-}
-
static int app_reset(bundle *b, void *data)
{
struct appdata *ad = data;
struct ug_cbs cbs = { 0, };
app_control_h app_control;
enum ug_mode mode = UG_MODE_FULLVIEW;
- int ret;
- Ecore_X_Window id2 = elm_win_xwindow_get(ad->win);
-
- ret = aul_svc_request_transient_app(b, id2, svc_cb, "svc test");
-
- if (ret) {
- LOGD("fail to request transient app: return value(%d)", ret);
- if (_ug_client_dbus_listen_signal(data) < 0)
- LOGW("home screen dbus register error");
- } else {
- /* check home screen raise */
- ad->is_transient = 1;
- }
if (ad->win) {
elm_win_activate(ad->win);
#include <X11/Xatom.h>
#include <X11/Xutil.h>
#include <Ecore_X.h>
+#else
+#include <Ecore_Wayland.h>
#endif
#include <Ecore.h>
Display *disp;
#endif
- void *conform;
-
enum ug_option base_opt;
enum ug_event last_rotate_evt;
}
}
+static int ugman_ug_free(ui_gadget_h ug)
+{
+ if (!ug) {
+ _ERR("ug free failed: Invalid ug");
+ errno = EINVAL;
+ return -1;
+ }
+
+ if (ug->module)
+ ug_module_unload(ug->module);
+
+ if (ug->name) {
+ free((void *)ug->name);
+ ug->name = NULL;
+ }
+ if (ug->app_control) {
+ app_control_destroy(ug->app_control);
+ ug->app_control = NULL;
+ }
+ free(ug);
+ ug = NULL;
+ return 0;
+}
+
+
static int ugman_ug_find(ui_gadget_h p, ui_gadget_h ug)
{
GSList *child = NULL;
struct ug_module_ops *ops = NULL;
GSList *child = NULL;
+ if (!ug_man.is_initted) {
+ _ERR("ugman_pause failed: manager is not initted");
+ return -1;
+ }
+
+ if (!ug_man.root) {
+ _WRN("ugman_pause failed: no root");
+ return -1;
+ }
+
+ if (ug_man.destroy_all == 1) {
+ _WRN("ugman_pause skipped : app is termanating with ug_destory_all");
+ return -1;
+ }
+
+ if ((data != ug_man.root) && (!ugman_ug_find(ug_man.root, data))) {
+ _WRN("ugman_pause skipped : invalid ug(%p)", data);
+ return -1;
+ }
+
job_start();
- if (!ug || ug->state != UG_STATE_RUNNING)
+ if (!ug) {
+ _WRN("ug pointer is null");
goto end;
-
- ug->state = UG_STATE_STOPPED;
+ }
if (ug->children) {
child = ug->children;
}
}
+ if (ug->state != UG_STATE_RUNNING) {
+ if (ug != ug_man.root)
+ _WRN("ug(%p)->state : %d", ug, ug->state);
+ goto end;
+ }
+
if (ug->module)
ops = &ug->module->ops;
- if (ops && ops->pause)
+ if (ops && ops->pause) {
+ _DBG("call ug(%p) pause cb", ug);
ops->pause(ug, ug->app_control, ops->priv);
+ }
+
+ ug->state = UG_STATE_STOPPED;
end:
job_end();
struct ug_module_ops *ops = NULL;
GSList *child = NULL;
+ if (!ug_man.is_initted) {
+ _ERR("ugman_resume failed: manager is not initted");
+ return -1;
+ }
+
+ if (!ug_man.root) {
+ _WRN("ugman_resume failed: no root");
+ return -1;
+ }
+
+ if (ug_man.destroy_all == 1) {
+ _WRN("ugman_resume skipped : app is termanating with ug_destory_all");
+ return -1;
+ }
+
+ if ((data != ug_man.root) && (!ugman_ug_find(ug_man.root, data))) {
+ _WRN("ugman_resume skipped : invalid ug(%p)", data);
+ return -1;
+ }
+
job_start();
- if (!ug)
+ if (!ug) {
+ _WRN("ug pointer is null");
goto end;
+ }
+
+ if (ug->children) {
+ child = ug->children;
+ while (child) {
+ ugman_ug_resume(child->data);
+ child = g_slist_next(child);
+ }
+ }
- _DBG("ug(%p)->state : %d", ug, ug->state);
+ if (ug->state != UG_STATE_STOPPED) {
+ if (ug != ug_man.root)
+ _WRN("ug(%p)->state : %d", ug, ug->state);
+ }
switch (ug->state) {
case UG_STATE_CREATED:
goto end;
}
- ug->state = UG_STATE_RUNNING;
-
- if (ug->children) {
- child = ug->children;
- while (child) {
- ugman_ug_resume(child->data);
- child = g_slist_next(child);
- }
- }
-
if (ug->module)
ops = &ug->module->ops;
- if (ops && ops->resume)
+ if (ops && ops->resume) {
+ _DBG("call ug(%p) resume cb", ug);
ops->resume(ug, ug->app_control, ops->priv);
+ }
+
+ ug->state = UG_STATE_RUNNING;
end:
job_end();
return 0;
}
+#ifdef UG_WAYLAND
+static void _ugman_enable_indicator(Evas_Object *win, int enable)
+{
+ Ecore_Wl_Window *wlwin = elm_win_wl_window_get(win);
+
+ if (enable == 1)
+ ecore_wl_window_indicator_state_set(wlwin, ECORE_WL_INDICATOR_STATE_ON);
+ else
+ ecore_wl_window_indicator_state_set(wlwin, ECORE_WL_INDICATOR_STATE_OFF);
+}
+
+static int _ugman_get_indicator_state(Evas_Object *win)
+{
+ Ecore_Wl_Window *wlwin = elm_win_wl_window_get(win);
+ Ecore_Wl_Indicator_State state;
+ int ret;
+
+ state = ecore_wl_window_indicator_state_get(wlwin);
+ if (state == ECORE_WL_INDICATOR_STATE_OFF)
+ ret = 0;
+ else if (state == ECORE_WL_INDICATOR_STATE_ON)
+ ret = 1;
+ else
+ ret = -1;
+
+ return ret;
+}
+#endif
+
static int ugman_indicator_update(enum ug_option opt, enum ug_event event)
{
+#ifndef UG_WAYLAND
_ERR("controlling indicator is disabled");
+#else
+ int enable;
+ int cur_state;
+
+ cur_state = _ugman_get_indicator_state(ug_man.win);
+
+ _DBG("indicator update opt(%d) cur_state(%d)", opt, cur_state);
+
+ switch (opt) {
+#ifndef ENABLE_UG_HANDLE_INDICATOR_HIDE
+ case UG_OPT_INDICATOR_ENABLE:
+ case UG_OPT_INDICATOR_PORTRAIT_ONLY:
+ case UG_OPT_INDICATOR_LANDSCAPE_ONLY:
+ case UG_OPT_INDICATOR_DISABLE:
+ enable = 1;
+ break;
+#else
+ case UG_OPT_INDICATOR_ENABLE:
+ if (event == UG_EVENT_NONE)
+ enable = 1;
+ else
+ enable = cur_state ? 1 : 0;
+ break;
+ case UG_OPT_INDICATOR_PORTRAIT_ONLY:
+ enable = ug_man.is_landscape ? 0 : 1;
+ break;
+ case UG_OPT_INDICATOR_LANDSCAPE_ONLY:
+ enable = ug_man.is_landscape ? 1 : 0;
+ break;
+ case UG_OPT_INDICATOR_DISABLE:
+ enable = 0;
+ break;
+#endif
+ case UG_OPT_INDICATOR_MANUAL:
+ return 0;
+ default:
+ _ERR("update failed: Invalid opt(%d)", opt);
+ return -1;
+ }
+ if (cur_state != enable) {
+ _DBG("set indicator status as %d", enable);
+ _ugman_enable_indicator(ug_man.win, enable);
+ }
+
+#endif
return 0;
}
} else {
_WRN("pended parent ug(%p) will be destroyed after another children is destroyed", ug->parent);
}
+ } else {
+ if (ug->parent)
+ _DBG("ug parent(%p) state(%d)", ug->parent, ug->parent->state);
+ else
+ _WRN("ug parent is null");
}
if (ug != ug_man.root)
}
_DBG("free ug(%p)", ug);
- ug_free(ug);
+ ugman_ug_free(ug);
if (ug_man.root == ug)
ug_man.root = NULL;
struct ug_module_ops *ops = NULL;
struct ug_cbs *cbs;
struct ug_engine_ops *eng_ops = NULL;
+ void *conformant = NULL;
+
if (!ug || ug->state != UG_STATE_READY) {
- _ERR("ug(%p) input param error");
+ _ERR("ug(%p) input param error", ug);
return -1;
}
if (ops && ops->create) {
ug->layout = ops->create(ug, ug->mode, ug->app_control, ops->priv);
if (!ug->layout) {
- ug_relation_del(ug);
_ERR("ug(%p) layout is null", ug);
return -1;
}
if (ug->mode == UG_MODE_FULLVIEW) {
if (eng_ops && eng_ops->create) {
- ug_man.conform = eng_ops->create(ug_man.win, ug, ugman_ug_start);
- if (!ug_man.conform)
+ conformant = eng_ops->create(ug_man.win, ug, ugman_ug_start);
+ if (!conformant) {
+ _ERR("conformant(%p) error. ug(%p) destory cb is invoked.",
+ conformant, ug);
+ ops->destroy(ug, ug->app_control, ops->priv);
return -1;
+ }
}
}
cbs = &ug->cbs;
return 0;
}
+static ui_gadget_h ugman_root_ug_create(void)
+{
+ ui_gadget_h ug;
+
+ ug = calloc(1, sizeof(struct ui_gadget_s));
+ if (!ug) {
+ _ERR("ug root create failed: Memory allocation failed");
+ return NULL;
+ }
+
+ ug->mode = UG_MODE_FULLVIEW;
+ ug->state = UG_STATE_RUNNING;
+ ug->children = NULL;
+
+ return ug;
+}
+
int ugman_ug_add(ui_gadget_h parent, ui_gadget_h ug)
{
if (!ug_man.is_initted) {
- _ERR("failed: manager is not initted");
+ _ERR("failed: manager is not initialized");
return -1;
}
return -1;
}
- ug_man.root = ug_root_create();
+ ug_man.root = ugman_root_ug_create();
if (!ug_man.root) {
_ERR("failed : ug root create fail");
return -1;
if (ugman_ug_create(ug) == -1) {
_ERR("failed : ugman_ug_create fail");
+ ug_relation_del(ug);
return -1;
}
if (ug->mode == UG_MODE_FULLVIEW)
r = ugman_ug_add(parent, ug);
if (r) {
- _ERR("ug_create() failed: Tree update failed");
+ _ERR("ugman ug add failed");
goto load_fail;
}
return ug;
load_fail:
- ug_free(ug);
+ ugman_ug_free(ug);
return NULL;
}
{
struct ug_module_ops *ops = NULL;
- _DBG("ugman_ug_destroying");
+ _DBG("ugman_ug_destroying start ug(%p)", ug);
+
+ if (!ug || !ugman_ug_exist(ug)) {
+ _ERR("ugman_ug_destroying failed: Invalid ug(%p)");
+ errno = EINVAL;
+ return -1;
+ }
+
+ switch (ug->state) {
+ case UG_STATE_DESTROYING:
+ case UG_STATE_PENDING_DESTROY:
+ case UG_STATE_DESTROYED:
+ _WRN("ug(%p) state(%d) is already on destroying", ug, ug->state);
+ return 0;
+ default:
+ break;
+ }
ug->destroy_me = 1;
ug->state = UG_STATE_DESTROYING;
{
struct ug_engine_ops *eng_ops = NULL;
- if (!ug || !ugman_ug_exist(ug) || ug->state == UG_STATE_DESTROYED) {
+ _DBG("ugman_ug_del start ug(%p)", ug);
+
+ if (!ug || !ugman_ug_exist(ug)) {
_ERR("ugman_ug_del failed: Invalid ug(%p)");
errno = EINVAL;
return -1;
}
- _DBG("ugman_ug_del start ug(%p)", ug);
+ switch (ug->state) {
+ case UG_STATE_DESTROYING:
+ case UG_STATE_PENDING_DESTROY:
+ case UG_STATE_DESTROYED:
+ _WRN("ug(%p) state(%d) is already on destroying", ug, ug->state);
+ return 0;
+ default:
+ break;
+ }
if (ug->destroy_me) {
_WRN("ugman_ug_del failed: ug is alreay on destroying");
}
if (!ug_man.is_initted) {
- _WRN("ugman_ug_del failed: manager is not initted");
+ _WRN("ugman_ug_del failed: manager is not initialized");
return -1;
}
return 0;
}
+static void ugman_ug_unset_content(void)
+{
+ struct ug_engine_ops *eng_ops = NULL;
+
+ if (ug_man.engine) {
+ eng_ops = &ug_man.engine->ops;
+ } else {
+ _WRN("ui engine is not loaded");
+ return;
+ }
+
+ if (eng_ops && eng_ops->create)
+ eng_ops->request(ug_man.win, NULL, UG_UI_REQ_UNSET_CONTENT);
+ else
+ _WRN("ui engine is not loaded");
+
+ return;
+}
+
int ugman_ug_del_all(void)
{
/* Terminate */
if (!ug_man.is_initted) {
- _ERR("ugman_ug_del_all failed: manager is not initted");
+ _ERR("ugman_ug_del_all failed: manager is not initialized");
return -1;
}
_DBG("ug_del_all. root(%p) walking(%d) ", ug_man.root, ug_man.walking);
- if (ug_man.walking > 0)
+ if (ug_man.walking > 0) {
ug_man.destroy_all = 1;
- else
+ } else {
+ ugman_ug_unset_content();
ugman_ug_del_child(ug_man.root);
+ }
return 0;
}
{
/* RESUME */
if (!ug_man.is_initted) {
- _ERR("ugman_resume failed: manager is not initted");
+ _ERR("ugman_resume failed: manager is not initialized");
return -1;
}
return -1;
}
+ if (ug_man.destroy_all == 1) {
+ _WRN("ugman_resume skip : app is termanating with ug_destory_all");
+ return 0;
+ }
+
_DBG("ugman_resume called");
ugman_idler_add((Idle_Cb)ugman_ug_resume, ug_man.root);
{
/* PAUSE (Background) */
if (!ug_man.is_initted) {
- _ERR("ugman_pause failed: manager is not initted");
+ _ERR("ugman_pause failed: manager is not initialized");
return -1;
}
return -1;
}
+ if (ug_man.destroy_all == 1) {
+ _WRN("ugman_pause skip : app is termanating with ug_destory_all");
+ return 0;
+ }
+
_DBG("ugman_pause called");
ugman_idler_add((Idle_Cb)ugman_ug_pause, ug_man.root);
/* Propagate event */
if (!ug_man.is_initted) {
- _ERR("ugman_send_event failed: manager is not initted");
+ _ERR("ugman_send_event failed: manager is not initialized");
return -1;
}
if (ops && ops->key_event)
ops->key_event(ug, event, ug->app_control, ops->priv);
- else
- return -1;
return 0;
}
int ugman_send_key_event(enum ug_key_event event)
{
if (!ug_man.is_initted) {
- _ERR("ugman_send_key_event failed: manager is not initted");
+ _ERR("ugman_send_key_event failed: manager is not initialized");
return -1;
}
{
struct ug_module_ops *ops = NULL;
if (!ug || !ugman_ug_exist(ug) || ug->state == UG_STATE_DESTROYED) {
- _ERR("ugman_send_message failed: Invalid ug");
+ _ERR("ugman_send_message failed: Invalid ug(%p)", ug);
errno = EINVAL;
return -1;
}
struct ug_engine_ops *eng_ops = NULL;
void* ret = NULL;
- if (ug_man.conform) {
- _DBG("return cached conform(%p) info", ug_man.conform);
- return ug_man.conform;
- }
-
if (ug_man.engine) {
eng_ops = &ug_man.engine->ops;
} else {
if (eng_ops && eng_ops->create) {
ret = eng_ops->request(ug_man.win, NULL, UG_UI_REQ_GET_CONFORMANT);
- ug_man.conform = ret;
} else {
_WRN("ui engine is not loaded");
}
evas_object_event_callback_del(ug->layout, EVAS_CALLBACK_DEL,
(Evas_Object_Event_Cb)_layout_del_cb);
-
- ug->layout_state = UG_LAYOUT_DESTROY;
ug->layout = NULL;
}
static void __del_finished(void *data, Evas_Object *obj, void *event_info)
{
- ui_gadget_h ug = (ui_gadget_h)data;
- if (!ug)
+ if (!event_info) {
+ _ERR("invalid event_info param");
return;
+ }
+ Elm_Object_Item *item = event_info;
+ if (!item) {
+ _ERR("item is null");
+ return;
+ }
- _DBG("\t obj=%p ug=%p", obj, ug);
+ ui_gadget_h ug = (ui_gadget_h) elm_object_item_data_get(item);
+ if (!ug) {
+ _ERR("ug is null");
+ return;
+ }
- evas_object_smart_callback_del(obj, "transition,finished",
- __del_finished);
+ _WRN("\t obj=%p ug=%p", obj, ug);
+
+ elm_object_item_del_cb_set(obj, NULL);
if (ug->layout_state == UG_LAYOUT_HIDEEFFECT)
__del_effect_end(ug);
static void __del_effect_top_layout(ui_gadget_h ug)
{
- _DBG("\t cb transition add ug=%p", ug);
- evas_object_smart_callback_add(navi, "transition,finished",
- __del_finished, ug);
+ _WRN("\t cb transition add ug=%p", ug);
+
+ elm_object_item_del_cb_set(ug->effect_layout, __del_finished);
elm_naviframe_item_pop(navi);
ug->effect_layout = NULL;
ug->layout_state = UG_LAYOUT_HIDEEFFECT;
_DBG("\t obj=%p ug=%p layout_state=%d state=%d", obj, ug, ug->layout_state, ug->state);
evas_object_intercept_hide_callback_del(ug->layout, __on_hideonly_cb);
+
+ switch (ug->state) {
+ case UG_STATE_READY:
+ case UG_STATE_DESTROYING:
+ case UG_STATE_PENDING_DESTROY:
+ case UG_STATE_DESTROYED:
+ _DBG("wrong ug state");
+ return;
+ default:
+ break;
+ }
+
evas_object_event_callback_add(ug->layout, EVAS_CALLBACK_SHOW, on_show_cb, ug);
if (ug->layout_state == UG_LAYOUT_SHOW) {
__hide_finished, ug);
elm_naviframe_item_pop(navi);
ug->layout_state = UG_LAYOUT_HIDEEFFECT;
+ ug->effect_layout = NULL;
} else {
elm_object_item_del(ug->effect_layout);
__hide_end(ug);
|| ug->layout_state == UG_LAYOUT_NOEFFECT) {
__del_effect_layout(ug, t_ug);
} else if (ug->layout_state == UG_LAYOUT_HIDEEFFECT) {
- ;
+ evas_object_smart_callback_del(navi, "transition,finished",
+ __hide_finished);
+ elm_object_item_del_cb_set(ug->effect_layout, __del_finished);
} else {
_WRN("[UG Effect Plug-in] : layout state(%p) error!!", ug->layout_state);
__del_effect_end(ug);
return;
}
+static int __show_end_cb_by_job_add(void *data)
+{
+ if (show_end_cb)
+ show_end_cb(data);
+
+ return 0;
+}
+
static void on_show_cb(void *data, Evas *e, Evas_Object *obj,
void *event_info)
{
/*
* if 'elm.swallow.ug' string is changed, msg team have to apply this changes.
*/
+ evas_object_show(navi);
elm_object_part_content_set(conform, "elm.swallow.ug", navi);
if (ug->layout_state == UG_LAYOUT_HIDEEFFECT
__show_finished, ug);
ug->effect_layout = elm_naviframe_item_push(navi, NULL, NULL, NULL,
ug->layout, NULL);
+ elm_object_item_data_set(ug->effect_layout, (void *)ug);
} else if (ug->layout_state == UG_LAYOUT_NOEFFECT) {
_DBG("\t UG_LAYOUT_NOEFFECT obj=%p", obj);
Elm_Object_Item *navi_top = elm_naviframe_top_item_get(navi);
ug->effect_layout = elm_naviframe_item_insert_after(navi,
navi_top, NULL, NULL, NULL, ug->layout, NULL);
-
- if (show_end_cb)
- show_end_cb(ug);
+ ecore_job_add((Ecore_Cb)__show_end_cb_by_job_add, (void *)data);
} else {
_ERR("\tlayout state error!! state=%d\n", ug->layout_state);
}
if (!navi) {
navi = elm_naviframe_add(conform);
- elm_object_focus_allow_set(navi, EINA_FALSE);
elm_object_style_set(navi, "uglib");
elm_naviframe_content_preserve_on_pop_set(navi, EINA_TRUE);
_DBG("\t new navi first navi=%p", navi);
static void *on_request(void *data, ui_gadget_h ug, int req)
{
- void *ret;
+ void *ret = NULL;
+ Elm_Object_Item *navi_bottom_item = NULL;
+ Elm_Object_Item *navi_top_item = NULL;
_DBG("on_request ug(%p) req(%d)", ug, req);
case UG_UI_REQ_GET_CONFORMANT:
ret = (void *)_get_win_conformant((Evas_Object *)data);
break;
+ case UG_UI_REQ_UNSET_CONTENT:
+ _DBG("unset swallow ug content");
+ if (navi) {
+ navi_bottom_item = elm_naviframe_bottom_item_get(navi);
+ navi_top_item = elm_naviframe_top_item_get(navi);
+
+ while (navi_bottom_item != navi_top_item) {
+ _DBG("navi item : %p", navi_top_item);
+ elm_object_item_del(navi_top_item);
+ navi_top_item = elm_naviframe_top_item_get(navi);
+ }
+
+ _DBG("\t unset navi");
+ elm_object_part_content_unset(conform, "elm.swallow.ug");
+ evas_object_hide(navi);
+ }
+ break;
default:
_WRN("wrong req id(%d)", req);
return NULL;
projects / platform / core / appfw / ui-gadget-1.git / commitdiff