diff --git a/src/Makefile_Elementary.am b/src/Makefile_Elementary.am index ec34d3eda7..69e65aded5 100644 --- a/src/Makefile_Elementary.am +++ b/src/Makefile_Elementary.am @@ -211,7 +211,6 @@ elm_legacy_eolian_files = \ lib/elementary/elm_sys_notify.eo \ lib/elementary/elm_sys_notify_dbus.eo \ lib/elementary/elm_systray.eo \ - lib/elementary/elm_flipselector_item.eo \ lib/elementary/elm_menu_item.eo \ lib/elementary/elm_index_item.eo \ lib/elementary/elm_widget_item_static_focus.eo \ @@ -236,7 +235,6 @@ elm_legacy_eolian_files = \ lib/elementary/elm_actionslider_part.eo \ lib/elementary/elm_bubble_part.eo \ lib/elementary/elm_fileselector_part.eo \ - lib/elementary/elm_flipselector.eo \ lib/elementary/elm_grid.eo \ lib/elementary/elm_icon.eo \ lib/elementary/elm_inwin.eo \ @@ -347,6 +345,10 @@ lib/elementary/elm_fileselector_button_eo.c \ lib/elementary/elm_fileselector_entry_eo.c \ lib/elementary/elm_fileselector_eo.legacy.c \ lib/elementary/elm_fileselector_eo.c \ +lib/elementary/elm_flipselector_eo.legacy.c \ +lib/elementary/elm_flipselector_eo.c \ +lib/elementary/elm_flipselector_item_eo.legacy.c \ +lib/elementary/elm_flipselector_item_eo.c \ lib/elementary/elm_hoversel_eo.c \ lib/elementary/elm_hoversel_item_eo.c \ lib/elementary/elm_hoversel_item_eo.legacy.c @@ -438,6 +440,10 @@ lib/elementary/elm_fileselector_entry_eo.h \ lib/elementary/elm_fileselector_entry_eo.legacy.h \ lib/elementary/elm_fileselector_eo.h \ lib/elementary/elm_fileselector_eo.legacy.h \ +lib/elementary/elm_flipselector_eo.h \ +lib/elementary/elm_flipselector_eo.legacy.h \ +lib/elementary/elm_flipselector_item_eo.h \ +lib/elementary/elm_flipselector_item_eo.legacy.h \ lib/elementary/elm_hoversel_eo.h \ lib/elementary/elm_hoversel_eo.legacy.h \ lib/elementary/elm_hoversel_item_eo.h \ diff --git a/src/lib/elementary/elm_flipselector.c b/src/lib/elementary/elm_flipselector.c index 86f66e03d0..98535b4acd 100644 --- a/src/lib/elementary/elm_flipselector.c +++ b/src/lib/elementary/elm_flipselector.c @@ -10,8 +10,8 @@ #include "elm_priv.h" #include "elm_widget_flipselector.h" -#include "elm_flipselector.eo.h" -#include "elm_flipselector_item.eo.h" +#include "elm_flipselector_eo.h" +#include "elm_flipselector_item_eo.h" #define MY_CLASS ELM_FLIPSELECTOR_CLASS @@ -903,5 +903,5 @@ ELM_WIDGET_KEY_DOWN_DEFAULT_IMPLEMENT(elm_flipselector, Elm_Flipselector_Data) ELM_LAYOUT_SIZING_EVAL_OPS(elm_flipselector), \ EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_flipselector) -#include "elm_flipselector_item.eo.c" -#include "elm_flipselector.eo.c" +#include "elm_flipselector_item_eo.c" +#include "elm_flipselector_eo.c" diff --git a/src/lib/elementary/elm_flipselector.eo b/src/lib/elementary/elm_flipselector.eo deleted file mode 100644 index e5171f7e50..0000000000 --- a/src/lib/elementary/elm_flipselector.eo +++ /dev/null @@ -1,175 +0,0 @@ -class Elm.Flipselector extends Efl.Ui.Layout_Base implements Efl.Ui.Range_Interactive, - Efl.Access.Widget.Action, - Efl.Ui.Selectable, Efl.Ui.Legacy -{ - [[Elementary flipselector class]] - legacy_prefix: elm_flipselector; - eo_prefix: elm_obj_flipselector; - event_prefix: elm_flipselector; - methods { - @property items { - get { - [[Get the internal list of items in a given flip selector widget. - - This list is not to be modified in any way and must not be - freed. Use the list members with functions like - \@ref elm_object_item_text_set, - \@ref elm_object_item_text_get, - \@ref elm_object_item_del, - \@ref elm_flipselector_item_selected_get, - \@ref elm_flipselector_item_selected_set. - - Warning: This list is only valid until $obj object's internal - items list is changed. It should be fetched again with another - call to this function when changes happen. - ]] - return: const(list); [[List of items]] - } - } - @property first_item { - get { - [[Get the first item in the given flip selector widget's list of - items. - - See also @.item_append, - @.last_item.get. - ]] - return: Elm.Widget.Item; [[The first item or $null, if it has no items (and on - errors).]] - - } - } - @property last_item { - get { - [[Get the last item in the given flip selector widget's list of - items. - - See also @.item_prepend, - @.first_item.get. - ]] - return: Elm.Widget.Item; [[The last item or $null, if it has no items (and on - errors).]] - - } - } - @property selected_item { - get { - [[Get the currently selected item in a flip selector widget.]] - return: Elm.Widget.Item; [[The selected item or $null, if the widget has no items - (and on errors).]] - - } - } - @property first_interval { - set { - [[Set the interval on time updates for a user mouse button hold - on a flip selector widget. - - This interval value is decreased while the user holds the - mouse pointer either flipping up or flipping down a given flip - selector. - - This helps the user to get to a given item distant from the - current one easier/faster, as it will start to flip quicker and - quicker on mouse button holds. - - The calculation for the next flip interval value, starting from - the one set with this call, is the previous interval divided by - 1.05, so it decreases a little bit. - - The default starting interval value for automatic flips is - 0.85 seconds. - - See also @.first_interval.get. - ]] - } - get { - [[Get the interval on time updates for an user mouse button hold - on a flip selector widget. - - See also @.first_interval.set for more details. - ]] - } - values { - interval: double; [[The (first) interval value in seconds.]] - } - } - item_prepend { - [[Prepend a (text) item to a flip selector widget - - The widget's list of labels to show will be prepended with the - given value. If the user wishes so, a callback function pointer - can be passed, which will get called when this same item is - selected. - - Note: The current selection won't be modified by prepending - an element to the list. - - Note: The maximum length of the text label is going to be - determined by the widget's theme. Strings larger than - that value are going to be truncated. - ]] - return: Elm.Widget.Item; [[New widget item]] - params { - @in label: string; [[The (text) label of the new item.]] - @in func: Evas_Smart_Cb @optional; [[Convenience callback function to take place when - item is selected.]] - @in data: void_ptr @optional; [[Data passed to $func, above.]] - } - } - flip_next { - [[Programmatically select the next item of a flip selector widget - - Note: The selection will be animated. Also, if it reaches the - end of its list of member items, it will continue with the first - one onwards. - ]] - } - item_append { - [[Append a (text) item to a flip selector widget - - The widget's list of labels to show will be appended with the - given value. If the user wishes so, a callback function pointer - can be passed, which will get called when this same item is - selected. - - Note: The current selection won't be modified by appending an - element to the list. - - Note: The maximum length of the text label is going to be - determined by the widget's theme. Strings larger than - that value are going to be truncated. - ]] - return: Elm.Widget.Item; [[New widget item]] - params { - @in label: string; [[The (text) label of the new item.]] - @in func: Evas_Smart_Cb @optional; [[Convenience callback function to take place when - item is selected.]] - @in data: const(void_ptr) @optional; [[Data passed to $func, above.]] - } - } - flip_prev { - [[Programmatically select the previous item of a flip selector - widget - - Note: The selection will be animated. Also, if it reaches the - beginning of its list of member items, it will continue with the - last one backwards. - ]] - } - } - implements { - class.constructor; - Efl.Object.constructor; - Efl.Ui.Widget.theme_apply; - Efl.Ui.Widget.widget_input_event_handler; - Efl.Ui.Range_Display.range_min_max { get; set; } - Efl.Ui.Range_Interactive.range_step { get; set; } - Efl.Ui.Range_Display.range_value { get; set; } - Efl.Access.Widget.Action.elm_actions { get; } - } - events { - underflowed: void; [[Called when flipselector is underflowed]] - overflowed: void; [[Called when flipselector is overflowed]] - } -} diff --git a/src/lib/elementary/elm_flipselector_eo.c b/src/lib/elementary/elm_flipselector_eo.c new file mode 100644 index 0000000000..083cc58e4e --- /dev/null +++ b/src/lib/elementary/elm_flipselector_eo.c @@ -0,0 +1,159 @@ +EWAPI const Efl_Event_Description _ELM_FLIPSELECTOR_EVENT_UNDERFLOWED = + EFL_EVENT_DESCRIPTION("underflowed"); +EWAPI const Efl_Event_Description _ELM_FLIPSELECTOR_EVENT_OVERFLOWED = + EFL_EVENT_DESCRIPTION("overflowed"); + +const Eina_List *_elm_flipselector_items_get(const Eo *obj, Elm_Flipselector_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_flipselector_items_get, const Eina_List *, NULL); + +Elm_Widget_Item *_elm_flipselector_first_item_get(const Eo *obj, Elm_Flipselector_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_flipselector_first_item_get, Elm_Widget_Item *, NULL); + +Elm_Widget_Item *_elm_flipselector_last_item_get(const Eo *obj, Elm_Flipselector_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_flipselector_last_item_get, Elm_Widget_Item *, NULL); + +Elm_Widget_Item *_elm_flipselector_selected_item_get(const Eo *obj, Elm_Flipselector_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_flipselector_selected_item_get, Elm_Widget_Item *, NULL); + +void _elm_flipselector_first_interval_set(Eo *obj, Elm_Flipselector_Data *pd, double interval); + + +static Eina_Error +__eolian_elm_flipselector_first_interval_set_reflect(Eo *obj, Eina_Value val) +{ + Eina_Error r = 0; double cval; + if (!eina_value_double_convert(&val, &cval)) + { + r = EINA_ERROR_VALUE_FAILED; + goto end; + } + elm_obj_flipselector_first_interval_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_flipselector_first_interval_set, EFL_FUNC_CALL(interval), double interval); + +double _elm_flipselector_first_interval_get(const Eo *obj, Elm_Flipselector_Data *pd); + + +static Eina_Value +__eolian_elm_flipselector_first_interval_get_reflect(Eo *obj) +{ + double val = elm_obj_flipselector_first_interval_get(obj); + return eina_value_double_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_flipselector_first_interval_get, double, 0); + +Elm_Widget_Item *_elm_flipselector_item_prepend(Eo *obj, Elm_Flipselector_Data *pd, const char *label, Evas_Smart_Cb func, void *data); + +EOAPI EFL_FUNC_BODYV(elm_obj_flipselector_item_prepend, Elm_Widget_Item *, NULL, EFL_FUNC_CALL(label, func, data), const char *label, Evas_Smart_Cb func, void *data); + +void _elm_flipselector_flip_next(Eo *obj, Elm_Flipselector_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_flipselector_flip_next); + +Elm_Widget_Item *_elm_flipselector_item_append(Eo *obj, Elm_Flipselector_Data *pd, const char *label, Evas_Smart_Cb func, const void *data); + +EOAPI EFL_FUNC_BODYV(elm_obj_flipselector_item_append, Elm_Widget_Item *, NULL, EFL_FUNC_CALL(label, func, data), const char *label, Evas_Smart_Cb func, const void *data); + +void _elm_flipselector_flip_prev(Eo *obj, Elm_Flipselector_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_flipselector_flip_prev); + +Efl_Object *_elm_flipselector_efl_object_constructor(Eo *obj, Elm_Flipselector_Data *pd); + + +Eina_Error _elm_flipselector_efl_ui_widget_theme_apply(Eo *obj, Elm_Flipselector_Data *pd); + + +Eina_Bool _elm_flipselector_efl_ui_widget_widget_input_event_handler(Eo *obj, Elm_Flipselector_Data *pd, const Efl_Event *eo_event, Efl_Canvas_Object *source); + + +void _elm_flipselector_efl_ui_range_display_range_min_max_set(Eo *obj, Elm_Flipselector_Data *pd, double min, double max); + + +void _elm_flipselector_efl_ui_range_display_range_min_max_get(const Eo *obj, Elm_Flipselector_Data *pd, double *min, double *max); + + +void _elm_flipselector_efl_ui_range_interactive_range_step_set(Eo *obj, Elm_Flipselector_Data *pd, double step); + + +double _elm_flipselector_efl_ui_range_interactive_range_step_get(const Eo *obj, Elm_Flipselector_Data *pd); + + +void _elm_flipselector_efl_ui_range_display_range_value_set(Eo *obj, Elm_Flipselector_Data *pd, double val); + + +double _elm_flipselector_efl_ui_range_display_range_value_get(const Eo *obj, Elm_Flipselector_Data *pd); + + +const Efl_Access_Action_Data *_elm_flipselector_efl_access_widget_action_elm_actions_get(const Eo *obj, Elm_Flipselector_Data *pd); + + +static Eina_Bool +_elm_flipselector_class_initializer(Efl_Class *klass) +{ + const Efl_Object_Ops *opsp = NULL; + + const Efl_Object_Property_Reflection_Ops *ropsp = NULL; + +#ifndef ELM_FLIPSELECTOR_EXTRA_OPS +#define ELM_FLIPSELECTOR_EXTRA_OPS +#endif + + EFL_OPS_DEFINE(ops, + EFL_OBJECT_OP_FUNC(elm_obj_flipselector_items_get, _elm_flipselector_items_get), + EFL_OBJECT_OP_FUNC(elm_obj_flipselector_first_item_get, _elm_flipselector_first_item_get), + EFL_OBJECT_OP_FUNC(elm_obj_flipselector_last_item_get, _elm_flipselector_last_item_get), + EFL_OBJECT_OP_FUNC(elm_obj_flipselector_selected_item_get, _elm_flipselector_selected_item_get), + EFL_OBJECT_OP_FUNC(elm_obj_flipselector_first_interval_set, _elm_flipselector_first_interval_set), + EFL_OBJECT_OP_FUNC(elm_obj_flipselector_first_interval_get, _elm_flipselector_first_interval_get), + EFL_OBJECT_OP_FUNC(elm_obj_flipselector_item_prepend, _elm_flipselector_item_prepend), + EFL_OBJECT_OP_FUNC(elm_obj_flipselector_flip_next, _elm_flipselector_flip_next), + EFL_OBJECT_OP_FUNC(elm_obj_flipselector_item_append, _elm_flipselector_item_append), + EFL_OBJECT_OP_FUNC(elm_obj_flipselector_flip_prev, _elm_flipselector_flip_prev), + EFL_OBJECT_OP_FUNC(efl_constructor, _elm_flipselector_efl_object_constructor), + EFL_OBJECT_OP_FUNC(efl_ui_widget_theme_apply, _elm_flipselector_efl_ui_widget_theme_apply), + EFL_OBJECT_OP_FUNC(efl_ui_widget_input_event_handler, _elm_flipselector_efl_ui_widget_widget_input_event_handler), + EFL_OBJECT_OP_FUNC(efl_ui_range_min_max_set, _elm_flipselector_efl_ui_range_display_range_min_max_set), + EFL_OBJECT_OP_FUNC(efl_ui_range_min_max_get, _elm_flipselector_efl_ui_range_display_range_min_max_get), + EFL_OBJECT_OP_FUNC(efl_ui_range_step_set, _elm_flipselector_efl_ui_range_interactive_range_step_set), + EFL_OBJECT_OP_FUNC(efl_ui_range_step_get, _elm_flipselector_efl_ui_range_interactive_range_step_get), + EFL_OBJECT_OP_FUNC(efl_ui_range_value_set, _elm_flipselector_efl_ui_range_display_range_value_set), + EFL_OBJECT_OP_FUNC(efl_ui_range_value_get, _elm_flipselector_efl_ui_range_display_range_value_get), + EFL_OBJECT_OP_FUNC(efl_access_widget_action_elm_actions_get, _elm_flipselector_efl_access_widget_action_elm_actions_get), + ELM_FLIPSELECTOR_EXTRA_OPS + ); + opsp = &ops; + + static const Efl_Object_Property_Reflection refl_table[] = { + {"first_interval", __eolian_elm_flipselector_first_interval_set_reflect, __eolian_elm_flipselector_first_interval_get_reflect}, + }; + static const Efl_Object_Property_Reflection_Ops rops = { + refl_table, EINA_C_ARRAY_LENGTH(refl_table) + }; + ropsp = &rops; + + return efl_class_functions_set(klass, opsp, ropsp); +} + +static const Efl_Class_Description _elm_flipselector_class_desc = { + EO_VERSION, + "Elm.Flipselector", + EFL_CLASS_TYPE_REGULAR, + sizeof(Elm_Flipselector_Data), + _elm_flipselector_class_initializer, + _elm_flipselector_class_constructor, + NULL +}; + +EFL_DEFINE_CLASS(elm_flipselector_class_get, &_elm_flipselector_class_desc, EFL_UI_LAYOUT_BASE_CLASS, EFL_UI_RANGE_INTERACTIVE_INTERFACE, EFL_ACCESS_WIDGET_ACTION_MIXIN, EFL_UI_SELECTABLE_INTERFACE, EFL_UI_LEGACY_INTERFACE, NULL); + +#include "elm_flipselector_eo.legacy.c" diff --git a/src/lib/elementary/elm_flipselector_eo.h b/src/lib/elementary/elm_flipselector_eo.h new file mode 100644 index 0000000000..59b3c483e3 --- /dev/null +++ b/src/lib/elementary/elm_flipselector_eo.h @@ -0,0 +1,212 @@ +#ifndef _ELM_FLIPSELECTOR_EO_H_ +#define _ELM_FLIPSELECTOR_EO_H_ + +#ifndef _ELM_FLIPSELECTOR_EO_CLASS_TYPE +#define _ELM_FLIPSELECTOR_EO_CLASS_TYPE + +typedef Eo Elm_Flipselector; + +#endif + +#ifndef _ELM_FLIPSELECTOR_EO_TYPES +#define _ELM_FLIPSELECTOR_EO_TYPES + + +#endif +/** Elementary flipselector class + * + * @ingroup Elm_Flipselector + */ +#define ELM_FLIPSELECTOR_CLASS elm_flipselector_class_get() + +EWAPI const Efl_Class *elm_flipselector_class_get(void); + +/** + * @brief Get the internal list of items in a given flip selector widget. + * + * This list is not to be modified in any way and must not be freed. Use the + * list members with functions like @ref elm_object_item_text_set, @ref + * elm_object_item_text_get, @ref elm_object_item_del, @ref + * elm_flipselector_item_selected_get, @ref elm_flipselector_item_selected_set. + * + * @warning This list is only valid until @c obj object's internal items list + * is changed. It should be fetched again with another call to this function + * when changes happen. + * + * @param[in] obj The object. + * + * @return List of items + * + * @ingroup Elm_Flipselector + */ +EOAPI const Eina_List *elm_obj_flipselector_items_get(const Eo *obj); + +/** + * @brief Get the first item in the given flip selector widget's list of items. + * + * See also @ref elm_obj_flipselector_item_append, + * @ref elm_obj_flipselector_last_item_get. + * + * @param[in] obj The object. + * + * @return The first item or @c null, if it has no items (and on errors). + * + * @ingroup Elm_Flipselector + */ +EOAPI Elm_Widget_Item *elm_obj_flipselector_first_item_get(const Eo *obj); + +/** + * @brief Get the last item in the given flip selector widget's list of items. + * + * See also @ref elm_obj_flipselector_item_prepend, + * @ref elm_obj_flipselector_first_item_get. + * + * @param[in] obj The object. + * + * @return The last item or @c null, if it has no items (and on errors). + * + * @ingroup Elm_Flipselector + */ +EOAPI Elm_Widget_Item *elm_obj_flipselector_last_item_get(const Eo *obj); + +/** + * @brief Get the currently selected item in a flip selector widget. + * + * @param[in] obj The object. + * + * @return The selected item or @c null, if the widget has no items (and on + * errors). + * + * @ingroup Elm_Flipselector + */ +EOAPI Elm_Widget_Item *elm_obj_flipselector_selected_item_get(const Eo *obj); + +/** + * @brief Set the interval on time updates for a user mouse button hold on a + * flip selector widget. + * + * This interval value is decreased while the user holds the mouse pointer + * either flipping up or flipping down a given flip selector. + * + * This helps the user to get to a given item distant from the current one + * easier/faster, as it will start to flip quicker and quicker on mouse button + * holds. + * + * The calculation for the next flip interval value, starting from the one set + * with this call, is the previous interval divided by 1.05, so it decreases a + * little bit. + * + * The default starting interval value for automatic flips is 0.85 seconds. + * + * See also @ref elm_obj_flipselector_first_interval_get. + * + * @param[in] obj The object. + * @param[in] interval The (first) interval value in seconds. + * + * @ingroup Elm_Flipselector + */ +EOAPI void elm_obj_flipselector_first_interval_set(Eo *obj, double interval); + +/** + * @brief Get the interval on time updates for an user mouse button hold on a + * flip selector widget. + * + * See also @ref elm_obj_flipselector_first_interval_set for more details. + * + * @param[in] obj The object. + * + * @return The (first) interval value in seconds. + * + * @ingroup Elm_Flipselector + */ +EOAPI double elm_obj_flipselector_first_interval_get(const Eo *obj); + +/** + * @brief Prepend a (text) item to a flip selector widget + * + * The widget's list of labels to show will be prepended with the given value. + * If the user wishes so, a callback function pointer can be passed, which will + * get called when this same item is selected. + * + * @note The current selection won't be modified by prepending an element to + * the list. + * + * @note The maximum length of the text label is going to be determined by the + * widget's theme. Strings larger than that value are going to be truncated. + * + * @param[in] obj The object. + * @param[in] label The (text) label of the new item. + * @param[in] func Convenience callback function to take place when item is + * selected. + * @param[in] data Data passed to @c func, above. + * + * @return New widget item + * + * @ingroup Elm_Flipselector + */ +EOAPI Elm_Widget_Item *elm_obj_flipselector_item_prepend(Eo *obj, const char *label, Evas_Smart_Cb func, void *data); + +/** + * @brief Programmatically select the next item of a flip selector widget + * + * @note The selection will be animated. Also, if it reaches the end of its + * list of member items, it will continue with the first one onwards. + * @param[in] obj The object. + * + * @ingroup Elm_Flipselector + */ +EOAPI void elm_obj_flipselector_flip_next(Eo *obj); + +/** + * @brief Append a (text) item to a flip selector widget + * + * The widget's list of labels to show will be appended with the given value. + * If the user wishes so, a callback function pointer can be passed, which will + * get called when this same item is selected. + * + * @note The current selection won't be modified by appending an element to the + * list. + * + * @note The maximum length of the text label is going to be determined by the + * widget's theme. Strings larger than that value are going to be truncated. + * + * @param[in] obj The object. + * @param[in] label The (text) label of the new item. + * @param[in] func Convenience callback function to take place when item is + * selected. + * @param[in] data Data passed to @c func, above. + * + * @return New widget item + * + * @ingroup Elm_Flipselector + */ +EOAPI Elm_Widget_Item *elm_obj_flipselector_item_append(Eo *obj, const char *label, Evas_Smart_Cb func, const void *data); + +/** + * @brief Programmatically select the previous item of a flip selector widget + * + * @note The selection will be animated. Also, if it reaches the beginning of + * its list of member items, it will continue with the last one backwards. + * @param[in] obj The object. + * + * @ingroup Elm_Flipselector + */ +EOAPI void elm_obj_flipselector_flip_prev(Eo *obj); + +EWAPI extern const Efl_Event_Description _ELM_FLIPSELECTOR_EVENT_UNDERFLOWED; + +/** Called when flipselector is underflowed + * + * @ingroup Elm_Flipselector + */ +#define ELM_FLIPSELECTOR_EVENT_UNDERFLOWED (&(_ELM_FLIPSELECTOR_EVENT_UNDERFLOWED)) + +EWAPI extern const Efl_Event_Description _ELM_FLIPSELECTOR_EVENT_OVERFLOWED; + +/** Called when flipselector is overflowed + * + * @ingroup Elm_Flipselector + */ +#define ELM_FLIPSELECTOR_EVENT_OVERFLOWED (&(_ELM_FLIPSELECTOR_EVENT_OVERFLOWED)) + +#endif diff --git a/src/lib/elementary/elm_flipselector_eo.legacy.c b/src/lib/elementary/elm_flipselector_eo.legacy.c new file mode 100644 index 0000000000..26bdc3a228 --- /dev/null +++ b/src/lib/elementary/elm_flipselector_eo.legacy.c @@ -0,0 +1,60 @@ + +EAPI const Eina_List * +elm_flipselector_items_get(const Elm_Flipselector *obj) +{ + return elm_obj_flipselector_items_get(obj); +} + +EAPI Elm_Widget_Item * +elm_flipselector_first_item_get(const Elm_Flipselector *obj) +{ + return elm_obj_flipselector_first_item_get(obj); +} + +EAPI Elm_Widget_Item * +elm_flipselector_last_item_get(const Elm_Flipselector *obj) +{ + return elm_obj_flipselector_last_item_get(obj); +} + +EAPI Elm_Widget_Item * +elm_flipselector_selected_item_get(const Elm_Flipselector *obj) +{ + return elm_obj_flipselector_selected_item_get(obj); +} + +EAPI void +elm_flipselector_first_interval_set(Elm_Flipselector *obj, double interval) +{ + elm_obj_flipselector_first_interval_set(obj, interval); +} + +EAPI double +elm_flipselector_first_interval_get(const Elm_Flipselector *obj) +{ + return elm_obj_flipselector_first_interval_get(obj); +} + +EAPI Elm_Widget_Item * +elm_flipselector_item_prepend(Elm_Flipselector *obj, const char *label, Evas_Smart_Cb func, void *data) +{ + return elm_obj_flipselector_item_prepend(obj, label, func, data); +} + +EAPI void +elm_flipselector_flip_next(Elm_Flipselector *obj) +{ + elm_obj_flipselector_flip_next(obj); +} + +EAPI Elm_Widget_Item * +elm_flipselector_item_append(Elm_Flipselector *obj, const char *label, Evas_Smart_Cb func, const void *data) +{ + return elm_obj_flipselector_item_append(obj, label, func, data); +} + +EAPI void +elm_flipselector_flip_prev(Elm_Flipselector *obj) +{ + elm_obj_flipselector_flip_prev(obj); +} diff --git a/src/lib/elementary/elm_flipselector_eo.legacy.h b/src/lib/elementary/elm_flipselector_eo.legacy.h new file mode 100644 index 0000000000..707d7a3d5e --- /dev/null +++ b/src/lib/elementary/elm_flipselector_eo.legacy.h @@ -0,0 +1,189 @@ +#ifndef _ELM_FLIPSELECTOR_EO_LEGACY_H_ +#define _ELM_FLIPSELECTOR_EO_LEGACY_H_ + +#ifndef _ELM_FLIPSELECTOR_EO_CLASS_TYPE +#define _ELM_FLIPSELECTOR_EO_CLASS_TYPE + +typedef Eo Elm_Flipselector; + +#endif + +#ifndef _ELM_FLIPSELECTOR_EO_TYPES +#define _ELM_FLIPSELECTOR_EO_TYPES + + +#endif + +/** + * @brief Get the internal list of items in a given flip selector widget. + * + * This list is not to be modified in any way and must not be freed. Use the + * list members with functions like @ref elm_object_item_text_set, @ref + * elm_object_item_text_get, @ref elm_object_item_del, @ref + * elm_flipselector_item_selected_get, @ref elm_flipselector_item_selected_set. + * + * @warning This list is only valid until @c obj object's internal items list + * is changed. It should be fetched again with another call to this function + * when changes happen. + * + * @param[in] obj The object. + * + * @return List of items + * + * @ingroup Elm_Flipselector_Group + */ +EAPI const Eina_List *elm_flipselector_items_get(const Elm_Flipselector *obj); + +/** + * @brief Get the first item in the given flip selector widget's list of items. + * + * See also @ref elm_flipselector_item_append, + * @ref elm_flipselector_last_item_get. + * + * @param[in] obj The object. + * + * @return The first item or @c null, if it has no items (and on errors). + * + * @ingroup Elm_Flipselector_Group + */ +EAPI Elm_Widget_Item *elm_flipselector_first_item_get(const Elm_Flipselector *obj); + +/** + * @brief Get the last item in the given flip selector widget's list of items. + * + * See also @ref elm_flipselector_item_prepend, + * @ref elm_flipselector_first_item_get. + * + * @param[in] obj The object. + * + * @return The last item or @c null, if it has no items (and on errors). + * + * @ingroup Elm_Flipselector_Group + */ +EAPI Elm_Widget_Item *elm_flipselector_last_item_get(const Elm_Flipselector *obj); + +/** + * @brief Get the currently selected item in a flip selector widget. + * + * @param[in] obj The object. + * + * @return The selected item or @c null, if the widget has no items (and on + * errors). + * + * @ingroup Elm_Flipselector_Group + */ +EAPI Elm_Widget_Item *elm_flipselector_selected_item_get(const Elm_Flipselector *obj); + +/** + * @brief Set the interval on time updates for a user mouse button hold on a + * flip selector widget. + * + * This interval value is decreased while the user holds the mouse pointer + * either flipping up or flipping down a given flip selector. + * + * This helps the user to get to a given item distant from the current one + * easier/faster, as it will start to flip quicker and quicker on mouse button + * holds. + * + * The calculation for the next flip interval value, starting from the one set + * with this call, is the previous interval divided by 1.05, so it decreases a + * little bit. + * + * The default starting interval value for automatic flips is 0.85 seconds. + * + * See also @ref elm_flipselector_first_interval_get. + * + * @param[in] obj The object. + * @param[in] interval The (first) interval value in seconds. + * + * @ingroup Elm_Flipselector_Group + */ +EAPI void elm_flipselector_first_interval_set(Elm_Flipselector *obj, double interval); + +/** + * @brief Get the interval on time updates for an user mouse button hold on a + * flip selector widget. + * + * See also @ref elm_flipselector_first_interval_set for more details. + * + * @param[in] obj The object. + * + * @return The (first) interval value in seconds. + * + * @ingroup Elm_Flipselector_Group + */ +EAPI double elm_flipselector_first_interval_get(const Elm_Flipselector *obj); + +/** + * @brief Prepend a (text) item to a flip selector widget + * + * The widget's list of labels to show will be prepended with the given value. + * If the user wishes so, a callback function pointer can be passed, which will + * get called when this same item is selected. + * + * @note The current selection won't be modified by prepending an element to + * the list. + * + * @note The maximum length of the text label is going to be determined by the + * widget's theme. Strings larger than that value are going to be truncated. + * + * @param[in] obj The object. + * @param[in] label The (text) label of the new item. + * @param[in] func Convenience callback function to take place when item is + * selected. + * @param[in] data Data passed to @c func, above. + * + * @return New widget item + * + * @ingroup Elm_Flipselector_Group + */ +EAPI Elm_Widget_Item *elm_flipselector_item_prepend(Elm_Flipselector *obj, const char *label, Evas_Smart_Cb func, void *data); + +/** + * @brief Programmatically select the next item of a flip selector widget + * + * @note The selection will be animated. Also, if it reaches the end of its + * list of member items, it will continue with the first one onwards. + * @param[in] obj The object. + * + * @ingroup Elm_Flipselector_Group + */ +EAPI void elm_flipselector_flip_next(Elm_Flipselector *obj); + +/** + * @brief Append a (text) item to a flip selector widget + * + * The widget's list of labels to show will be appended with the given value. + * If the user wishes so, a callback function pointer can be passed, which will + * get called when this same item is selected. + * + * @note The current selection won't be modified by appending an element to the + * list. + * + * @note The maximum length of the text label is going to be determined by the + * widget's theme. Strings larger than that value are going to be truncated. + * + * @param[in] obj The object. + * @param[in] label The (text) label of the new item. + * @param[in] func Convenience callback function to take place when item is + * selected. + * @param[in] data Data passed to @c func, above. + * + * @return New widget item + * + * @ingroup Elm_Flipselector_Group + */ +EAPI Elm_Widget_Item *elm_flipselector_item_append(Elm_Flipselector *obj, const char *label, Evas_Smart_Cb func, const void *data); + +/** + * @brief Programmatically select the previous item of a flip selector widget + * + * @note The selection will be animated. Also, if it reaches the beginning of + * its list of member items, it will continue with the last one backwards. + * @param[in] obj The object. + * + * @ingroup Elm_Flipselector_Group + */ +EAPI void elm_flipselector_flip_prev(Elm_Flipselector *obj); + +#endif diff --git a/src/lib/elementary/elm_flipselector_item.eo b/src/lib/elementary/elm_flipselector_item.eo deleted file mode 100644 index 9710ebe354..0000000000 --- a/src/lib/elementary/elm_flipselector_item.eo +++ /dev/null @@ -1,55 +0,0 @@ -class Elm.Flipselector.Item extends Elm.Widget.Item -{ - [[Elementary flipselector item class]] - legacy_prefix: elm_flipselector_item; - eo_prefix: elm_obj_flipselector_item; - methods { - @property selected { - get { - [[Get whether a given flip selector widget's item is the currently - selected one. - - See also @.selected.set. - ]] - } - set { - [[Set whether a given flip selector widget's item should be the - currently selected one. - - This sets whether $item is or not the selected (thus, under - display) one. If $item is different than the one under display, - the latter will be unselected. If the $item is set to be - unselected, on the other hand, the first item in the widget's - internal members list will be the new selected one. - - See also @.selected.get. - ]] - } - values { - selected: bool; [[$true if selected, $false otherwise.]] - } - } - prev_get @const { - [[Get the item before $item in a flip selector widget's internal list of - items. - - See also @.next_get. - ]] - return: Elm.Widget.Item; [[The item before the $item, in its parent's list. If there is no previous item for $item or there's an error, $null is returned.]] - } - next_get @const { - [[Get the item after $item in a flip selector widget's - internal list of items. - - See also @.prev_get. - ]] - return: Elm.Widget.Item; [[The item after the $item, in its parent's list. If there is no next item for $item or there's an error, $null is returned.]] - } - } - implements { - Efl.Object.constructor; - Efl.Object.destructor; - Elm.Widget.Item.signal_emit; - Elm.Widget.Item.part_text { get; set; } - } -} diff --git a/src/lib/elementary/elm_flipselector_item_eo.c b/src/lib/elementary/elm_flipselector_item_eo.c new file mode 100644 index 0000000000..a9fb16250b --- /dev/null +++ b/src/lib/elementary/elm_flipselector_item_eo.c @@ -0,0 +1,105 @@ + +void _elm_flipselector_item_selected_set(Eo *obj, Elm_Flipselector_Item_Data *pd, Eina_Bool selected); + + +static Eina_Error +__eolian_elm_flipselector_item_selected_set_reflect(Eo *obj, Eina_Value val) +{ + Eina_Error r = 0; Eina_Bool cval; + if (!eina_value_bool_convert(&val, &cval)) + { + r = EINA_ERROR_VALUE_FAILED; + goto end; + } + elm_obj_flipselector_item_selected_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_flipselector_item_selected_set, EFL_FUNC_CALL(selected), Eina_Bool selected); + +Eina_Bool _elm_flipselector_item_selected_get(const Eo *obj, Elm_Flipselector_Item_Data *pd); + + +static Eina_Value +__eolian_elm_flipselector_item_selected_get_reflect(Eo *obj) +{ + Eina_Bool val = elm_obj_flipselector_item_selected_get(obj); + return eina_value_bool_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_flipselector_item_selected_get, Eina_Bool, 0); + +Elm_Widget_Item *_elm_flipselector_item_prev_get(const Eo *obj, Elm_Flipselector_Item_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_flipselector_item_prev_get, Elm_Widget_Item *, NULL); + +Elm_Widget_Item *_elm_flipselector_item_next_get(const Eo *obj, Elm_Flipselector_Item_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_flipselector_item_next_get, Elm_Widget_Item *, NULL); + +Efl_Object *_elm_flipselector_item_efl_object_constructor(Eo *obj, Elm_Flipselector_Item_Data *pd); + + +void _elm_flipselector_item_efl_object_destructor(Eo *obj, Elm_Flipselector_Item_Data *pd); + + +void _elm_flipselector_item_elm_widget_item_signal_emit(Eo *obj, Elm_Flipselector_Item_Data *pd, const char *emission, const char *source); + + +void _elm_flipselector_item_elm_widget_item_part_text_set(Eo *obj, Elm_Flipselector_Item_Data *pd, const char *part, const char *label); + + +const char *_elm_flipselector_item_elm_widget_item_part_text_get(const Eo *obj, Elm_Flipselector_Item_Data *pd, const char *part); + + +static Eina_Bool +_elm_flipselector_item_class_initializer(Efl_Class *klass) +{ + const Efl_Object_Ops *opsp = NULL; + + const Efl_Object_Property_Reflection_Ops *ropsp = NULL; + +#ifndef ELM_FLIPSELECTOR_ITEM_EXTRA_OPS +#define ELM_FLIPSELECTOR_ITEM_EXTRA_OPS +#endif + + EFL_OPS_DEFINE(ops, + EFL_OBJECT_OP_FUNC(elm_obj_flipselector_item_selected_set, _elm_flipselector_item_selected_set), + EFL_OBJECT_OP_FUNC(elm_obj_flipselector_item_selected_get, _elm_flipselector_item_selected_get), + EFL_OBJECT_OP_FUNC(elm_obj_flipselector_item_prev_get, _elm_flipselector_item_prev_get), + EFL_OBJECT_OP_FUNC(elm_obj_flipselector_item_next_get, _elm_flipselector_item_next_get), + EFL_OBJECT_OP_FUNC(efl_constructor, _elm_flipselector_item_efl_object_constructor), + EFL_OBJECT_OP_FUNC(efl_destructor, _elm_flipselector_item_efl_object_destructor), + EFL_OBJECT_OP_FUNC(elm_wdg_item_signal_emit, _elm_flipselector_item_elm_widget_item_signal_emit), + EFL_OBJECT_OP_FUNC(elm_wdg_item_part_text_set, _elm_flipselector_item_elm_widget_item_part_text_set), + EFL_OBJECT_OP_FUNC(elm_wdg_item_part_text_get, _elm_flipselector_item_elm_widget_item_part_text_get), + ELM_FLIPSELECTOR_ITEM_EXTRA_OPS + ); + opsp = &ops; + + static const Efl_Object_Property_Reflection refl_table[] = { + {"selected", __eolian_elm_flipselector_item_selected_set_reflect, __eolian_elm_flipselector_item_selected_get_reflect}, + }; + static const Efl_Object_Property_Reflection_Ops rops = { + refl_table, EINA_C_ARRAY_LENGTH(refl_table) + }; + ropsp = &rops; + + return efl_class_functions_set(klass, opsp, ropsp); +} + +static const Efl_Class_Description _elm_flipselector_item_class_desc = { + EO_VERSION, + "Elm.Flipselector.Item", + EFL_CLASS_TYPE_REGULAR, + sizeof(Elm_Flipselector_Item_Data), + _elm_flipselector_item_class_initializer, + NULL, + NULL +}; + +EFL_DEFINE_CLASS(elm_flipselector_item_class_get, &_elm_flipselector_item_class_desc, ELM_WIDGET_ITEM_CLASS, NULL); + +#include "elm_flipselector_item_eo.legacy.c" diff --git a/src/lib/elementary/elm_flipselector_item_eo.h b/src/lib/elementary/elm_flipselector_item_eo.h new file mode 100644 index 0000000000..ad156fe753 --- /dev/null +++ b/src/lib/elementary/elm_flipselector_item_eo.h @@ -0,0 +1,87 @@ +#ifndef _ELM_FLIPSELECTOR_ITEM_EO_H_ +#define _ELM_FLIPSELECTOR_ITEM_EO_H_ + +#ifndef _ELM_FLIPSELECTOR_ITEM_EO_CLASS_TYPE +#define _ELM_FLIPSELECTOR_ITEM_EO_CLASS_TYPE + +typedef Eo Elm_Flipselector_Item; + +#endif + +#ifndef _ELM_FLIPSELECTOR_ITEM_EO_TYPES +#define _ELM_FLIPSELECTOR_ITEM_EO_TYPES + + +#endif +/** Elementary flipselector item class + * + * @ingroup Elm_Flipselector_Item + */ +#define ELM_FLIPSELECTOR_ITEM_CLASS elm_flipselector_item_class_get() + +EWAPI const Efl_Class *elm_flipselector_item_class_get(void); + +/** + * @brief Set whether a given flip selector widget's item should be the + * currently selected one. + * + * This sets whether @c item is or not the selected (thus, under display) one. + * If @c item is different than the one under display, the latter will be + * unselected. If the @c item is set to be unselected, on the other hand, the + * first item in the widget's internal members list will be the new selected + * one. + * + * See also @ref elm_obj_flipselector_item_selected_get. + * + * @param[in] obj The object. + * @param[in] selected @c true if selected, @c false otherwise. + * + * @ingroup Elm_Flipselector_Item + */ +EOAPI void elm_obj_flipselector_item_selected_set(Eo *obj, Eina_Bool selected); + +/** + * @brief Get whether a given flip selector widget's item is the currently + * selected one. + * + * See also @ref elm_obj_flipselector_item_selected_set. + * + * @param[in] obj The object. + * + * @return @c true if selected, @c false otherwise. + * + * @ingroup Elm_Flipselector_Item + */ +EOAPI Eina_Bool elm_obj_flipselector_item_selected_get(const Eo *obj); + +/** + * @brief Get the item before @c item in a flip selector widget's internal list + * of items. + * + * See also @ref elm_obj_flipselector_item_next_get. + * + * @param[in] obj The object. + * + * @return The item before the @c item, in its parent's list. If there is no + * previous item for @c item or there's an error, @c null is returned. + * + * @ingroup Elm_Flipselector_Item + */ +EOAPI Elm_Widget_Item *elm_obj_flipselector_item_prev_get(const Eo *obj); + +/** + * @brief Get the item after @c item in a flip selector widget's internal list + * of items. + * + * See also @ref elm_obj_flipselector_item_prev_get. + * + * @param[in] obj The object. + * + * @return The item after the @c item, in its parent's list. If there is no + * next item for @c item or there's an error, @c null is returned. + * + * @ingroup Elm_Flipselector_Item + */ +EOAPI Elm_Widget_Item *elm_obj_flipselector_item_next_get(const Eo *obj); + +#endif diff --git a/src/lib/elementary/elm_flipselector_item_eo.legacy.c b/src/lib/elementary/elm_flipselector_item_eo.legacy.c new file mode 100644 index 0000000000..85d4040f11 --- /dev/null +++ b/src/lib/elementary/elm_flipselector_item_eo.legacy.c @@ -0,0 +1,24 @@ + +EAPI void +elm_flipselector_item_selected_set(Elm_Flipselector_Item *obj, Eina_Bool selected) +{ + elm_obj_flipselector_item_selected_set(obj, selected); +} + +EAPI Eina_Bool +elm_flipselector_item_selected_get(const Elm_Flipselector_Item *obj) +{ + return elm_obj_flipselector_item_selected_get(obj); +} + +EAPI Elm_Widget_Item * +elm_flipselector_item_prev_get(const Elm_Flipselector_Item *obj) +{ + return elm_obj_flipselector_item_prev_get(obj); +} + +EAPI Elm_Widget_Item * +elm_flipselector_item_next_get(const Elm_Flipselector_Item *obj) +{ + return elm_obj_flipselector_item_next_get(obj); +} diff --git a/src/lib/elementary/elm_flipselector_item_eo.legacy.h b/src/lib/elementary/elm_flipselector_item_eo.legacy.h new file mode 100644 index 0000000000..f2e9453d9b --- /dev/null +++ b/src/lib/elementary/elm_flipselector_item_eo.legacy.h @@ -0,0 +1,80 @@ +#ifndef _ELM_FLIPSELECTOR_ITEM_EO_LEGACY_H_ +#define _ELM_FLIPSELECTOR_ITEM_EO_LEGACY_H_ + +#ifndef _ELM_FLIPSELECTOR_ITEM_EO_CLASS_TYPE +#define _ELM_FLIPSELECTOR_ITEM_EO_CLASS_TYPE + +typedef Eo Elm_Flipselector_Item; + +#endif + +#ifndef _ELM_FLIPSELECTOR_ITEM_EO_TYPES +#define _ELM_FLIPSELECTOR_ITEM_EO_TYPES + + +#endif + +/** + * @brief Set whether a given flip selector widget's item should be the + * currently selected one. + * + * This sets whether @c item is or not the selected (thus, under display) one. + * If @c item is different than the one under display, the latter will be + * unselected. If the @c item is set to be unselected, on the other hand, the + * first item in the widget's internal members list will be the new selected + * one. + * + * See also @ref elm_flipselector_item_selected_get. + * + * @param[in] obj The object. + * @param[in] selected @c true if selected, @c false otherwise. + * + * @ingroup Elm_Flipselector_Item_Group + */ +EAPI void elm_flipselector_item_selected_set(Elm_Flipselector_Item *obj, Eina_Bool selected); + +/** + * @brief Get whether a given flip selector widget's item is the currently + * selected one. + * + * See also @ref elm_flipselector_item_selected_set. + * + * @param[in] obj The object. + * + * @return @c true if selected, @c false otherwise. + * + * @ingroup Elm_Flipselector_Item_Group + */ +EAPI Eina_Bool elm_flipselector_item_selected_get(const Elm_Flipselector_Item *obj); + +/** + * @brief Get the item before @c item in a flip selector widget's internal list + * of items. + * + * See also @ref elm_flipselector_item_next_get. + * + * @param[in] obj The object. + * + * @return The item before the @c item, in its parent's list. If there is no + * previous item for @c item or there's an error, @c null is returned. + * + * @ingroup Elm_Flipselector_Item_Group + */ +EAPI Elm_Widget_Item *elm_flipselector_item_prev_get(const Elm_Flipselector_Item *obj); + +/** + * @brief Get the item after @c item in a flip selector widget's internal list + * of items. + * + * See also @ref elm_flipselector_item_prev_get. + * + * @param[in] obj The object. + * + * @return The item after the @c item, in its parent's list. If there is no + * next item for @c item or there's an error, @c null is returned. + * + * @ingroup Elm_Flipselector_Item_Group + */ +EAPI Elm_Widget_Item *elm_flipselector_item_next_get(const Elm_Flipselector_Item *obj); + +#endif diff --git a/src/lib/elementary/elm_flipselector_legacy.h b/src/lib/elementary/elm_flipselector_legacy.h index a2fbd58ae0..8f005e8f17 100644 --- a/src/lib/elementary/elm_flipselector_legacy.h +++ b/src/lib/elementary/elm_flipselector_legacy.h @@ -11,5 +11,5 @@ */ EAPI Evas_Object *elm_flipselector_add(Evas_Object *parent); -#include "elm_flipselector_item.eo.legacy.h" -#include "elm_flipselector.eo.legacy.h" +#include "elm_flipselector_item_eo.legacy.h" +#include "elm_flipselector_eo.legacy.h" diff --git a/src/lib/elementary/meson.build b/src/lib/elementary/meson.build index 73f97ee3a4..28f793f61d 100644 --- a/src/lib/elementary/meson.build +++ b/src/lib/elementary/meson.build @@ -25,7 +25,6 @@ pub_legacy_eo_files = [ 'elm_sys_notify.eo', 'elm_sys_notify_dbus.eo', 'elm_systray.eo', - 'elm_flipselector_item.eo', 'elm_menu_item.eo', 'elm_index_item.eo', 'elm_widget_item_static_focus.eo', @@ -50,7 +49,6 @@ pub_legacy_eo_files = [ 'elm_actionslider_part.eo', 'elm_bubble_part.eo', 'elm_fileselector_part.eo', - 'elm_flipselector.eo', 'elm_grid.eo', 'elm_icon.eo', 'elm_inwin.eo', @@ -744,6 +742,10 @@ elementary_pub_headers = [ 'elm_fileselector_entry_eo.legacy.h', 'elm_fileselector_eo.h', 'elm_fileselector_eo.legacy.h', + 'elm_flipselector_eo.h', + 'elm_flipselector_eo.legacy.h', + 'elm_flipselector_item_eo.h', + 'elm_flipselector_item_eo.legacy.h', 'elm_hoversel_eo.h', 'elm_hoversel_eo.legacy.h', 'elm_hoversel_item_eo.h',