diff --git a/src/Makefile_Elementary.am b/src/Makefile_Elementary.am index 484a6ef96f..6e9470f11a 100644 --- a/src/Makefile_Elementary.am +++ b/src/Makefile_Elementary.am @@ -141,7 +141,6 @@ elm_public_eolian_files += \ lib/elementary/efl_ui_radio_legacy_part.eo \ lib/elementary/efl_ui_check_legacy_part.eo \ lib/elementary/efl_ui_progressbar_legacy_part.eo \ - lib/elementary/elm_spinner.eo \ lib/elementary/elm_multibuttonentry_part.eo \ lib/elementary/elm_interface_scrollable.eo \ lib/elementary/elm_atspi_bridge.eo \ @@ -387,6 +386,8 @@ lib/elementary/elm_slideshow_eo.c \ lib/elementary/elm_slideshow_eo.legacy.c \ lib/elementary/elm_slideshow_item_eo.c \ lib/elementary/elm_slideshow_item_eo.legacy.c \ +lib/elementary/elm_spinner_eo.c \ +lib/elementary/elm_spinner_eo.legacy.c \ $(NULL) elm_legacy_eo_headers = \ @@ -576,6 +577,8 @@ lib/elementary/elm_slideshow_eo.h \ lib/elementary/elm_slideshow_eo.legacy.h \ lib/elementary/elm_slideshow_item_eo.h \ lib/elementary/elm_slideshow_item_eo.legacy.h \ +lib/elementary/elm_spinner_eo.h \ +lib/elementary/elm_spinner_eo.legacy.h \ $(NULL) diff --git a/src/lib/elementary/Elementary.h b/src/lib/elementary/Elementary.h index 8e54b4a710..c37c41df0a 100644 --- a/src/lib/elementary/Elementary.h +++ b/src/lib/elementary/Elementary.h @@ -167,7 +167,7 @@ EAPI void efl_ui_focus_relation_free(Efl_Ui_Focus_Relations *rel); # include # include # include -# include +# include #endif #include diff --git a/src/lib/elementary/elm_spinner.c b/src/lib/elementary/elm_spinner.c index e00f0d38f6..001dd3b152 100644 --- a/src/lib/elementary/elm_spinner.c +++ b/src/lib/elementary/elm_spinner.c @@ -1722,4 +1722,4 @@ _elm_spinner_efl_access_object_i18n_name_get(const Eo *obj, Elm_Spinner_Data *sd ELM_LAYOUT_SIZING_EVAL_OPS(elm_spinner), \ EFL_CANVAS_GROUP_ADD_DEL_OPS(elm_spinner) -#include "elm_spinner.eo.c" +#include "elm_spinner_eo.c" diff --git a/src/lib/elementary/elm_spinner.eo b/src/lib/elementary/elm_spinner.eo deleted file mode 100644 index 9c9819ff08..0000000000 --- a/src/lib/elementary/elm_spinner.eo +++ /dev/null @@ -1,195 +0,0 @@ -class Elm.Spinner extends Efl.Ui.Layout_Base implements Efl.Ui.Range_Interactive, Efl.Ui.Focus.Composition, - Efl.Access.Value, Efl.Access.Widget.Action, Efl.Ui.Legacy -{ - [[Elementary spinner class]] - legacy_prefix: elm_spinner; - eo_prefix: elm_obj_spinner; - event_prefix: elm_spinner; - methods { - @property wrap { - [[Control whether the spinner should wrap when it reaches its minimum or maximum value. - - Disabled by default. If disabled, when the user tries to increment the - value, - but displayed value plus step value is bigger than maximum value, - the new value will be the maximum value. - The same happens when the user tries to decrement it, - but the value less step is less than minimum value. In this case, - the new displayed value will be the minimum value. - - When wrap is enabled, when the user tries to increment the value, - but displayed value plus step value is bigger than maximum value, - the new value will be the minimum value. When the the user tries to - decrement it, but the value less step is less than minimum value, - the new displayed value will be the maximum value. - - E.g.: - $min = 10 - $max = 50 - $step = 20 - $displayed = 20 - - When the user decrement value (using left or bottom arrow), it will - displays $50.]] - set { - } - get { - } - values { - wrap: bool; [[$true to enable wrap or $false to disable it.]] - } - } - @property interval { - [[Control the interval on time updates for an user mouse button hold on spinner widgets' arrows. - - This interval value is decreased while the user holds the - mouse pointer either incrementing or decrementing spinner's value. - - This helps the user to get to a given value distant from the - current one easier/faster, as it will start to change quicker and - quicker on mouse button holds. - - The calculation for the next change 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 changes is - $0.85 seconds.]] - set { - } - get { - } - values { - interval: double; [[The (first) interval value in seconds.]] - } - } - @property round { - [[Control the round value for rounding - - Sets the rounding value used for value rounding in the spinner.]] - set { - } - get { - } - values { - rnd: int; [[The rounding value]] - } - } - @property editable { - [[Control whether the spinner can be directly edited by the user or not. - - Spinner objects can have edition disabled, in which state they will - be changed only by arrows. - Useful for contexts - where you don't want your users to interact with it writing the value. - Specially - when using special values, the user can see real value instead - of special label on edition. - - It's enabled by default.]] - set { - } - get { - } - values { - editable: bool; [[$true to allow users to edit it or $false to don't allow users to edit it directly.]] - } - } - @property base { - [[Control the base for rounding - - Rounding works as follows: - - rounded_val = base + (double)(((value - base) / round) * round) - - Where rounded_val, value and base are doubles, and round is an integer. - - This means that things will be rounded to increments (or decrements) of - "round" starting from value $base. The default base for rounding is 0. - - Example: round = 3, base = 2 - Values: ..., -2, 0, 2, 5, 8, 11, 14, ... - - Example: round = 2, base = 5.5 - Values: ..., -0.5, 1.5, 3.5, 5.5, 7.5, 9.5, 11.5, ...]] - set { - } - get { - } - values { - base: double; [[The base value]] - } - } - @property label_format { - [[Control the format string of the displayed label. - - If $NULL, this sets the format to "%.0f". If not it sets the format - string for the label text. The label text is provided a floating point - value, so the label text can display up to 1 floating point value. - Note that this is optional. - - Use a format string such as "%1.2f meters" for example, and it will - display values like: "3.14 meters" for a value equal to 3.14159. - - Default is "%0.f".]] - set { - } - get { - } - values { - fmt: string @nullable; [[The format string for the label display.]] - } - } - special_value_add { - [[Control special string to display in the place of the numerical value. - - It's useful for cases when a user should select an item that is - better indicated by a label than a value. For example, weekdays or months. - - Note: If another label was previously set to $value, it will be replaced - by the new label.]] - - /* FIXME-doc - E.g.: - @code - sp = elm_spinner_add(win); - elm_spinner_min_max_set(sp, 1, 3); - elm_spinner_special_value_add(sp, 1, "January"); - elm_spinner_special_value_add(sp, 2, "February"); - elm_spinner_special_value_add(sp, 3, "March"); - evas_object_show(sp); - @endcode - */ - params { - @in value: double; [[The value to be replaced.]] - @in label: string; [[The label to be used.]] - - } - } - } - implements { - class.constructor; - Efl.Object.constructor; - Efl.Ui.Widget.theme_apply; - Efl.Ui.Widget.on_access_update; - Efl.Ui.Focus.Object.on_focus_update; - 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.Object.i18n_name { get; } - Efl.Access.Value.value_and_text { get; set; } - Efl.Access.Value.range { get; } - Efl.Access.Value.increment { get; } - Efl.Access.Widget.Action.elm_actions { get; } - } - events { - /* FIXME: Colorselector puts Colorselector_Data here! */ - changed: void; [[Called when spinner changed]] - delay,changed: void; [[Called when spinner delay changed]] - spinner,drag,start: void; [[Called when spinner drag started]] - spinner,drag,stop: void; [[Called when spinner drag stopped]] - min,reached: void; [[Called when spinner value reached min]] - max,reached: void; [[Called when spinner value reached max]] - } -} diff --git a/src/lib/elementary/elm_spinner.h b/src/lib/elementary/elm_spinner.h index 16c040a3e7..6da9976379 100644 --- a/src/lib/elementary/elm_spinner.h +++ b/src/lib/elementary/elm_spinner.h @@ -58,7 +58,7 @@ */ #ifdef EFL_EO_API_SUPPORT -#include "elm_spinner.eo.h" +#include "elm_spinner_eo.h" #endif #ifndef EFL_NOLEGACY_API_SUPPORT #include "elm_spinner_legacy.h" diff --git a/src/lib/elementary/elm_spinner_eo.c b/src/lib/elementary/elm_spinner_eo.c new file mode 100644 index 0000000000..3a616dcd04 --- /dev/null +++ b/src/lib/elementary/elm_spinner_eo.c @@ -0,0 +1,335 @@ +EWAPI const Efl_Event_Description _ELM_SPINNER_EVENT_CHANGED = + EFL_EVENT_DESCRIPTION("changed"); +EWAPI const Efl_Event_Description _ELM_SPINNER_EVENT_DELAY_CHANGED = + EFL_EVENT_DESCRIPTION("delay,changed"); +EWAPI const Efl_Event_Description _ELM_SPINNER_EVENT_SPINNER_DRAG_START = + EFL_EVENT_DESCRIPTION("spinner,drag,start"); +EWAPI const Efl_Event_Description _ELM_SPINNER_EVENT_SPINNER_DRAG_STOP = + EFL_EVENT_DESCRIPTION("spinner,drag,stop"); +EWAPI const Efl_Event_Description _ELM_SPINNER_EVENT_MIN_REACHED = + EFL_EVENT_DESCRIPTION("min,reached"); +EWAPI const Efl_Event_Description _ELM_SPINNER_EVENT_MAX_REACHED = + EFL_EVENT_DESCRIPTION("max,reached"); + +void _elm_spinner_wrap_set(Eo *obj, Elm_Spinner_Data *pd, Eina_Bool wrap); + + +static Eina_Error +__eolian_elm_spinner_wrap_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_spinner_wrap_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_spinner_wrap_set, EFL_FUNC_CALL(wrap), Eina_Bool wrap); + +Eina_Bool _elm_spinner_wrap_get(const Eo *obj, Elm_Spinner_Data *pd); + + +static Eina_Value +__eolian_elm_spinner_wrap_get_reflect(Eo *obj) +{ + Eina_Bool val = elm_obj_spinner_wrap_get(obj); + return eina_value_bool_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_spinner_wrap_get, Eina_Bool, 0); + +void _elm_spinner_interval_set(Eo *obj, Elm_Spinner_Data *pd, double interval); + + +static Eina_Error +__eolian_elm_spinner_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_spinner_interval_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_spinner_interval_set, EFL_FUNC_CALL(interval), double interval); + +double _elm_spinner_interval_get(const Eo *obj, Elm_Spinner_Data *pd); + + +static Eina_Value +__eolian_elm_spinner_interval_get_reflect(Eo *obj) +{ + double val = elm_obj_spinner_interval_get(obj); + return eina_value_double_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_spinner_interval_get, double, 0); + +void _elm_spinner_round_set(Eo *obj, Elm_Spinner_Data *pd, int rnd); + + +static Eina_Error +__eolian_elm_spinner_round_set_reflect(Eo *obj, Eina_Value val) +{ + Eina_Error r = 0; int cval; + if (!eina_value_int_convert(&val, &cval)) + { + r = EINA_ERROR_VALUE_FAILED; + goto end; + } + elm_obj_spinner_round_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_spinner_round_set, EFL_FUNC_CALL(rnd), int rnd); + +int _elm_spinner_round_get(const Eo *obj, Elm_Spinner_Data *pd); + + +static Eina_Value +__eolian_elm_spinner_round_get_reflect(Eo *obj) +{ + int val = elm_obj_spinner_round_get(obj); + return eina_value_int_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_spinner_round_get, int, 0); + +void _elm_spinner_editable_set(Eo *obj, Elm_Spinner_Data *pd, Eina_Bool editable); + + +static Eina_Error +__eolian_elm_spinner_editable_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_spinner_editable_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_spinner_editable_set, EFL_FUNC_CALL(editable), Eina_Bool editable); + +Eina_Bool _elm_spinner_editable_get(const Eo *obj, Elm_Spinner_Data *pd); + + +static Eina_Value +__eolian_elm_spinner_editable_get_reflect(Eo *obj) +{ + Eina_Bool val = elm_obj_spinner_editable_get(obj); + return eina_value_bool_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_spinner_editable_get, Eina_Bool, 0); + +void _elm_spinner_base_set(Eo *obj, Elm_Spinner_Data *pd, double base); + + +static Eina_Error +__eolian_elm_spinner_base_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_spinner_base_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_spinner_base_set, EFL_FUNC_CALL(base), double base); + +double _elm_spinner_base_get(const Eo *obj, Elm_Spinner_Data *pd); + + +static Eina_Value +__eolian_elm_spinner_base_get_reflect(Eo *obj) +{ + double val = elm_obj_spinner_base_get(obj); + return eina_value_double_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_spinner_base_get, double, 0); + +void _elm_spinner_label_format_set(Eo *obj, Elm_Spinner_Data *pd, const char *fmt); + + +static Eina_Error +__eolian_elm_spinner_label_format_set_reflect(Eo *obj, Eina_Value val) +{ + Eina_Error r = 0; const char *cval; + if (!eina_value_string_convert(&val, &cval)) + { + r = EINA_ERROR_VALUE_FAILED; + goto end; + } + elm_obj_spinner_label_format_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_spinner_label_format_set, EFL_FUNC_CALL(fmt), const char *fmt); + +const char *_elm_spinner_label_format_get(const Eo *obj, Elm_Spinner_Data *pd); + + +static Eina_Value +__eolian_elm_spinner_label_format_get_reflect(Eo *obj) +{ + const char *val = elm_obj_spinner_label_format_get(obj); + return eina_value_string_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_spinner_label_format_get, const char *, NULL); + +void _elm_spinner_special_value_add(Eo *obj, Elm_Spinner_Data *pd, double value, const char *label); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_spinner_special_value_add, EFL_FUNC_CALL(value, label), double value, const char *label); + +Efl_Object *_elm_spinner_efl_object_constructor(Eo *obj, Elm_Spinner_Data *pd); + + +Eina_Error _elm_spinner_efl_ui_widget_theme_apply(Eo *obj, Elm_Spinner_Data *pd); + + +void _elm_spinner_efl_ui_widget_on_access_update(Eo *obj, Elm_Spinner_Data *pd, Eina_Bool enable); + + +Eina_Bool _elm_spinner_efl_ui_focus_object_on_focus_update(Eo *obj, Elm_Spinner_Data *pd); + + +Eina_Bool _elm_spinner_efl_ui_widget_widget_input_event_handler(Eo *obj, Elm_Spinner_Data *pd, const Efl_Event *eo_event, Efl_Canvas_Object *source); + + +void _elm_spinner_efl_ui_range_display_range_min_max_set(Eo *obj, Elm_Spinner_Data *pd, double min, double max); + + +void _elm_spinner_efl_ui_range_display_range_min_max_get(const Eo *obj, Elm_Spinner_Data *pd, double *min, double *max); + + +void _elm_spinner_efl_ui_range_interactive_range_step_set(Eo *obj, Elm_Spinner_Data *pd, double step); + + +double _elm_spinner_efl_ui_range_interactive_range_step_get(const Eo *obj, Elm_Spinner_Data *pd); + + +void _elm_spinner_efl_ui_range_display_range_value_set(Eo *obj, Elm_Spinner_Data *pd, double val); + + +double _elm_spinner_efl_ui_range_display_range_value_get(const Eo *obj, Elm_Spinner_Data *pd); + + +const char *_elm_spinner_efl_access_object_i18n_name_get(const Eo *obj, Elm_Spinner_Data *pd); + + +Eina_Bool _elm_spinner_efl_access_value_value_and_text_set(Eo *obj, Elm_Spinner_Data *pd, double value, const char *text); + + +void _elm_spinner_efl_access_value_value_and_text_get(const Eo *obj, Elm_Spinner_Data *pd, double *value, const char **text); + + +void _elm_spinner_efl_access_value_range_get(const Eo *obj, Elm_Spinner_Data *pd, double *lower_limit, double *upper_limit, const char **description); + + +double _elm_spinner_efl_access_value_increment_get(const Eo *obj, Elm_Spinner_Data *pd); + + +const Efl_Access_Action_Data *_elm_spinner_efl_access_widget_action_elm_actions_get(const Eo *obj, Elm_Spinner_Data *pd); + + +static Eina_Bool +_elm_spinner_class_initializer(Efl_Class *klass) +{ + const Efl_Object_Ops *opsp = NULL; + + const Efl_Object_Property_Reflection_Ops *ropsp = NULL; + +#ifndef ELM_SPINNER_EXTRA_OPS +#define ELM_SPINNER_EXTRA_OPS +#endif + + EFL_OPS_DEFINE(ops, + EFL_OBJECT_OP_FUNC(elm_obj_spinner_wrap_set, _elm_spinner_wrap_set), + EFL_OBJECT_OP_FUNC(elm_obj_spinner_wrap_get, _elm_spinner_wrap_get), + EFL_OBJECT_OP_FUNC(elm_obj_spinner_interval_set, _elm_spinner_interval_set), + EFL_OBJECT_OP_FUNC(elm_obj_spinner_interval_get, _elm_spinner_interval_get), + EFL_OBJECT_OP_FUNC(elm_obj_spinner_round_set, _elm_spinner_round_set), + EFL_OBJECT_OP_FUNC(elm_obj_spinner_round_get, _elm_spinner_round_get), + EFL_OBJECT_OP_FUNC(elm_obj_spinner_editable_set, _elm_spinner_editable_set), + EFL_OBJECT_OP_FUNC(elm_obj_spinner_editable_get, _elm_spinner_editable_get), + EFL_OBJECT_OP_FUNC(elm_obj_spinner_base_set, _elm_spinner_base_set), + EFL_OBJECT_OP_FUNC(elm_obj_spinner_base_get, _elm_spinner_base_get), + EFL_OBJECT_OP_FUNC(elm_obj_spinner_label_format_set, _elm_spinner_label_format_set), + EFL_OBJECT_OP_FUNC(elm_obj_spinner_label_format_get, _elm_spinner_label_format_get), + EFL_OBJECT_OP_FUNC(elm_obj_spinner_special_value_add, _elm_spinner_special_value_add), + EFL_OBJECT_OP_FUNC(efl_constructor, _elm_spinner_efl_object_constructor), + EFL_OBJECT_OP_FUNC(efl_ui_widget_theme_apply, _elm_spinner_efl_ui_widget_theme_apply), + EFL_OBJECT_OP_FUNC(efl_ui_widget_on_access_update, _elm_spinner_efl_ui_widget_on_access_update), + EFL_OBJECT_OP_FUNC(efl_ui_focus_object_on_focus_update, _elm_spinner_efl_ui_focus_object_on_focus_update), + EFL_OBJECT_OP_FUNC(efl_ui_widget_input_event_handler, _elm_spinner_efl_ui_widget_widget_input_event_handler), + EFL_OBJECT_OP_FUNC(efl_ui_range_min_max_set, _elm_spinner_efl_ui_range_display_range_min_max_set), + EFL_OBJECT_OP_FUNC(efl_ui_range_min_max_get, _elm_spinner_efl_ui_range_display_range_min_max_get), + EFL_OBJECT_OP_FUNC(efl_ui_range_step_set, _elm_spinner_efl_ui_range_interactive_range_step_set), + EFL_OBJECT_OP_FUNC(efl_ui_range_step_get, _elm_spinner_efl_ui_range_interactive_range_step_get), + EFL_OBJECT_OP_FUNC(efl_ui_range_value_set, _elm_spinner_efl_ui_range_display_range_value_set), + EFL_OBJECT_OP_FUNC(efl_ui_range_value_get, _elm_spinner_efl_ui_range_display_range_value_get), + EFL_OBJECT_OP_FUNC(efl_access_object_i18n_name_get, _elm_spinner_efl_access_object_i18n_name_get), + EFL_OBJECT_OP_FUNC(efl_access_value_and_text_set, _elm_spinner_efl_access_value_value_and_text_set), + EFL_OBJECT_OP_FUNC(efl_access_value_and_text_get, _elm_spinner_efl_access_value_value_and_text_get), + EFL_OBJECT_OP_FUNC(efl_access_value_range_get, _elm_spinner_efl_access_value_range_get), + EFL_OBJECT_OP_FUNC(efl_access_value_increment_get, _elm_spinner_efl_access_value_increment_get), + EFL_OBJECT_OP_FUNC(efl_access_widget_action_elm_actions_get, _elm_spinner_efl_access_widget_action_elm_actions_get), + ELM_SPINNER_EXTRA_OPS + ); + opsp = &ops; + + static const Efl_Object_Property_Reflection refl_table[] = { + {"wrap", __eolian_elm_spinner_wrap_set_reflect, __eolian_elm_spinner_wrap_get_reflect}, + {"interval", __eolian_elm_spinner_interval_set_reflect, __eolian_elm_spinner_interval_get_reflect}, + {"round", __eolian_elm_spinner_round_set_reflect, __eolian_elm_spinner_round_get_reflect}, + {"editable", __eolian_elm_spinner_editable_set_reflect, __eolian_elm_spinner_editable_get_reflect}, + {"base", __eolian_elm_spinner_base_set_reflect, __eolian_elm_spinner_base_get_reflect}, + {"label_format", __eolian_elm_spinner_label_format_set_reflect, __eolian_elm_spinner_label_format_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_spinner_class_desc = { + EO_VERSION, + "Elm.Spinner", + EFL_CLASS_TYPE_REGULAR, + sizeof(Elm_Spinner_Data), + _elm_spinner_class_initializer, + _elm_spinner_class_constructor, + NULL +}; + +EFL_DEFINE_CLASS(elm_spinner_class_get, &_elm_spinner_class_desc, EFL_UI_LAYOUT_BASE_CLASS, EFL_UI_RANGE_INTERACTIVE_INTERFACE, EFL_UI_FOCUS_COMPOSITION_MIXIN, EFL_ACCESS_VALUE_INTERFACE, EFL_ACCESS_WIDGET_ACTION_MIXIN, EFL_UI_LEGACY_INTERFACE, NULL); + +#include "elm_spinner_eo.legacy.c" diff --git a/src/lib/elementary/elm_spinner_eo.h b/src/lib/elementary/elm_spinner_eo.h new file mode 100644 index 0000000000..ff9205c262 --- /dev/null +++ b/src/lib/elementary/elm_spinner_eo.h @@ -0,0 +1,350 @@ +#ifndef _ELM_SPINNER_EO_H_ +#define _ELM_SPINNER_EO_H_ + +#ifndef _ELM_SPINNER_EO_CLASS_TYPE +#define _ELM_SPINNER_EO_CLASS_TYPE + +typedef Eo Elm_Spinner; + +#endif + +#ifndef _ELM_SPINNER_EO_TYPES +#define _ELM_SPINNER_EO_TYPES + + +#endif +/** Elementary spinner class + * + * @ingroup Elm_Spinner + */ +#define ELM_SPINNER_CLASS elm_spinner_class_get() + +EWAPI const Efl_Class *elm_spinner_class_get(void); + +/** + * @brief Control whether the spinner should wrap when it reaches its minimum + * or maximum value. + * + * Disabled by default. If disabled, when the user tries to increment the + * value, but displayed value plus step value is bigger than maximum value, the + * new value will be the maximum value. The same happens when the user tries to + * decrement it, but the value less step is less than minimum value. In this + * case, the new displayed value will be the minimum value. + * + * When wrap is enabled, when the user tries to increment the value, but + * displayed value plus step value is bigger than maximum value, the new value + * will be the minimum value. When the the user tries to decrement it, but the + * value less step is less than minimum value, the new displayed value will be + * the maximum value. + * + * E.g.: @c min = 10 @c max = 50 @c step = 20 @c displayed = 20 + * + * When the user decrement value (using left or bottom arrow), it will displays + * $50. + * + * @param[in] obj The object. + * @param[in] wrap @c true to enable wrap or @c false to disable it. + * + * @ingroup Elm_Spinner + */ +EOAPI void elm_obj_spinner_wrap_set(Eo *obj, Eina_Bool wrap); + +/** + * @brief Control whether the spinner should wrap when it reaches its minimum + * or maximum value. + * + * Disabled by default. If disabled, when the user tries to increment the + * value, but displayed value plus step value is bigger than maximum value, the + * new value will be the maximum value. The same happens when the user tries to + * decrement it, but the value less step is less than minimum value. In this + * case, the new displayed value will be the minimum value. + * + * When wrap is enabled, when the user tries to increment the value, but + * displayed value plus step value is bigger than maximum value, the new value + * will be the minimum value. When the the user tries to decrement it, but the + * value less step is less than minimum value, the new displayed value will be + * the maximum value. + * + * E.g.: @c min = 10 @c max = 50 @c step = 20 @c displayed = 20 + * + * When the user decrement value (using left or bottom arrow), it will displays + * $50. + * + * @param[in] obj The object. + * + * @return @c true to enable wrap or @c false to disable it. + * + * @ingroup Elm_Spinner + */ +EOAPI Eina_Bool elm_obj_spinner_wrap_get(const Eo *obj); + +/** + * @brief Control the interval on time updates for an user mouse button hold on + * spinner widgets' arrows. + * + * This interval value is decreased while the user holds the mouse pointer + * either incrementing or decrementing spinner's value. + * + * This helps the user to get to a given value distant from the current one + * easier/faster, as it will start to change quicker and quicker on mouse + * button holds. + * + * The calculation for the next change 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 changes is $0.85 seconds. + * + * @param[in] obj The object. + * @param[in] interval The (first) interval value in seconds. + * + * @ingroup Elm_Spinner + */ +EOAPI void elm_obj_spinner_interval_set(Eo *obj, double interval); + +/** + * @brief Control the interval on time updates for an user mouse button hold on + * spinner widgets' arrows. + * + * This interval value is decreased while the user holds the mouse pointer + * either incrementing or decrementing spinner's value. + * + * This helps the user to get to a given value distant from the current one + * easier/faster, as it will start to change quicker and quicker on mouse + * button holds. + * + * The calculation for the next change 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 changes is $0.85 seconds. + * + * @param[in] obj The object. + * + * @return The (first) interval value in seconds. + * + * @ingroup Elm_Spinner + */ +EOAPI double elm_obj_spinner_interval_get(const Eo *obj); + +/** + * @brief Control the round value for rounding + * + * Sets the rounding value used for value rounding in the spinner. + * + * @param[in] obj The object. + * @param[in] rnd The rounding value + * + * @ingroup Elm_Spinner + */ +EOAPI void elm_obj_spinner_round_set(Eo *obj, int rnd); + +/** + * @brief Control the round value for rounding + * + * Sets the rounding value used for value rounding in the spinner. + * + * @param[in] obj The object. + * + * @return The rounding value + * + * @ingroup Elm_Spinner + */ +EOAPI int elm_obj_spinner_round_get(const Eo *obj); + +/** + * @brief Control whether the spinner can be directly edited by the user or + * not. + * + * Spinner objects can have edition disabled, in which state they will be + * changed only by arrows. Useful for contexts where you don't want your users + * to interact with it writing the value. Specially when using special values, + * the user can see real value instead of special label on edition. + * + * It's enabled by default. + * + * @param[in] obj The object. + * @param[in] editable @c true to allow users to edit it or @c false to don't + * allow users to edit it directly. + * + * @ingroup Elm_Spinner + */ +EOAPI void elm_obj_spinner_editable_set(Eo *obj, Eina_Bool editable); + +/** + * @brief Control whether the spinner can be directly edited by the user or + * not. + * + * Spinner objects can have edition disabled, in which state they will be + * changed only by arrows. Useful for contexts where you don't want your users + * to interact with it writing the value. Specially when using special values, + * the user can see real value instead of special label on edition. + * + * It's enabled by default. + * + * @param[in] obj The object. + * + * @return @c true to allow users to edit it or @c false to don't allow users + * to edit it directly. + * + * @ingroup Elm_Spinner + */ +EOAPI Eina_Bool elm_obj_spinner_editable_get(const Eo *obj); + +/** + * @brief Control the base for rounding + * + * Rounding works as follows: + * + * rounded_val = base + (double)(((value - base) / round) * round) + * + * Where rounded_val, value and base are doubles, and round is an integer. + * + * This means that things will be rounded to increments (or decrements) of + * "round" starting from value @c base. The default base for rounding is 0. + * + * Example: round = 3, base = 2 Values: ..., -2, 0, 2, 5, 8, 11, 14, ... + * + * Example: round = 2, base = 5.5 Values: ..., -0.5, 1.5, 3.5, 5.5, 7.5, 9.5, + * 11.5, ... + * + * @param[in] obj The object. + * @param[in] base The base value + * + * @ingroup Elm_Spinner + */ +EOAPI void elm_obj_spinner_base_set(Eo *obj, double base); + +/** + * @brief Control the base for rounding + * + * Rounding works as follows: + * + * rounded_val = base + (double)(((value - base) / round) * round) + * + * Where rounded_val, value and base are doubles, and round is an integer. + * + * This means that things will be rounded to increments (or decrements) of + * "round" starting from value @c base. The default base for rounding is 0. + * + * Example: round = 3, base = 2 Values: ..., -2, 0, 2, 5, 8, 11, 14, ... + * + * Example: round = 2, base = 5.5 Values: ..., -0.5, 1.5, 3.5, 5.5, 7.5, 9.5, + * 11.5, ... + * + * @param[in] obj The object. + * + * @return The base value + * + * @ingroup Elm_Spinner + */ +EOAPI double elm_obj_spinner_base_get(const Eo *obj); + +/** + * @brief Control the format string of the displayed label. + * + * If @c NULL, this sets the format to "%.0f". If not it sets the format string + * for the label text. The label text is provided a floating point value, so + * the label text can display up to 1 floating point value. Note that this is + * optional. + * + * Use a format string such as "%1.2f meters" for example, and it will display + * values like: "3.14 meters" for a value equal to 3.14159. + * + * Default is "%0.f". + * + * @param[in] obj The object. + * @param[in] fmt The format string for the label display. + * + * @ingroup Elm_Spinner + */ +EOAPI void elm_obj_spinner_label_format_set(Eo *obj, const char *fmt); + +/** + * @brief Control the format string of the displayed label. + * + * If @c NULL, this sets the format to "%.0f". If not it sets the format string + * for the label text. The label text is provided a floating point value, so + * the label text can display up to 1 floating point value. Note that this is + * optional. + * + * Use a format string such as "%1.2f meters" for example, and it will display + * values like: "3.14 meters" for a value equal to 3.14159. + * + * Default is "%0.f". + * + * @param[in] obj The object. + * + * @return The format string for the label display. + * + * @ingroup Elm_Spinner + */ +EOAPI const char *elm_obj_spinner_label_format_get(const Eo *obj); + +/** + * @brief Control special string to display in the place of the numerical + * value. + * + * It's useful for cases when a user should select an item that is better + * indicated by a label than a value. For example, weekdays or months. + * + * @note If another label was previously set to @c value, it will be replaced + * by the new label. + * + * @param[in] obj The object. + * @param[in] value The value to be replaced. + * @param[in] label The label to be used. + * + * @ingroup Elm_Spinner + */ +EOAPI void elm_obj_spinner_special_value_add(Eo *obj, double value, const char *label); + +EWAPI extern const Efl_Event_Description _ELM_SPINNER_EVENT_CHANGED; + +/** Called when spinner changed + * + * @ingroup Elm_Spinner + */ +#define ELM_SPINNER_EVENT_CHANGED (&(_ELM_SPINNER_EVENT_CHANGED)) + +EWAPI extern const Efl_Event_Description _ELM_SPINNER_EVENT_DELAY_CHANGED; + +/** Called when spinner delay changed + * + * @ingroup Elm_Spinner + */ +#define ELM_SPINNER_EVENT_DELAY_CHANGED (&(_ELM_SPINNER_EVENT_DELAY_CHANGED)) + +EWAPI extern const Efl_Event_Description _ELM_SPINNER_EVENT_SPINNER_DRAG_START; + +/** Called when spinner drag started + * + * @ingroup Elm_Spinner + */ +#define ELM_SPINNER_EVENT_SPINNER_DRAG_START (&(_ELM_SPINNER_EVENT_SPINNER_DRAG_START)) + +EWAPI extern const Efl_Event_Description _ELM_SPINNER_EVENT_SPINNER_DRAG_STOP; + +/** Called when spinner drag stopped + * + * @ingroup Elm_Spinner + */ +#define ELM_SPINNER_EVENT_SPINNER_DRAG_STOP (&(_ELM_SPINNER_EVENT_SPINNER_DRAG_STOP)) + +EWAPI extern const Efl_Event_Description _ELM_SPINNER_EVENT_MIN_REACHED; + +/** Called when spinner value reached min + * + * @ingroup Elm_Spinner + */ +#define ELM_SPINNER_EVENT_MIN_REACHED (&(_ELM_SPINNER_EVENT_MIN_REACHED)) + +EWAPI extern const Efl_Event_Description _ELM_SPINNER_EVENT_MAX_REACHED; + +/** Called when spinner value reached max + * + * @ingroup Elm_Spinner + */ +#define ELM_SPINNER_EVENT_MAX_REACHED (&(_ELM_SPINNER_EVENT_MAX_REACHED)) + +#endif diff --git a/src/lib/elementary/elm_spinner_eo.legacy.c b/src/lib/elementary/elm_spinner_eo.legacy.c new file mode 100644 index 0000000000..ed35ba1df0 --- /dev/null +++ b/src/lib/elementary/elm_spinner_eo.legacy.c @@ -0,0 +1,78 @@ + +EAPI void +elm_spinner_wrap_set(Elm_Spinner *obj, Eina_Bool wrap) +{ + elm_obj_spinner_wrap_set(obj, wrap); +} + +EAPI Eina_Bool +elm_spinner_wrap_get(const Elm_Spinner *obj) +{ + return elm_obj_spinner_wrap_get(obj); +} + +EAPI void +elm_spinner_interval_set(Elm_Spinner *obj, double interval) +{ + elm_obj_spinner_interval_set(obj, interval); +} + +EAPI double +elm_spinner_interval_get(const Elm_Spinner *obj) +{ + return elm_obj_spinner_interval_get(obj); +} + +EAPI void +elm_spinner_round_set(Elm_Spinner *obj, int rnd) +{ + elm_obj_spinner_round_set(obj, rnd); +} + +EAPI int +elm_spinner_round_get(const Elm_Spinner *obj) +{ + return elm_obj_spinner_round_get(obj); +} + +EAPI void +elm_spinner_editable_set(Elm_Spinner *obj, Eina_Bool editable) +{ + elm_obj_spinner_editable_set(obj, editable); +} + +EAPI Eina_Bool +elm_spinner_editable_get(const Elm_Spinner *obj) +{ + return elm_obj_spinner_editable_get(obj); +} + +EAPI void +elm_spinner_base_set(Elm_Spinner *obj, double base) +{ + elm_obj_spinner_base_set(obj, base); +} + +EAPI double +elm_spinner_base_get(const Elm_Spinner *obj) +{ + return elm_obj_spinner_base_get(obj); +} + +EAPI void +elm_spinner_label_format_set(Elm_Spinner *obj, const char *fmt) +{ + elm_obj_spinner_label_format_set(obj, fmt); +} + +EAPI const char * +elm_spinner_label_format_get(const Elm_Spinner *obj) +{ + return elm_obj_spinner_label_format_get(obj); +} + +EAPI void +elm_spinner_special_value_add(Elm_Spinner *obj, double value, const char *label) +{ + elm_obj_spinner_special_value_add(obj, value, label); +} diff --git a/src/lib/elementary/elm_spinner_eo.legacy.h b/src/lib/elementary/elm_spinner_eo.legacy.h new file mode 100644 index 0000000000..798ec39d37 --- /dev/null +++ b/src/lib/elementary/elm_spinner_eo.legacy.h @@ -0,0 +1,295 @@ +#ifndef _ELM_SPINNER_EO_LEGACY_H_ +#define _ELM_SPINNER_EO_LEGACY_H_ + +#ifndef _ELM_SPINNER_EO_CLASS_TYPE +#define _ELM_SPINNER_EO_CLASS_TYPE + +typedef Eo Elm_Spinner; + +#endif + +#ifndef _ELM_SPINNER_EO_TYPES +#define _ELM_SPINNER_EO_TYPES + + +#endif + +/** + * @brief Control whether the spinner should wrap when it reaches its minimum + * or maximum value. + * + * Disabled by default. If disabled, when the user tries to increment the + * value, but displayed value plus step value is bigger than maximum value, the + * new value will be the maximum value. The same happens when the user tries to + * decrement it, but the value less step is less than minimum value. In this + * case, the new displayed value will be the minimum value. + * + * When wrap is enabled, when the user tries to increment the value, but + * displayed value plus step value is bigger than maximum value, the new value + * will be the minimum value. When the the user tries to decrement it, but the + * value less step is less than minimum value, the new displayed value will be + * the maximum value. + * + * E.g.: @c min = 10 @c max = 50 @c step = 20 @c displayed = 20 + * + * When the user decrement value (using left or bottom arrow), it will displays + * $50. + * + * @param[in] obj The object. + * @param[in] wrap @c true to enable wrap or @c false to disable it. + * + * @ingroup Elm_Spinner_Group + */ +EAPI void elm_spinner_wrap_set(Elm_Spinner *obj, Eina_Bool wrap); + +/** + * @brief Control whether the spinner should wrap when it reaches its minimum + * or maximum value. + * + * Disabled by default. If disabled, when the user tries to increment the + * value, but displayed value plus step value is bigger than maximum value, the + * new value will be the maximum value. The same happens when the user tries to + * decrement it, but the value less step is less than minimum value. In this + * case, the new displayed value will be the minimum value. + * + * When wrap is enabled, when the user tries to increment the value, but + * displayed value plus step value is bigger than maximum value, the new value + * will be the minimum value. When the the user tries to decrement it, but the + * value less step is less than minimum value, the new displayed value will be + * the maximum value. + * + * E.g.: @c min = 10 @c max = 50 @c step = 20 @c displayed = 20 + * + * When the user decrement value (using left or bottom arrow), it will displays + * $50. + * + * @param[in] obj The object. + * + * @return @c true to enable wrap or @c false to disable it. + * + * @ingroup Elm_Spinner_Group + */ +EAPI Eina_Bool elm_spinner_wrap_get(const Elm_Spinner *obj); + +/** + * @brief Control the interval on time updates for an user mouse button hold on + * spinner widgets' arrows. + * + * This interval value is decreased while the user holds the mouse pointer + * either incrementing or decrementing spinner's value. + * + * This helps the user to get to a given value distant from the current one + * easier/faster, as it will start to change quicker and quicker on mouse + * button holds. + * + * The calculation for the next change 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 changes is $0.85 seconds. + * + * @param[in] obj The object. + * @param[in] interval The (first) interval value in seconds. + * + * @ingroup Elm_Spinner_Group + */ +EAPI void elm_spinner_interval_set(Elm_Spinner *obj, double interval); + +/** + * @brief Control the interval on time updates for an user mouse button hold on + * spinner widgets' arrows. + * + * This interval value is decreased while the user holds the mouse pointer + * either incrementing or decrementing spinner's value. + * + * This helps the user to get to a given value distant from the current one + * easier/faster, as it will start to change quicker and quicker on mouse + * button holds. + * + * The calculation for the next change 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 changes is $0.85 seconds. + * + * @param[in] obj The object. + * + * @return The (first) interval value in seconds. + * + * @ingroup Elm_Spinner_Group + */ +EAPI double elm_spinner_interval_get(const Elm_Spinner *obj); + +/** + * @brief Control the round value for rounding + * + * Sets the rounding value used for value rounding in the spinner. + * + * @param[in] obj The object. + * @param[in] rnd The rounding value + * + * @ingroup Elm_Spinner_Group + */ +EAPI void elm_spinner_round_set(Elm_Spinner *obj, int rnd); + +/** + * @brief Control the round value for rounding + * + * Sets the rounding value used for value rounding in the spinner. + * + * @param[in] obj The object. + * + * @return The rounding value + * + * @ingroup Elm_Spinner_Group + */ +EAPI int elm_spinner_round_get(const Elm_Spinner *obj); + +/** + * @brief Control whether the spinner can be directly edited by the user or + * not. + * + * Spinner objects can have edition disabled, in which state they will be + * changed only by arrows. Useful for contexts where you don't want your users + * to interact with it writing the value. Specially when using special values, + * the user can see real value instead of special label on edition. + * + * It's enabled by default. + * + * @param[in] obj The object. + * @param[in] editable @c true to allow users to edit it or @c false to don't + * allow users to edit it directly. + * + * @ingroup Elm_Spinner_Group + */ +EAPI void elm_spinner_editable_set(Elm_Spinner *obj, Eina_Bool editable); + +/** + * @brief Control whether the spinner can be directly edited by the user or + * not. + * + * Spinner objects can have edition disabled, in which state they will be + * changed only by arrows. Useful for contexts where you don't want your users + * to interact with it writing the value. Specially when using special values, + * the user can see real value instead of special label on edition. + * + * It's enabled by default. + * + * @param[in] obj The object. + * + * @return @c true to allow users to edit it or @c false to don't allow users + * to edit it directly. + * + * @ingroup Elm_Spinner_Group + */ +EAPI Eina_Bool elm_spinner_editable_get(const Elm_Spinner *obj); + +/** + * @brief Control the base for rounding + * + * Rounding works as follows: + * + * rounded_val = base + (double)(((value - base) / round) * round) + * + * Where rounded_val, value and base are doubles, and round is an integer. + * + * This means that things will be rounded to increments (or decrements) of + * "round" starting from value @c base. The default base for rounding is 0. + * + * Example: round = 3, base = 2 Values: ..., -2, 0, 2, 5, 8, 11, 14, ... + * + * Example: round = 2, base = 5.5 Values: ..., -0.5, 1.5, 3.5, 5.5, 7.5, 9.5, + * 11.5, ... + * + * @param[in] obj The object. + * @param[in] base The base value + * + * @ingroup Elm_Spinner_Group + */ +EAPI void elm_spinner_base_set(Elm_Spinner *obj, double base); + +/** + * @brief Control the base for rounding + * + * Rounding works as follows: + * + * rounded_val = base + (double)(((value - base) / round) * round) + * + * Where rounded_val, value and base are doubles, and round is an integer. + * + * This means that things will be rounded to increments (or decrements) of + * "round" starting from value @c base. The default base for rounding is 0. + * + * Example: round = 3, base = 2 Values: ..., -2, 0, 2, 5, 8, 11, 14, ... + * + * Example: round = 2, base = 5.5 Values: ..., -0.5, 1.5, 3.5, 5.5, 7.5, 9.5, + * 11.5, ... + * + * @param[in] obj The object. + * + * @return The base value + * + * @ingroup Elm_Spinner_Group + */ +EAPI double elm_spinner_base_get(const Elm_Spinner *obj); + +/** + * @brief Control the format string of the displayed label. + * + * If @c NULL, this sets the format to "%.0f". If not it sets the format string + * for the label text. The label text is provided a floating point value, so + * the label text can display up to 1 floating point value. Note that this is + * optional. + * + * Use a format string such as "%1.2f meters" for example, and it will display + * values like: "3.14 meters" for a value equal to 3.14159. + * + * Default is "%0.f". + * + * @param[in] obj The object. + * @param[in] fmt The format string for the label display. + * + * @ingroup Elm_Spinner_Group + */ +EAPI void elm_spinner_label_format_set(Elm_Spinner *obj, const char *fmt); + +/** + * @brief Control the format string of the displayed label. + * + * If @c NULL, this sets the format to "%.0f". If not it sets the format string + * for the label text. The label text is provided a floating point value, so + * the label text can display up to 1 floating point value. Note that this is + * optional. + * + * Use a format string such as "%1.2f meters" for example, and it will display + * values like: "3.14 meters" for a value equal to 3.14159. + * + * Default is "%0.f". + * + * @param[in] obj The object. + * + * @return The format string for the label display. + * + * @ingroup Elm_Spinner_Group + */ +EAPI const char *elm_spinner_label_format_get(const Elm_Spinner *obj); + +/** + * @brief Control special string to display in the place of the numerical + * value. + * + * It's useful for cases when a user should select an item that is better + * indicated by a label than a value. For example, weekdays or months. + * + * @note If another label was previously set to @c value, it will be replaced + * by the new label. + * + * @param[in] obj The object. + * @param[in] value The value to be replaced. + * @param[in] label The label to be used. + * + * @ingroup Elm_Spinner_Group + */ +EAPI void elm_spinner_special_value_add(Elm_Spinner *obj, double value, const char *label); + +#endif diff --git a/src/lib/elementary/elm_spinner_legacy.h b/src/lib/elementary/elm_spinner_legacy.h index 8c4812b013..1b4e241c0c 100644 --- a/src/lib/elementary/elm_spinner_legacy.h +++ b/src/lib/elementary/elm_spinner_legacy.h @@ -148,4 +148,4 @@ EAPI void elm_spinner_value_set(Evas_Object *obj, double val); */ EAPI double elm_spinner_value_get(const Evas_Object *obj); -#include "elm_spinner.eo.legacy.h" +#include "elm_spinner_eo.legacy.h" diff --git a/src/lib/elementary/meson.build b/src/lib/elementary/meson.build index d24f65eaf2..27b4b23761 100644 --- a/src/lib/elementary/meson.build +++ b/src/lib/elementary/meson.build @@ -177,7 +177,6 @@ pub_eo_files = [ 'efl_ui_check_legacy_part.eo', 'efl_ui_progressbar_legacy_part.eo', 'elm_widget_item_container.eo', - 'elm_spinner.eo', 'elm_multibuttonentry_part.eo', 'elm_interface_scrollable.eo', 'elm_atspi_bridge.eo', @@ -795,6 +794,8 @@ elementary_pub_headers = [ 'elm_slideshow_eo.legacy.h', 'elm_slideshow_item_eo.h', 'elm_slideshow_item_eo.legacy.h', + 'elm_spinner_eo.h', + 'elm_spinner_eo.legacy.h', ] elementary_header_src = [ diff --git a/src/modules/elementary/prefs/elm_spinner.c b/src/modules/elementary/prefs/elm_spinner.c index 6b169fca69..2463628e96 100644 --- a/src/modules/elementary/prefs/elm_spinner.c +++ b/src/modules/elementary/prefs/elm_spinner.c @@ -1,5 +1,5 @@ #include "private.h" -#include "elm_spinner.eo.h" +#include "elm_spinner_eo.h" static Elm_Prefs_Item_Type supported_types[] = {