From 380b3eb09a785bab5d3bbd4921712c103b3cddd4 Mon Sep 17 00:00:00 2001 From: Daniel Hirt Date: Tue, 19 Sep 2017 19:17:26 +0300 Subject: [PATCH] Edje: move IMF-related part_text API to legacy --- src/lib/edje/Edje_Legacy.h | 392 ++++++++++++++++++++++++++++++++++++ src/lib/edje/edje_object.eo | 292 --------------------------- src/lib/edje/edje_util.c | 216 +++++++++++++------- 3 files changed, 540 insertions(+), 360 deletions(-) diff --git a/src/lib/edje/Edje_Legacy.h b/src/lib/edje/Edje_Legacy.h index 28c69b6d77..2e1efc8ed4 100644 --- a/src/lib/edje/Edje_Legacy.h +++ b/src/lib/edje/Edje_Legacy.h @@ -2156,6 +2156,398 @@ EAPI char *edje_object_part_text_unescaped_get(const Edje_Object *obj, const cha */ EAPI void edje_object_part_text_insert(Edje_Object *obj, const char *part, const char *text); +/** + * @brief Sets the autocapitalization type on the immodule. + * + * @param[in] part The part name + * @param[in] autocapital_type The type of autocapitalization + * + * @since 1.1.0 + * + * @ingroup Edje_Object + */ +EAPI void edje_object_part_text_autocapital_type_set(Edje_Object *obj, const char *part, Edje_Text_Autocapital_Type autocapital_type); + +/** + * @brief Retrieves the autocapitalization type + * + * @param[in] part The part name + * + * @return The type of autocapitalization + * + * @since 1.1.0 + * + * @ingroup Edje_Object + */ +EAPI Edje_Text_Autocapital_Type edje_object_part_text_autocapital_type_get(const Edje_Object *obj, const char *part); + +/** + * @brief Sets whether the prediction is allowed or not. + * + * @param[in] part The part name + * @param[in] prediction If @c true, the prediction feature is allowed. + * + * @since 1.2.0 + * + * @ingroup Edje_Object + */ +EAPI void edje_object_part_text_prediction_allow_set(Edje_Object *obj, const char *part, Eina_Bool prediction); + +/** + * @brief Gets whether the prediction is allowed or not. + * + * @param[in] part The part name + * + * @return If @c true, the prediction feature is allowed. + * + * @since 1.2.0 + * + * @ingroup Edje_Object + */ +EAPI Eina_Bool edje_object_part_text_prediction_allow_get(const Edje_Object *obj, const char *part); + +/** + * @brief Gets the input method context in entry. + * + * If ecore_imf was not available when edje was compiled, this function returns + * @c null otherwise, the returned pointer is an Ecore_IMF + * + * @param[in] part The part name + * + * @return The input method context (Ecore_IMF_Context *) in entry + * + * @since 1.2.0 + * + * @ingroup Edje_Object + */ +EAPI void *edje_object_part_text_imf_context_get(const Edje_Object *obj, const char *part); + +/** + * @brief Resets the input method context if needed. + * + * This can be necessary in the case where modifying the buffer would confuse + * on-going input method behavior + * + * @param[in] part The part name + * + * @since 1.2.0 + * + * @ingroup Edje_Object + */ +EAPI void edje_object_part_text_imf_context_reset(const Edje_Object *obj, const char *part); + +/** + * @brief Sets the input hint which allows input methods to fine-tune their + * behavior. + * + * @param[in] part The part name + * @param[in] input_hints Input hints + * + * @since 1.12.0 + * + * @ingroup Edje_Object + */ +EAPI void edje_object_part_text_input_hint_set(Edje_Object *obj, const char *part, Edje_Input_Hints input_hints); + +/** + * @brief Gets the value of input hint + * + * @param[in] part The part name + * + * @return Input hints + * + * @since 1.12.0 + * + * @ingroup Edje_Object + */ +EAPI Edje_Input_Hints edje_object_part_text_input_hint_get(const Edje_Object *obj, const char *part); + +/** + * @brief Shows the input panel (virtual keyboard) based on the input panel + * property such as layout, autocapital types, and so on. + * + * Note that input panel is shown or hidden automatically according to the + * focus state. This API can be used in the case of manually controlling by + * using edje_object_part_text_input_panel_enabled_set. + * + * @param[in] part The part name + * + * @since 1.2.0 + * + * @ingroup Edje_Object + */ +EAPI void edje_object_part_text_input_panel_show(const Edje_Object *obj, const char *part); + +/** + * @brief Hides the input panel (virtual keyboard). See also + * @ref edje_object_part_text_input_panel_show + * + * Note that input panel is shown or hidden automatically according to the + * focus state. This API can be used in the case of manually controlling by + * using edje_object_part_text_input_panel_enabled_set. + * + * @param[in] part The part name + * + * @since 1.2.0 + * + * @ingroup Edje_Object + */ +EAPI void edje_object_part_text_input_panel_hide(const Edje_Object *obj, const char *part); + +/** + * @brief Sets the input panel-specific data to deliver to the input panel. + * + * This API is used by applications to deliver specific data to the input + * panel. The data format MUST be negotiated by both application and the input + * panel. The size and format of data are defined by the input panel. + * + * @param[in] part The part name + * @param[in] data The specific data to be set to the input panel. + * @param[in] len The length of data, in bytes, to send to the input panel + * + * @since 1.2.0 + * + * @ingroup Edje_Object + */ +EAPI void edje_object_part_text_input_panel_imdata_set(Edje_Object *obj, const char *part, const void *data, int len); + +/** + * @brief Gets the specific data of the current active input panel. + * + * @param[in] part The part name + * @param[in] data The specific data to be set to the input panel. + * @param[out] len The length of data, in bytes, to send to the input panel + * + * @return FIXME: void needed here? + * + * @since 1.2.0 + * + * @ingroup Edje_Object + */ +EAPI void edje_object_part_text_input_panel_imdata_get(const Edje_Object *obj, const char *part, void *data, int *len); + +/** + * @brief Sets the layout of the input panel. + * + * The layout of the input panel or virtual keyboard can make it easier or + * harder to enter content. This allows you to hint what kind of input you are + * expecting to enter and thus have the input panel automatically come up with + * the right mode. + * + * @param[in] part The part name + * @param[in] layout Layout type of the input panel + * + * @since 1.1 + * + * @ingroup Edje_Object + */ +EAPI void edje_object_part_text_input_panel_layout_set(Edje_Object *obj, const char *part, Edje_Input_Panel_Layout layout); + +/** + * @brief Gets the layout of the input panel. + * + * See also @ref edje_object_part_text_input_panel_layout_set + * + * @param[in] part The part name + * + * @return Layout type of the input panel + * + * @since 1.1 + * + * @ingroup Edje_Object + */ +EAPI Edje_Input_Panel_Layout edje_object_part_text_input_panel_layout_get(const Edje_Object *obj, const char *part); + +/** + * @brief Sets the language mode of the input panel. + * + * This API can be used if you want to show the Alphabet keyboard. + * + * @param[in] part The part name + * @param[in] lang The language to be set to the input panel. + * + * @since 1.2.0 + * + * @ingroup Edje_Object + */ +EAPI void edje_object_part_text_input_panel_language_set(Edje_Object *obj, const char *part, Edje_Input_Panel_Lang lang); + +/** + * @brief Gets the language mode of the input panel. + * + * See also @ref edje_object_part_text_input_panel_language_set for more + * details. + * + * @param[in] part The part name + * + * @return The language to be set to the input panel. + * + * @since 1.2.0 + * + * @ingroup Edje_Object + */ +EAPI Edje_Input_Panel_Lang edje_object_part_text_input_panel_language_get(const Edje_Object *obj, const char *part); + +/** + * @brief Sets the layout variation of the input panel. + * + * The layout variation of the input panel or virtual keyboard can make it + * easier or harder to enter content. This allows you to hint what kind of + * input you are expecting to enter and thus have the input panel automatically + * come up with the right mode. + * + * @param[in] part The part name + * @param[in] variation Layout variation type + * + * @since 1.8 + * + * @ingroup Edje_Object + */ +EAPI void edje_object_part_text_input_panel_layout_variation_set(Edje_Object *obj, const char *part, int variation); + +/** + * @brief Gets the layout variation of the input panel. + * + * See also @ref edje_object_part_text_input_panel_layout_variation_set + * + * @param[in] part The part name + * + * @return Layout variation type + * + * @since 1.8 + * + * @ingroup Edje_Object + */ +EAPI int edje_object_part_text_input_panel_layout_variation_get(const Edje_Object *obj, const char *part); + +/** + * @brief Sets the attribute to show the input panel automatically. + * + * @param[in] part The part name + * @param[in] enabled If @c true, the input panel is appeared when entry is + * clicked or has a focus + * + * @since 1.1.0 + * + * @ingroup Edje_Object + */ +EAPI void edje_object_part_text_input_panel_enabled_set(Edje_Object *obj, const char *part, Eina_Bool enabled); + +/** + * @brief Retrieves the attribute to show the input panel automatically. See + * also @ref edje_object_part_text_input_panel_enabled_set + * + * @param[in] part The part name + * + * @return If @c true, the input panel is appeared when entry is clicked or has + * a focus + * + * @since 1.1.0 + * + * @ingroup Edje_Object + */ +EAPI Eina_Bool edje_object_part_text_input_panel_enabled_get(const Edje_Object *obj, const char *part); + +/** + * @brief Sets the return key on the input panel to be disabled. + * + * @param[in] part The part name + * @param[in] disabled The state + * + * @since 1.2.0 + * + * @ingroup Edje_Object + */ +EAPI void edje_object_part_text_input_panel_return_key_disabled_set(Edje_Object *obj, const char *part, Eina_Bool disabled); + +/** + * @brief Gets whether the return key on the input panel should be disabled or + * not. + * + * @param[in] part The part name + * + * @return The state + * + * @since 1.2.0 + * + * @ingroup Edje_Object + */ +EAPI Eina_Bool edje_object_part_text_input_panel_return_key_disabled_get(const Edje_Object *obj, const char *part); + +/** + * @brief Sets the "return" key type. This type is used to set string or icon + * on the "return" key of the input panel. + * + * An input panel displays the string or icon associated with this type + * + * @param[in] part The part name + * @param[in] return_key_type The type of "return" key on the input panel + * + * @since 1.2.0 + * + * @ingroup Edje_Object + */ +EAPI void edje_object_part_text_input_panel_return_key_type_set(Edje_Object *obj, const char *part, Edje_Input_Panel_Return_Key_Type return_key_type); + +/** + * @brief Gets the "return" key type. + * + * See also @ref edje_object_part_text_input_panel_return_key_type_set() for + * more details + * + * @param[in] part The part name + * + * @return The type of "return" key on the input panel + * + * @since 1.2.0 + * + * @ingroup Edje_Object + */ +EAPI Edje_Input_Panel_Return_Key_Type edje_object_part_text_input_panel_return_key_type_get(const Edje_Object *obj, const char *part); + +/** + * @brief Sets the attribute to show the input panel in case of only an user's + * explicit Mouse Up event. It doesn't request to show the input panel even + * though it has focus. + * + * @param[in] part The part name + * @param[in] ondemand If @c true, the input panel will be shown in case of + * only Mouse up event. (Focus event will be ignored.) + * + * @since 1.9.0 + * + * @ingroup Edje_Object + */ +EAPI void edje_object_part_text_input_panel_show_on_demand_set(Edje_Object *obj, const char *part, Eina_Bool ondemand); + +/** + * @brief Gets the attribute to show the input panel in case of only an user's + * explicit Mouse Up event. + * + * @param[in] part The part name + * + * @return If @c true, the input panel will be shown in case of only Mouse up + * event. (Focus event will be ignored.) + * + * @since 1.9.0 + * + * @ingroup Edje_Object + */ +EAPI Eina_Bool edje_object_part_text_input_panel_show_on_demand_get(const Edje_Object *obj, const char *part); + +/** + * @brief Sets the prediction hint to use an intelligent reply suggestion + * service. + * + * @param[in] part The part name + * @param[in] prediction_hint Prediction hint + * + * @since 1.20.0 + * + * @ingroup Edje_Object + */ +EAPI void edje_object_part_text_prediction_hint_set(Edje_Object *obj, const char *part, const char *prediction_hint); + /** * @brief Whether this object is playing or not. * diff --git a/src/lib/edje/edje_object.eo b/src/lib/edje/edje_object.eo index 13293c7d5d..2463b8408e 100644 --- a/src/lib/edje/edje_object.eo +++ b/src/lib/edje/edje_object.eo @@ -353,42 +353,6 @@ class Edje.Object (Efl.Canvas.Group, Efl.File, Efl.Container, Efl.Part, data: void_ptr; [[The data associated to the callback function.]] } } - @property part_text_autocapital_type { - set { - [[Sets the autocapitalization type on the immodule. - - @since 1.1.0]] - } - get { - [[Retrieves the autocapitalization type - - @since 1.1.0]] - } - keys { - part: string; [[The part name]] - } - values { - autocapital_type: Edje.Text.Autocapital_Type; [[The type of autocapitalization]] - } - } - @property part_text_prediction_allow { - set { - [[Sets whether the prediction is allowed or not. - - @since 1.2.0]] - } - get { - [[Gets whether the prediction is allowed or not. - - @since 1.2.0]] - } - keys { - part: string; [[The part name]] - } - values { - prediction: bool; [[If $true, the prediction feature is allowed.]] - } - } @property item_provider { set { [[Sets the function that provides item objects for named items in an edje entry text @@ -465,262 +429,6 @@ class Edje.Object (Efl.Canvas.Group, Efl.File, Efl.Container, Efl.Part, part: string; [[The part name]] } } - @property part_text_imf_context { - get { - [[Gets the input method context in entry. - - If ecore_imf was not available when edje was compiled, this function returns $null - otherwise, the returned pointer is an Ecore_IMF - - @since 1.2.0]] - return: void_ptr; [[The input method context (Ecore_IMF_Context *) in entry]] - } - keys { - part: string; [[The part name]] - } - } - part_text_imf_context_reset @const { - [[Resets the input method context if needed. - - This can be necessary in the case where modifying the buffer would confuse on-going input method behavior - - @since 1.2.0]] - params { - @in part: string; [[The part name]] - } - } - @property part_text_input_hint { - set { - [[Sets the input hint which allows input methods to fine-tune their behavior. - - @since 1.12.0]] - } - get { - [[Gets the value of input hint - - @since 1.12.0]] - } - keys { - part: string; [[The part name]] - } - values { - input_hints: Edje.Input_Hints; [[Input hints]] - } - } - part_text_input_panel_show @const { - [[Shows the input panel (virtual keyboard) based on the input panel property such as layout, autocapital types, and so on. - - Note that input panel is shown or hidden automatically according to the focus state. - This API can be used in the case of manually controlling by using edje_object_part_text_input_panel_enabled_set. - - @since 1.2.0]] - params { - @in part: string; [[The part name]] - } - } - part_text_input_panel_hide @const { - [[Hides the input panel (virtual keyboard). - See also @.part_text_input_panel_show - - Note that input panel is shown or hidden automatically according to the focus state. - This API can be used in the case of manually controlling by using edje_object_part_text_input_panel_enabled_set. - - @since 1.2.0]] - params { - @in part: string; [[The part name]] - } - } - @property part_text_input_panel_imdata { - set { - [[Sets the input panel-specific data to deliver to the input panel. - - This API is used by applications to deliver specific data to the input panel. - The data format MUST be negotiated by both application and the input panel. - The size and format of data are defined by the input panel. - - @since 1.2.0]] - keys { - part: string; [[The part name]] - data: const(void_ptr); [[The specific data to be set to the input panel.]] - } - } - get { - [[Gets the specific data of the current active input panel. - - @since 1.2.0]] - return: void; [[FIXME: void needed here?]] - keys { - part: string; [[The part name]] - data: void_ptr; [[The specific data to be set to the input panel.]] - } - } - values { - len: int; [[The length of data, in bytes, to send to the input panel]] - } - } - @property part_text_input_panel_layout { - set { - [[Sets the layout of the input panel. - - The layout of the input panel or virtual keyboard can make it easier or - harder to enter content. This allows you to hint what kind of input you - are expecting to enter and thus have the input panel automatically - come up with the right mode. - - @since 1.1]] - } - get { - [[Gets the layout of the input panel. - - See also @.part_text_input_panel_layout.set - - @since 1.1]] - } - keys { - part: string; [[The part name]] - } - values { - layout: Edje.Input_Panel.Layout; [[Layout type of the input panel]] - } - } - @property part_text_input_panel_language { - set { - [[Sets the language mode of the input panel. - - This API can be used if you want to show the Alphabet keyboard. - - @since 1.2.0]] - } - get { - [[Gets the language mode of the input panel. - - See also @.part_text_input_panel_language.set for more details. - - @since 1.2.0]] - } - keys { - part: string; [[The part name]] - } - values { - lang: Edje.Input_Panel.Lang; [[The language to be set to the input panel.]] - } - } - @property part_text_input_panel_layout_variation { - set { - [[Sets the layout variation of the input panel. - - The layout variation of the input panel or virtual keyboard can make it easier or - harder to enter content. This allows you to hint what kind of input you - are expecting to enter and thus have the input panel automatically - come up with the right mode. - - @since 1.8]] - } - get { - [[Gets the layout variation of the input panel. - - See also @.part_text_input_panel_layout_variation.set - - @since 1.8]] - } - keys { - part: string; [[The part name]] - } - values { - variation: int; [[Layout variation type]] - } - } - @property part_text_input_panel_enabled { - set { - [[Sets the attribute to show the input panel automatically. - - @since 1.1.0]] - } - get { - [[Retrieves the attribute to show the input panel automatically. - See also @.part_text_input_panel_enabled.set - - @since 1.1.0]] - } - keys { - part: string; [[The part name]] - } - values { - enabled: bool; [[If $true, the input panel is appeared when entry is clicked or has a focus]] - } - } - @property part_text_input_panel_return_key_disabled { - set { - [[Sets the return key on the input panel to be disabled. - - @since 1.2.0]] - } - get { - [[Gets whether the return key on the input panel should be disabled or not. - - @since 1.2.0]] - } - keys { - part: string; [[The part name]] - } - values { - disabled: bool; [[The state]] - } - } - @property part_text_input_panel_return_key_type { - set { - [[Sets the "return" key type. This type is used to set string or icon on the "return" key of the input panel. - - An input panel displays the string or icon associated with this type - - @since 1.2.0]] - } - get { - [[Gets the "return" key type. - - See also @.part_text_input_panel_return_key_type.set() for more details - - @since 1.2.0]] - } - keys { - part: string; [[The part name]] - } - values { - return_key_type: Edje.Input_Panel.Return_Key_Type; [[The type of "return" key on the input panel]] - } - } - @property part_text_input_panel_show_on_demand { - set { - [[Sets the attribute to show the input panel in case of only an user's explicit Mouse Up event. - It doesn't request to show the input panel even though it has focus. - - @since 1.9.0]] - } - get { - [[Gets the attribute to show the input panel in case of only an user's explicit Mouse Up event. - - @since 1.9.0]] - } - keys { - part: string; [[The part name]] - } - values { - ondemand: bool; [[If $true, the input panel will be shown in case of only Mouse up event. (Focus event will be ignored.)]] - } - } - @property part_text_prediction_hint { - set { - [[Sets the prediction hint to use an intelligent reply suggestion service. - - @since 1.20.0]] - } - keys { - part: string; [[The part name]] - } - values { - prediction_hint: string; [[Prediction hint]] - } - } /* TEXT PART APIS END ------------------------------------------------ */ @property seat { diff --git a/src/lib/edje/edje_util.c b/src/lib/edje/edje_util.c index 99acd13ea2..67c18c6535 100644 --- a/src/lib/edje/edje_util.c +++ b/src/lib/edje/edje_util.c @@ -2091,22 +2091,6 @@ _edje_object_part_text_select_extend(Eo *obj EINA_UNUSED, Edje *ed, const char * _edje_entry_select_extend(rp); } -EOLIAN void * -_edje_object_part_text_imf_context_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part) -{ - Edje_Real_Part *rp; - - if ((!ed) || (!part)) return NULL; - - rp = _edje_real_part_recursive_get(&ed, (char *)part); - if (!rp) return NULL; - - if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE) - return _edje_entry_imf_context_get(rp); - - return NULL; -} - EOLIAN Eina_Bool _edje_object_part_text_cursor_next(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Cursor cur) { @@ -2289,10 +2273,32 @@ _edje_object_part_text_cursor_pos_get(Eo *obj EINA_UNUSED, Edje *ed, const char return ret; } -EOLIAN void -_edje_object_part_text_imf_context_reset(Eo *obj EINA_UNUSED, Edje *ed, const char *part) +EAPI void * +edje_object_part_text_imf_context_get(const Eo *obj, const char *part) { Edje_Real_Part *rp; + Edje *ed; + + ed = _edje_fetch(obj); + + if ((!ed) || (!part)) return NULL; + + rp = _edje_real_part_recursive_get(&ed, (char *)part); + if (!rp) return NULL; + + if (rp->part->entry_mode > EDJE_ENTRY_EDIT_MODE_NONE) + return _edje_entry_imf_context_get(rp); + + return NULL; +} + +EAPI void +edje_object_part_text_imf_context_reset(const Eo *obj, const char *part) +{ + Edje_Real_Part *rp; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return; rp = _edje_real_part_recursive_get(&ed, part); @@ -2303,10 +2309,13 @@ _edje_object_part_text_imf_context_reset(Eo *obj EINA_UNUSED, Edje *ed, const ch } } -EOLIAN void -_edje_object_part_text_input_panel_layout_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Input_Panel_Layout layout) +EAPI void +edje_object_part_text_input_panel_layout_set(Eo *obj, const char *part, Edje_Input_Panel_Layout layout) { Edje_Real_Part *rp; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return; rp = _edje_real_part_recursive_get(&ed, part); @@ -2317,12 +2326,15 @@ _edje_object_part_text_input_panel_layout_set(Eo *obj EINA_UNUSED, Edje *ed, con } } -EOLIAN Edje_Input_Panel_Layout -_edje_object_part_text_input_panel_layout_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part) +EAPI Edje_Input_Panel_Layout +edje_object_part_text_input_panel_layout_get(const Eo *obj, const char *part) { Edje_Input_Panel_Layout ret; Edje_Real_Part *rp; ret = EDJE_INPUT_PANEL_LAYOUT_INVALID; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return ret; rp = _edje_real_part_recursive_get(&ed, part); @@ -2335,10 +2347,13 @@ _edje_object_part_text_input_panel_layout_get(Eo *obj EINA_UNUSED, Edje *ed, con return ret; } -EOLIAN void -_edje_object_part_text_input_panel_layout_variation_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, int variation) +EAPI void +edje_object_part_text_input_panel_layout_variation_set(Eo *obj, const char *part, int variation) { Edje_Real_Part *rp; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return; rp = _edje_real_part_recursive_get(&ed, part); @@ -2349,12 +2364,15 @@ _edje_object_part_text_input_panel_layout_variation_set(Eo *obj EINA_UNUSED, Edj } } -EOLIAN int -_edje_object_part_text_input_panel_layout_variation_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part) +EAPI int +edje_object_part_text_input_panel_layout_variation_get(const Eo *obj, const char *part) { int r; Edje_Real_Part *rp; + Edje *ed; + + ed = _edje_fetch(obj); r = 0; if ((!ed) || (!part)) return r; @@ -2367,11 +2385,13 @@ _edje_object_part_text_input_panel_layout_variation_get(Eo *obj EINA_UNUSED, Edj return r; } -EOLIAN void -_edje_object_part_text_autocapital_type_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Text_Autocapital_Type autocapital_type) +EAPI void +edje_object_part_text_autocapital_type_set(Eo *obj, const char *part, Edje_Text_Autocapital_Type autocapital_type) { Edje_Real_Part *rp; + Edje *ed; + ed = _edje_fetch(obj); if ((!ed) || (!part)) return; rp = _edje_real_part_recursive_get(&ed, part); if (!rp) return; @@ -2381,12 +2401,15 @@ _edje_object_part_text_autocapital_type_set(Eo *obj EINA_UNUSED, Edje *ed, const } } -EOLIAN Edje_Text_Autocapital_Type -_edje_object_part_text_autocapital_type_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part) +EAPI Edje_Text_Autocapital_Type +edje_object_part_text_autocapital_type_get(const Eo *obj, const char *part) { Edje_Text_Autocapital_Type ret; Edje_Real_Part *rp; ret = EDJE_TEXT_AUTOCAPITAL_TYPE_NONE; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return ret; rp = _edje_real_part_recursive_get(&ed, part); @@ -2399,10 +2422,13 @@ _edje_object_part_text_autocapital_type_get(Eo *obj EINA_UNUSED, Edje *ed, const return ret; } -EOLIAN void -_edje_object_part_text_prediction_allow_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Eina_Bool prediction) +EAPI void +edje_object_part_text_prediction_allow_set(Eo *obj, const char *part, Eina_Bool prediction) { Edje_Real_Part *rp; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return; rp = _edje_real_part_recursive_get(&ed, part); @@ -2413,12 +2439,15 @@ _edje_object_part_text_prediction_allow_set(Eo *obj EINA_UNUSED, Edje *ed, const } } -EOLIAN Eina_Bool -_edje_object_part_text_prediction_allow_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part) +EAPI Eina_Bool +edje_object_part_text_prediction_allow_get(const Eo *obj, const char *part) { Eina_Bool ret; Edje_Real_Part *rp; ret = EINA_FALSE; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return ret; rp = _edje_real_part_recursive_get(&ed, part); @@ -2431,10 +2460,13 @@ _edje_object_part_text_prediction_allow_get(Eo *obj EINA_UNUSED, Edje *ed, const return ret; } -EOLIAN void -_edje_object_part_text_input_hint_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Input_Hints input_hints) +EAPI void +edje_object_part_text_input_hint_set(Eo *obj, const char *part, Edje_Input_Hints input_hints) { Edje_Real_Part *rp; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return; rp = _edje_real_part_recursive_get(&ed, part); @@ -2445,10 +2477,13 @@ _edje_object_part_text_input_hint_set(Eo *obj EINA_UNUSED, Edje *ed, const char } } -EOLIAN Edje_Input_Hints -_edje_object_part_text_input_hint_get(const Eo *obj EINA_UNUSED, Edje *ed, const char *part) +EAPI Edje_Input_Hints +edje_object_part_text_input_hint_get(const Eo *obj, const char *part) { Edje_Real_Part *rp; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return EINA_FALSE; rp = _edje_real_part_recursive_get(&ed, part); @@ -2460,10 +2495,13 @@ _edje_object_part_text_input_hint_get(const Eo *obj EINA_UNUSED, Edje *ed, const return EINA_FALSE; } -EOLIAN void -_edje_object_part_text_input_panel_enabled_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Eina_Bool enabled) +EAPI void +edje_object_part_text_input_panel_enabled_set(Eo *obj, const char *part, Eina_Bool enabled) { Edje_Real_Part *rp; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return; rp = _edje_real_part_recursive_get(&ed, part); @@ -2474,12 +2512,15 @@ _edje_object_part_text_input_panel_enabled_set(Eo *obj EINA_UNUSED, Edje *ed, co } } -EOLIAN Eina_Bool -_edje_object_part_text_input_panel_enabled_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part) +EAPI Eina_Bool +edje_object_part_text_input_panel_enabled_get(const Eo *obj, const char *part) { Eina_Bool ret; Edje_Real_Part *rp; ret = EINA_FALSE; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return ret; rp = _edje_real_part_recursive_get(&ed, part); @@ -2492,10 +2533,13 @@ _edje_object_part_text_input_panel_enabled_get(Eo *obj EINA_UNUSED, Edje *ed, co return ret; } -EOLIAN void -_edje_object_part_text_input_panel_show(Eo *obj EINA_UNUSED, Edje *ed, const char *part) +EAPI void +edje_object_part_text_input_panel_show(const Eo *obj, const char *part) { Edje_Real_Part *rp; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return; rp = _edje_real_part_recursive_get(&ed, part); @@ -2504,10 +2548,13 @@ _edje_object_part_text_input_panel_show(Eo *obj EINA_UNUSED, Edje *ed, const cha _edje_entry_input_panel_show(rp); } -EOLIAN void -_edje_object_part_text_input_panel_hide(Eo *obj EINA_UNUSED, Edje *ed, const char *part) +EAPI void +edje_object_part_text_input_panel_hide(const Eo *obj, const char *part) { Edje_Real_Part *rp; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return; rp = _edje_real_part_recursive_get(&ed, part); @@ -2516,10 +2563,13 @@ _edje_object_part_text_input_panel_hide(Eo *obj EINA_UNUSED, Edje *ed, const cha _edje_entry_input_panel_hide(rp); } -EOLIAN void -_edje_object_part_text_input_panel_language_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Input_Panel_Lang lang) +EAPI void +edje_object_part_text_input_panel_language_set(Eo *obj, const char *part, Edje_Input_Panel_Lang lang) { Edje_Real_Part *rp; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return; rp = _edje_real_part_recursive_get(&ed, part); @@ -2530,12 +2580,15 @@ _edje_object_part_text_input_panel_language_set(Eo *obj EINA_UNUSED, Edje *ed, c } } -EOLIAN Edje_Input_Panel_Lang -_edje_object_part_text_input_panel_language_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part) +EAPI Edje_Input_Panel_Lang +edje_object_part_text_input_panel_language_get(const Eo *obj, const char *part) { Edje_Input_Panel_Lang ret; Edje_Real_Part *rp; ret = EDJE_INPUT_PANEL_LANG_AUTOMATIC; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return ret; rp = _edje_real_part_recursive_get(&ed, part); @@ -2548,10 +2601,13 @@ _edje_object_part_text_input_panel_language_get(Eo *obj EINA_UNUSED, Edje *ed, c return ret; } -EOLIAN void -_edje_object_part_text_input_panel_imdata_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, const void *data, int len) +EAPI void +edje_object_part_text_input_panel_imdata_set(Eo *obj, const char *part, const void *data, int len) { Edje_Real_Part *rp; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return; rp = _edje_real_part_recursive_get(&ed, part); @@ -2562,10 +2618,13 @@ _edje_object_part_text_input_panel_imdata_set(Eo *obj EINA_UNUSED, Edje *ed, con } } -EOLIAN void -_edje_object_part_text_input_panel_imdata_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part, void *data, int *len) +EAPI void +edje_object_part_text_input_panel_imdata_get(const Eo *obj, const char *part, void *data, int *len) { Edje_Real_Part *rp; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return; rp = _edje_real_part_recursive_get(&ed, part); @@ -2576,10 +2635,13 @@ _edje_object_part_text_input_panel_imdata_get(Eo *obj EINA_UNUSED, Edje *ed, con } } -EOLIAN void -_edje_object_part_text_input_panel_return_key_type_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Edje_Input_Panel_Return_Key_Type return_key_type) +EAPI void +edje_object_part_text_input_panel_return_key_type_set(Eo *obj, const char *part, Edje_Input_Panel_Return_Key_Type return_key_type) { Edje_Real_Part *rp; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return; rp = _edje_real_part_recursive_get(&ed, part); @@ -2590,12 +2652,15 @@ _edje_object_part_text_input_panel_return_key_type_set(Eo *obj EINA_UNUSED, Edje } } -EOLIAN Edje_Input_Panel_Return_Key_Type -_edje_object_part_text_input_panel_return_key_type_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part) +EAPI Edje_Input_Panel_Return_Key_Type +edje_object_part_text_input_panel_return_key_type_get(const Eo *obj, const char *part) { Edje_Input_Panel_Return_Key_Type ret; Edje_Real_Part *rp; ret = EDJE_INPUT_PANEL_RETURN_KEY_TYPE_DEFAULT; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return ret; rp = _edje_real_part_recursive_get(&ed, part); @@ -2608,10 +2673,13 @@ _edje_object_part_text_input_panel_return_key_type_get(Eo *obj EINA_UNUSED, Edje return ret; } -EOLIAN void -_edje_object_part_text_input_panel_return_key_disabled_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Eina_Bool disabled) +EAPI void +edje_object_part_text_input_panel_return_key_disabled_set(Eo *obj, const char *part, Eina_Bool disabled) { Edje_Real_Part *rp; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return; rp = _edje_real_part_recursive_get(&ed, part); @@ -2622,12 +2690,15 @@ _edje_object_part_text_input_panel_return_key_disabled_set(Eo *obj EINA_UNUSED, } } -EOLIAN Eina_Bool -_edje_object_part_text_input_panel_return_key_disabled_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part) +EAPI Eina_Bool +edje_object_part_text_input_panel_return_key_disabled_get(const Eo *obj, const char *part) { Eina_Bool ret; Edje_Real_Part *rp; + Edje *ed; + ret = EINA_FALSE; + ed = _edje_fetch(obj); if ((!ed) || (!part)) return ret; rp = _edje_real_part_recursive_get(&ed, part); @@ -2640,10 +2711,13 @@ _edje_object_part_text_input_panel_return_key_disabled_get(Eo *obj EINA_UNUSED, return ret; } -EOLIAN void -_edje_object_part_text_input_panel_show_on_demand_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, Eina_Bool ondemand) +EAPI void +edje_object_part_text_input_panel_show_on_demand_set(Eo *obj, const char *part, Eina_Bool ondemand) { Edje_Real_Part *rp; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return; rp = _edje_real_part_recursive_get(&ed, part); @@ -2654,12 +2728,15 @@ _edje_object_part_text_input_panel_show_on_demand_set(Eo *obj EINA_UNUSED, Edje } } -EOLIAN Eina_Bool -_edje_object_part_text_input_panel_show_on_demand_get(Eo *obj EINA_UNUSED, Edje *ed, const char *part) +EAPI Eina_Bool +edje_object_part_text_input_panel_show_on_demand_get(const Eo *obj, const char *part) { Eina_Bool ret; Edje_Real_Part *rp; + Edje *ed; + ret = EINA_FALSE; + ed = _edje_fetch(obj); if ((!ed) || (!part)) return ret; rp = _edje_real_part_recursive_get(&ed, part); @@ -2672,10 +2749,13 @@ _edje_object_part_text_input_panel_show_on_demand_get(Eo *obj EINA_UNUSED, Edje return ret; } -EOLIAN void -_edje_object_part_text_prediction_hint_set(Eo *obj EINA_UNUSED, Edje *ed, const char *part, const char *prediction_hint) +EAPI void +edje_object_part_text_prediction_hint_set(Eo *obj, const char *part, const char *prediction_hint) { Edje_Real_Part *rp; + Edje *ed; + + ed = _edje_fetch(obj); if ((!ed) || (!part)) return; rp = _edje_real_part_recursive_get(&ed, part);