From 3a2642df01418054719cd9c142efd22db2910f42 Mon Sep 17 00:00:00 2001 From: Baptiste DURAND Date: Wed, 11 Sep 2013 10:49:34 +0200 Subject: [PATCH] [Elementary] : Backport Tizen changes (needed for webkit) --- .../recipes-efl/efl/elementary_1.7.8.bbappend | 20 + ...Patch-from-Alex-Wu-zhiwen.wu-linux.intel..patch | 54 ++ ...mplemention-of-Tizen-specific-elm_config-.patch | 75 ++ .../0010-Add-elm_scale_get-and-elm_scale_set.patch | 61 ++ ...m_finger_size_get-and-elm_finger_size_set.patch | 51 + .../0012-Add-elm_widget_sub_object_list_get.patch | 44 + .../0013-Add-elm_win_indicator_state_set.patch | 48 + .../0014-Adding-tickernoti-widget.patch | 1017 ++++++++++++++++++++ ...AYLAND_EGL-if-engine-set-called-when-DISP.patch | 42 + ...elm_gesture_layer_-support-from-Tizen-2.1.patch | 528 ++++++++++ .../0020-Adding-elm_win_wm_rotation-support.patch | 411 ++++++++ ...list-Fix-list_example_03-call-elm_list_go.patch | 88 ++ ...-examples-Fix-theme-path-search-for-tizen.patch | 34 + ...-Fix-example-must-call-elm_index_level_go.patch | 24 + 14 files changed, 2497 insertions(+) create mode 100644 meta-wrt-tizen/recipes-efl/efl/elementary_1.7.8.bbappend create mode 100644 meta-wrt-tizen/recipes-efl/efl/files_elementary/0007-Elementary-Patch-from-Alex-Wu-zhiwen.wu-linux.intel..patch create mode 100644 meta-wrt-tizen/recipes-efl/efl/files_elementary/0009-Add-dummy-implemention-of-Tizen-specific-elm_config-.patch create mode 100644 meta-wrt-tizen/recipes-efl/efl/files_elementary/0010-Add-elm_scale_get-and-elm_scale_set.patch create mode 100644 meta-wrt-tizen/recipes-efl/efl/files_elementary/0011-Adding-elm_finger_size_get-and-elm_finger_size_set.patch create mode 100644 meta-wrt-tizen/recipes-efl/efl/files_elementary/0012-Add-elm_widget_sub_object_list_get.patch create mode 100644 meta-wrt-tizen/recipes-efl/efl/files_elementary/0013-Add-elm_win_indicator_state_set.patch create mode 100644 meta-wrt-tizen/recipes-efl/efl/files_elementary/0014-Adding-tickernoti-widget.patch create mode 100644 meta-wrt-tizen/recipes-efl/efl/files_elementary/0015-Force-ELM_WAYLAND_EGL-if-engine-set-called-when-DISP.patch create mode 100644 meta-wrt-tizen/recipes-efl/efl/files_elementary/0018-Add-elm_gesture_layer_-support-from-Tizen-2.1.patch create mode 100644 meta-wrt-tizen/recipes-efl/efl/files_elementary/0020-Adding-elm_win_wm_rotation-support.patch create mode 100644 meta-wrt-tizen/recipes-efl/efl/files_elementary/0030-list-Fix-list_example_03-call-elm_list_go.patch create mode 100644 meta-wrt-tizen/recipes-efl/efl/files_elementary/0032-elementary-examples-Fix-theme-path-search-for-tizen.patch create mode 100644 meta-wrt-tizen/recipes-efl/efl/files_elementary/0033-elm-index-Fix-example-must-call-elm_index_level_go.patch diff --git a/meta-wrt-tizen/recipes-efl/efl/elementary_1.7.8.bbappend b/meta-wrt-tizen/recipes-efl/efl/elementary_1.7.8.bbappend new file mode 100644 index 0000000..fecd7fc --- /dev/null +++ b/meta-wrt-tizen/recipes-efl/efl/elementary_1.7.8.bbappend @@ -0,0 +1,20 @@ +FILESEXTRAPATHS_prepend := "${THISDIR}/files_elementary" +SRC_URI += "file://0007-Elementary-Patch-from-Alex-Wu-zhiwen.wu-linux.intel..patch;apply=yes " +SRC_URI += "file://0009-Add-dummy-implemention-of-Tizen-specific-elm_config-.patch;apply=yes " +SRC_URI += "file://0010-Add-elm_scale_get-and-elm_scale_set.patch;apply=yes " +SRC_URI += "file://0011-Adding-elm_finger_size_get-and-elm_finger_size_set.patch;apply=yes " +SRC_URI += "file://0013-Add-elm_win_indicator_state_set.patch;apply=yes " +SRC_URI += "file://0014-Adding-tickernoti-widget.patch;apply=yes " +SRC_URI += "file://0015-Force-ELM_WAYLAND_EGL-if-engine-set-called-when-DISP.patch;apply=yes " +SRC_URI += "file://0018-Add-elm_gesture_layer_-support-from-Tizen-2.1.patch;apply=yes " +SRC_URI += "file://0030-list-Fix-list_example_03-call-elm_list_go.patch;apply=yes " +SRC_URI += "file://0032-elementary-examples-Fix-theme-path-search-for-tizen.patch;apply=yes " +SRC_URI += "file://0033-elm-index-Fix-example-must-call-elm_index_level_go.patch;apply=yes " + + + + + + + + diff --git a/meta-wrt-tizen/recipes-efl/efl/files_elementary/0007-Elementary-Patch-from-Alex-Wu-zhiwen.wu-linux.intel..patch b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0007-Elementary-Patch-from-Alex-Wu-zhiwen.wu-linux.intel..patch new file mode 100644 index 0000000..6c11ea6 --- /dev/null +++ b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0007-Elementary-Patch-from-Alex-Wu-zhiwen.wu-linux.intel..patch @@ -0,0 +1,54 @@ +From 4081ed3612a564591eda8654f2ad2326bc8d2656 Mon Sep 17 00:00:00 2001 +From: Christopher Michael +Date: Fri, 31 Aug 2012 09:27:22 +0000 +Subject: [PATCH 07/33] Elementary: Patch from Alex Wu + to fix glview tests in Wayland: + +If the preferred engine set to "opengl_x11" and we actully run on +"wayland_egl" engine, the elm_win_add will eventully use "Software FB" +engine, and no chance to use the correct engine. + +Don't set the preference but let the _elm_config to determine the right +engine. + +SVN revision: 75921 +--- + src/bin/test_glview.c | 4 ---- + src/bin/test_glview_simple.c | 4 ---- + 2 files changed, 8 deletions(-) + +diff --git a/src/bin/test_glview.c b/src/bin/test_glview.c +index 2bd6dc9..a97cc47 100644 +--- a/src/bin/test_glview.c ++++ b/src/bin/test_glview.c +@@ -577,11 +577,7 @@ test_glview(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info + gldata_init(gld); + + // new window - do the usual and give it a name, title and delete handler +- // Set the engine to opengl_x11 +- elm_config_preferred_engine_set("opengl_x11"); + win = elm_win_util_standard_add("glview", "GLView"); +- // Set preferred engine back to default from config +- elm_config_preferred_engine_set(NULL); + + elm_win_autodel_set(win, EINA_TRUE); + +diff --git a/src/bin/test_glview_simple.c b/src/bin/test_glview_simple.c +index fc21ef4..d62b2c2 100644 +--- a/src/bin/test_glview_simple.c ++++ b/src/bin/test_glview_simple.c +@@ -238,11 +238,7 @@ test_glview_simple(void *data __UNUSED__, Evas_Object *obj __UNUSED__, void *eve + + if (!(gld = calloc(1, sizeof(GLData)))) return; + +- // Set the engine to opengl_x11 +- elm_config_preferred_engine_set("opengl_x11"); + win = elm_win_util_standard_add("glview simple", "GLView Simple"); +- // Set preferred engine back to default from config +- elm_config_preferred_engine_set(NULL); + + elm_win_autodel_set(win, EINA_TRUE); + +-- +1.8.1.4 + diff --git a/meta-wrt-tizen/recipes-efl/efl/files_elementary/0009-Add-dummy-implemention-of-Tizen-specific-elm_config-.patch b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0009-Add-dummy-implemention-of-Tizen-specific-elm_config-.patch new file mode 100644 index 0000000..4cae574 --- /dev/null +++ b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0009-Add-dummy-implemention-of-Tizen-specific-elm_config-.patch @@ -0,0 +1,75 @@ +From 8b7a01238781362c581205f8d58ccbe0c167c221 Mon Sep 17 00:00:00 2001 +From: Rusty Lynch +Date: Mon, 17 Dec 2012 16:58:24 -0800 +Subject: [PATCH 09/33] Add dummy implemention of Tizen specific elm_config + magnification + +The Tizen elementary tree contains a magnification feature that for +some reason has not been pushed into upstream EFL. Attempting to just +cherry pick the implementation into an up to date elementay tree will +require some additional porting effort since the codebase has evolved +so much since the Tizen tree was branched. This change just adds dummy +implementations for each of the external methods so that the unmodified +tizen pre-installed applications run before the port is available. +--- + src/lib/elm_entry.c | 18 ++++++++++++++++++ + src/lib/elm_entry.h | 18 ++++++++++++++++++ + 2 files changed, 36 insertions(+) + +diff --git a/src/lib/elm_entry.c b/src/lib/elm_entry.c +index e1dbbef..5bd6a6a 100644 +--- a/src/lib/elm_entry.c ++++ b/src/lib/elm_entry.c +@@ -4094,3 +4094,21 @@ _entry_hover_anchor_clicked(void *data, Evas_Object *obj, void *event_info) + evas_object_show(wd->anchor_hover.hover); + } + /* END - ANCHOR HOVER */ ++ ++EAPI void ++elm_entry_magnifier_disabled_set(Evas_Object *obj, Eina_Bool disabled) ++{ ++ /* TODO: Forward port tizen specific magnification feature */ ++} ++ ++EAPI Eina_Bool ++elm_entry_magnifier_disabled_get(const Evas_Object *obj) ++{ ++ /* TODO: Forward port tizen specific magnification feature */ ++} ++ ++EAPI void ++elm_entry_magnifier_type_set(Evas_Object *obj, int type) ++{ ++ /* TODO: Forward port tizen specific magnification feature */ ++} +diff --git a/src/lib/elm_entry.h b/src/lib/elm_entry.h +index 4ace8a1..8a00bfa 100644 +--- a/src/lib/elm_entry.h ++++ b/src/lib/elm_entry.h +@@ -1773,5 +1773,23 @@ EAPI const char *elm_entry_anchor_hover_style_get(const Evas_Obj + EAPI void elm_entry_anchor_hover_end(Evas_Object *obj); + + /** ++ * This disables the entry's magnifer feature. ++ * ++ * @param obj The entry object ++ * @param disabled If true, the magnifier is not displayed ++ */ ++ ++EAPI void elm_entry_magnifier_disabled_set(Evas_Object *obj, Eina_Bool disabled); ++/** ++ * This returns whether the entry's magnifier feature is disabled. ++ * ++ * @param obj The entry object ++ * @return If true, the feature is disabled ++ */ ++EAPI Eina_Bool elm_entry_magnifier_disabled_get(const Evas_Object *obj); ++ ++EAPI void elm_entry_magnifier_type_set(Evas_Object *obj, int type); ++ ++/** + * @} + */ +-- +1.8.1.4 + diff --git a/meta-wrt-tizen/recipes-efl/efl/files_elementary/0010-Add-elm_scale_get-and-elm_scale_set.patch b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0010-Add-elm_scale_get-and-elm_scale_set.patch new file mode 100644 index 0000000..f9a4710 --- /dev/null +++ b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0010-Add-elm_scale_get-and-elm_scale_set.patch @@ -0,0 +1,61 @@ +From d4fe69a1b858b50991865ac007ead4af01803cba Mon Sep 17 00:00:00 2001 +From: Rusty Lynch +Date: Wed, 21 Nov 2012 14:17:50 -0800 +Subject: [PATCH 10/33] Add elm_scale_get and elm_scale_set + +In order to run unmodified Tizen 2.0 applications on a newer elementary +library then we need to add back the elm_scale_get and set methods. +--- + src/lib/elm_config.c | 17 +++++++++++++++++ + src/lib/elm_config.h | 7 +++++++ + 2 files changed, 24 insertions(+) + +diff --git a/src/lib/elm_config.c b/src/lib/elm_config.c +index ce3a723..c37e9f2 100644 +--- a/src/lib/elm_config.c ++++ b/src/lib/elm_config.c +@@ -1629,6 +1629,23 @@ elm_config_scale_set(double scale) + _elm_rescale(); + } + ++/* ++ * Add backwards compatability implementation for elm_scale_get and elm_scale_set ++ * to allow running unmodified Tizen applications on a new drop of elementary ++ */ ++ ++EAPI double ++elm_scale_get(void) ++{ ++ return elm_config_scale_get(); ++} ++ ++EAPI void ++elm_scale_set(double scale) ++{ ++ elm_config_scale_set(scale); ++} ++ + EAPI Eina_Bool + elm_config_password_show_last_get(void) + { +diff --git a/src/lib/elm_config.h b/src/lib/elm_config.h +index 1728353..7810e4f 100644 +--- a/src/lib/elm_config.h ++++ b/src/lib/elm_config.h +@@ -514,6 +514,13 @@ EAPI double elm_config_scale_get(void); + */ + EAPI void elm_config_scale_set(double scale); + ++/* ++ * Add backwards compatability implementation for elm_scale_get and elm_scale_set ++ * to allow running unmodified Tizen applications on a new drop of elementary ++ */ ++EAPI double elm_scale_get(void); ++EAPI void elm_scale_set(double scale); ++ + /** + * @defgroup Password_last_show Password show last + * @ingroup Elementary +-- +1.8.1.4 + diff --git a/meta-wrt-tizen/recipes-efl/efl/files_elementary/0011-Adding-elm_finger_size_get-and-elm_finger_size_set.patch b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0011-Adding-elm_finger_size_get-and-elm_finger_size_set.patch new file mode 100644 index 0000000..4b62967 --- /dev/null +++ b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0011-Adding-elm_finger_size_get-and-elm_finger_size_set.patch @@ -0,0 +1,51 @@ +From a62c0d8d0d2f341f661942fa24988e7831c44876 Mon Sep 17 00:00:00 2001 +From: Rusty Lynch +Date: Mon, 17 Dec 2012 18:07:32 -0800 +Subject: [PATCH 11/33] Adding elm_finger_size_get and elm_finger_size_set + +Adding the previously removed elm_finger_size_[get|set] functions +to work past breakage in the Tizen 2.0 alpha middleware +--- + src/lib/elm_config.c | 11 +++++++++++ + src/lib/elm_config.h | 2 ++ + 2 files changed, 13 insertions(+) + +diff --git a/src/lib/elm_config.c b/src/lib/elm_config.c +index c37e9f2..e061205 100644 +--- a/src/lib/elm_config.c ++++ b/src/lib/elm_config.c +@@ -1801,6 +1801,12 @@ elm_config_finger_size_get(void) + } + + EAPI void ++elm_finger_size_set(Evas_Coord size) ++{ ++ elm_config_finger_size_set(size); ++} ++ ++EAPI void + elm_config_finger_size_set(Evas_Coord size) + { + if (_elm_config->finger_size == size) return; +@@ -2309,3 +2315,8 @@ _elm_config_shutdown(void) + _desc_shutdown(); + } + ++EAPI Evas_Coord ++elm_finger_size_get(void) ++{ ++ return elm_config_finger_size_get(); ++} +diff --git a/src/lib/elm_config.h b/src/lib/elm_config.h +index 7810e4f..f574301 100644 +--- a/src/lib/elm_config.h ++++ b/src/lib/elm_config.h +@@ -1023,3 +1023,5 @@ EAPI void elm_config_mirrored_set(Eina_Bool mirrored); + * @} + */ + ++EAPI Evas_Coord elm_finger_size_get(void); ++EAPI void elm_finger_size_set(Evas_Coord size); +-- +1.8.1.4 + diff --git a/meta-wrt-tizen/recipes-efl/efl/files_elementary/0012-Add-elm_widget_sub_object_list_get.patch b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0012-Add-elm_widget_sub_object_list_get.patch new file mode 100644 index 0000000..064c622 --- /dev/null +++ b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0012-Add-elm_widget_sub_object_list_get.patch @@ -0,0 +1,44 @@ +From 6b54fd0a98516fe84f4c911f8f6a973d3960ce48 Mon Sep 17 00:00:00 2001 +From: Rusty Lynch +Date: Wed, 19 Dec 2012 14:31:59 -0800 +Subject: [PATCH 12/33] Add elm_widget_sub_object_list_get() + +This is needed for backwards compatability with various Tizen apps +and libraries +--- + src/lib/elm_widget.c | 7 +++++++ + src/lib/elm_widget.h | 3 +++ + 2 files changed, 10 insertions(+) + +diff --git a/src/lib/elm_widget.c b/src/lib/elm_widget.c +index ad22b3f..951862c 100644 +--- a/src/lib/elm_widget.c ++++ b/src/lib/elm_widget.c +@@ -5130,3 +5130,10 @@ elm_widget_tree_dot_dump(const Evas_Object *top, + (void)output; + #endif + } ++ ++EAPI const Eina_List * ++elm_widget_sub_object_list_get(const Evas_Object *obj) ++{ ++ API_ENTRY return NULL; ++ return (const Eina_List *)sd->subobjs; ++} +diff --git a/src/lib/elm_widget.h b/src/lib/elm_widget.h +index 161da33..f0444ae 100644 +--- a/src/lib/elm_widget.h ++++ b/src/lib/elm_widget.h +@@ -825,6 +825,9 @@ EAPI void _elm_widget_item_del_pre_hook_set(Elm_Widget_Item *item, E + EAPI void elm_widget_tree_dump(const Evas_Object *top); + EAPI void elm_widget_tree_dot_dump(const Evas_Object *top, FILE *output); + ++/* Added for backwards compatability */ ++EAPI const Eina_List *elm_widget_sub_object_list_get(const Evas_Object *obj); ++ + /** + * Convenience macro to create new widget item, doing casts for you. + * @see _elm_widget_item_new() +-- +1.8.1.4 + diff --git a/meta-wrt-tizen/recipes-efl/efl/files_elementary/0013-Add-elm_win_indicator_state_set.patch b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0013-Add-elm_win_indicator_state_set.patch new file mode 100644 index 0000000..8501f55 --- /dev/null +++ b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0013-Add-elm_win_indicator_state_set.patch @@ -0,0 +1,48 @@ +From b9cd7583cc2911d3057994e0ac639344c086a96f Mon Sep 17 00:00:00 2001 +From: Rusty Lynch +Date: Wed, 19 Dec 2012 15:16:11 -0800 +Subject: [PATCH 13/33] Add elm_win_indicator_state_set + +This function exist in the Tizen 2.0 elementary tree with a simple +comment that calls it a 'wrapper'. The rpm-installer can not build +without this. +--- + src/lib/elm_win.c | 7 +++++++ + src/lib/elm_win.h | 3 +++ + 2 files changed, 10 insertions(+) + +diff --git a/src/lib/elm_win.c b/src/lib/elm_win.c +index 80a3035..5dfa5cd 100644 +--- a/src/lib/elm_win.c ++++ b/src/lib/elm_win.c +@@ -3603,6 +3603,13 @@ elm_win_indicator_mode_set(Evas_Object *obj, + #endif + } + ++// Wrapper that only exist in the Tizen 2.0 Elementary tree ++EAPI void ++elm_win_indicator_state_set(Evas_Object *obj, Elm_Win_Indicator_Mode mode) ++{ ++ elm_win_indicator_mode_set(obj, mode); ++} ++ + EAPI Elm_Win_Indicator_Mode + elm_win_indicator_mode_get(const Evas_Object *obj) + { +diff --git a/src/lib/elm_win.h b/src/lib/elm_win.h +index 66566e5..5e88009 100644 +--- a/src/lib/elm_win.h ++++ b/src/lib/elm_win.h +@@ -1480,6 +1480,9 @@ struct _Elm_Win_Trap + */ + EAPI Eina_Bool elm_win_trap_set(const Elm_Win_Trap *trap); + ++// Wrapper that only exist in the Tizen 2.0 elementary tree ++EAPI void elm_win_indicator_state_set(Evas_Object *obj, Elm_Win_Indicator_Mode mode); ++ + /** + * @} + */ +-- +1.8.1.4 + diff --git a/meta-wrt-tizen/recipes-efl/efl/files_elementary/0014-Adding-tickernoti-widget.patch b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0014-Adding-tickernoti-widget.patch new file mode 100644 index 0000000..81947c2 --- /dev/null +++ b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0014-Adding-tickernoti-widget.patch @@ -0,0 +1,1017 @@ +From a3e001556665cbec74d0ebb1e29c45a3746a9568 Mon Sep 17 00:00:00 2001 +From: brianjjones +Date: Tue, 8 Jan 2013 16:35:34 -0800 +Subject: [PATCH 14/33] Adding tickernoti widget + +Adding Tizen specific tickernoti widget used by various Tizen 2.x +middleware and applications +--- + src/lib/Elementary.h.in | 1 + + src/lib/Makefile.am | 1 + + src/lib/elm_tickernoti.c | 734 +++++++++++++++++++++++++++++++++++++++++++++++ + src/lib/elm_tickernoti.h | 228 +++++++++++++++ + 4 files changed, 964 insertions(+) + create mode 100644 src/lib/elm_tickernoti.c + create mode 100644 src/lib/elm_tickernoti.h + +diff --git a/src/lib/Elementary.h.in b/src/lib/Elementary.h.in +index 12a1799..0e8deef 100644 +--- a/src/lib/Elementary.h.in ++++ b/src/lib/Elementary.h.in +@@ -237,6 +237,7 @@ EAPI extern Elm_Version *elm_version; + #include + #include + #include ++#include + #include + #include + #include +diff --git a/src/lib/Makefile.am b/src/lib/Makefile.am +index deed0ed..7b75dd4 100644 +--- a/src/lib/Makefile.am ++++ b/src/lib/Makefile.am +@@ -97,6 +97,7 @@ elm_widget_slideshow.h \ + elm_widget_spinner.h \ + elm_widget_table.h \ + elm_widget_thumb.h \ ++elm_tickernoti.h \ + elm_widget_video.h \ + elm_widget_web.h + includesunstabledir = $(includedir)/elementary-@VMAJ@ +diff --git a/src/lib/elm_tickernoti.c b/src/lib/elm_tickernoti.c +new file mode 100644 +index 0000000..bfd4d2e +--- /dev/null ++++ b/src/lib/elm_tickernoti.c +@@ -0,0 +1,734 @@ ++#include ++#include "elm_priv.h" ++ ++typedef struct _Widget_Data Widget_Data; ++ ++struct _Widget_Data ++{ ++ Evas_Object *win; ++ Evas_Object *edje_obj; ++ Evas_Object *icon; ++ Evas_Object *button; ++ Ecore_Event_Handler *rotation_event_handler; ++ const char *label; ++ int noti_height; ++ int angle; ++ Elm_Tickernoti_Mode mode; ++ Elm_Tickernoti_Orient orient; ++}; ++ ++static const char *widtype = NULL; ++static void _del_hook(Evas_Object *obj); ++static void _theme_hook(Evas_Object *obj); ++static void _sizing_eval(Evas_Object *obj); ++static void _update_geometry_on_rotation(Evas_Object *obj, int angle, int *x, int *y, int *w); ++ ++static const char SIG_CLICKED[] = "clicked"; ++static const char SIG_HIDDEN[] = "hide"; ++static const Evas_Smart_Cb_Description _signals[] = { ++ {SIG_CLICKED, ""}, ++ {SIG_HIDDEN, ""}, ++ {NULL, NULL} ++}; ++ ++static void ++_del_job(void *data) ++{ ++ evas_object_del(data); ++} ++ ++static void ++_del_hook(Evas_Object *obj) ++{ ++ Evas_Object *parent; ++ Widget_Data *wd = elm_widget_data_get(obj); ++ ++ if (!wd) return; ++ parent = elm_widget_parent_get(obj); ++ if (wd->rotation_event_handler) ++ ecore_event_handler_del(wd->rotation_event_handler); ++ if (wd->win) ecore_job_add(_del_job, parent); ++ evas_object_del(wd->edje_obj); ++ wd->edje_obj = NULL; ++ free(wd); ++} ++ ++static void ++_mirrored_set(Evas_Object *obj, Eina_Bool rtl) ++{ ++ Widget_Data *wd = elm_widget_data_get(obj); ++ ++ if (!wd) return; ++ edje_object_mirrored_set(wd->edje_obj, rtl); ++} ++ ++static void ++_theme_hook(Evas_Object *obj) ++{ ++ char *data_win_height = NULL; ++ Evas_Coord w; ++ Widget_Data *wd = elm_widget_data_get(obj); ++ ++ if (!wd) return; ++ _elm_widget_mirrored_reload(obj); ++ _mirrored_set(obj, elm_widget_mirrored_get(obj)); ++ ++ _elm_theme_object_set(wd->win, wd->edje_obj, "tickernoti", ++ "base", elm_widget_style_get(obj)); ++ ++ /* tickernoti detail height set */ ++ data_win_height = (char *)edje_object_data_get(wd->edje_obj, "height"); ++ if (data_win_height != NULL && elm_scale_get() > 0.0) ++ wd->noti_height = (int)(elm_scale_get() * atoi(data_win_height)); ++ ++ evas_object_geometry_get(wd->win, NULL, NULL, &w, NULL); ++ evas_object_resize(wd->win, w, wd->noti_height); ++ ++ edje_object_signal_emit(wd->edje_obj, "effect,show", "elm");/*goes too late*/ ++ edje_object_message_signal_process(wd->edje_obj); ++ edje_object_scale_set(wd->edje_obj, elm_widget_scale_get(obj) * _elm_config->scale); ++ ++ _sizing_eval(obj); ++} ++ ++static void ++_sizing_eval(Evas_Object *obj) ++{ ++ Widget_Data *wd = elm_widget_data_get(obj); ++ Evas_Coord minw = -1, minh = -1; ++ ++ if (!wd) return; ++ elm_coords_finger_size_adjust(1, &minw, 1, &minh); ++ edje_object_size_min_restricted_calc(wd->edje_obj, &minw, &minh, minw, minh); ++ evas_object_size_hint_min_set(obj, minw, minh); ++} ++ ++#ifdef HAVE_ELEMENTARY_X ++static void ++_update_window_hints(Evas_Object *obj) ++{ ++ Ecore_X_Window xwin; ++ Ecore_X_Atom _notification_level_atom; ++ int level; ++ // elm_win_xwindow_get() must call after elm_win_alpha_set() ++ xwin = elm_win_xwindow_get(obj); ++ ++ ecore_x_icccm_hints_set(xwin, 0, ECORE_X_WINDOW_STATE_HINT_NONE, 0, 0, 0, 0, 0); ++ ecore_x_netwm_window_type_set(xwin, ECORE_X_WINDOW_TYPE_NOTIFICATION); ++ ecore_x_netwm_opacity_set(xwin, 0); ++ // Create atom for notification level ++ _notification_level_atom = ecore_x_atom_get("_E_ILLUME_NOTIFICATION_LEVEL"); ++ ++ // HIGH:150, NORMAL:100, LOW:50 ++ level = 100; ++ ++ // Set notification level of the window ++ ecore_x_window_prop_property_set(xwin, _notification_level_atom, ECORE_X_ATOM_CARDINAL, 32, &level, 1); ++} ++#endif ++ ++static void _hide_cb(void *data, Evas_Object *obj __UNUSED__, ++ const char *emission __UNUSED__, ++ const char *source __UNUSED__) ++{ ++ Widget_Data *wd = elm_widget_data_get(data); ++ ++ if (!wd) return; ++ evas_object_hide(wd->win); ++ evas_object_smart_callback_call(data, SIG_HIDDEN, NULL); ++} ++ ++static void _clicked_cb(void *data, Evas_Object *obj __UNUSED__, ++ const char *emission __UNUSED__, ++ const char *source __UNUSED__) ++{ ++ Widget_Data *wd = elm_widget_data_get(data); ++ ++ if (!wd) return; ++ evas_object_smart_callback_call(data, SIG_CLICKED, NULL); ++} ++ ++static Evas_Object ++*_create_window(Evas_Object *parent, const char *name) ++{ ++ Evas_Object *win; ++ ++ win = elm_win_add(parent, name, ELM_WIN_BASIC); ++ elm_win_title_set(win, name); ++ elm_win_borderless_set(win, EINA_TRUE); ++ elm_win_autodel_set(win, EINA_TRUE); ++ elm_win_alpha_set(win, EINA_TRUE); ++ evas_object_size_hint_weight_set(win, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); ++ evas_object_size_hint_align_set(win, EVAS_HINT_FILL, EVAS_HINT_FILL); ++ ++#ifdef HAVE_ELEMENTARY_X ++ // set top window ++ _update_window_hints(win); ++#endif ++ return win; ++} ++ ++static void ++_win_rotated(Evas_Object *obj) ++{ ++ Widget_Data *wd = elm_widget_data_get(obj); ++ int x = 0, y = 0, w = 0, angle = 0; ++ ++ if (!wd) return; ++ angle = elm_win_rotation_get(wd->win); ++ if (angle % 90) return; ++ angle %= 360; ++ if (angle < 0) angle += 360; ++ wd->angle = angle; ++ _update_geometry_on_rotation(obj, wd->angle, &x, &y, &w); ++ evas_object_move(wd->win, x, y); ++ evas_object_resize(wd->win, w, wd->noti_height); ++#ifdef HAVE_ELEMENTARY_X ++ _update_window_hints(wd->win); ++#endif ++} ++ ++static Eina_Bool ++_prop_change(void *data, int type __UNUSED__, void *event) ++{ ++#ifdef HAVE_ELEMENTARY_X ++ Ecore_X_Event_Window_Property *ev; ++ Widget_Data *wd = elm_widget_data_get(data); ++ ++ if (!wd) return ECORE_CALLBACK_PASS_ON; ++ ev = event; ++ if (ev->atom == ECORE_X_ATOM_E_ILLUME_ROTATE_WINDOW_ANGLE) ++ { ++ if (ev->win == elm_win_xwindow_get(wd->win)) ++ { ++ _win_rotated(data); ++ } ++ } ++ return ECORE_CALLBACK_PASS_ON; ++#endif ++} ++ ++static void ++_create_tickernoti(Evas_Object *obj) ++{ ++#ifdef HAVE_ELEMENTARY_X ++ Evas_Coord w; ++#endif ++ Widget_Data *wd = elm_widget_data_get(obj); ++ char *data_win_height = NULL; ++ Evas *e; ++ ++ if (!wd) return; ++ ++ evas_object_move(wd->win, 0, 0); ++ e = evas_object_evas_get(wd->win); ++ ++ wd->edje_obj = edje_object_add(e); ++ _elm_theme_object_set(wd->win, wd->edje_obj, "tickernoti", "base", "default"); ++ elm_win_resize_object_add(wd->win, wd->edje_obj); ++ ++ // tickernoti height setting ++ data_win_height = (char *)edje_object_data_get(wd->edje_obj, "height"); ++ if (data_win_height != NULL && elm_scale_get() > 0.0) ++ wd->noti_height = (int)(elm_scale_get() * atoi(data_win_height)); ++ ++#ifdef HAVE_ELEMENTARY_X ++ ecore_x_window_size_get(ecore_x_window_root_first_get(), &w, NULL); ++ evas_object_size_hint_min_set(wd->edje_obj, w, wd->noti_height); ++ evas_object_resize(wd->win, w, wd->noti_height); ++ wd->rotation_event_handler = ecore_event_handler_add( ++ ECORE_X_EVENT_WINDOW_PROPERTY, _prop_change, obj); ++#endif ++ ++ edje_object_signal_callback_add(wd->edje_obj, "request,hide", "", _hide_cb, obj); ++ edje_object_signal_callback_add(wd->edje_obj, "clicked", "", _clicked_cb, obj); ++ evas_object_show(wd->edje_obj); ++} ++ ++static void ++_disable_hook(Evas_Object *obj) ++{ ++ Widget_Data *wd = elm_widget_data_get(obj); ++ ++ if (!wd) return; ++//TODO: To stop the event in case of being disabled ++} ++ ++static void ++_show(void *data __UNUSED__, Evas *e __UNUSED__, Evas_Object *obj, ++ void *event_info __UNUSED__) ++{ ++ Widget_Data *wd = elm_widget_data_get(obj); ++ if (!wd) return; ++ ++#ifdef HAVE_ELEMENTARY_X ++ _update_window_hints(wd->win); ++#endif ++ evas_object_show(wd->win); ++ edje_object_signal_emit(wd->edje_obj, "effect,show", "elm"); ++ edje_object_message_signal_process(wd->edje_obj); ++} ++ ++static void ++_hide(void *data __UNUSED__, Evas *e __UNUSED__, Evas_Object *obj, ++ void *event_info __UNUSED__) ++{ ++ Widget_Data *wd = elm_widget_data_get(obj); ++ ++ if (!wd) return; ++ evas_object_hide(wd->win); ++} ++ ++static void _tickernoti_hide_cb(void *data, Evas_Object *obj __UNUSED__, ++ void *event_info __UNUSED__) ++{ ++ Widget_Data *wd = data; ++ ++ if (!wd) return; ++ ++ edje_object_signal_emit(wd->edje_obj, "effect,hide", "elm"); ++ edje_object_message_signal_process(wd->edje_obj); ++} ++ ++static void ++_update_geometry_on_rotation(Evas_Object *obj, int angle, int *x, int *y, int *w) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype); ++ Widget_Data *wd = elm_widget_data_get(obj); ++ ++ if (!wd) return; ++ ++#ifdef HAVE_ELEMENTARY_X ++ Evas_Coord root_w, root_h; ++ ++ /* ++ * manually calculate win_tickernoti_indi window position & size ++ * - win_indi is not full size window ++ */ ++ ecore_x_window_size_get(ecore_x_window_root_first_get(), &root_w, &root_h); ++ // rotate win ++ switch(angle) ++ { ++ case 90: ++ *w = root_h; ++ if (wd->orient == ELM_TICKERNOTI_ORIENT_BOTTOM) ++ *x = root_w - wd->noti_height; ++ break; ++ case 270: ++ *w = root_h; ++ if (!(wd->orient == ELM_TICKERNOTI_ORIENT_BOTTOM)) ++ *x = root_w - wd->noti_height; ++ break; ++ case 180: ++ *w = root_w; ++ if (!wd->orient == ELM_TICKERNOTI_ORIENT_BOTTOM) ++ *y = root_h - wd->noti_height; ++ break; ++ case 0: ++ default: ++ *w = root_w; ++ if (wd->orient == ELM_TICKERNOTI_ORIENT_BOTTOM) ++ *y = root_h - wd->noti_height; ++ break; ++ } ++#endif ++} ++ ++static void ++_sub_del(void *data __UNUSED__, Evas_Object *obj, void *event_info) ++{ ++ Widget_Data *wd = elm_widget_data_get(obj); ++ Evas_Object *sub = event_info; ++ if (!wd) return; ++ if (sub == wd->icon) ++ wd->icon = NULL; ++ if (sub == wd->button) ++ wd->button = NULL; ++} ++ ++static void ++_elm_tickernoti_label_set(Evas_Object *obj, const char *part, const char *label) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype); ++ Widget_Data *wd = elm_widget_data_get(obj); ++ ++ if (!wd) return; ++ if (part && strcmp(part, "default")) return; ++ eina_stringshare_replace(&wd->label, label); ++ edje_object_part_text_set(wd->edje_obj, "elm.text", wd->label); ++ _sizing_eval(obj); ++} ++ ++const char * ++_elm_tickernoti_label_get(const Evas_Object *obj, const char *part) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype) NULL; ++ Widget_Data *wd = elm_widget_data_get(obj); ++ ++ if (part && strcmp(part, "default")) return NULL; ++ if (!wd) return NULL; ++ return wd->label; ++} ++ ++static void ++_elm_tickernoti_icon_set(Evas_Object *obj, Evas_Object *icon) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype); ++ Widget_Data *wd = elm_widget_data_get(obj); ++ ++ if (!wd) return; ++ if (wd->icon == icon) return; ++ if (wd->icon) evas_object_del(wd->icon); ++ wd->icon = icon; ++ if (icon) ++ { ++ elm_widget_sub_object_add(obj, icon); ++ edje_object_part_swallow(wd->edje_obj, "icon", icon); ++ } ++} ++ ++static void ++_elm_tickernoti_button_set(Evas_Object *obj, Evas_Object *button) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype); ++ Widget_Data *wd = elm_widget_data_get(obj); ++ ++ if (!wd) return; ++ if (wd->button == button) return; ++ if (wd->button) evas_object_del(wd->button); ++ wd->button = button; ++ if (button) ++ { ++ elm_widget_sub_object_add(obj, button); ++ edje_object_part_swallow(wd->edje_obj, "button", button); ++ evas_object_smart_callback_add(wd->button, "clicked", _tickernoti_hide_cb, wd); ++ } ++} ++ ++static void ++_elm_tickernoti_content_part_set_hook(Evas_Object *obj, const char *part, Evas_Object *content) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype); ++ Widget_Data *wd = elm_widget_data_get(obj); ++ ++ if (!wd || !part) return; ++ if (!part || !strcmp(part, "icon")) ++ { ++ _elm_tickernoti_icon_set(obj, content); ++ return; ++ } ++ else if (!strcmp(part, "button")) ++ { ++ _elm_tickernoti_button_set(obj, content); ++ return; ++ } ++} ++ ++static Evas_Object * ++_elm_tickernoti_icon_get(const Evas_Object *obj) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype) NULL; ++ Widget_Data *wd = elm_widget_data_get(obj); ++ if (!wd) return NULL; ++ return wd->icon; ++} ++ ++static Evas_Object * ++_elm_tickernoti_button_get(const Evas_Object *obj) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype) NULL; ++ Widget_Data *wd = elm_widget_data_get(obj); ++ if (!wd) return NULL; ++ return wd->button; ++} ++ ++static Evas_Object * ++_elm_tickernoti_content_part_get_hook(Evas_Object *obj, const char *part) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype) NULL; ++ Widget_Data *wd = elm_widget_data_get(obj); ++ ++ if (!wd || !part) return NULL; ++ if (!part || !strcmp(part, "icon")) ++ return _elm_tickernoti_icon_get(obj); ++ else if (!strcmp(part, "button")) ++ return _elm_tickernoti_button_get(obj); ++ return NULL; ++} ++ ++static Evas_Object * ++_elm_tickernoti_icon_unset(Evas_Object *obj) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype) NULL; ++ Evas_Object *icon; ++ Widget_Data *wd = elm_widget_data_get(obj); ++ ++ if (!wd || !wd->icon) return NULL; ++ icon = wd->icon; ++ elm_widget_sub_object_del(obj, wd->icon); ++ edje_object_part_unswallow(wd->edje_obj, icon); ++ wd->icon = NULL; ++ return icon; ++} ++ ++static Evas_Object * ++_elm_tickernoti_button_unset(Evas_Object *obj) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype) NULL; ++ Evas_Object *button; ++ Widget_Data *wd = elm_widget_data_get(obj); ++ ++ if (!wd || !wd->button) return NULL; ++ button = wd->button; ++ elm_widget_sub_object_del(obj, wd->button); ++ edje_object_part_unswallow(wd->edje_obj, button); ++ wd->button = NULL; ++ return button; ++} ++ ++static Evas_Object * ++_elm_tickernoti_content_part_unset_hook(Evas_Object *obj, const char *part) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype) NULL; ++ Widget_Data *wd = elm_widget_data_get(obj); ++ ++ if (!wd || !part) return NULL; ++ if (!strcmp(part, "icon")) ++ return _elm_tickernoti_icon_unset(obj); ++ else if (!strcmp(part, "button")) ++ return _elm_tickernoti_button_unset(obj); ++ return NULL; ++} ++ ++EAPI Evas_Object * ++elm_tickernoti_add(Evas_Object *parent) ++{ ++ Evas_Object *obj; ++ Evas *e; ++ Widget_Data *wd; ++ ++ wd = ELM_NEW(Widget_Data); ++ wd->win = _create_window(parent, "noti-window"); ++ ++ e = evas_object_evas_get(wd->win); ++ obj = elm_widget_add(e); ++ ELM_SET_WIDTYPE(widtype, "tickernoti"); ++ elm_widget_type_set(obj, widtype); ++ elm_widget_sub_object_add(wd->win, obj); ++ elm_widget_data_set(obj, wd); ++ elm_widget_del_hook_set(obj, _del_hook); ++ elm_widget_theme_hook_set(obj, _theme_hook); ++ elm_widget_can_focus_set(obj, 0); ++ elm_widget_disable_hook_set(obj, _disable_hook); ++ ++ wd->orient = ELM_TICKERNOTI_ORIENT_TOP; ++ ++ _create_tickernoti(obj); ++ elm_widget_text_set_hook_set(obj, _elm_tickernoti_label_set); ++ elm_widget_text_get_hook_set(obj, _elm_tickernoti_label_get); ++ elm_widget_content_set_hook_set(obj, _elm_tickernoti_content_part_set_hook); ++ elm_widget_content_get_hook_set(obj, _elm_tickernoti_content_part_get_hook); ++ elm_widget_content_unset_hook_set(obj, _elm_tickernoti_content_part_unset_hook); ++ evas_object_smart_callback_add(obj, "sub-object-del", _sub_del, NULL); ++ ++ evas_object_event_callback_add(obj, EVAS_CALLBACK_SHOW, _show, NULL); ++ evas_object_event_callback_add(obj, EVAS_CALLBACK_HIDE, _hide, NULL); ++ evas_object_smart_callbacks_descriptions_set(obj, _signals); ++ return obj; ++} ++ ++EAPI int ++elm_tickernoti_rotation_get(const Evas_Object *obj) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype) -1; ++ Widget_Data *wd = elm_widget_data_get(obj); ++ if (!wd) return -1; ++ return wd->angle; ++} ++ ++EAPI void ++elm_tickernoti_rotation_set(Evas_Object *obj, int angle) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype); ++ Widget_Data *wd = elm_widget_data_get(obj); ++ ++ if (!wd) return; ++ if (angle % 90) return; ++ angle %= 360; ++ if (angle < 0) angle += 360; ++ wd->angle = angle; ++ elm_win_rotation_set(wd->win, angle); ++ _win_rotated(obj); ++} ++ ++EAPI void ++elm_tickernoti_orient_set(Evas_Object *obj, Elm_Tickernoti_Orient orient) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype); ++ ++#ifdef HAVE_ELEMENTARY_X ++ Evas_Coord root_w, root_h; ++#endif ++ Widget_Data *wd = elm_widget_data_get(obj); ++ ++ if (!wd) return; ++ if (orient >= ELM_TICKERNOTI_ORIENT_LAST) return; ++ ++#ifdef HAVE_ELEMENTARY_X ++ ecore_x_window_size_get(ecore_x_window_root_first_get(), &root_w, &root_h); ++#endif ++ ++ switch(orient) { ++ case ELM_TICKERNOTI_ORIENT_BOTTOM: ++#ifdef HAVE_ELEMENTARY_X ++ evas_object_move(wd->win, 0, root_h - wd->noti_height); ++#endif ++ wd->orient = ELM_TICKERNOTI_ORIENT_BOTTOM; ++ break; ++ case ELM_TICKERNOTI_ORIENT_TOP: ++ default: ++#ifdef HAVE_ELEMENTARY_X ++ evas_object_move(wd->win, 0, 0); ++#endif ++ wd->orient = ELM_TICKERNOTI_ORIENT_TOP; ++ break; ++ } ++#ifdef HAVE_ELEMENTARY_X ++ _update_window_hints(wd->win); ++#endif ++} ++ ++EAPI Elm_Tickernoti_Orient ++elm_tickernoti_orient_get(const Evas_Object *obj) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype) -1; ++ Widget_Data *wd = elm_widget_data_get(obj); ++ ++ if (!wd) return ELM_TICKERNOTI_ORIENT_LAST; ++ return wd->orient; ++} ++ ++EAPI Evas_Object * ++elm_tickernoti_win_get(const Evas_Object *obj) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype) NULL; ++ Widget_Data *wd = elm_widget_data_get(obj); ++ if (!wd) return NULL; ++ return wd->win; ++} ++ ++EAPI void ++elm_tickernoti_detailview_label_set(Evas_Object *obj, const char *label) ++{ ++ _elm_tickernoti_label_set(obj, NULL, label); ++} ++ ++EAPI const char * ++elm_tickernoti_detailview_label_get(const Evas_Object *obj) ++{ ++ return _elm_tickernoti_label_get(obj, NULL); ++} ++ ++EAPI void ++elm_tickernoti_detailview_button_set(Evas_Object *obj, Evas_Object *button) ++{ ++ _elm_tickernoti_button_set(obj, button); ++} ++ ++EAPI Evas_Object * ++elm_tickernoti_detailview_button_get(const Evas_Object *obj) ++{ ++ return _elm_tickernoti_button_get(obj); ++} ++ ++EAPI void ++elm_tickernoti_detailview_icon_set(Evas_Object *obj, Evas_Object *icon) ++{ ++ _elm_tickernoti_icon_set(obj, icon); ++} ++ ++EAPI Evas_Object * ++elm_tickernoti_detailview_icon_get(const Evas_Object *obj) ++{ ++ return _elm_tickernoti_icon_get(obj); ++} ++ ++EAPI Elm_Tickernoti_Mode ++elm_tickernoti_mode_get(const Evas_Object *obj) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype) -1; ++ Widget_Data *wd = elm_widget_data_get(obj); ++ if (!wd) return -1; ++ return wd->mode; ++} ++ ++EAPI void ++elm_tickernoti_mode_set(Evas_Object *obj, Elm_Tickernoti_Mode mode) ++{ ++ ELM_CHECK_WIDTYPE(obj, widtype); ++ Widget_Data *wd = elm_widget_data_get(obj); ++ if (!wd) return; ++ ++ switch(mode){ ++ case ELM_TICKERNOTI_DEFAULT: ++ case ELM_TICKERNOTI_DETAILVIEW: ++ wd->mode = mode; ++ break; ++ default: ++ break; ++ } ++} ++ ++EAPI Evas_Object * ++elm_tickernoti_detailview_get(const Evas_Object *obj) ++{ ++ return elm_tickernoti_win_get(obj); ++} ++ ++EAPI void ++elm_tickernoti_orientation_set(Evas_Object *obj, Elm_Tickernoti_Orient orient) ++{ ++ elm_tickernoti_orient_set(obj, orient); ++} ++ ++EAPI Elm_Tickernoti_Orient ++elm_tickernoti_orientation_get(const Evas_Object *obj) ++{ ++ return elm_tickernoti_orient_get(obj); ++} ++ ++EAPI void ++elm_tickernoti_label_set(Evas_Object *obj, const char *label) ++{ ++ _elm_tickernoti_label_set(obj, NULL, label); ++} ++ ++EAPI const char * ++elm_tickernoti_label_get(const Evas_Object *obj) ++{ ++ return _elm_tickernoti_label_get(obj, NULL); ++} ++ ++EAPI void ++elm_tickernoti_button_set(Evas_Object *obj, Evas_Object *button) ++{ ++ _elm_tickernoti_button_set(obj, button); ++} ++ ++EAPI Evas_Object * ++elm_tickernoti_button_get(const Evas_Object *obj) ++{ ++ return _elm_tickernoti_button_get(obj); ++} ++ ++EAPI void ++elm_tickernoti_icon_set(Evas_Object *obj, Evas_Object *icon) ++{ ++ _elm_tickernoti_icon_set(obj, icon); ++} ++ ++EAPI Evas_Object * ++elm_tickernoti_icon_get(const Evas_Object *obj) ++{ ++ return _elm_tickernoti_icon_get(obj); ++} +diff --git a/src/lib/elm_tickernoti.h b/src/lib/elm_tickernoti.h +new file mode 100644 +index 0000000..f92cf2d +--- /dev/null ++++ b/src/lib/elm_tickernoti.h +@@ -0,0 +1,228 @@ ++ /** ++ * @defgroup TickerNoti TickerNoti ++ * @ingroup Elementary ++ * ++ * This is a notification widget which can be used to display some short information. ++ * ++ * Signals that you can add callback for are: ++ * @li "clicked" - tickernoti object has been clicked, except at the ++ * swallow/button region ++ * @li "hide" - tickernoti is completely hidden. In case of ++ * any hide animation, this signal is emitted after the animation. ++ * ++ * Default contents parts of a tickernoti object that you can use for are: ++ * @li "icon" - The icon in tickernoti object ++ * @li "button" - The button in tickernoti object ++ * ++ * Default text parts of the tickernoti object that you can use for are: ++ * @li "default" - textual content in the tickernoti object ++ * ++ * Supported elm_object common APIs. ++ * @li elm_object_text_set ++ * @li elm_object_part_text_set ++ * @li elm_object_part_content_set ++ * ++ */ ++ ++ /** ++ * @addtogroup Tickernoti ++ * @{ ++ */ ++ typedef enum ++ { ++ ELM_TICKERNOTI_ORIENT_TOP = 0, ++ ELM_TICKERNOTI_ORIENT_BOTTOM, ++ ELM_TICKERNOTI_ORIENT_LAST ++ } Elm_Tickernoti_Orient; ++ ++ /** ++ * Add a tickernoti object to @p parent ++ * ++ * @param parent The parent object ++ * ++ * @return The tickernoti object, or NULL upon failure ++ */ ++ EAPI Evas_Object *elm_tickernoti_add (Evas_Object *parent); ++ /** ++ * Set the orientation of the tickernoti object ++ * ++ * @param obj The tickernoti object ++ * @param orient The orientation of tickernoti object ++ */ ++ EAPI void elm_tickernoti_orient_set (Evas_Object *obj, Elm_Tickernoti_Orient orient) EINA_ARG_NONNULL(1); ++ /** ++ * Get the orientation of the tickernoti object ++ * ++ * @param obj The tickernotil object ++ * @return The orientation of tickernotil object ++ */ ++ EAPI Elm_Tickernoti_Orient elm_tickernoti_orient_get (const Evas_Object *obj) EINA_ARG_NONNULL(1); ++ /** ++ * Get the rotation of tickernoti object ++ * ++ * @param obj The tickernotil object ++ * @return The rotation angle ++ */ ++ EAPI int elm_tickernoti_rotation_get (const Evas_Object *obj) EINA_ARG_NONNULL(1); ++ /** ++ * Set the rotation angle for the tickernoti object ++ * ++ * @param obj The tickernoti object ++ * @param angle The rotation angle(in degree) will be used on the tickernoti object ++ */ ++ EAPI void elm_tickernoti_rotation_set (Evas_Object *obj, int angle) EINA_ARG_NONNULL(1); ++ /** ++ * Get the view window(elm_win) on the tickernoti object ++ * ++ * @param obj The tickernotil object ++ * @return internal view window(elm_win) object ++ */ ++ EAPI Evas_Object *elm_tickernoti_win_get (const Evas_Object *obj) EINA_ARG_NONNULL(1); ++ /* #### Below APIs and data structures are going to be deprecated, announcment will be made soon ####*/ ++ /** ++ * @deprecated ++ */ ++ typedef enum ++ { ++ ELM_TICKERNOTI_DEFAULT, ++ ELM_TICKERNOTI_DETAILVIEW ++ } Elm_Tickernoti_Mode; ++ /** ++ * Set the detail label on the tickernoti object ++ * ++ * @param obj The tickernoti object ++ * @param label The label will be used on the tickernoti object ++ * @deprecated use elm_object_text_set() instead ++ */ ++ EINA_DEPRECATED EAPI void elm_tickernoti_detailview_label_set (Evas_Object *obj, const char *label) EINA_ARG_NONNULL(1); ++ /** ++ * Get the detail label used on the tickernoti object ++ * ++ * @param obj The tickernotil object ++ * @return The string inside the label ++ * @deprecated use elm_object_text_get() instead ++ */ ++ EINA_DEPRECATED EAPI const char *elm_tickernoti_detailview_label_get (const Evas_Object *obj)EINA_ARG_NONNULL(1); ++ /** ++ * Set the button object used on the tickernoti object ++ * ++ * @param obj The tickernotil object ++ * @param button The button object will be used on the tickernoti object ++ * @deprecated use elm_object_part_content_set() instead with "button" as part name ++ */ ++ EINA_DEPRECATED EAPI void elm_tickernoti_detailview_button_set (Evas_Object *obj, Evas_Object *button) EINA_ARG_NONNULL(2); ++ /** ++ * Get the button object used on the tickernoti object ++ * ++ * @param obj The tickernotil object ++ * @return The button object inside the tickernoti ++ * @deprecated use elm_object_part_content_get() instead with "button" as part name ++ */ ++ EINA_DEPRECATED EAPI Evas_Object *elm_tickernoti_detailview_button_get (const Evas_Object *obj) EINA_ARG_NONNULL(1); ++ /** ++ * Set the detail icon object used on the tickernoti object ++ * ++ * @param obj The tickernotil object ++ * @param icon The icon object will be used on the tickernoti object ++ * @deprecated use elm_object_part_content_set() instead with "icon" as part name ++ */ ++ EINA_DEPRECATED EAPI void elm_tickernoti_detailview_icon_set (Evas_Object *obj, Evas_Object *icon) EINA_ARG_NONNULL(1); ++ /** ++ * Get the detail icon object used on the tickernoti object ++ * ++ * @param obj The tickernotil object ++ * @return The icon object inside the tickernoti ++ * @deprecated use elm_object_part_content_get() instead with "icon" as part name ++ */ ++ EINA_DEPRECATED EAPI Evas_Object *elm_tickernoti_detailview_icon_get (const Evas_Object *obj) EINA_ARG_NONNULL(1); ++ /** ++ * Get the view mode on the tickernoti object ++ * ++ * @param obj The tickernotil object ++ * @return The internal window used ++ * @deprecated use elm_tickernoti_win_get instead when internal window object is needed ++ */ ++ EINA_DEPRECATED EAPI Evas_Object *elm_tickernoti_detailview_get (const Evas_Object *obj) EINA_ARG_NONNULL(1); ++ /** ++ * Set the view mode used on the tickernoti object ++ * ++ * @param obj The tickernotil object ++ * @param mode The view mode will be used on the tickernoti object ++ * @deprecated removed as now styles are used. Use elm_object_style_set instead. ++ */ ++ EINA_DEPRECATED EAPI void elm_tickernoti_mode_set (Evas_Object *obj, Elm_Tickernoti_Mode mode) EINA_ARG_NONNULL(1); ++ /** ++ * Get the current mode of the tickernoti object ++ * ++ * @param obj The tickernotil object ++ * @return the mode of the object. Can be ELM_TICKERNOTI_DEFAULT/ELM_TICKERNOTI_DETAILVIEW ++ */ ++ EINA_DEPRECATED EAPI Elm_Tickernoti_Mode elm_tickernoti_mode_get (const Evas_Object *obj) EINA_ARG_NONNULL(1); ++ /** ++ * Set the orientation of the tickernoti object ++ * ++ * @param obj The tickernoti object ++ * @param orient The orientation of tickernoti object ++ * @deprecated use elm_tickernoti_orient_set() instead ++ */ ++ EINA_DEPRECATED EAPI void elm_tickernoti_orientation_set (Evas_Object *obj, Elm_Tickernoti_Orient orient) EINA_ARG_NONNULL(1); ++ /** ++ * Get the orientation of the tickernoti object ++ * ++ * @param obj The tickernotil object ++ * @return The orientation of tickernotil object ++ * @deprecated use elm_tickernoti_orient_get() instead ++ */ ++ EINA_DEPRECATED EAPI Elm_Tickernoti_Orient elm_tickernoti_orientation_get (const Evas_Object *obj) EINA_ARG_NONNULL(1); ++ /** ++ * Set the label on the tickernoti object ++ * ++ * @param obj The tickernoti object ++ * @param label The label will be used on the tickernoti object ++ * @deprecated use elm_object_text_set() ++ */ ++ EINA_DEPRECATED EAPI void elm_tickernoti_label_set (Evas_Object *obj, const char *label) EINA_ARG_NONNULL(1); ++ /** ++ * Get the label used on the tickernoti object ++ * ++ * @param obj The tickernotil object ++ * @return The string inside the label ++ * @deprecated use elm_object_text_get() instead ++ */ ++ EINA_DEPRECATED EAPI const char *elm_tickernoti_label_get (const Evas_Object *obj) EINA_ARG_NONNULL(1); ++ /** ++ * Set the icon object of the tickernoti object ++ * ++ * @param obj The tickernotil object ++ * @param icon The icon object will be used on the tickernoti object ++ * @deprecated use elm_object_part_content_set() instead with "icon" as part name ++ */ ++ EINA_DEPRECATED EAPI void elm_tickernoti_icon_set (Evas_Object *obj, Evas_Object *icon) EINA_ARG_NONNULL(1); ++ /** ++ * Get the icon object of the tickernoti object ++ * ++ * @param obj The tickernotil object ++ * @return The icon object inside the tickernoti ++ * @deprecated use elm_object_part_content_get() instead with "icon" as part name ++ */ ++ EINA_DEPRECATED EAPI Evas_Object *elm_tickernoti_icon_get (const Evas_Object *obj) EINA_ARG_NONNULL(1); ++ /** ++ * Set the action button object used on the tickernoti object ++ * ++ * @param obj The tickernotil object ++ * @param button The button object will be used on the tickernoti object ++ * @deprecated use elm_object_part_content_set() instead with "button" as part name ++ */ ++ EINA_DEPRECATED EAPI void elm_tickernoti_button_set (Evas_Object *obj, Evas_Object *button) EINA_ARG_NONNULL(1); ++ /** ++ * Get the action button object used on the tickernoti object ++ * ++ * @param obj The tickernotil object ++ * @return The button object inside the tickernoti ++ * @deprecated use elm_object_part_content_get() instead with "button" as part name ++ */ ++ EINA_DEPRECATED EAPI Evas_Object *elm_tickernoti_button_get (const Evas_Object *obj) EINA_ARG_NONNULL(1); ++ /** ++ * @} ++ */ ++ +-- +1.8.1.4 + diff --git a/meta-wrt-tizen/recipes-efl/efl/files_elementary/0015-Force-ELM_WAYLAND_EGL-if-engine-set-called-when-DISP.patch b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0015-Force-ELM_WAYLAND_EGL-if-engine-set-called-when-DISP.patch new file mode 100644 index 0000000..a2d79b1 --- /dev/null +++ b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0015-Force-ELM_WAYLAND_EGL-if-engine-set-called-when-DISP.patch @@ -0,0 +1,42 @@ +From acdc579a8dde37f6bb639f31358dc451f15b415e Mon Sep 17 00:00:00 2001 +From: Mikko Ylinen +Date: Thu, 10 Jan 2013 14:30:37 +0200 +Subject: [PATCH 15/33] Force ELM_WAYLAND_EGL if engine set called when DISPLAY + not set + +Some applications are directly calling elm_config_preferred_engine_set. +To avoid patching all apps to work with Wayland, always set +ELM_WAYLAND_EGL if elm_config_preferred_engine_set is called with +EGL_OPENGL_X11 or EGL_SOFTWARE_X11 when DISPLAY is not set. + +Signed-off-by: Mikko Ylinen +--- + src/lib/elm_config.c | 12 ++++++++++-- + 1 file changed, 10 insertions(+), 2 deletions(-) + +diff --git a/src/lib/elm_config.c b/src/lib/elm_config.c +index e061205..9bc1470 100644 +--- a/src/lib/elm_config.c ++++ b/src/lib/elm_config.c +@@ -2252,8 +2252,16 @@ elm_config_preferred_engine_get(void) + EAPI void + elm_config_preferred_engine_set(const char *engine) + { +- if (engine) +- eina_stringshare_replace(&(_elm_preferred_engine), engine); ++ char *d; ++ if (engine) { ++#define ENGINE_COMPARE(name) (!strcmp(name, engine)) ++ if (!(d = getenv("DISPLAY")) && (ENGINE_COMPARE(ELM_SOFTWARE_X11) || ++ ENGINE_COMPARE(ELM_OPENGL_X11))) ++ eina_stringshare_replace(&(_elm_preferred_engine), ELM_WAYLAND_EGL); ++ else ++ eina_stringshare_replace(&(_elm_preferred_engine), engine); ++#undef ENGINE_COMPARE ++ } + else + { + if (_elm_preferred_engine) eina_stringshare_del(_elm_preferred_engine); +-- +1.8.1.4 + diff --git a/meta-wrt-tizen/recipes-efl/efl/files_elementary/0018-Add-elm_gesture_layer_-support-from-Tizen-2.1.patch b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0018-Add-elm_gesture_layer_-support-from-Tizen-2.1.patch new file mode 100644 index 0000000..40578b8 --- /dev/null +++ b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0018-Add-elm_gesture_layer_-support-from-Tizen-2.1.patch @@ -0,0 +1,528 @@ +From 765e32f982ec08c1c105233c6466b8044521ad31 Mon Sep 17 00:00:00 2001 +From: Rusty Lynch +Date: Sun, 19 May 2013 11:27:22 -0700 +Subject: [PATCH 18/33] Add elm_gesture_layer_* support from Tizen 2.1 + +--- + src/lib/elm_gesture_layer.c | 237 +++++++++++++++++++++++++++++++++++++++----- + src/lib/elm_gesture_layer.h | 220 ++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 433 insertions(+), 24 deletions(-) + +diff --git a/src/lib/elm_gesture_layer.c b/src/lib/elm_gesture_layer.c +index b85b266..27bce9e 100644 +--- a/src/lib/elm_gesture_layer.c ++++ b/src/lib/elm_gesture_layer.c +@@ -372,6 +372,7 @@ struct _Elm_Gesture_Layer_Smart_Data + unsigned int flick_time_limit_ms; + double long_tap_start_timeout; + Eina_Bool glayer_continues_enable; ++ double double_tap_timeout; + + double zoom_step; + double rotate_step; +@@ -1003,29 +1004,29 @@ _callbacks_unregister(Evas_Object *obj) + + if (!sd->target) return; + +- evas_object_event_callback_del +- (sd->target, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down_cb); +- evas_object_event_callback_del +- (sd->target, EVAS_CALLBACK_MOUSE_MOVE, _mouse_move_cb); +- evas_object_event_callback_del +- (sd->target, EVAS_CALLBACK_MOUSE_UP, _mouse_up_cb); ++ evas_object_event_callback_del_full ++ (sd->target, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down_cb, obj); ++ evas_object_event_callback_del_full ++ (sd->target, EVAS_CALLBACK_MOUSE_MOVE, _mouse_move_cb, obj); ++ evas_object_event_callback_del_full ++ (sd->target, EVAS_CALLBACK_MOUSE_UP, _mouse_up_cb, obj); + +- evas_object_event_callback_del +- (sd->target, EVAS_CALLBACK_MOUSE_WHEEL, _mouse_wheel_cb); ++ evas_object_event_callback_del_full ++ (sd->target, EVAS_CALLBACK_MOUSE_WHEEL, _mouse_wheel_cb, obj); + +- evas_object_event_callback_del +- (sd->target, EVAS_CALLBACK_MULTI_DOWN, _multi_down_cb); ++ evas_object_event_callback_del_full ++ (sd->target, EVAS_CALLBACK_MULTI_DOWN, _multi_down_cb, obj); + +- evas_object_event_callback_del +- (sd->target, EVAS_CALLBACK_MULTI_MOVE, _multi_move_cb); ++ evas_object_event_callback_del_full ++ (sd->target, EVAS_CALLBACK_MULTI_MOVE, _multi_move_cb, obj); + +- evas_object_event_callback_del +- (sd->target, EVAS_CALLBACK_MULTI_UP, _multi_up_cb); ++ evas_object_event_callback_del_full ++ (sd->target, EVAS_CALLBACK_MULTI_UP, _multi_up_cb, obj); + +- evas_object_event_callback_del +- (sd->target, EVAS_CALLBACK_KEY_DOWN, _key_down_cb); +- evas_object_event_callback_del +- (sd->target, EVAS_CALLBACK_KEY_UP, _key_up_cb); ++ evas_object_event_callback_del_full ++ (sd->target, EVAS_CALLBACK_KEY_DOWN, _key_down_cb, obj); ++ evas_object_event_callback_del_full ++ (sd->target, EVAS_CALLBACK_KEY_UP, _key_up_cb, obj); + } + + /** +@@ -1792,12 +1793,16 @@ _tap_gesture_test(Evas_Object *obj, + + pe_list = _pointer_event_record + (st, pe_list, pe, sd, event_info, event_type); +- if ((!sd->gest_taps_timeout) && +- (_elm_config->glayer_double_tap_timeout > 0.0)) +- sd->gest_taps_timeout = +- ecore_timer_add(_elm_config->glayer_double_tap_timeout, +- _multi_tap_timeout, gesture->obj); +- else if (sd->gest_taps_timeout) ++ if (!sd->gest_taps_timeout) ++ { ++ if (sd->double_tap_timeout > 0.0) ++ { ++ sd->gest_taps_timeout = ++ ecore_timer_add(sd->double_tap_timeout, ++ _multi_tap_timeout, gesture->obj); ++ } ++ } ++ else + ecore_timer_reset(sd->gest_taps_timeout); + + /* This is the first mouse down we got */ +@@ -3612,6 +3617,7 @@ _elm_gesture_layer_smart_add(Evas_Object *obj) + /* FIXME: Hack to get around old configs - if too small, enlarge. */ + if (_elm_config->glayer_double_tap_timeout < 0.00001) + _elm_config->glayer_double_tap_timeout = 0.25; ++ priv->double_tap_timeout = _elm_config->glayer_double_tap_timeout; + + memset(priv->gesture, 0, sizeof(priv->gesture)); + } +@@ -3642,6 +3648,11 @@ _elm_gesture_layer_smart_del(Evas_Object *obj) + + free(sd->gesture[i]); + } ++ if (sd->gest_taps_timeout) ++ { ++ ecore_timer_del(sd->gest_taps_timeout); ++ sd->gest_taps_timeout = NULL; ++ } + + _elm_gesture_layer_parent_sc->base.del(obj); /* handles freeing sd */ + } +@@ -3775,3 +3786,181 @@ elm_gesture_layer_cb_set(Evas_Object *obj, + p->state = ELM_GESTURE_STATE_UNDEFINED; + SET_TEST_BIT(p); + } ++ ++ ++EAPI void ++elm_gesture_layer_line_min_length_set(Evas_Object *obj, int line_min_length) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj); ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ sd->line_min_length = line_min_length; ++} ++ ++ ++EAPI int ++elm_gesture_layer_line_min_length_get(const Evas_Object *obj) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj) 0; ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ return sd->line_min_length; ++} ++ ++EAPI void ++elm_gesture_layer_zoom_distance_tolerance_set(Evas_Object *obj, Evas_Coord zoom_distance_tolerance) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj); ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ sd->zoom_distance_tolerance = zoom_distance_tolerance; ++} ++ ++EAPI Evas_Coord ++elm_gesture_layer_zoom_distance_tolerance_get(const Evas_Object *obj) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj) 0; ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ return sd->zoom_distance_tolerance; ++} ++ ++EAPI void ++elm_gesture_layer_line_distance_tolerance_set(Evas_Object *obj, Evas_Coord line_distance_tolerance) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj); ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ sd->line_distance_tolerance = line_distance_tolerance; ++} ++ ++EAPI Evas_Coord ++elm_gesture_layer_line_distance_tolerance_get(const Evas_Object *obj) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj) 0; ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ return sd->line_distance_tolerance; ++} ++ ++EAPI void ++elm_gesture_layer_line_angular_tolerance_set(Evas_Object *obj, double line_angular_tolerance) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj); ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ sd->line_angular_tolerance = line_angular_tolerance; ++} ++ ++EAPI double ++elm_gesture_layer_line_angular_tolerance_get(const Evas_Object *obj) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj) 0.0; ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ return sd->line_angular_tolerance; ++} ++ ++EAPI void ++elm_gesture_layer_zoom_wheel_factor_set(Evas_Object *obj, double zoom_wheel_factor) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj); ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ sd->zoom_wheel_factor = zoom_wheel_factor; ++} ++ ++EAPI double ++elm_gesture_layer_zoom_wheel_factor_get(const Evas_Object *obj) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj) 0.0; ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ return sd->zoom_wheel_factor; ++} ++ ++EAPI void ++elm_gesture_layer_zoom_finger_factor_set(Evas_Object *obj, double zoom_finger_factor) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj); ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ sd->zoom_finger_factor = zoom_finger_factor; ++} ++ ++EAPI double ++elm_gesture_layer_zoom_finger_factor_get(const Evas_Object *obj) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj) 0.0; ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ return sd->zoom_finger_factor; ++} ++ ++EAPI void ++elm_gesture_layer_rotate_angular_tolerance_set(Evas_Object *obj, double rotate_angular_tolerance) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj); ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ sd->rotate_angular_tolerance = rotate_angular_tolerance; ++} ++ ++EAPI double ++elm_gesture_layer_rotate_angular_tolerance_get(const Evas_Object *obj) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj) 0.0; ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ return sd->rotate_angular_tolerance; ++} ++ ++EAPI void ++elm_gesture_layer_flick_time_limit_ms_set(Evas_Object *obj, unsigned int flick_time_limit_ms) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj); ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ sd->flick_time_limit_ms = flick_time_limit_ms; ++} ++ ++EAPI unsigned int ++elm_gesture_layer_flick_time_limit_ms_get(const Evas_Object *obj) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj) 0; ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ return sd->flick_time_limit_ms; ++} ++ ++EAPI void ++elm_gesture_layer_long_tap_start_timeout_set(Evas_Object *obj, double long_tap_start_timeout) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj); ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ sd->long_tap_start_timeout = long_tap_start_timeout; ++} ++ ++EAPI double ++elm_gesture_layer_long_tap_start_timeout_get(const Evas_Object *obj) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj) 0.0; ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ return sd->long_tap_start_timeout; ++} ++ ++EAPI void ++elm_gesture_layer_continues_enable_set(Evas_Object *obj, Eina_Bool continues_enable) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj); ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ sd->glayer_continues_enable = continues_enable; ++} ++ ++EAPI Eina_Bool ++elm_gesture_layer_continues_enable_get(const Evas_Object *obj) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj) 0.0; ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ return sd->glayer_continues_enable; ++} ++ ++EAPI void ++elm_gesture_layer_double_tap_timeout_set(Evas_Object *obj, double double_tap_timeout) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj); ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ sd->double_tap_timeout = double_tap_timeout; ++} ++ ++EAPI double ++elm_gesture_layer_double_tap_timeout_get(const Evas_Object *obj) ++{ ++ ELM_GESTURE_LAYER_CHECK(obj) 0.0; ++ ELM_GESTURE_LAYER_DATA_GET(obj, sd); ++ return sd->double_tap_timeout; ++} +diff --git a/src/lib/elm_gesture_layer.h b/src/lib/elm_gesture_layer.h +index 66451b7..8789aba 100644 +--- a/src/lib/elm_gesture_layer.h ++++ b/src/lib/elm_gesture_layer.h +@@ -339,5 +339,225 @@ EAPI Eina_Bool elm_gesture_layer_attach(Evas_Object *obj, Evas_Object *target + EAPI Evas_Object *elm_gesture_layer_add(Evas_Object *parent); + + /** ++ * @since 1.8 ++ * This function sets the gesture layer line min length of an object ++ * ++ * @param obj gesture-layer. ++ * @param line_min_length the length. ++ * ++ */ ++EAPI void elm_gesture_layer_line_min_length_set(Evas_Object *obj, int line_min_length); ++ ++/** ++ * @since 1.8 ++ * This function returns the gesture layer line min length of an object ++ * ++ * @param obj gesture-layer. ++ * @return the length. ++ * ++ */ ++EAPI int elm_gesture_layer_line_min_length_get(const Evas_Object *obj); ++ ++/** ++ * @since 1.8 ++ * This function sets the gesture layer zoom distance tolerance of an object ++ * ++ * @param obj gesture-layer. ++ * @param zoom_distance_tolerance zoom distance tolerance ++ * ++ */ ++EAPI void elm_gesture_layer_zoom_distance_tolerance_set(Evas_Object *obj, Evas_Coord zoom_distance_tolerance); ++ ++/** ++ * @since 1.8 ++ * This function returns the gesture layer zoom distance tolerance of an object ++ * ++ * @param obj gesture-layer. ++ * @return zoom distance tolerance ++ * ++ */ ++EAPI Evas_Coord elm_gesture_layer_zoom_distance_tolerance_get(const Evas_Object *obj); ++ ++/** ++ * @since 1.8 ++ * This function sets the gesture layer line distance tolerance of an object ++ * ++ * @param obj gesture-layer. ++ * @param line_distance_tolerance line distance tolerance ++ * ++ */ ++EAPI void elm_gesture_layer_line_distance_tolerance_set(Evas_Object *obj, Evas_Coord line_distance_tolerance); ++ ++/** ++ * @since 1.8 ++ * This function returns the gesture layer line distance tolerance of an object ++ * ++ * @param obj gesture-layer. ++ * @return line distance tolerance ++ * ++ */ ++EAPI Evas_Coord elm_gesture_layer_line_distance_tolerance_get(const Evas_Object *obj); ++ ++/** ++ * @since 1.8 ++ * This function sets the gesture layer line angular tolerance of an object ++ * ++ * @param obj gesture-layer. ++ * @param line_angular_tolerance line angular tolerance ++ * ++ */ ++EAPI void elm_gesture_layer_line_angular_tolerance_set(Evas_Object *obj, double line_angular_tolerance); ++ ++/** ++ * @since 1.8 ++ * This function returns the gesture layer line angular tolerance of an object ++ * ++ * @param obj gesture-layer. ++ * @return line angular tolerance ++ * ++ */ ++EAPI double elm_gesture_layer_line_angular_tolerance_get(const Evas_Object *obj); ++ ++/** ++ * @since 1.8 ++ * This function sets the gesture layer zoom wheel factor of an object ++ * ++ * @param obj gesture-layer. ++ * @param zoom_wheel_factor zoom wheel factor ++ * ++ */ ++EAPI void elm_gesture_layer_zoom_wheel_factor_set(Evas_Object *obj, double zoom_wheel_factor); ++ ++/** ++ * @since 1.8 ++ * This function returns the gesture layer zoom wheel factor of an object ++ * ++ * @param obj gesture-layer. ++ * @return zoom wheel factor ++ * ++ */ ++EAPI double elm_gesture_layer_zoom_wheel_factor_get(const Evas_Object *obj); ++ ++/** ++ * @since 1.8 ++ * This function sets the gesture layer zoom finger factor of an object ++ * ++ * @param obj gesture-layer. ++ * @param zoom_finger_factor zoom finger factor ++ * ++ */ ++EAPI void elm_gesture_layer_zoom_finger_factor_set(Evas_Object *obj, double zoom_finger_factor); ++ ++/** ++ * @since 1.8 ++ * This function returns the gesture layer zoom finger factor of an object ++ * ++ * @param obj gesture-layer. ++ * @return zoom finger factor ++ * ++ */ ++EAPI double elm_gesture_layer_zoom_finger_factor_get(const Evas_Object *obj); ++ ++/** ++ * @since 1.8 ++ * This function sets the gesture layer rotate angular tolerance of an object ++ * ++ * @param obj gesture-layer. ++ * @param rotate_angular_tolerance rotate angular tolerance ++ * ++ */ ++EAPI void elm_gesture_layer_rotate_angular_tolerance_set(Evas_Object *obj, double rotate_angular_tolerance); ++ ++/** ++ * @since 1.8 ++ * This function returns the gesture layer rotate angular tolerance of an object ++ * ++ * @param obj gesture-layer. ++ * @return rotate angular tolerance ++ * ++ */ ++EAPI double elm_gesture_layer_rotate_angular_tolerance_get(const Evas_Object *obj); ++ ++/** ++ * @since 1.8 ++ * This function sets the gesture layer flick time limit (in ms) of an object ++ * ++ * @param obj gesture-layer. ++ * @param flick_time_limit_ms flick time limit (in ms) ++ * ++ */ ++EAPI void elm_gesture_layer_flick_time_limit_ms_set(Evas_Object *obj, unsigned int flick_time_limit_ms); ++ ++/** ++ * @since 1.8 ++ * This function returns the gesture layer flick time limit (in ms) of an object ++ * ++ * @param obj gesture-layer. ++ * @return flick time limit (in ms) ++ * ++ */ ++EAPI unsigned int elm_gesture_layer_flick_time_limit_ms_get(const Evas_Object *obj); ++ ++/** ++ * @since 1.8 ++ * This function sets the gesture layer long tap start timeout of an object ++ * ++ * @param obj gesture-layer. ++ * @param long_tap_start_timeout long tap start timeout ++ * ++ */ ++EAPI void elm_gesture_layer_long_tap_start_timeout_set(Evas_Object *obj, double long_tap_start_timeout); ++ ++/** ++ * @since 1.8 ++ * this function returns the gesture layer long tap start timeout of an object ++ * ++ * @param obj gesture-layer. ++ * @return long tap start timeout ++ * ++ */ ++EAPI double elm_gesture_layer_long_tap_start_timeout_get(const Evas_Object *obj); ++ ++/** ++ * @since 1.8 ++ * This function sets the gesture layer continues enable of an object ++ * ++ * @param obj gesture-layer. ++ * @param continues_enable continues enable ++ * ++ */ ++EAPI void elm_gesture_layer_continues_enable_set(Evas_Object *obj, Eina_Bool continues_enable); ++ ++/** ++ * @since 1.8 ++ * This function returns the gesture layer continues enable of an object ++ * ++ * @param obj gesture-layer. ++ * @return continues enable ++ * ++ */ ++EAPI Eina_Bool elm_gesture_layer_continues_enable_get(const Evas_Object *obj); ++ ++/** ++ * @since 1.8 ++ * This function sets the gesture layer double tap timeout of an object ++ * ++ * @param obj gesture-layer. ++ * @param double_tap_timeout double tap timeout ++ * ++ */ ++EAPI void elm_gesture_layer_double_tap_timeout_set(Evas_Object *obj, double double_tap_timeout); ++ ++/** ++ * @since 1.8 ++ * this function returns the gesture layer double tap timeout of an object ++ * ++ * @param obj gesture-layer. ++ * @return double tap timeout ++ * ++ */ ++EAPI double elm_gesture_layer_double_tap_timeout_get(const Evas_Object *obj); ++ ++/** + * @} + */ +-- +1.8.1.4 + diff --git a/meta-wrt-tizen/recipes-efl/efl/files_elementary/0020-Adding-elm_win_wm_rotation-support.patch b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0020-Adding-elm_win_wm_rotation-support.patch new file mode 100644 index 0000000..bcaf609 --- /dev/null +++ b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0020-Adding-elm_win_wm_rotation-support.patch @@ -0,0 +1,411 @@ +From d2eeec6d1f15a2e881aba936dd9d12bd1049ac8c Mon Sep 17 00:00:00 2001 +From: Rusty Lynch +Date: Wed, 22 May 2013 10:08:09 -0700 +Subject: [PATCH 20/33] Adding elm_win_wm_rotation support + +--- + src/lib/elm_widget.c | 70 +++++++++++++++++++++- + src/lib/elm_widget.h | 4 ++ + src/lib/elm_win.c | 166 +++++++++++++++++++++++++++++++++++++++++++++++++++ + src/lib/elm_win.h | 7 +++ + 4 files changed, 246 insertions(+), 1 deletion(-) + +diff --git a/src/lib/elm_widget.c b/src/lib/elm_widget.c +index 951862c..b12f727 100644 +--- a/src/lib/elm_widget.c ++++ b/src/lib/elm_widget.c +@@ -400,6 +400,7 @@ _elm_widget_sub_object_add_func(Evas_Object *obj, + return EINA_FALSE; + } + sdc->parent_obj = obj; ++ sdc->orient_mode = sd->orient_mode; + _elm_widget_top_win_focused_set(sobj, sd->top_win_focused); + + /* update child focusable-ness on self and parents, now that a +@@ -3523,7 +3524,18 @@ elm_widget_theme_object_set(Evas_Object *obj, + const char *wstyle) + { + API_ENTRY return EINA_FALSE; +- return _elm_theme_object_set(obj, edj, wname, welement, wstyle); ++ char buf[128]; ++ ++ if (!_elm_theme_object_set(obj, edj, wname, welement, wstyle)) ++ return EINA_FALSE; ++ ++ if (sd->orient_mode != -1) ++ { ++ snprintf(buf, sizeof(buf), "elm,state,orient,%d", sd->orient_mode); ++ elm_widget_signal_emit(obj, buf, "elm"); ++ ++ } ++ return EINA_TRUE; + } + + EAPI Eina_Bool +@@ -3616,6 +3628,62 @@ elm_widget_name_find(const Evas_Object *obj, const char *name, int recurse) + return _widget_name_find(obj, name, recurse); + } + ++EAPI void ++elm_widget_orientation_mode_disabled_set(Evas_Object *obj, Eina_Bool disabled) ++{ ++ int orient_mode = -1; ++ ++ API_ENTRY return; ++ ++ if (disabled && (sd->orient_mode == -1)) return; ++ if (!disabled && (sd->orient_mode != -1)) return; ++ ++ if (!disabled) ++ { ++ //Get current orient mode from it's parent otherwise, 0. ++ sd->orient_mode = 0; ++ ELM_WIDGET_DATA_GET(sd->parent_obj, sd_parent); ++ if (!sd_parent) orient_mode = 0; ++ else orient_mode = sd_parent->orient_mode; ++ } ++ elm_widget_orientation_set(obj, orient_mode); ++} ++ ++EAPI Eina_Bool ++elm_widget_orientation_mode_disabled_get(const Evas_Object *obj) ++{ ++ Eina_Bool ret; ++ ++ API_ENTRY return EINA_FALSE; ++ ++ if (sd->orient_mode == -1) ret = EINA_TRUE; ++ else ret = EINA_FALSE; ++ return ret; ++} ++ ++EAPI void ++elm_widget_orientation_set(Evas_Object *obj, int rotation) ++{ ++ Evas_Object *child; ++ Eina_List *l; ++ ++ API_ENTRY return; ++ ++ if ((sd->orient_mode == rotation) || (sd->orient_mode == -1)) return; ++ ++ sd->orient_mode = rotation; ++ ++ EINA_LIST_FOREACH (sd->subobjs, l, child) ++ elm_widget_orientation_set(child, rotation); ++ ++ if (rotation != -1) ++ { ++ char buf[128]; ++ snprintf(buf, sizeof(buf), "elm,state,orient,%d", sd->orient_mode); ++ elm_widget_signal_emit(obj, buf, "elm"); ++ } ++} ++ + /** + * @internal + * +diff --git a/src/lib/elm_widget.h b/src/lib/elm_widget.h +index f0444ae..9c12a9a 100644 +--- a/src/lib/elm_widget.h ++++ b/src/lib/elm_widget.h +@@ -488,6 +488,7 @@ typedef struct _Elm_Widget_Smart_Data + Evas_Coord *h); + + int frozen; ++ int orient_mode; /* -1 is disabled */ + + Eina_Bool drag_x_locked : 1; + Eina_Bool drag_y_locked : 1; +@@ -780,6 +781,9 @@ EAPI Evas_Object *elm_widget_content_part_get(const Evas_Object *obj, const + EAPI Evas_Object *elm_widget_content_part_unset(Evas_Object *obj, const char *part); + EAPI void elm_widget_access_info_set(Evas_Object *obj, const char *txt); + EAPI const char *elm_widget_access_info_get(const Evas_Object *obj); ++EAPI void elm_widget_orientation_set(Evas_Object *obj, int rotation); ++EAPI void elm_widget_orientation_mode_disabled_set(Evas_Object *obj, Eina_Bool disabled); ++EAPI Eina_Bool elm_widget_orientation_mode_disabled_get(const Evas_Object *obj); + EAPI Elm_Widget_Item *_elm_widget_item_new(Evas_Object *parent, size_t alloc_size); + EAPI void _elm_widget_item_free(Elm_Widget_Item *item); + EAPI Evas_Object *_elm_widget_item_widget_get(const Elm_Widget_Item *item); +diff --git a/src/lib/elm_win.c b/src/lib/elm_win.c +index 5dfa5cd..958d1f8 100644 +--- a/src/lib/elm_win.c ++++ b/src/lib/elm_win.c +@@ -120,6 +120,15 @@ struct _Elm_Win_Smart_Data + Eina_Bool top_animate : 1; + Eina_Bool geometry_changed : 1; + } focus_highlight; ++ struct ++ { ++ int preferred_rot; // specified by app ++ int *rots; // available rotations ++ unsigned int count; // number of elements in available rotations ++ Eina_Bool wm_supported : 1; ++ Eina_Bool use : 1; ++ } wm_rot; ++ + + Evas_Object *icon; + const char *title; +@@ -160,6 +169,8 @@ static const char SIG_UNFULLSCREEN[] = "unfullscreen"; + static const char SIG_MAXIMIZED[] = "maximized"; + static const char SIG_UNMAXIMIZED[] = "unmaximized"; + static const char SIG_IOERR[] = "ioerr"; ++static const char SIG_ROTATION_CHANGED[] = "rotation,changed"; ++static const char SIG_WM_ROTATION_CHANGED[] = "wm,rotation,changed"; + + static const Evas_Smart_Cb_Description _smart_callbacks[] = { + {SIG_DELETE_REQUEST, ""}, +@@ -176,6 +187,8 @@ static const Evas_Smart_Cb_Description _smart_callbacks[] = { + {SIG_MAXIMIZED, ""}, + {SIG_UNMAXIMIZED, ""}, + {SIG_IOERR, ""}, ++ {SIG_ROTATION_CHANGED, ""}, ++ {SIG_WM_ROTATION_CHANGED, ""}, + {NULL, NULL} + }; + +@@ -195,6 +208,8 @@ static Eina_Bool _elm_win_auto_throttled = EINA_FALSE; + + static Ecore_Job *_elm_win_state_eval_job = NULL; + ++static void _elm_win_resize_objects_eval(Evas_Object *obj); ++ + static void + _elm_win_state_eval(void *data __UNUSED__) + { +@@ -835,6 +850,8 @@ _elm_win_state_change(Ecore_Evas *ee) + Eina_Bool ch_iconified = EINA_FALSE; + Eina_Bool ch_fullscreen = EINA_FALSE; + Eina_Bool ch_maximized = EINA_FALSE; ++ Eina_Bool ch_rotation = EINA_FALSE; ++ Eina_Bool ch_wm_rotation = EINA_FALSE; + + EINA_SAFETY_ON_NULL_RETURN(sd); + +@@ -868,6 +885,14 @@ _elm_win_state_change(Ecore_Evas *ee) + sd->maximized = ecore_evas_maximized_get(sd->ee); + ch_maximized = EINA_TRUE; + } ++ if (sd->wm_rot.use) ++ { ++ if (sd->rot != ecore_evas_rotation_get(sd->ee)) ++ { ++ sd->rot = ecore_evas_rotation_get(sd->ee); ++ ch_wm_rotation = EINA_TRUE; ++ } ++ } + + if (sd->withdrawn) _elm_win_count_withdrawn++; + if (sd->iconified) _elm_win_count_iconified++; +@@ -903,6 +928,19 @@ _elm_win_state_change(Ecore_Evas *ee) + else + evas_object_smart_callback_call(obj, SIG_UNMAXIMIZED, NULL); + } ++ if (ch_rotation) ++ { ++ // TODO: Implement me ++ } ++ if (ch_wm_rotation) ++ { ++ evas_object_size_hint_min_set(obj, -1, -1); ++ evas_object_size_hint_max_set(obj, -1, -1); ++ _elm_win_resize_objects_eval(obj); ++ elm_widget_orientation_set(obj, sd->rot); ++ ++ evas_object_smart_callback_call(obj, SIG_WM_ROTATION_CHANGED, NULL); ++ } + } + + static Eina_Bool +@@ -1315,6 +1353,9 @@ _elm_win_smart_del(Evas_Object *obj) + if (sd->shot.info) eina_stringshare_del(sd->shot.info); + if (sd->shot.timer) ecore_timer_del(sd->shot.timer); + ++ if (sd->wm_rot.rots) free(sd->wm_rot.rots); ++ sd->wm_rot.rots = NULL; ++ + #ifdef HAVE_ELEMENTARY_X + if (sd->x.client_message_handler) + ecore_event_handler_del(sd->x.client_message_handler); +@@ -2766,6 +2807,9 @@ elm_win_add(Evas_Object *parent, + // do nothing + } + ++ sd->wm_rot.wm_supported = ecore_evas_wm_rotation_supported_get(sd->ee); ++ sd->wm_rot.preferred_rot = -1; // it means that elm_win doesn't use preferred rotation. ++ + return obj; + } + +@@ -3451,6 +3495,18 @@ elm_win_render(Evas_Object *obj) + ecore_evas_manual_render(sd->ee); + } + ++static int ++_win_rotation_degree_check(int rotation) ++{ ++ if ((rotation > 360) || (rotation < 0)) ++ { ++ WRN("Rotation degree should be 0 ~ 360 (passed degree: %d)", rotation); ++ rotation %= 360; ++ if (rotation < 0) rotation += 360; ++ } ++ return rotation; ++} ++ + EAPI void + elm_win_rotation_set(Evas_Object *obj, + int rotation) +@@ -3467,6 +3523,8 @@ elm_win_rotation_set(Evas_Object *obj, + #ifdef HAVE_ELEMENTARY_X + _elm_win_xwin_update(sd); + #endif ++ elm_widget_orientation_set(obj, rotation); ++ evas_object_smart_callback_call(obj, SIG_ROTATION_CHANGED, NULL); + } + + EAPI void +@@ -3497,6 +3555,114 @@ elm_win_rotation_get(const Evas_Object *obj) + return sd->rot; + } + ++EAPI Eina_Bool ++elm_win_wm_rotation_supported_get(const Evas_Object *obj) ++{ ++ ELM_WIN_CHECK(obj) EINA_FALSE; ++ ELM_WIN_DATA_GET_OR_RETURN_VAL(obj, sd, EINA_FALSE); ++ return sd->wm_rot.wm_supported; ++} ++ ++/* This will unset a preferred rotation, if given preferred rotation is '-1'. ++ */ ++EAPI void ++elm_win_wm_rotation_preferred_rotation_set(Evas_Object *obj, ++ const int rotation) ++{ ++ int rot; ++ ++ ELM_WIN_CHECK(obj); ++ ELM_WIN_DATA_GET_OR_RETURN(obj, sd); ++ ++ if (!sd->wm_rot.use) ++ sd->wm_rot.use = EINA_TRUE; ++ ++ // '-1' means that elm_win doesn't use preferred rotation. ++ if (rotation == -1) ++ rot = -1; ++ else ++ rot = _win_rotation_degree_check(rotation); ++ ++ if (sd->wm_rot.preferred_rot == rot) return; ++ sd->wm_rot.preferred_rot = rot; ++ ++ ecore_evas_wm_rotation_preferred_rotation_set(sd->ee, rot); ++} ++ ++EAPI int ++elm_win_wm_rotation_preferred_rotation_get(const Evas_Object *obj) ++{ ++ ELM_WIN_CHECK(obj) -1; ++ ELM_WIN_DATA_GET_OR_RETURN_VAL(obj, sd, -1); ++ if (!sd->wm_rot.use) return -1; ++ return sd->wm_rot.preferred_rot; ++} ++ ++EAPI void ++elm_win_wm_rotation_available_rotations_set(Evas_Object *obj, ++ const int *rotations, ++ unsigned int count) ++{ ++ unsigned int i; ++ int r; ++ ++ ELM_WIN_CHECK(obj); ++ ELM_WIN_DATA_GET_OR_RETURN(obj, sd); ++ ++ if (!sd->wm_rot.use) ++ sd->wm_rot.use = EINA_TRUE; ++ ++ if (sd->wm_rot.rots) free(sd->wm_rot.rots); ++ ++ sd->wm_rot.rots = NULL; ++ sd->wm_rot.count = 0; ++ ++ if (count > 0) ++ { ++ sd->wm_rot.rots = calloc(count, sizeof(int)); ++ if (!sd->wm_rot.rots) return; ++ for (i = 0; i < count; i++) ++ { ++ r = _win_rotation_degree_check(rotations[i]); ++ sd->wm_rot.rots[i] = r; ++ } ++ } ++ ++ sd->wm_rot.count = count; ++ ++ ecore_evas_wm_rotation_available_rotations_set(sd->ee, ++ sd->wm_rot.rots, ++ sd->wm_rot.count); ++} ++ ++EAPI Eina_Bool ++elm_win_wm_rotation_available_rotations_get(const Evas_Object *obj, ++ int **rotations, ++ unsigned int *count) ++{ ++ ELM_WIN_CHECK(obj) EINA_FALSE; ++ ELM_WIN_DATA_GET_OR_RETURN_VAL(obj, sd, EINA_FALSE); ++ if (!sd->wm_rot.use) return EINA_FALSE; ++ ++ if (sd->wm_rot.count > 0) ++ { ++ if ((rotations) && (*rotations)) ++ { ++ *rotations = calloc(sd->wm_rot.count, sizeof(int)); ++ if (*rotations) ++ { ++ memcpy(*rotations, ++ sd->wm_rot.rots, ++ sizeof(int) * sd->wm_rot.count); ++ } ++ } ++ } ++ ++ if (count) *count = sd->wm_rot.count; ++ ++ return EINA_TRUE; ++} ++ + EAPI void + elm_win_sticky_set(Evas_Object *obj, + Eina_Bool sticky) +diff --git a/src/lib/elm_win.h b/src/lib/elm_win.h +index 5e88009..185395e 100644 +--- a/src/lib/elm_win.h ++++ b/src/lib/elm_win.h +@@ -82,6 +82,7 @@ + * @li "unfullscreen": window has stopped being fullscreen + * @li "maximized": window has been maximized + * @li "unmaximized": window has stopped being maximized ++ * @li "wm,rotation,changed": rotation of window has been changed by window manager + * @li "ioerr": there has been a low-level I/O error with the display system + * + * Examples: +@@ -1483,6 +1484,12 @@ EAPI Eina_Bool elm_win_trap_set(const Elm_Win_Trap *trap); + // Wrapper that only exist in the Tizen 2.0 elementary tree + EAPI void elm_win_indicator_state_set(Evas_Object *obj, Elm_Win_Indicator_Mode mode); + ++EAPI Eina_Bool elm_win_wm_rotation_supported_get(const Evas_Object *obj); ++EAPI void elm_win_wm_rotation_preferred_rotation_set(Evas_Object *obj, const int rotation); ++EAPI int elm_win_wm_rotation_preferred_rotation_get(const Evas_Object *obj); ++EAPI void elm_win_wm_rotation_available_rotations_set(Evas_Object *obj, const int *rotations, unsigned int count); ++EAPI Eina_Bool elm_win_wm_rotation_available_rotations_get(const Evas_Object *obj, int **rotations, unsigned int *count); ++ + /** + * @} + */ +-- +1.8.1.4 + diff --git a/meta-wrt-tizen/recipes-efl/efl/files_elementary/0030-list-Fix-list_example_03-call-elm_list_go.patch b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0030-list-Fix-list_example_03-call-elm_list_go.patch new file mode 100644 index 0000000..23089dd --- /dev/null +++ b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0030-list-Fix-list_example_03-call-elm_list_go.patch @@ -0,0 +1,88 @@ +From daaaf8cb22e8ae615cde039b5da64666d9be7c90 Mon Sep 17 00:00:00 2001 +From: Rafael Antognolli +Date: Sat, 24 Aug 2013 17:02:01 -0300 +Subject: [PATCH 30/33] list: Fix list_example_03 - call elm_list_go(). + +--- + src/examples/list_example_03.c | 9 +++++++++ + 1 file changed, 9 insertions(+) + +diff --git a/src/examples/list_example_03.c b/src/examples/list_example_03.c +index 3b79bb9..8c6e1df 100644 +--- a/src/examples/list_example_03.c ++++ b/src/examples/list_example_03.c +@@ -30,6 +30,7 @@ _prepend_cb(void *data, Evas_Object *obj, void *event_info) + + snprintf(label, sizeof(label), "Item %i", counter++); + list_it = elm_list_item_prepend(li, label, NULL, NULL, NULL, NULL); ++ elm_list_go(li); + if (!list_it) + printf("Error adding item\n"); + } +@@ -43,6 +44,7 @@ _add_cb(void *data, Evas_Object *obj, void *event_info) + + snprintf(label, sizeof(label), "Item %i", counter++); + list_it = elm_list_item_append(li, label, NULL, NULL, NULL, NULL); ++ elm_list_go(li); + if (!list_it) + printf("Error adding item\n"); + } +@@ -60,6 +62,7 @@ _add_ic_cb(void *data, Evas_Object *obj, void *event_info) + elm_image_resizable_set(ic, EINA_FALSE, EINA_FALSE); + + list_it = elm_list_item_append(li, label, ic, NULL, NULL, NULL); ++ elm_list_go(li); + if (!list_it) + printf("Error adding item with icon\n"); + } +@@ -80,6 +83,7 @@ _add_func_cb(void *data, Evas_Object *obj, void *event_info) + + snprintf(label, sizeof(label), "Item %i", counter++); + list_it = elm_list_item_append(li, label, NULL, NULL, _sel_cb, NULL); ++ elm_list_go(li); + if (!list_it) + printf("Error adding item\n"); + } +@@ -110,6 +114,7 @@ _add_data_cb(void *data, Evas_Object *obj, void *event_info) + snprintf(content, 32, "Item content %i", counter); + snprintf(label, sizeof(label), "Item %i", counter++); + list_it = elm_list_item_append(li, label, NULL, NULL, _sel_data_cb, content); ++ elm_list_go(li); + if (!list_it) { + printf("Error adding item\n"); + return; +@@ -125,6 +130,7 @@ _del_cb(void *data, Evas_Object *obj, void *event_info) + + selected_item = elm_list_selected_item_get(li); + elm_object_item_del(selected_item); ++ elm_list_go(li); + } + + static void +@@ -183,6 +189,7 @@ _insert_after_cb(void *data, Evas_Object *obj, void *event_info) + snprintf(label, sizeof(label), "Item %i", counter++); + list_it = elm_list_item_insert_after(li, selected_item, label, NULL, NULL, + NULL, NULL); ++ elm_list_go(li); + if (!list_it) + printf("Error adding item\n"); + } +@@ -214,6 +221,7 @@ _insert_before_cb(void *data, Evas_Object *obj, void *event_info) + snprintf(label, sizeof(label), "Item %i", counter++); + list_it = elm_list_item_insert_before(li, selected_item, label, NULL, NULL, + NULL, NULL); ++ elm_list_go(li); + if (!list_it) + printf("Error adding item\n"); + } +@@ -227,6 +235,7 @@ _set_separator_cb(void *data, Evas_Object *obj, void *event_info) + selected_item = elm_list_selected_item_get(li); + if (!selected_item) return; + elm_list_item_separator_set(selected_item, EINA_TRUE); ++ elm_list_go(li); + } + + static void +-- +1.8.1.4 + diff --git a/meta-wrt-tizen/recipes-efl/efl/files_elementary/0032-elementary-examples-Fix-theme-path-search-for-tizen.patch b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0032-elementary-examples-Fix-theme-path-search-for-tizen.patch new file mode 100644 index 0000000..5a6ad18 --- /dev/null +++ b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0032-elementary-examples-Fix-theme-path-search-for-tizen.patch @@ -0,0 +1,34 @@ +From 674e7687afea0cedde476511ed6c0aa2d4226461 Mon Sep 17 00:00:00 2001 +From: Rafael Antognolli +Date: Sat, 24 Aug 2013 19:17:05 -0300 +Subject: [PATCH 32/33] elementary/examples: Fix theme path search for tizen. + +--- + src/examples/layout_example_01.c | 4 ++-- + 1 file changed, 2 insertions(+), 2 deletions(-) + +diff --git a/src/examples/layout_example_01.c b/src/examples/layout_example_01.c +index b9ebe1a..31cef47 100644 +--- a/src/examples/layout_example_01.c ++++ b/src/examples/layout_example_01.c +@@ -57,7 +57,7 @@ elm_main(int argc, char **argv) + Evas_Object *item; + char buf[PATH_MAX]; + +- elm_app_info_set(elm_main, "elementary", "examples/layout_example.edj"); ++ elm_app_info_set(elm_main, "elementary", "config/profile.cfg"); + win = elm_win_add(NULL, "layout", ELM_WIN_BASIC); + elm_policy_set(ELM_POLICY_QUIT, ELM_POLICY_QUIT_LAST_WINDOW_CLOSED); + elm_win_autodel_set(win, EINA_TRUE); +@@ -72,7 +72,7 @@ elm_main(int argc, char **argv) + layout = elm_layout_add(win); + evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + elm_win_resize_object_add(win, layout); +- snprintf(buf, sizeof(buf), "%s/examples/layout_example.edj", elm_app_data_dir_get()); ++ snprintf(buf, sizeof(buf), "%s/elementary/examples/layout_example.edj", elm_app_lib_dir_get()); + elm_layout_file_set(layout, buf, "example/mylayout"); + evas_object_show(layout); + +-- +1.8.1.4 + diff --git a/meta-wrt-tizen/recipes-efl/efl/files_elementary/0033-elm-index-Fix-example-must-call-elm_index_level_go.patch b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0033-elm-index-Fix-example-must-call-elm_index_level_go.patch new file mode 100644 index 0000000..a59c0ce --- /dev/null +++ b/meta-wrt-tizen/recipes-efl/efl/files_elementary/0033-elm-index-Fix-example-must-call-elm_index_level_go.patch @@ -0,0 +1,24 @@ +From 92a706afa980e14cefca0fca3ec068757d6e8236 Mon Sep 17 00:00:00 2001 +From: Rafael Antognolli +Date: Tue, 27 Aug 2013 18:04:53 -0300 +Subject: [PATCH 33/33] elm/index: Fix example, must call elm_index_level_go(). + +--- + src/examples/index_example_01.c | 1 + + 1 file changed, 1 insertion(+) + +diff --git a/src/examples/index_example_01.c b/src/examples/index_example_01.c +index fefdb5c..6572316 100644 +--- a/src/examples/index_example_01.c ++++ b/src/examples/index_example_01.c +@@ -166,6 +166,7 @@ elm_main(int argc, + evas_object_smart_callback_add(d.index, "delay,changed", _index_changed, + NULL); + evas_object_smart_callback_add(d.index, "selected", _index_selected, NULL); ++ elm_index_level_go(d.index, 0); + + /* attribute setting knobs */ + sep = elm_separator_add(win); +-- +1.8.1.4 + -- 2.7.4