From 8cafe361772512280127f3ecc817c745cb766bf6 Mon Sep 17 00:00:00 2001 From: Mike Blumenkrantz Date: Tue, 5 Mar 2019 17:00:37 -0500 Subject: [PATCH] elm_entry: remove all legacy usage from eo files this takes the current generated output from eolian for legacy code in efl and adds it to the tree, then removes legacy references from the corresponding eo files. in the case where the entire eo file was for a legacy object, that eo file has been removed from the tree ref T7724 Reviewed-by: Cedric BAIL Differential Revision: https://phab.enlightenment.org/D8166 Change-Id: I83c9a33de81a6f4c2332d06e04924bcf4396d5b6 --- src/Makefile_Elementary.am | 5 +- src/bin/elementary/test_entry.c | 2 +- src/lib/elementary/efl_ui_layout.c | 2 +- src/lib/elementary/efl_ui_spin_button.c | 2 +- src/lib/elementary/efl_ui_tags.c | 2 +- src/lib/elementary/elc_combobox.c | 2 +- src/lib/elementary/elc_fileselector.c | 2 +- src/lib/elementary/elc_fileselector_entry.c | 2 +- src/lib/elementary/elc_multibuttonentry.c | 2 +- src/lib/elementary/elm_entry.c | 2 +- src/lib/elementary/elm_entry.eo | 969 ------------------ src/lib/elementary/elm_entry_eo.c | 1190 ++++++++++++++++++++++ src/lib/elementary/elm_entry_eo.h | 1448 ++++++++++++++++++++++++++- src/lib/elementary/elm_entry_eo.legacy.c | 582 +++++++++++ src/lib/elementary/elm_entry_eo.legacy.h | 1252 +++++++++++++++++++++++ src/lib/elementary/elm_entry_legacy.h | 2 +- src/lib/elementary/elm_spinner.c | 2 +- src/lib/elementary/elm_view_form.c | 2 +- src/lib/elementary/elm_widget_entry.h | 2 +- src/lib/elementary/meson.build | 3 +- src/modules/elementary/prefs/elm_entry.c | 2 +- 21 files changed, 4491 insertions(+), 986 deletions(-) delete mode 100644 src/lib/elementary/elm_entry.eo create mode 100644 src/lib/elementary/elm_entry_eo.c create mode 100644 src/lib/elementary/elm_entry_eo.legacy.c create mode 100644 src/lib/elementary/elm_entry_eo.legacy.h diff --git a/src/Makefile_Elementary.am b/src/Makefile_Elementary.am index baa2ce3..4f622e5 100644 --- a/src/Makefile_Elementary.am +++ b/src/Makefile_Elementary.am @@ -199,7 +199,6 @@ elm_legacy_eolian_files = \ lib/elementary/efl_ui_animation_view.eo \ lib/elementary/efl_ui_clock_legacy.eo \ lib/elementary/elm_interface_fileselector.eo \ - lib/elementary/elm_entry.eo \ lib/elementary/elm_fileselector.eo \ lib/elementary/elm_gengrid.eo \ lib/elementary/elm_gengrid_pan.eo \ @@ -357,6 +356,8 @@ lib/elementary/elm_diskselector_eo.legacy.c \ lib/elementary/elm_diskselector_eo.c \ lib/elementary/elm_diskselector_item_eo.legacy.c \ lib/elementary/elm_diskselector_item_eo.c \ +lib/elementary/elm_entry_eo.legacy.c \ +lib/elementary/elm_entry_eo.c \ lib/elementary/elm_hoversel_eo.c \ lib/elementary/elm_hoversel_item_eo.c \ lib/elementary/elm_hoversel_item_eo.legacy.c @@ -440,6 +441,8 @@ lib/elementary/elm_diskselector_eo.h \ lib/elementary/elm_diskselector_eo.legacy.h \ lib/elementary/elm_diskselector_item_eo.h \ lib/elementary/elm_diskselector_item_eo.legacy.h \ +lib/elementary/elm_entry_eo.h \ +lib/elementary/elm_entry_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/bin/elementary/test_entry.c b/src/bin/elementary/test_entry.c index cf3b1484..dde8927 100644 --- a/src/bin/elementary/test_entry.c +++ b/src/bin/elementary/test_entry.c @@ -5,7 +5,7 @@ #include // FIXME: elm_entry is not part of EO API, the below test cases may be useless -#include "elm_entry.eo.h" +#include "elm_entry_eo.h" #include "elm_popup.eo.h" static void diff --git a/src/lib/elementary/efl_ui_layout.c b/src/lib/elementary/efl_ui_layout.c index eb3872a..c9c06c1 100644 --- a/src/lib/elementary/efl_ui_layout.c +++ b/src/lib/elementary/efl_ui_layout.c @@ -13,7 +13,7 @@ #include "elm_priv.h" #include "elm_widget_layout.h" #include "elm_part_helper.h" -#include "elm_entry.eo.h" +#include "elm_entry_eo.h" #define MY_CLASS EFL_UI_LAYOUT_BASE_CLASS #define MY_CLASS_PFX efl_ui_layout diff --git a/src/lib/elementary/efl_ui_spin_button.c b/src/lib/elementary/efl_ui_spin_button.c index c64642f..0194921 100644 --- a/src/lib/elementary/efl_ui_spin_button.c +++ b/src/lib/elementary/efl_ui_spin_button.c @@ -12,7 +12,7 @@ #include "elm_priv.h" #include "efl_ui_spin_button_private.h" #include "efl_ui_spin_private.h" -#include "elm_entry.eo.h" +#include "elm_entry_eo.h" #define MY_CLASS EFL_UI_SPIN_BUTTON_CLASS diff --git a/src/lib/elementary/efl_ui_tags.c b/src/lib/elementary/efl_ui_tags.c index 348c877..8d377b6 100644 --- a/src/lib/elementary/efl_ui_tags.c +++ b/src/lib/elementary/efl_ui_tags.c @@ -5,7 +5,7 @@ #include #include "elm_priv.h" #include "efl_ui_tags_private.h" -#include "elm_entry.eo.h" +#include "elm_entry_eo.h" #define MY_CLASS EFL_UI_TAGS_CLASS diff --git a/src/lib/elementary/elc_combobox.c b/src/lib/elementary/elc_combobox.c index ba4d39e..4a67f07 100644 --- a/src/lib/elementary/elc_combobox.c +++ b/src/lib/elementary/elc_combobox.c @@ -10,7 +10,7 @@ #include #include "elm_priv.h" #include "elm_widget_combobox.h" -#include "elm_entry.eo.h" +#include "elm_entry_eo.h" #include "elm_genlist.eo.h" #include "elm_hover.eo.h" diff --git a/src/lib/elementary/elc_fileselector.c b/src/lib/elementary/elc_fileselector.c index 6f523dc..eaf27b8 100644 --- a/src/lib/elementary/elc_fileselector.c +++ b/src/lib/elementary/elc_fileselector.c @@ -21,7 +21,7 @@ #include "elm_fileselector_entry.eo.h" #include "elm_interface_fileselector.h" #include "elm_widget_fileselector.h" -#include "elm_entry.eo.h" +#include "elm_entry_eo.h" #include "elm_fileselector.eo.h" #include "elm_genlist.eo.h" #include "elm_gengrid.eo.h" diff --git a/src/lib/elementary/elc_fileselector_entry.c b/src/lib/elementary/elc_fileselector_entry.c index 4b84254..9004408 100644 --- a/src/lib/elementary/elc_fileselector_entry.c +++ b/src/lib/elementary/elc_fileselector_entry.c @@ -13,7 +13,7 @@ #include "elm_fileselector_entry.eo.h" #include "elm_interface_fileselector.h" #include "elm_widget_fileselector_entry.h" -#include "elm_entry.eo.h" +#include "elm_entry_eo.h" #include "elm_fileselector.eo.h" #include "elm_fileselector_entry_part.eo.h" diff --git a/src/lib/elementary/elc_multibuttonentry.c b/src/lib/elementary/elc_multibuttonentry.c index c52799f..9c0b082 100644 --- a/src/lib/elementary/elc_multibuttonentry.c +++ b/src/lib/elementary/elc_multibuttonentry.c @@ -13,7 +13,7 @@ #include "elm_priv.h" #include "elm_widget_multibuttonentry.h" #include "elm_multibuttonentry_part.eo.h" -#include "elm_entry.eo.h" +#include "elm_entry_eo.h" #include "elm_part_helper.h" #define MY_CLASS ELM_MULTIBUTTONENTRY_CLASS diff --git a/src/lib/elementary/elm_entry.c b/src/lib/elementary/elm_entry.c index 813a122..290d059 100644 --- a/src/lib/elementary/elm_entry.c +++ b/src/lib/elementary/elm_entry.c @@ -9313,4 +9313,4 @@ ELM_LAYOUT_TEXT_ALIASES_IMPLEMENT(MY_CLASS_PFX) * END * *******/ -#include "elm_entry.eo.c" +#include "elm_entry_eo.c" diff --git a/src/lib/elementary/elm_entry.eo b/src/lib/elementary/elm_entry.eo deleted file mode 100644 index 8e066b1..0000000 --- a/src/lib/elementary/elm_entry.eo +++ /dev/null @@ -1,969 +0,0 @@ -import elm_general; - -type Elm_Entry_Item_Provider_Cb: __undefined_type; [[Elementary entry item provider callback type]] -type Elm_Entry_Filter_Cb: __undefined_type; [[Elementary entry filter callback type]] - -class Elm.Entry extends Efl.Ui.Layout_Base implements Elm.Interface_Scrollable, Efl.Ui.Clickable, - Efl.Access.Text, Efl.Access.Editable.Text, Efl.File, - Efl.Ui.Selectable, Efl.Ui.Scrollable, Efl.Access.Widget.Action, - Efl.Ui.Legacy -{ - [[Elementary entry class]] - legacy_prefix: elm_entry; - eo_prefix: elm_obj_entry; - event_prefix: elm_entry; - methods { - @property scrollable { - set { - [[Enable or disable scrolling in entry - - Normally the entry is not scrollable unless you enable it with this call. - ]] - } - get { - [[Get the scrollable state of the entry - - Normally the entry is not scrollable. This gets the scrollable state - of the entry. - ]] - } - values { - scroll: bool; [[$true if it is to be scrollable, $false otherwise.]] - } - } - @property input_panel_show_on_demand { - set { - [[Set 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 - ]] - } - get { - [[Get the attribute to show the input panel in case of only an user's explicit Mouse Up event. - - @since 1.9 - ]] - } - values { - ondemand: bool; [[If $true, the input panel will be shown in case of only Mouse up event. - (Focus event will be ignored.) - ]] - } - } - @property context_menu_disabled { - set { - [[This disables the entry's contextual (longpress) menu.]] - } - get { - [[This returns whether the entry's contextual (longpress) menu is - disabled. - ]] - } - values { - disabled: bool; [[If $true, the menu is disabled.]] - } - } - @property cnp_mode { - set { - [[Control pasting of text and images for the widget. - - Normally the entry allows both text and images to be pasted. - By setting cnp_mode to be #ELM_CNP_MODE_NO_IMAGE, this prevents images from being copy or past. - By setting cnp_mode to be #ELM_CNP_MODE_PLAINTEXT, this remove all tags in text . - - Note: This only changes the behaviour of text. - ]] - } - get { - [[Getting elm_entry text paste/drop mode. - - Normally the entry allows both text and images to be pasted. - This gets the copy & paste mode of the entry. - ]] - } - values { - cnp_mode: Elm.Cnp_Mode; [[One of #Elm_Cnp_Mode: #ELM_CNP_MODE_MARKUP, #ELM_CNP_MODE_NO_IMAGE, #ELM_CNP_MODE_PLAINTEXT.]] - } - } - @property file_text_format { - [[Text format used to load and save the file, which could be plain text or markup text. - - Default is $ELM_TEXT_FORMAT_PLAIN_UTF8, if you want to use - $ELM_TEXT_FORMAT_MARKUP_UTF8 then you need to set the text format - before calling @Efl.File.load. - - You could also set it before a call to @.file_save - in order to save with the given format. - ]] - - set { - [[Use it before calling @Efl.File.load or @.file_save.]] - } - values { - format: Elm.Text_Format(Elm.Text_Format.plain_utf8); [[ The file format ]] - } - } - @property input_panel_language { - set { - [[Set the language mode of the input panel. - - This API can be used if you want to show the alphabet keyboard mode. - ]] - } - get { - [[Get the language mode of the input panel.]] - } - values { - lang: Elm.Input.Panel.Lang; [[Language to be set to the input panel.]] - } - } - @property selection_handler_disabled { - set { - [[This disabled the entry's selection handlers.]] - } - get { - [[This returns whether the entry's selection handlers are disabled.]] - legacy: null; - } - values { - disabled: bool; [[If $true, the selection handlers are disabled.]] - } - } - @property input_panel_layout_variation { - set { - [[Set the input panel layout variation of the entry - - @since 1.8 - ]] - } - get { - [[Get the input panel layout variation of the entry - - @since 1.8 - ]] - } - values { - variation: int; [[Layout variation type.]] - } - } - @property autocapital_type { - set { - [[Set the autocapitalization type on the immodule.]] - } - get { - [[Get the autocapitalization type on the immodule.]] - } - values { - autocapital_type: Elm.Autocapital.Type; [[The type of autocapitalization.]] - } - } - @property editable { - set { - [[Sets if the entry is to be editable or not. - - By default, entries are editable and when focused, any text input by the - user will be inserted at the current cursor position. But calling this - function with $editable as $false will prevent the user from - inputting text into the entry. - - The only way to change the text of a non-editable entry is to use - \@ref elm_object_text_set, \@ref elm_entry_entry_insert and other related - functions. - ]] - } - get { - [[Get whether the entry is editable or not.]] - } - values { - editable: bool; [[If $true, user input will be inserted in the entry, - if not, the entry is read-only and no user input is allowed.]] - } - } - @property anchor_hover_style { - set { - [[Set the style that the hover should use - - When creating the popup hover, entry will request that it's - themed according to $style. - - Setting style no $null means disabling automatic hover. - ]] - } - get { - [[Get the style that the hover should use.]] - } - values { - style: string @nullable; [[The style to use for the underlying hover.]] - } - } - @property single_line { - set { - [[Sets the entry to single line mode. - - In single line mode, entries don't ever wrap when the text reaches the - edge, and instead they keep growing horizontally. Pressing the $Enter - key will generate an $"activate" event instead of adding a new line. - - When $single_line is $false, line wrapping takes effect again - and pressing enter will break the text into a different line - without generating any events. - ]] - } - get { - [[Get whether the entry is set to be single line.]] - } - values { - single_line: bool; [[If $true, the text in the entry - will be on a single line.]] - } - } - @property password { - set { - [[Sets the entry to password mode. - - In password mode, entries are implicitly single line and the display of - any text in them is replaced with asterisks (*). - ]] - } - get { - [[Get whether the entry is set to password mode.]] - } - values { - password: bool; [[If $true, password mode is enabled.]] - } - } - @property input_panel_return_key_disabled { - set { - [[Set the return key on the input panel to be disabled.]] - } - get { - [[Get whether the return key on the input panel should be disabled or not.]] - } - values { - disabled: bool; [[The state to put in in: $true for - disabled, $false for enabled.]] - } - } - @property autosave { - set { - [[This sets the entry object to 'autosave' the loaded text file or not.]] - } - get { - [[This gets the entry object's 'autosave' status.]] - } - values { - auto_save: bool; [[Autosave the loaded file or not.]] - } - } - @property anchor_hover_parent { - set { - [[Set the parent of the hover popup - - Sets the parent object to use by the hover created by the entry - when an anchor is clicked. - ]] - } - get { - [[Get the parent of the hover popup - - Get the object used as parent for the hover created by the entry - widget. If no parent is set, the same entry object will be used. - ]] - } - values { - parent: Efl.Canvas.Object @nullable; [[The object to use as parent for the hover.]] - } - } - @property prediction_allow { - set { - [[Set whether the entry should allow to use the text prediction.]] - } - get { - [[Get whether the entry should allow to use the text prediction.]] - } - values { - prediction: bool; [[Whether the entry should allow to use the text prediction.]] - } - } - @property input_hint { - set { - [[Sets the input hint which allows input methods to fine-tune their behavior.]] - } - get { - [[Gets the value of input hint.]] - } - values { - hints: Elm.Input.Hints; [[Input hint.]] - } - } - @property input_panel_layout { - set { - [[Set the input panel layout of the entry.]] - } - get { - [[Get the input panel layout of the entry.]] - } - values { - layout: Elm.Input.Panel.Layout(Elm.Input.Panel.Layout.invalid); [[Layout type.]] - } - } - @property input_panel_return_key_type { - set { - [[Set 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. - - Regardless of return key type, "activated" event will be generated when pressing return key in single line entry. - ]] - } - get { - [[Get the "return" key type.]] - } - values { - return_key_type: Elm.Input.Panel.Return_Key.Type; [[The type of "return" key on the input panel.]] - } - } - @property input_panel_enabled { - set { - [[Sets the attribute to show the input panel automatically.]] - } - get { - [[Get the attribute to show the input panel automatically.]] - } - values { - enabled: bool; [[If $true, the input panel is appeared when entry is clicked or has a focus.]] - } - } - @property line_wrap { - set { - [[Set the line wrap type to use on multi-line entries. - - Sets the wrap type used by the entry to any of the specified in - Elm_Wrap_Type. This tells how the text will be implicitly cut into a new - line (without inserting a line break or paragraph separator) when it - reaches the far edge of the widget. - - Note that this only makes sense for multi-line entries. A widget set - to be single line will never wrap. - ]] - } - get { - [[Get the wrap mode the entry was set to use.]] - } - values { - wrap: Elm.Wrap.Type; [[The wrap mode to use. See Elm_Wrap_Type for details on them.]] - } - } - @property cursor_pos { - set { - [[Sets the cursor position in the entry to the given value - - The value in $pos is the index of the character position within the - contents of the string as returned by @.cursor_pos.get. - ]] - } - get { - [[Get the current position of the cursor in the entry.]] - } - values { - pos: int; [[The position of the cursor.]] - } - } - @property icon_visible { - set { - [[Sets the visibility of the left-side widget of the entry, - set by \@ref elm_object_part_content_set.]] - } - values { - setting: bool; [[$true if the object should be displayed, - $false if not.]] - } - } - @property cursor_line_end { - set { - [[This moves the cursor to the end of the current line.]] - } - } - @property select_region { - set { - [[This selects a region of text within the entry. - - @since 1.9 - ]] - } - get { - [[Get the current position of the selection cursors in the entry. - - @since 1.18 - ]] - } - values { - start: int; [[The starting position.]] - end: int; [[The end position.]] - } - } - @property input_panel_return_key_autoenabled { - set { - [[Set whether the return key on the input panel is disabled automatically when entry has no text. - - If $enabled is $true, The return key on input panel is disabled when the entry has no text. - The return key on the input panel is automatically enabled when the entry has text. - The default value is $false. - ]] - } - values { - enabled: bool; [[If $enabled is $true, the return key is automatically disabled when the entry has no text.]] - } - } - @property end_visible { - set { - [[Sets the visibility of the end widget of the entry, set by - \@ref elm_object_part_content_set(ent, "end", content).]] - } - values { - setting: bool; [[$true if the object should be displayed, - false if not.]] - } - } - @property cursor_begin { - set { - [[This moves the cursor to the beginning of the entry.]] - } - } - @property cursor_line_begin { - set { - [[This moves the cursor to the beginning of the current line.]] - } - } - @property cursor_end { - set { - [[This moves the cursor to the end of the entry.]] - } - } - @property textblock { - get { - [[ - Returns the actual textblock object of the entry. - - This function exposes the internal textblock object that actually - contains and draws the text. This should be used for low-level - manipulations that are otherwise not possible. - - Changing the textblock directly from here will not notify edje/elm to - recalculate the textblock size automatically, so any modifications - done to the textblock returned by this function should be followed by - a call to \@ref elm_entry_calc_force. - - The return value is marked as const as an additional warning. - One should not use the returned object with any of the generic evas - functions (geometry_get/resize/move and etc), but only with the textblock - functions; The former will either not work at all, or break the correct - functionality. - - IMPORTANT: Many functions may change (i.e delete and create a new one) - the internal textblock object. Do NOT cache the returned object, and try - not to mix calls on this object with regular elm_entry calls (which may - change the internal textblock object). This applies to all cursors - returned from textblock calls, and all the other derivative values. - ]] - return: Efl.Canvas.Object; [[Textblock object]] - } - } - @property textblock_cursor_geometry { - get { - [[This function returns the geometry of the cursor. - - It's useful if you want to draw something on the cursor (or where it is), - or for example in the case of scrolled entry where you want to show the - cursor. - ]] - legacy: elm_entry_cursor_geometry_get; - return: bool; [[$true on success, $false otherwise]] - } - values { - x: int; [[X coordinate]] - y: int; [[Y coordinate]] - w: int; [[Width]] - h: int; [[Height]] - } - } - /* TIZEN_ONLY(20180605): add elm_entry_cursor_coord_set/get */ - @property cursor_coord { - set { - [[Sets the cursor position in the entry according to the given coordinate. - \@since_tizen 5.0 - ]] - return: bool; - } - get { - [[Gets the cursor coordinate in the entry. - \@since_tizen 5.0 - ]] - } - values { - x: int; [[x coordinate]] - y: int; [[y coordinate]] - } - } - /* END */ - @property imf_context { - get { - [[Returns the input method context of the entry. - - This function exposes the internal input method context. - - IMPORTANT: Many functions may change (i.e delete and create a new one) - the internal input method context. Do NOT cache the returned object. - ]] - return: void_ptr; [[Input method context]] - } - } - @property cursor_is_format { - get { - [[Get whether a format node exists at the current cursor position. - - A format node is anything that defines how the text is rendered. It can - be a visible format node, such as a line break or a paragraph separator, - or an invisible one, such as bold begin or end tag. - This function returns whether any format node exists at the current - cursor position. - ]] - return: bool; [[$true if format node exists, $false otherwise]] - } - } - @property textblock_cursor_content { - get { - [[Get the character pointed by the cursor at its current position. - - This function returns a string with the utf8 character stored at the - current cursor position. - Only the text is returned, any format that may exist will not be part - of the return value. You must free the string when done with \@ref free. - ]] - legacy: elm_entry_cursor_content_get; - return: mstring @owned @warn_unused; [[Character]] - } - } - @property selection { - get { - [[Get any selected text within the entry. - - If there's any selected text in the entry, this function returns it as - a string in markup format. $null is returned if no selection exists or - if an error occurred. - - The returned value points to an internal string and should not be freed - or modified in any way. If the $entry object is deleted or its - contents are changed, the returned pointer should be considered invalid. - ]] - return: string; [[Selected string]] - } - } - @property cursor_is_visible_format { - get { - [[Get if the current cursor position holds a visible format node.]] - return: bool; [[$true if position has a visible format, $false otherwise]] - } - } - @property select_allow { - [[Allow selection in the entry. - - @since 1.18 - ]] - set { - } - get { - } - values { - allow: bool; [[If $allow is true, the text selection is allowed.]] - } - } - cursor_prev { - [[This moves the cursor one place to the left within the entry.]] - return: bool; [[$true on success, $false otherwise]] - } - text_style_user_pop { - [[Remove the style in the top of user style stack. - - @since 1.7 - ]] - } - item_provider_prepend { - [[This prepends a custom item provider to the list for that entry - - This prepends the given callback.]] - params { - @in func: Elm_Entry_Item_Provider_Cb; [[The function called to provide the item object.]] - @in data: void_ptr @optional; [[The data passed to $func.]] - } - } - input_panel_show { - [[Show the input panel (virtual keyboard) based on the input panel property of entry such as layout, autocapital types, and so on. - - Note that input panel is shown or hidden automatically according to the focus state of entry widget. - This API can be used in the case of manually controlling by using @.input_panel_enabled.set(en, $false). - ]] - } - imf_context_reset { - [[Reset the input method context of the entry if needed. - - This can be necessary in the case where modifying the buffer would confuse on-going input method behavior. - This will typically cause the Input Method Context to clear the preedit state. - ]] - } - anchor_hover_end { - [[Ends the hover popup in the entry - - When an anchor is clicked, the entry widget will create a hover - object to use as a popup with user provided content. This function - terminates this popup, returning the entry to its normal state. - ]] - } - cursor_selection_begin { - [[This begins a selection within the entry as though - the user were holding down the mouse button to make a selection.]] - } - cursor_down { - [[This moves the cursor one line down within the entry.]] - return: bool; [[$true on success, $false otherwise]] - } - file_save { - [[This function writes any changes made to the file set with - \@ref elm_entry_file_set.]] - } - selection_copy { - [[This executes a "copy" action on the selected text in the entry.]] - } - text_style_user_push { - [[Push the style to the top of user style stack. - If there is styles in the user style stack, the properties in the top style - of user style stack will replace the properties in current theme. - The input style is specified in format tag='property=value' (i.e. DEFAULT='font=Sans font_size=60'hilight=' + font_weight=Bold'). - - @since 1.7 - ]] - params { - @in style: string; [[The style user to push.]] - } - } - item_provider_remove { - [[This removes a custom item provider to the list for that entry - - This removes the given callback. See @.item_provider_append for - more information - ]] - params { - @in func: Elm_Entry_Item_Provider_Cb; [[The function called to provide the item object.]] - @in data: void_ptr @optional; [[The data passed to $func.]] - } - } - text_style_user_peek @const { - [[Get the style on the top of user style stack. - - See also @.text_style_user_push. - - @since 1.7 - ]] - return: string; [[Style]] - } - context_menu_clear { - [[This clears and frees the items in a entry's contextual (longpress) - menu. - - See also @.context_menu_item_add. - ]] - } - cursor_up { - [[This moves the cursor one line up within the entry.]] - return: bool; [[$true on success, $false otherwise]] - } - entry_insert { - [[Inserts the given text into the entry at the current cursor position. - - This inserts text at the cursor position as if it was typed - by the user (note that this also allows markup which a user - can't just "type" as it would be converted to escaped text, so this - call can be used to insert things like emoticon items or bold push/pop - tags, other font and color change tags etc.) - - If any selection exists, it will be replaced by the inserted text. - - The inserted text is subject to any filters set for the widget. - - See also @.markup_filter_append. - ]] - params { - @in entry: string; [[The text to insert.]] - } - } - input_panel_imdata_set { - [[Set 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. - ]] - params { - @in data: const(void_ptr); [[The specific data to be set to the input panel.]] - @in len: int; [[The length of data, in bytes, to send to the input panel.]] - } - } - input_panel_imdata_get @const { - [[Get the specific data of the current input panel.]] - params { - @out data: void; [[The specific data to be got from the input panel.]] - @out len: int; [[The length of data.]] - } - } - selection_paste { - [[This executes a "paste" action in the entry.]] - } - cursor_next { - [[This moves the cursor one place to the right within the entry.]] - return: bool; [[$true on success, $false otherwise]] - } - select_none { - [[This drops any existing text selection within the entry.]] - } - input_panel_hide { - [[Hide the input panel (virtual keyboard). - - Note that input panel is shown or hidden automatically according to the focus state of entry widget. - This API can be used in the case of manually controlling by using @.input_panel_enabled.set(en, $false) - ]] - } - select_all { - [[This selects all text within the entry.]] - } - cursor_selection_end { - [[This ends a selection within the entry as though - the user had just released the mouse button while making a selection.]] - } - selection_cut { - [[This executes a "cut" action on the selected text in the entry.]] - } - is_empty @const { - [[Get whether the entry is empty. - - Empty means no text at all. If there are any markup tags, like an item - tag for which no provider finds anything, and no text is displayed, this - function still returns $false. - ]] - return: bool(true); [[$true if empty, $false otherwise]] - } - markup_filter_remove { - [[Remove a markup filter from the list - - Removes the given callback from the filter list. See - @.markup_filter_append for more information. - ]] - params { - @in func: Elm_Entry_Filter_Cb; [[The filter function to remove.]] - @in data: void_ptr @optional; [[The user data passed when adding the function.]] - } - } - item_provider_append { - [[This appends a custom item provider to the list for that entry - - This appends the given callback. The list is walked from beginning to end - with each function called given the item href string in the text. If the - function returns an object handle other than $null (it should create an - object to do this), then this object is used to replace that item. If - not the next provider is called until one provides an item object, or the - default provider in entry does. - - See also \@ref entry-items. - ]] - params { - @in func: Elm_Entry_Item_Provider_Cb; [[The function called to provide the item object.]] - @in data: void_ptr @optional; [[The data passed to $func.]] - } - } - markup_filter_append { - [[Append a markup filter function for text inserted in the entry - - Append the given callback to the list. This functions will be called - whenever any text is inserted into the entry, with the text to be inserted - as a parameter. The type of given text is always markup. - The callback function is free to alter the text in any way it wants, but - it must remember to free the given pointer and update it. - If the new text is to be discarded, the function can free it and set its - text parameter to $null. This will also prevent any following filters from - being called. - ]] - params { - @in func: Elm_Entry_Filter_Cb; [[The function to use as text filter.]] - @in data: void_ptr @optional; [[User data to pass to $func.]] - } - } - entry_append { - [[Appends $str to the text of the entry. - - Adds the text in $str to the end of any text already present in the - widget. - - The appended text is subject to any filters set for the widget. - - See also @.markup_filter_append. - ]] - params { - @in str: string; [[The text to be appended.]] - } - } - context_menu_item_add { - [[This adds an item to the entry's contextual menu. - - A longpress on an entry will make the contextual menu show up, if this - hasn't been disabled with @.context_menu_disabled.set. - By default, this menu provides a few options like enabling selection mode, - which is useful on embedded devices that need to be explicit about it, - and when a selection exists it also shows the copy and cut actions. - - With this function, developers can add other options to this menu to - perform any action they deem necessary. - ]] - params { - @in label: string @optional; [[The item's text label.]] - @in icon_file: string @optional; [[The item's icon file.]] - @in icon_type: Elm.Icon.Type; [[The item's icon type.]] - @in func: Evas_Smart_Cb @optional; [[The callback to execute when the item is clicked.]] - @in data: const(void_ptr) @optional; [[The data to associate with the item for related functions.]] - } - } - markup_filter_prepend { - [[Prepend a markup filter function for text inserted in the entry - - Prepend the given callback to the list.]] - params { - @in func: Elm_Entry_Filter_Cb; [[The function to use as text filter.]] - @in data: void_ptr @optional; [[User data to pass to $func.]] - } - } - prediction_hint_set { - [[Sets the prediction hint to use an intelligent reply suggestion service. - - @since 1.20 - ]] - params { - prediction_hint: string; [[The prediction hint text.]] - } - } - prediction_hint_hash_set { - [[Sets the prediction hint data at the specified key. - - @since 1.21 - ]] - return: bool; [[$true on success, $false otherwise]] - params { - key: string; [[The key of the prediction hint.]] - value: string; [[The data to replace.]] - } - } - prediction_hint_hash_del { - [[Removes the prediction hint data identified by a key. - - @since 1.21 - ]] - return: bool; [[$true on success, $false otherwise]] - params { - key: string; [[The key of the prediction hint.]] - } - } - } - implements { - class.constructor; - Efl.Object.constructor; - Efl.Gfx.Entity.visible { set; } - Efl.Gfx.Entity.position { set; } - Efl.Gfx.Entity.size { set; } - Efl.Canvas.Group.group_member_add; - Efl.Layout.Signal.signal_callback_add; - Efl.Layout.Signal.signal_callback_del; - Efl.Layout.Signal.signal_emit; - Efl.Layout.Calc.calc_force; - Efl.Ui.Widget.on_access_activate; - Efl.Ui.Widget.theme_apply; - Efl.Ui.Widget_Focus_Manager.focus_manager_create; - Efl.Ui.Focus.Object.on_focus_update; - Efl.Ui.Widget.interest_region { get; } - Efl.Ui.Widget.disabled {set;} - Efl.Ui.Widget.widget_sub_object_del; - Elm.Interface_Scrollable.policy { set; } - Elm.Interface_Scrollable.bounce_allow { set; } - Efl.Access.Object.state_set { get; } - Efl.Access.Object.i18n_name { get; } - Efl.Access.Text.access_text { get; } - Efl.Access.Text.string { get; } - Efl.Access.Text.attribute { get; } - Efl.Access.Text.text_attributes { get; } - Efl.Access.Text.default_attributes { get; } - Efl.Access.Text.caret_offset { get; set; } - Efl.Access.Text.character { get; } - Efl.Access.Text.character_extents { get; } - Efl.Access.Text.character_count { get; } - Efl.Access.Text.offset_at_point { get; } - Efl.Access.Text.bounded_ranges { get; } - Efl.Access.Text.range_extents { get; } - Efl.Access.Text.access_selection { get; set; } - Efl.Access.Text.selections_count { get; } - Efl.Access.Text.selection_add; - Efl.Access.Text.selection_remove; - Efl.Access.Editable.Text.text_content { set; } - Efl.Access.Editable.Text.insert; - Efl.Access.Editable.Text.copy; - Efl.Access.Editable.Text.cut; - Efl.Access.Editable.Text.delete; - Efl.Access.Editable.Text.paste; - Efl.Access.Widget.Action.elm_actions { get; } - Efl.File.file { set; } - Efl.File.load; - Efl.Access.Object.access_children { get; } - Efl.Part.part_get; - - // TIZEN_ONLY(20170512): Support accessibility for entry anchors. - Efl.Ui.Widget.screen_reader; - // - - // TIZEN_ONLY(20170512): Support accessibility for entry anchors. - Efl.Access.Component.accessible_at_point_get; - // - - /***************************************************************************** - * TIZEN_ONLY_FEATURE: Fix entry size/cursor/region calculation for Tizen UX * - *****************************************************************************/ - //Efl.Ui.Widget.show_region { get; } - /******* - * END * - *******/ - - //TIZEN_ONLY(20180607): Restore legacy focus - Efl.Ui.Widget.focus_direction_manager_is; - Efl.Ui.Widget.focus_next_manager_is; - // - } - events { - activated: void; [[Called when entry got activated]] - changed: void; [[Called when entry changed]] - /* FIXME: Canm be NULL but @nullable does not work on events */ - changed,user: Elm.Entry_Change_Info; [[Called when the object changed due to user interaction]] - validate: Elm.Validate_Content; [[Called when validating]] - context,open: void; [[Called when context menu was opened]] - anchor,clicked: Elm.Entry_Anchor_Info; [[Called when anchor was clicked]] - rejected: void; [[Called when entry was rejected]] - maxlength,reached: void; [[Called when maximum entry length has been reached]] - preedit,changed: void; [[Called when entry preedit changed]] - press: void; [[Called when entry pressed]] - redo,request: void; [[Called when redo was requested]] - undo,request: void; [[Called when undo was requested]] - text,set,done: void; [[Called when text set finished]] - aborted: void; [[Called when entry was aborted]] - anchor,down: Elm.Entry_Anchor_Info; [[Called on anchor down]] - anchor,hover,opened: Elm.Entry_Anchor_Hover_Info; [[Called when hover opened]] - anchor,in: Elm.Entry_Anchor_Info; [[Called on anchor in]] - anchor,out: Elm.Entry_Anchor_Info; [[Called on anchor out]] - anchor,up: Elm.Entry_Anchor_Info; [[called on anchor up]] - cursor,changed: void; [[Called on cursor changed]] - cursor,changed,manual: void; [[Called on manual cursor change]] - } -} diff --git a/src/lib/elementary/elm_entry_eo.c b/src/lib/elementary/elm_entry_eo.c new file mode 100644 index 0000000..6df71f9 --- /dev/null +++ b/src/lib/elementary/elm_entry_eo.c @@ -0,0 +1,1190 @@ +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_ACTIVATED = + EFL_EVENT_DESCRIPTION("activated"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_CHANGED = + EFL_EVENT_DESCRIPTION("changed"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_CHANGED_USER = + EFL_EVENT_DESCRIPTION("changed,user"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_VALIDATE = + EFL_EVENT_DESCRIPTION("validate"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_CONTEXT_OPEN = + EFL_EVENT_DESCRIPTION("context,open"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_ANCHOR_CLICKED = + EFL_EVENT_DESCRIPTION("anchor,clicked"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_REJECTED = + EFL_EVENT_DESCRIPTION("rejected"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_MAXLENGTH_REACHED = + EFL_EVENT_DESCRIPTION("maxlength,reached"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_PREEDIT_CHANGED = + EFL_EVENT_DESCRIPTION("preedit,changed"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_PRESS = + EFL_EVENT_DESCRIPTION("press"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_REDO_REQUEST = + EFL_EVENT_DESCRIPTION("redo,request"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_UNDO_REQUEST = + EFL_EVENT_DESCRIPTION("undo,request"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_TEXT_SET_DONE = + EFL_EVENT_DESCRIPTION("text,set,done"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_ABORTED = + EFL_EVENT_DESCRIPTION("aborted"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_ANCHOR_DOWN = + EFL_EVENT_DESCRIPTION("anchor,down"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_ANCHOR_HOVER_OPENED = + EFL_EVENT_DESCRIPTION("anchor,hover,opened"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_ANCHOR_IN = + EFL_EVENT_DESCRIPTION("anchor,in"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_ANCHOR_OUT = + EFL_EVENT_DESCRIPTION("anchor,out"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_ANCHOR_UP = + EFL_EVENT_DESCRIPTION("anchor,up"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_CURSOR_CHANGED = + EFL_EVENT_DESCRIPTION("cursor,changed"); +EWAPI const Efl_Event_Description _ELM_ENTRY_EVENT_CURSOR_CHANGED_MANUAL = + EFL_EVENT_DESCRIPTION("cursor,changed,manual"); + +void _elm_entry_scrollable_set(Eo *obj, Elm_Entry_Data *pd, Eina_Bool scroll); + + +static Eina_Error +__eolian_elm_entry_scrollable_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_entry_scrollable_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_scrollable_set, EFL_FUNC_CALL(scroll), Eina_Bool scroll); + +Eina_Bool _elm_entry_scrollable_get(const Eo *obj, Elm_Entry_Data *pd); + + +static Eina_Value +__eolian_elm_entry_scrollable_get_reflect(Eo *obj) +{ + Eina_Bool val = elm_obj_entry_scrollable_get(obj); + return eina_value_bool_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_scrollable_get, Eina_Bool, 0); + +void _elm_entry_input_panel_show_on_demand_set(Eo *obj, Elm_Entry_Data *pd, Eina_Bool ondemand); + + +static Eina_Error +__eolian_elm_entry_input_panel_show_on_demand_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_entry_input_panel_show_on_demand_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_input_panel_show_on_demand_set, EFL_FUNC_CALL(ondemand), Eina_Bool ondemand); + +Eina_Bool _elm_entry_input_panel_show_on_demand_get(const Eo *obj, Elm_Entry_Data *pd); + + +static Eina_Value +__eolian_elm_entry_input_panel_show_on_demand_get_reflect(Eo *obj) +{ + Eina_Bool val = elm_obj_entry_input_panel_show_on_demand_get(obj); + return eina_value_bool_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_input_panel_show_on_demand_get, Eina_Bool, 0); + +void _elm_entry_context_menu_disabled_set(Eo *obj, Elm_Entry_Data *pd, Eina_Bool disabled); + + +static Eina_Error +__eolian_elm_entry_context_menu_disabled_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_entry_context_menu_disabled_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_context_menu_disabled_set, EFL_FUNC_CALL(disabled), Eina_Bool disabled); + +Eina_Bool _elm_entry_context_menu_disabled_get(const Eo *obj, Elm_Entry_Data *pd); + + +static Eina_Value +__eolian_elm_entry_context_menu_disabled_get_reflect(Eo *obj) +{ + Eina_Bool val = elm_obj_entry_context_menu_disabled_get(obj); + return eina_value_bool_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_context_menu_disabled_get, Eina_Bool, 0); + +void _elm_entry_cnp_mode_set(Eo *obj, Elm_Entry_Data *pd, Elm_Cnp_Mode cnp_mode); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_cnp_mode_set, EFL_FUNC_CALL(cnp_mode), Elm_Cnp_Mode cnp_mode); + +Elm_Cnp_Mode _elm_entry_cnp_mode_get(const Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_cnp_mode_get, Elm_Cnp_Mode, 0); + +void _elm_entry_file_text_format_set(Eo *obj, Elm_Entry_Data *pd, Elm_Text_Format format); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_file_text_format_set, EFL_FUNC_CALL(format), Elm_Text_Format format); + +void _elm_entry_input_panel_language_set(Eo *obj, Elm_Entry_Data *pd, Elm_Input_Panel_Lang lang); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_input_panel_language_set, EFL_FUNC_CALL(lang), Elm_Input_Panel_Lang lang); + +Elm_Input_Panel_Lang _elm_entry_input_panel_language_get(const Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_input_panel_language_get, Elm_Input_Panel_Lang, 0); + +void _elm_entry_selection_handler_disabled_set(Eo *obj, Elm_Entry_Data *pd, Eina_Bool disabled); + + +static Eina_Error +__eolian_elm_entry_selection_handler_disabled_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_entry_selection_handler_disabled_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_selection_handler_disabled_set, EFL_FUNC_CALL(disabled), Eina_Bool disabled); + +Eina_Bool _elm_entry_selection_handler_disabled_get(const Eo *obj, Elm_Entry_Data *pd); + + +static Eina_Value +__eolian_elm_entry_selection_handler_disabled_get_reflect(Eo *obj) +{ + Eina_Bool val = elm_obj_entry_selection_handler_disabled_get(obj); + return eina_value_bool_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_selection_handler_disabled_get, Eina_Bool, 0); + +void _elm_entry_input_panel_layout_variation_set(Eo *obj, Elm_Entry_Data *pd, int variation); + + +static Eina_Error +__eolian_elm_entry_input_panel_layout_variation_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_entry_input_panel_layout_variation_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_input_panel_layout_variation_set, EFL_FUNC_CALL(variation), int variation); + +int _elm_entry_input_panel_layout_variation_get(const Eo *obj, Elm_Entry_Data *pd); + + +static Eina_Value +__eolian_elm_entry_input_panel_layout_variation_get_reflect(Eo *obj) +{ + int val = elm_obj_entry_input_panel_layout_variation_get(obj); + return eina_value_int_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_input_panel_layout_variation_get, int, 0); + +void _elm_entry_autocapital_type_set(Eo *obj, Elm_Entry_Data *pd, Elm_Autocapital_Type autocapital_type); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_autocapital_type_set, EFL_FUNC_CALL(autocapital_type), Elm_Autocapital_Type autocapital_type); + +Elm_Autocapital_Type _elm_entry_autocapital_type_get(const Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_autocapital_type_get, Elm_Autocapital_Type, 0); + +void _elm_entry_editable_set(Eo *obj, Elm_Entry_Data *pd, Eina_Bool editable); + + +static Eina_Error +__eolian_elm_entry_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_entry_editable_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_editable_set, EFL_FUNC_CALL(editable), Eina_Bool editable); + +Eina_Bool _elm_entry_editable_get(const Eo *obj, Elm_Entry_Data *pd); + + +static Eina_Value +__eolian_elm_entry_editable_get_reflect(Eo *obj) +{ + Eina_Bool val = elm_obj_entry_editable_get(obj); + return eina_value_bool_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_editable_get, Eina_Bool, 0); + +void _elm_entry_anchor_hover_style_set(Eo *obj, Elm_Entry_Data *pd, const char *style); + + +static Eina_Error +__eolian_elm_entry_anchor_hover_style_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_entry_anchor_hover_style_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_anchor_hover_style_set, EFL_FUNC_CALL(style), const char *style); + +const char *_elm_entry_anchor_hover_style_get(const Eo *obj, Elm_Entry_Data *pd); + + +static Eina_Value +__eolian_elm_entry_anchor_hover_style_get_reflect(Eo *obj) +{ + const char *val = elm_obj_entry_anchor_hover_style_get(obj); + return eina_value_string_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_anchor_hover_style_get, const char *, NULL); + +void _elm_entry_single_line_set(Eo *obj, Elm_Entry_Data *pd, Eina_Bool single_line); + + +static Eina_Error +__eolian_elm_entry_single_line_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_entry_single_line_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_single_line_set, EFL_FUNC_CALL(single_line), Eina_Bool single_line); + +Eina_Bool _elm_entry_single_line_get(const Eo *obj, Elm_Entry_Data *pd); + + +static Eina_Value +__eolian_elm_entry_single_line_get_reflect(Eo *obj) +{ + Eina_Bool val = elm_obj_entry_single_line_get(obj); + return eina_value_bool_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_single_line_get, Eina_Bool, 0); + +void _elm_entry_password_set(Eo *obj, Elm_Entry_Data *pd, Eina_Bool password); + + +static Eina_Error +__eolian_elm_entry_password_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_entry_password_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_password_set, EFL_FUNC_CALL(password), Eina_Bool password); + +Eina_Bool _elm_entry_password_get(const Eo *obj, Elm_Entry_Data *pd); + + +static Eina_Value +__eolian_elm_entry_password_get_reflect(Eo *obj) +{ + Eina_Bool val = elm_obj_entry_password_get(obj); + return eina_value_bool_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_password_get, Eina_Bool, 0); + +void _elm_entry_input_panel_return_key_disabled_set(Eo *obj, Elm_Entry_Data *pd, Eina_Bool disabled); + + +static Eina_Error +__eolian_elm_entry_input_panel_return_key_disabled_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_entry_input_panel_return_key_disabled_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_input_panel_return_key_disabled_set, EFL_FUNC_CALL(disabled), Eina_Bool disabled); + +Eina_Bool _elm_entry_input_panel_return_key_disabled_get(const Eo *obj, Elm_Entry_Data *pd); + + +static Eina_Value +__eolian_elm_entry_input_panel_return_key_disabled_get_reflect(Eo *obj) +{ + Eina_Bool val = elm_obj_entry_input_panel_return_key_disabled_get(obj); + return eina_value_bool_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_input_panel_return_key_disabled_get, Eina_Bool, 0); + +void _elm_entry_autosave_set(Eo *obj, Elm_Entry_Data *pd, Eina_Bool auto_save); + + +static Eina_Error +__eolian_elm_entry_autosave_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_entry_autosave_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_autosave_set, EFL_FUNC_CALL(auto_save), Eina_Bool auto_save); + +Eina_Bool _elm_entry_autosave_get(const Eo *obj, Elm_Entry_Data *pd); + + +static Eina_Value +__eolian_elm_entry_autosave_get_reflect(Eo *obj) +{ + Eina_Bool val = elm_obj_entry_autosave_get(obj); + return eina_value_bool_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_autosave_get, Eina_Bool, 0); + +void _elm_entry_anchor_hover_parent_set(Eo *obj, Elm_Entry_Data *pd, Efl_Canvas_Object *parent); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_anchor_hover_parent_set, EFL_FUNC_CALL(parent), Efl_Canvas_Object *parent); + +Efl_Canvas_Object *_elm_entry_anchor_hover_parent_get(const Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_anchor_hover_parent_get, Efl_Canvas_Object *, NULL); + +void _elm_entry_prediction_allow_set(Eo *obj, Elm_Entry_Data *pd, Eina_Bool prediction); + + +static Eina_Error +__eolian_elm_entry_prediction_allow_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_entry_prediction_allow_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_prediction_allow_set, EFL_FUNC_CALL(prediction), Eina_Bool prediction); + +Eina_Bool _elm_entry_prediction_allow_get(const Eo *obj, Elm_Entry_Data *pd); + + +static Eina_Value +__eolian_elm_entry_prediction_allow_get_reflect(Eo *obj) +{ + Eina_Bool val = elm_obj_entry_prediction_allow_get(obj); + return eina_value_bool_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_prediction_allow_get, Eina_Bool, 0); + +void _elm_entry_input_hint_set(Eo *obj, Elm_Entry_Data *pd, Elm_Input_Hints hints); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_input_hint_set, EFL_FUNC_CALL(hints), Elm_Input_Hints hints); + +Elm_Input_Hints _elm_entry_input_hint_get(const Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_input_hint_get, Elm_Input_Hints, 0); + +void _elm_entry_input_panel_layout_set(Eo *obj, Elm_Entry_Data *pd, Elm_Input_Panel_Layout layout); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_input_panel_layout_set, EFL_FUNC_CALL(layout), Elm_Input_Panel_Layout layout); + +Elm_Input_Panel_Layout _elm_entry_input_panel_layout_get(const Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_input_panel_layout_get, Elm_Input_Panel_Layout, 8 /* Elm.Input.Panel.Layout.invalid */); + +void _elm_entry_input_panel_return_key_type_set(Eo *obj, Elm_Entry_Data *pd, Elm_Input_Panel_Return_Key_Type return_key_type); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_input_panel_return_key_type_set, EFL_FUNC_CALL(return_key_type), Elm_Input_Panel_Return_Key_Type return_key_type); + +Elm_Input_Panel_Return_Key_Type _elm_entry_input_panel_return_key_type_get(const Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_input_panel_return_key_type_get, Elm_Input_Panel_Return_Key_Type, 0); + +void _elm_entry_input_panel_enabled_set(Eo *obj, Elm_Entry_Data *pd, Eina_Bool enabled); + + +static Eina_Error +__eolian_elm_entry_input_panel_enabled_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_entry_input_panel_enabled_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_input_panel_enabled_set, EFL_FUNC_CALL(enabled), Eina_Bool enabled); + +Eina_Bool _elm_entry_input_panel_enabled_get(const Eo *obj, Elm_Entry_Data *pd); + + +static Eina_Value +__eolian_elm_entry_input_panel_enabled_get_reflect(Eo *obj) +{ + Eina_Bool val = elm_obj_entry_input_panel_enabled_get(obj); + return eina_value_bool_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_input_panel_enabled_get, Eina_Bool, 0); + +void _elm_entry_line_wrap_set(Eo *obj, Elm_Entry_Data *pd, Elm_Wrap_Type wrap); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_line_wrap_set, EFL_FUNC_CALL(wrap), Elm_Wrap_Type wrap); + +Elm_Wrap_Type _elm_entry_line_wrap_get(const Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_line_wrap_get, Elm_Wrap_Type, 0); + +void _elm_entry_cursor_pos_set(Eo *obj, Elm_Entry_Data *pd, int pos); + + +static Eina_Error +__eolian_elm_entry_cursor_pos_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_entry_cursor_pos_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_cursor_pos_set, EFL_FUNC_CALL(pos), int pos); + +int _elm_entry_cursor_pos_get(const Eo *obj, Elm_Entry_Data *pd); + + +static Eina_Value +__eolian_elm_entry_cursor_pos_get_reflect(Eo *obj) +{ + int val = elm_obj_entry_cursor_pos_get(obj); + return eina_value_int_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_cursor_pos_get, int, 0); + +void _elm_entry_icon_visible_set(Eo *obj, Elm_Entry_Data *pd, Eina_Bool setting); + + +static Eina_Error +__eolian_elm_entry_icon_visible_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_entry_icon_visible_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_icon_visible_set, EFL_FUNC_CALL(setting), Eina_Bool setting); + +void _elm_entry_cursor_line_end_set(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_entry_cursor_line_end_set); + +void _elm_entry_select_region_set(Eo *obj, Elm_Entry_Data *pd, int start, int end); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_select_region_set, EFL_FUNC_CALL(start, end), int start, int end); + +void _elm_entry_select_region_get(const Eo *obj, Elm_Entry_Data *pd, int *start, int *end); + +EOAPI EFL_VOID_FUNC_BODYV_CONST(elm_obj_entry_select_region_get, EFL_FUNC_CALL(start, end), int *start, int *end); + +void _elm_entry_input_panel_return_key_autoenabled_set(Eo *obj, Elm_Entry_Data *pd, Eina_Bool enabled); + + +static Eina_Error +__eolian_elm_entry_input_panel_return_key_autoenabled_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_entry_input_panel_return_key_autoenabled_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_input_panel_return_key_autoenabled_set, EFL_FUNC_CALL(enabled), Eina_Bool enabled); + +void _elm_entry_end_visible_set(Eo *obj, Elm_Entry_Data *pd, Eina_Bool setting); + + +static Eina_Error +__eolian_elm_entry_end_visible_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_entry_end_visible_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_end_visible_set, EFL_FUNC_CALL(setting), Eina_Bool setting); + +void _elm_entry_cursor_begin_set(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_entry_cursor_begin_set); + +void _elm_entry_cursor_line_begin_set(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_entry_cursor_line_begin_set); + +void _elm_entry_cursor_end_set(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_entry_cursor_end_set); + +Efl_Canvas_Object *_elm_entry_textblock_get(const Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_textblock_get, Efl_Canvas_Object *, NULL); + +Eina_Bool _elm_entry_textblock_cursor_geometry_get(const Eo *obj, Elm_Entry_Data *pd, int *x, int *y, int *w, int *h); + +EOAPI EFL_FUNC_BODYV_CONST(elm_obj_entry_textblock_cursor_geometry_get, Eina_Bool, 0, EFL_FUNC_CALL(x, y, w, h), int *x, int *y, int *w, int *h); + +void *_elm_entry_imf_context_get(const Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_imf_context_get, void *, NULL); + +Eina_Bool _elm_entry_cursor_is_format_get(const Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_cursor_is_format_get, Eina_Bool, 0); + +char *_elm_entry_textblock_cursor_content_get(const Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_textblock_cursor_content_get, char *, NULL); + +const char *_elm_entry_selection_get(const Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_selection_get, const char *, NULL); + +Eina_Bool _elm_entry_cursor_is_visible_format_get(const Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_cursor_is_visible_format_get, Eina_Bool, 0); + +void _elm_entry_select_allow_set(Eo *obj, Elm_Entry_Data *pd, Eina_Bool allow); + + +static Eina_Error +__eolian_elm_entry_select_allow_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_entry_select_allow_set(obj, cval); + end: + eina_value_flush(&val); + return r; +} + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_select_allow_set, EFL_FUNC_CALL(allow), Eina_Bool allow); + +Eina_Bool _elm_entry_select_allow_get(const Eo *obj, Elm_Entry_Data *pd); + + +static Eina_Value +__eolian_elm_entry_select_allow_get_reflect(Eo *obj) +{ + Eina_Bool val = elm_obj_entry_select_allow_get(obj); + return eina_value_bool_init(val); +} + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_select_allow_get, Eina_Bool, 0); + +Eina_Bool _elm_entry_cursor_prev(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY(elm_obj_entry_cursor_prev, Eina_Bool, 0); + +void _elm_entry_text_style_user_pop(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_entry_text_style_user_pop); + +void _elm_entry_item_provider_prepend(Eo *obj, Elm_Entry_Data *pd, Elm_Entry_Item_Provider_Cb func, void *data); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_item_provider_prepend, EFL_FUNC_CALL(func, data), Elm_Entry_Item_Provider_Cb func, void *data); + +void _elm_entry_input_panel_show(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_entry_input_panel_show); + +void _elm_entry_imf_context_reset(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_entry_imf_context_reset); + +void _elm_entry_anchor_hover_end(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_entry_anchor_hover_end); + +void _elm_entry_cursor_selection_begin(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_entry_cursor_selection_begin); + +Eina_Bool _elm_entry_cursor_down(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY(elm_obj_entry_cursor_down, Eina_Bool, 0); + +void _elm_entry_file_save(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_entry_file_save); + +void _elm_entry_selection_copy(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_entry_selection_copy); + +void _elm_entry_text_style_user_push(Eo *obj, Elm_Entry_Data *pd, const char *style); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_text_style_user_push, EFL_FUNC_CALL(style), const char *style); + +void _elm_entry_item_provider_remove(Eo *obj, Elm_Entry_Data *pd, Elm_Entry_Item_Provider_Cb func, void *data); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_item_provider_remove, EFL_FUNC_CALL(func, data), Elm_Entry_Item_Provider_Cb func, void *data); + +const char *_elm_entry_text_style_user_peek(const Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_text_style_user_peek, const char *, NULL); + +void _elm_entry_context_menu_clear(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_entry_context_menu_clear); + +Eina_Bool _elm_entry_cursor_up(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY(elm_obj_entry_cursor_up, Eina_Bool, 0); + +void _elm_entry_entry_insert(Eo *obj, Elm_Entry_Data *pd, const char *entry); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_insert, EFL_FUNC_CALL(entry), const char *entry); + +void _elm_entry_input_panel_imdata_set(Eo *obj, Elm_Entry_Data *pd, const void *data, int len); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_input_panel_imdata_set, EFL_FUNC_CALL(data, len), const void *data, int len); + +void _elm_entry_input_panel_imdata_get(const Eo *obj, Elm_Entry_Data *pd, void *data, int *len); + +EOAPI EFL_VOID_FUNC_BODYV_CONST(elm_obj_entry_input_panel_imdata_get, EFL_FUNC_CALL(data, len), void *data, int *len); + +void _elm_entry_selection_paste(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_entry_selection_paste); + +Eina_Bool _elm_entry_cursor_next(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY(elm_obj_entry_cursor_next, Eina_Bool, 0); + +void _elm_entry_select_none(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_entry_select_none); + +void _elm_entry_input_panel_hide(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_entry_input_panel_hide); + +void _elm_entry_select_all(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_entry_select_all); + +void _elm_entry_cursor_selection_end(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_entry_cursor_selection_end); + +void _elm_entry_selection_cut(Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_VOID_FUNC_BODY(elm_obj_entry_selection_cut); + +Eina_Bool _elm_entry_is_empty(const Eo *obj, Elm_Entry_Data *pd); + +EOAPI EFL_FUNC_BODY_CONST(elm_obj_entry_is_empty, Eina_Bool, EINA_TRUE /* true */); + +void _elm_entry_markup_filter_remove(Eo *obj, Elm_Entry_Data *pd, Elm_Entry_Filter_Cb func, void *data); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_markup_filter_remove, EFL_FUNC_CALL(func, data), Elm_Entry_Filter_Cb func, void *data); + +void _elm_entry_item_provider_append(Eo *obj, Elm_Entry_Data *pd, Elm_Entry_Item_Provider_Cb func, void *data); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_item_provider_append, EFL_FUNC_CALL(func, data), Elm_Entry_Item_Provider_Cb func, void *data); + +void _elm_entry_markup_filter_append(Eo *obj, Elm_Entry_Data *pd, Elm_Entry_Filter_Cb func, void *data); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_markup_filter_append, EFL_FUNC_CALL(func, data), Elm_Entry_Filter_Cb func, void *data); + +void _elm_entry_entry_append(Eo *obj, Elm_Entry_Data *pd, const char *str); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_append, EFL_FUNC_CALL(str), const char *str); + +void _elm_entry_context_menu_item_add(Eo *obj, Elm_Entry_Data *pd, const char *label, const char *icon_file, Elm_Icon_Type icon_type, Evas_Smart_Cb func, const void *data); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_context_menu_item_add, EFL_FUNC_CALL(label, icon_file, icon_type, func, data), const char *label, const char *icon_file, Elm_Icon_Type icon_type, Evas_Smart_Cb func, const void *data); + +void _elm_entry_markup_filter_prepend(Eo *obj, Elm_Entry_Data *pd, Elm_Entry_Filter_Cb func, void *data); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_markup_filter_prepend, EFL_FUNC_CALL(func, data), Elm_Entry_Filter_Cb func, void *data); + +void _elm_entry_prediction_hint_set(Eo *obj, Elm_Entry_Data *pd, const char *prediction_hint); + +EOAPI EFL_VOID_FUNC_BODYV(elm_obj_entry_prediction_hint_set, EFL_FUNC_CALL(prediction_hint), const char *prediction_hint); + +Eina_Bool _elm_entry_prediction_hint_hash_set(Eo *obj, Elm_Entry_Data *pd, const char *key, const char *value); + +EOAPI EFL_FUNC_BODYV(elm_obj_entry_prediction_hint_hash_set, Eina_Bool, 0, EFL_FUNC_CALL(key, value), const char *key, const char *value); + +Eina_Bool _elm_entry_prediction_hint_hash_del(Eo *obj, Elm_Entry_Data *pd, const char *key); + +EOAPI EFL_FUNC_BODYV(elm_obj_entry_prediction_hint_hash_del, Eina_Bool, 0, EFL_FUNC_CALL(key), const char *key); + +Efl_Object *_elm_entry_efl_object_constructor(Eo *obj, Elm_Entry_Data *pd); + + +void _elm_entry_efl_gfx_entity_visible_set(Eo *obj, Elm_Entry_Data *pd, Eina_Bool v); + + +void _elm_entry_efl_gfx_entity_position_set(Eo *obj, Elm_Entry_Data *pd, Eina_Position2D pos); + + +void _elm_entry_efl_gfx_entity_size_set(Eo *obj, Elm_Entry_Data *pd, Eina_Size2D size); + + +void _elm_entry_efl_canvas_group_group_member_add(Eo *obj, Elm_Entry_Data *pd, Efl_Canvas_Object *sub_obj); + + +Eina_Bool _elm_entry_efl_layout_signal_signal_callback_add(Eo *obj, Elm_Entry_Data *pd, const char *emission, const char *source, void *func_data, EflLayoutSignalCb func, Eina_Free_Cb func_free_cb); + + +Eina_Bool _elm_entry_efl_layout_signal_signal_callback_del(Eo *obj, Elm_Entry_Data *pd, const char *emission, const char *source, void *func_data, EflLayoutSignalCb func, Eina_Free_Cb func_free_cb); + + +void _elm_entry_efl_layout_signal_signal_emit(Eo *obj, Elm_Entry_Data *pd, const char *emission, const char *source); + + +void _elm_entry_efl_layout_calc_calc_force(Eo *obj, Elm_Entry_Data *pd); + + +Eina_Bool _elm_entry_efl_ui_widget_on_access_activate(Eo *obj, Elm_Entry_Data *pd, Efl_Ui_Activate act); + + +Eina_Error _elm_entry_efl_ui_widget_theme_apply(Eo *obj, Elm_Entry_Data *pd); + + +Efl_Ui_Focus_Manager *_elm_entry_efl_ui_widget_focus_manager_focus_manager_create(Eo *obj, Elm_Entry_Data *pd, Efl_Ui_Focus_Object *root); + + +Eina_Bool _elm_entry_efl_ui_focus_object_on_focus_update(Eo *obj, Elm_Entry_Data *pd); + + +Eina_Rect _elm_entry_efl_ui_widget_interest_region_get(const Eo *obj, Elm_Entry_Data *pd); + + +void _elm_entry_efl_ui_widget_disabled_set(Eo *obj, Elm_Entry_Data *pd, Eina_Bool disabled); + + +Eina_Bool _elm_entry_efl_ui_widget_widget_sub_object_del(Eo *obj, Elm_Entry_Data *pd, Efl_Canvas_Object *sub_obj); + + +void _elm_entry_elm_interface_scrollable_policy_set(Eo *obj, Elm_Entry_Data *pd, Elm_Scroller_Policy hbar, Elm_Scroller_Policy vbar); + + +void _elm_entry_elm_interface_scrollable_bounce_allow_set(Eo *obj, Elm_Entry_Data *pd, Eina_Bool horiz, Eina_Bool vert); + + +Efl_Access_State_Set _elm_entry_efl_access_object_state_set_get(const Eo *obj, Elm_Entry_Data *pd); + + +const char *_elm_entry_efl_access_object_i18n_name_get(const Eo *obj, Elm_Entry_Data *pd); + + +char *_elm_entry_efl_access_text_access_text_get(const Eo *obj, Elm_Entry_Data *pd, int start_offset, int end_offset); + + +char *_elm_entry_efl_access_text_string_get(const Eo *obj, Elm_Entry_Data *pd, Efl_Access_Text_Granularity granularity, int *start_offset, int *end_offset); + + +Eina_Bool _elm_entry_efl_access_text_attribute_get(const Eo *obj, Elm_Entry_Data *pd, const char *name, int *start_offset, int *end_offset, char **value); + + +Eina_List *_elm_entry_efl_access_text_text_attributes_get(const Eo *obj, Elm_Entry_Data *pd, int *start_offset, int *end_offset); + + +Eina_List *_elm_entry_efl_access_text_default_attributes_get(const Eo *obj, Elm_Entry_Data *pd); + + +Eina_Bool _elm_entry_efl_access_text_caret_offset_set(Eo *obj, Elm_Entry_Data *pd, int offset); + + +int _elm_entry_efl_access_text_caret_offset_get(const Eo *obj, Elm_Entry_Data *pd); + + +Eina_Unicode _elm_entry_efl_access_text_character_get(const Eo *obj, Elm_Entry_Data *pd, int offset); + + +Eina_Bool _elm_entry_efl_access_text_character_extents_get(const Eo *obj, Elm_Entry_Data *pd, int offset, Eina_Bool screen_coords, Eina_Rect *rect); + + +int _elm_entry_efl_access_text_character_count_get(const Eo *obj, Elm_Entry_Data *pd); + + +int _elm_entry_efl_access_text_offset_at_point_get(const Eo *obj, Elm_Entry_Data *pd, Eina_Bool screen_coords, int x, int y); + + +Eina_List *_elm_entry_efl_access_text_bounded_ranges_get(const Eo *obj, Elm_Entry_Data *pd, Eina_Bool screen_coords, Eina_Rect rect, Efl_Access_Text_Clip_Type xclip, Efl_Access_Text_Clip_Type yclip); + + +Eina_Bool _elm_entry_efl_access_text_range_extents_get(const Eo *obj, Elm_Entry_Data *pd, Eina_Bool screen_coords, int start_offset, int end_offset, Eina_Rect *rect); + + +Eina_Bool _elm_entry_efl_access_text_access_selection_set(Eo *obj, Elm_Entry_Data *pd, int selection_number, int start_offset, int end_offset); + + +void _elm_entry_efl_access_text_access_selection_get(const Eo *obj, Elm_Entry_Data *pd, int selection_number, int *start_offset, int *end_offset); + + +int _elm_entry_efl_access_text_selections_count_get(const Eo *obj, Elm_Entry_Data *pd); + + +Eina_Bool _elm_entry_efl_access_text_selection_add(Eo *obj, Elm_Entry_Data *pd, int start_offset, int end_offset); + + +Eina_Bool _elm_entry_efl_access_text_selection_remove(Eo *obj, Elm_Entry_Data *pd, int selection_number); + + +Eina_Bool _elm_entry_efl_access_editable_text_text_content_set(Eo *obj, Elm_Entry_Data *pd, const char *string); + + +Eina_Bool _elm_entry_efl_access_editable_text_insert(Eo *obj, Elm_Entry_Data *pd, const char *string, int position); + + +Eina_Bool _elm_entry_efl_access_editable_text_copy(Eo *obj, Elm_Entry_Data *pd, int start, int end); + + +Eina_Bool _elm_entry_efl_access_editable_text_cut(Eo *obj, Elm_Entry_Data *pd, int start, int end); + + +Eina_Bool _elm_entry_efl_access_editable_text_delete(Eo *obj, Elm_Entry_Data *pd, int start, int end); + + +Eina_Bool _elm_entry_efl_access_editable_text_paste(Eo *obj, Elm_Entry_Data *pd, int position); + + +const Efl_Access_Action_Data *_elm_entry_efl_access_widget_action_elm_actions_get(const Eo *obj, Elm_Entry_Data *pd); + + +Eina_Error _elm_entry_efl_file_file_set(Eo *obj, Elm_Entry_Data *pd, const char *file); + + +Eina_Error _elm_entry_efl_file_load(Eo *obj, Elm_Entry_Data *pd); + + +Efl_Object *_elm_entry_efl_part_part_get(const Eo *obj, Elm_Entry_Data *pd, const char *name); + + +static Eina_Bool +_elm_entry_class_initializer(Efl_Class *klass) +{ + const Efl_Object_Ops *opsp = NULL; + + const Efl_Object_Property_Reflection_Ops *ropsp = NULL; + +#ifndef ELM_ENTRY_EXTRA_OPS +#define ELM_ENTRY_EXTRA_OPS +#endif + + EFL_OPS_DEFINE(ops, + EFL_OBJECT_OP_FUNC(elm_obj_entry_scrollable_set, _elm_entry_scrollable_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_scrollable_get, _elm_entry_scrollable_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_show_on_demand_set, _elm_entry_input_panel_show_on_demand_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_show_on_demand_get, _elm_entry_input_panel_show_on_demand_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_context_menu_disabled_set, _elm_entry_context_menu_disabled_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_context_menu_disabled_get, _elm_entry_context_menu_disabled_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_cnp_mode_set, _elm_entry_cnp_mode_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_cnp_mode_get, _elm_entry_cnp_mode_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_file_text_format_set, _elm_entry_file_text_format_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_language_set, _elm_entry_input_panel_language_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_language_get, _elm_entry_input_panel_language_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_selection_handler_disabled_set, _elm_entry_selection_handler_disabled_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_selection_handler_disabled_get, _elm_entry_selection_handler_disabled_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_layout_variation_set, _elm_entry_input_panel_layout_variation_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_layout_variation_get, _elm_entry_input_panel_layout_variation_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_autocapital_type_set, _elm_entry_autocapital_type_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_autocapital_type_get, _elm_entry_autocapital_type_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_editable_set, _elm_entry_editable_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_editable_get, _elm_entry_editable_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_anchor_hover_style_set, _elm_entry_anchor_hover_style_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_anchor_hover_style_get, _elm_entry_anchor_hover_style_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_single_line_set, _elm_entry_single_line_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_single_line_get, _elm_entry_single_line_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_password_set, _elm_entry_password_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_password_get, _elm_entry_password_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_return_key_disabled_set, _elm_entry_input_panel_return_key_disabled_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_return_key_disabled_get, _elm_entry_input_panel_return_key_disabled_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_autosave_set, _elm_entry_autosave_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_autosave_get, _elm_entry_autosave_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_anchor_hover_parent_set, _elm_entry_anchor_hover_parent_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_anchor_hover_parent_get, _elm_entry_anchor_hover_parent_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_prediction_allow_set, _elm_entry_prediction_allow_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_prediction_allow_get, _elm_entry_prediction_allow_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_hint_set, _elm_entry_input_hint_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_hint_get, _elm_entry_input_hint_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_layout_set, _elm_entry_input_panel_layout_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_layout_get, _elm_entry_input_panel_layout_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_return_key_type_set, _elm_entry_input_panel_return_key_type_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_return_key_type_get, _elm_entry_input_panel_return_key_type_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_enabled_set, _elm_entry_input_panel_enabled_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_enabled_get, _elm_entry_input_panel_enabled_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_line_wrap_set, _elm_entry_line_wrap_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_line_wrap_get, _elm_entry_line_wrap_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_cursor_pos_set, _elm_entry_cursor_pos_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_cursor_pos_get, _elm_entry_cursor_pos_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_icon_visible_set, _elm_entry_icon_visible_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_cursor_line_end_set, _elm_entry_cursor_line_end_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_select_region_set, _elm_entry_select_region_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_select_region_get, _elm_entry_select_region_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_return_key_autoenabled_set, _elm_entry_input_panel_return_key_autoenabled_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_end_visible_set, _elm_entry_end_visible_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_cursor_begin_set, _elm_entry_cursor_begin_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_cursor_line_begin_set, _elm_entry_cursor_line_begin_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_cursor_end_set, _elm_entry_cursor_end_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_textblock_get, _elm_entry_textblock_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_textblock_cursor_geometry_get, _elm_entry_textblock_cursor_geometry_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_imf_context_get, _elm_entry_imf_context_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_cursor_is_format_get, _elm_entry_cursor_is_format_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_textblock_cursor_content_get, _elm_entry_textblock_cursor_content_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_selection_get, _elm_entry_selection_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_cursor_is_visible_format_get, _elm_entry_cursor_is_visible_format_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_select_allow_set, _elm_entry_select_allow_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_select_allow_get, _elm_entry_select_allow_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_cursor_prev, _elm_entry_cursor_prev), + EFL_OBJECT_OP_FUNC(elm_obj_entry_text_style_user_pop, _elm_entry_text_style_user_pop), + EFL_OBJECT_OP_FUNC(elm_obj_entry_item_provider_prepend, _elm_entry_item_provider_prepend), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_show, _elm_entry_input_panel_show), + EFL_OBJECT_OP_FUNC(elm_obj_entry_imf_context_reset, _elm_entry_imf_context_reset), + EFL_OBJECT_OP_FUNC(elm_obj_entry_anchor_hover_end, _elm_entry_anchor_hover_end), + EFL_OBJECT_OP_FUNC(elm_obj_entry_cursor_selection_begin, _elm_entry_cursor_selection_begin), + EFL_OBJECT_OP_FUNC(elm_obj_entry_cursor_down, _elm_entry_cursor_down), + EFL_OBJECT_OP_FUNC(elm_obj_entry_file_save, _elm_entry_file_save), + EFL_OBJECT_OP_FUNC(elm_obj_entry_selection_copy, _elm_entry_selection_copy), + EFL_OBJECT_OP_FUNC(elm_obj_entry_text_style_user_push, _elm_entry_text_style_user_push), + EFL_OBJECT_OP_FUNC(elm_obj_entry_item_provider_remove, _elm_entry_item_provider_remove), + EFL_OBJECT_OP_FUNC(elm_obj_entry_text_style_user_peek, _elm_entry_text_style_user_peek), + EFL_OBJECT_OP_FUNC(elm_obj_entry_context_menu_clear, _elm_entry_context_menu_clear), + EFL_OBJECT_OP_FUNC(elm_obj_entry_cursor_up, _elm_entry_cursor_up), + EFL_OBJECT_OP_FUNC(elm_obj_entry_insert, _elm_entry_entry_insert), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_imdata_set, _elm_entry_input_panel_imdata_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_imdata_get, _elm_entry_input_panel_imdata_get), + EFL_OBJECT_OP_FUNC(elm_obj_entry_selection_paste, _elm_entry_selection_paste), + EFL_OBJECT_OP_FUNC(elm_obj_entry_cursor_next, _elm_entry_cursor_next), + EFL_OBJECT_OP_FUNC(elm_obj_entry_select_none, _elm_entry_select_none), + EFL_OBJECT_OP_FUNC(elm_obj_entry_input_panel_hide, _elm_entry_input_panel_hide), + EFL_OBJECT_OP_FUNC(elm_obj_entry_select_all, _elm_entry_select_all), + EFL_OBJECT_OP_FUNC(elm_obj_entry_cursor_selection_end, _elm_entry_cursor_selection_end), + EFL_OBJECT_OP_FUNC(elm_obj_entry_selection_cut, _elm_entry_selection_cut), + EFL_OBJECT_OP_FUNC(elm_obj_entry_is_empty, _elm_entry_is_empty), + EFL_OBJECT_OP_FUNC(elm_obj_entry_markup_filter_remove, _elm_entry_markup_filter_remove), + EFL_OBJECT_OP_FUNC(elm_obj_entry_item_provider_append, _elm_entry_item_provider_append), + EFL_OBJECT_OP_FUNC(elm_obj_entry_markup_filter_append, _elm_entry_markup_filter_append), + EFL_OBJECT_OP_FUNC(elm_obj_entry_append, _elm_entry_entry_append), + EFL_OBJECT_OP_FUNC(elm_obj_entry_context_menu_item_add, _elm_entry_context_menu_item_add), + EFL_OBJECT_OP_FUNC(elm_obj_entry_markup_filter_prepend, _elm_entry_markup_filter_prepend), + EFL_OBJECT_OP_FUNC(elm_obj_entry_prediction_hint_set, _elm_entry_prediction_hint_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_prediction_hint_hash_set, _elm_entry_prediction_hint_hash_set), + EFL_OBJECT_OP_FUNC(elm_obj_entry_prediction_hint_hash_del, _elm_entry_prediction_hint_hash_del), + EFL_OBJECT_OP_FUNC(efl_constructor, _elm_entry_efl_object_constructor), + EFL_OBJECT_OP_FUNC(efl_gfx_entity_visible_set, _elm_entry_efl_gfx_entity_visible_set), + EFL_OBJECT_OP_FUNC(efl_gfx_entity_position_set, _elm_entry_efl_gfx_entity_position_set), + EFL_OBJECT_OP_FUNC(efl_gfx_entity_size_set, _elm_entry_efl_gfx_entity_size_set), + EFL_OBJECT_OP_FUNC(efl_canvas_group_member_add, _elm_entry_efl_canvas_group_group_member_add), + EFL_OBJECT_OP_FUNC(efl_layout_signal_callback_add, _elm_entry_efl_layout_signal_signal_callback_add), + EFL_OBJECT_OP_FUNC(efl_layout_signal_callback_del, _elm_entry_efl_layout_signal_signal_callback_del), + EFL_OBJECT_OP_FUNC(efl_layout_signal_emit, _elm_entry_efl_layout_signal_signal_emit), + EFL_OBJECT_OP_FUNC(efl_layout_calc_force, _elm_entry_efl_layout_calc_calc_force), + EFL_OBJECT_OP_FUNC(efl_ui_widget_on_access_activate, _elm_entry_efl_ui_widget_on_access_activate), + EFL_OBJECT_OP_FUNC(efl_ui_widget_theme_apply, _elm_entry_efl_ui_widget_theme_apply), + EFL_OBJECT_OP_FUNC(efl_ui_widget_focus_manager_create, _elm_entry_efl_ui_widget_focus_manager_focus_manager_create), + EFL_OBJECT_OP_FUNC(efl_ui_focus_object_on_focus_update, _elm_entry_efl_ui_focus_object_on_focus_update), + EFL_OBJECT_OP_FUNC(efl_ui_widget_interest_region_get, _elm_entry_efl_ui_widget_interest_region_get), + EFL_OBJECT_OP_FUNC(efl_ui_widget_disabled_set, _elm_entry_efl_ui_widget_disabled_set), + EFL_OBJECT_OP_FUNC(efl_ui_widget_sub_object_del, _elm_entry_efl_ui_widget_widget_sub_object_del), + EFL_OBJECT_OP_FUNC(elm_interface_scrollable_policy_set, _elm_entry_elm_interface_scrollable_policy_set), + EFL_OBJECT_OP_FUNC(elm_interface_scrollable_bounce_allow_set, _elm_entry_elm_interface_scrollable_bounce_allow_set), + EFL_OBJECT_OP_FUNC(efl_access_object_state_set_get, _elm_entry_efl_access_object_state_set_get), + EFL_OBJECT_OP_FUNC(efl_access_object_i18n_name_get, _elm_entry_efl_access_object_i18n_name_get), + EFL_OBJECT_OP_FUNC(efl_access_text_get, _elm_entry_efl_access_text_access_text_get), + EFL_OBJECT_OP_FUNC(efl_access_text_string_get, _elm_entry_efl_access_text_string_get), + EFL_OBJECT_OP_FUNC(efl_access_text_attribute_get, _elm_entry_efl_access_text_attribute_get), + EFL_OBJECT_OP_FUNC(efl_access_text_attributes_get, _elm_entry_efl_access_text_text_attributes_get), + EFL_OBJECT_OP_FUNC(efl_access_text_default_attributes_get, _elm_entry_efl_access_text_default_attributes_get), + EFL_OBJECT_OP_FUNC(efl_access_text_caret_offset_set, _elm_entry_efl_access_text_caret_offset_set), + EFL_OBJECT_OP_FUNC(efl_access_text_caret_offset_get, _elm_entry_efl_access_text_caret_offset_get), + EFL_OBJECT_OP_FUNC(efl_access_text_character_get, _elm_entry_efl_access_text_character_get), + EFL_OBJECT_OP_FUNC(efl_access_text_character_extents_get, _elm_entry_efl_access_text_character_extents_get), + EFL_OBJECT_OP_FUNC(efl_access_text_character_count_get, _elm_entry_efl_access_text_character_count_get), + EFL_OBJECT_OP_FUNC(efl_access_text_offset_at_point_get, _elm_entry_efl_access_text_offset_at_point_get), + EFL_OBJECT_OP_FUNC(efl_access_text_bounded_ranges_get, _elm_entry_efl_access_text_bounded_ranges_get), + EFL_OBJECT_OP_FUNC(efl_access_text_range_extents_get, _elm_entry_efl_access_text_range_extents_get), + EFL_OBJECT_OP_FUNC(efl_access_text_access_selection_set, _elm_entry_efl_access_text_access_selection_set), + EFL_OBJECT_OP_FUNC(efl_access_text_access_selection_get, _elm_entry_efl_access_text_access_selection_get), + EFL_OBJECT_OP_FUNC(efl_access_text_selections_count_get, _elm_entry_efl_access_text_selections_count_get), + EFL_OBJECT_OP_FUNC(efl_access_text_selection_add, _elm_entry_efl_access_text_selection_add), + EFL_OBJECT_OP_FUNC(efl_access_text_selection_remove, _elm_entry_efl_access_text_selection_remove), + EFL_OBJECT_OP_FUNC(efl_access_editable_text_content_set, _elm_entry_efl_access_editable_text_text_content_set), + EFL_OBJECT_OP_FUNC(efl_access_editable_text_insert, _elm_entry_efl_access_editable_text_insert), + EFL_OBJECT_OP_FUNC(efl_access_editable_text_copy, _elm_entry_efl_access_editable_text_copy), + EFL_OBJECT_OP_FUNC(efl_access_editable_text_cut, _elm_entry_efl_access_editable_text_cut), + EFL_OBJECT_OP_FUNC(efl_access_editable_text_delete, _elm_entry_efl_access_editable_text_delete), + EFL_OBJECT_OP_FUNC(efl_access_editable_text_paste, _elm_entry_efl_access_editable_text_paste), + EFL_OBJECT_OP_FUNC(efl_access_widget_action_elm_actions_get, _elm_entry_efl_access_widget_action_elm_actions_get), + EFL_OBJECT_OP_FUNC(efl_file_set, _elm_entry_efl_file_file_set), + EFL_OBJECT_OP_FUNC(efl_file_load, _elm_entry_efl_file_load), + EFL_OBJECT_OP_FUNC(efl_part_get, _elm_entry_efl_part_part_get), + ELM_ENTRY_EXTRA_OPS + ); + opsp = &ops; + + static const Efl_Object_Property_Reflection refl_table[] = { + {"scrollable", __eolian_elm_entry_scrollable_set_reflect, __eolian_elm_entry_scrollable_get_reflect}, + {"input_panel_show_on_demand", __eolian_elm_entry_input_panel_show_on_demand_set_reflect, __eolian_elm_entry_input_panel_show_on_demand_get_reflect}, + {"context_menu_disabled", __eolian_elm_entry_context_menu_disabled_set_reflect, __eolian_elm_entry_context_menu_disabled_get_reflect}, + {"selection_handler_disabled", __eolian_elm_entry_selection_handler_disabled_set_reflect, __eolian_elm_entry_selection_handler_disabled_get_reflect}, + {"input_panel_layout_variation", __eolian_elm_entry_input_panel_layout_variation_set_reflect, __eolian_elm_entry_input_panel_layout_variation_get_reflect}, + {"editable", __eolian_elm_entry_editable_set_reflect, __eolian_elm_entry_editable_get_reflect}, + {"anchor_hover_style", __eolian_elm_entry_anchor_hover_style_set_reflect, __eolian_elm_entry_anchor_hover_style_get_reflect}, + {"single_line", __eolian_elm_entry_single_line_set_reflect, __eolian_elm_entry_single_line_get_reflect}, + {"password", __eolian_elm_entry_password_set_reflect, __eolian_elm_entry_password_get_reflect}, + {"input_panel_return_key_disabled", __eolian_elm_entry_input_panel_return_key_disabled_set_reflect, __eolian_elm_entry_input_panel_return_key_disabled_get_reflect}, + {"autosave", __eolian_elm_entry_autosave_set_reflect, __eolian_elm_entry_autosave_get_reflect}, + {"prediction_allow", __eolian_elm_entry_prediction_allow_set_reflect, __eolian_elm_entry_prediction_allow_get_reflect}, + {"input_panel_enabled", __eolian_elm_entry_input_panel_enabled_set_reflect, __eolian_elm_entry_input_panel_enabled_get_reflect}, + {"cursor_pos", __eolian_elm_entry_cursor_pos_set_reflect, __eolian_elm_entry_cursor_pos_get_reflect}, + {"icon_visible", __eolian_elm_entry_icon_visible_set_reflect, NULL}, + {"input_panel_return_key_autoenabled", __eolian_elm_entry_input_panel_return_key_autoenabled_set_reflect, NULL}, + {"end_visible", __eolian_elm_entry_end_visible_set_reflect, NULL}, + {"select_allow", __eolian_elm_entry_select_allow_set_reflect, __eolian_elm_entry_select_allow_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_entry_class_desc = { + EO_VERSION, + "Elm.Entry", + EFL_CLASS_TYPE_REGULAR, + sizeof(Elm_Entry_Data), + _elm_entry_class_initializer, + _elm_entry_class_constructor, + NULL +}; + +EFL_DEFINE_CLASS(elm_entry_class_get, &_elm_entry_class_desc, EFL_UI_LAYOUT_BASE_CLASS, ELM_INTERFACE_SCROLLABLE_MIXIN, EFL_UI_CLICKABLE_INTERFACE, EFL_ACCESS_TEXT_INTERFACE, EFL_ACCESS_EDITABLE_TEXT_INTERFACE, EFL_FILE_MIXIN, EFL_UI_SELECTABLE_INTERFACE, EFL_UI_SCROLLABLE_INTERFACE, EFL_ACCESS_WIDGET_ACTION_MIXIN, EFL_UI_LEGACY_INTERFACE, NULL); + +#include "elm_entry_eo.legacy.c" diff --git a/src/lib/elementary/elm_entry_eo.h b/src/lib/elementary/elm_entry_eo.h index 8d7fab3..f762563 100644 --- a/src/lib/elementary/elm_entry_eo.h +++ b/src/lib/elementary/elm_entry_eo.h @@ -1 +1,1447 @@ -#include "elm_entry.eo.h" +#ifndef _ELM_ENTRY_EO_H_ +#define _ELM_ENTRY_EO_H_ + +#ifndef _ELM_ENTRY_EO_CLASS_TYPE +#define _ELM_ENTRY_EO_CLASS_TYPE + +typedef Eo Elm_Entry; + +#endif + +#ifndef _ELM_ENTRY_EO_TYPES +#define _ELM_ENTRY_EO_TYPES + + +#endif +/** Elementary entry class + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_CLASS elm_entry_class_get() + +EWAPI const Efl_Class *elm_entry_class_get(void); + +/** + * @brief Enable or disable scrolling in entry + * + * Normally the entry is not scrollable unless you enable it with this call. + * + * @param[in] obj The object. + * @param[in] scroll @c true if it is to be scrollable, @c false otherwise. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_scrollable_set(Eo *obj, Eina_Bool scroll); + +/** + * @brief Get the scrollable state of the entry + * + * Normally the entry is not scrollable. This gets the scrollable state of the + * entry. + * + * @param[in] obj The object. + * + * @return @c true if it is to be scrollable, @c false otherwise. + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_scrollable_get(const Eo *obj); + +/** + * @brief Set 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] obj The object. + * @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 + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_input_panel_show_on_demand_set(Eo *obj, Eina_Bool ondemand); + +/** + * @brief Get the attribute to show the input panel in case of only an user's + * explicit Mouse Up event. + * + * @param[in] obj The object. + * + * @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 + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_input_panel_show_on_demand_get(const Eo *obj); + +/** + * @brief This disables the entry's contextual (longpress) menu. + * + * @param[in] obj The object. + * @param[in] disabled If @c true, the menu is disabled. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_context_menu_disabled_set(Eo *obj, Eina_Bool disabled); + +/** + * @brief This returns whether the entry's contextual (longpress) menu is + * disabled. + * + * @param[in] obj The object. + * + * @return If @c true, the menu is disabled. + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_context_menu_disabled_get(const Eo *obj); + +/** + * @brief Control pasting of text and images for the widget. + * + * Normally the entry allows both text and images to be pasted. By setting + * cnp_mode to be #ELM_CNP_MODE_NO_IMAGE, this prevents images from being copy + * or past. By setting cnp_mode to be #ELM_CNP_MODE_PLAINTEXT, this remove all + * tags in text . + * + * @note This only changes the behaviour of text. + * + * @param[in] obj The object. + * @param[in] cnp_mode One of #Elm_Cnp_Mode: #ELM_CNP_MODE_MARKUP, + * #ELM_CNP_MODE_NO_IMAGE, #ELM_CNP_MODE_PLAINTEXT. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_cnp_mode_set(Eo *obj, Elm_Cnp_Mode cnp_mode); + +/** + * @brief Getting elm_entry text paste/drop mode. + * + * Normally the entry allows both text and images to be pasted. This gets the + * copy & paste mode of the entry. + * + * @param[in] obj The object. + * + * @return One of #Elm_Cnp_Mode: #ELM_CNP_MODE_MARKUP, #ELM_CNP_MODE_NO_IMAGE, + * #ELM_CNP_MODE_PLAINTEXT. + * + * @ingroup Elm_Entry + */ +EOAPI Elm_Cnp_Mode elm_obj_entry_cnp_mode_get(const Eo *obj); + +/** + * @brief Text format used to load and save the file, which could be plain text + * or markup text. + * + * Default is @c ELM_TEXT_FORMAT_PLAIN_UTF8, if you want to use + * @c ELM_TEXT_FORMAT_MARKUP_UTF8 then you need to set the text format before + * calling @ref efl_file_load. + * + * You could also set it before a call to @ref elm_obj_entry_file_save in order + * to save with the given format. + * + * Use it before calling @ref efl_file_load or @ref elm_obj_entry_file_save. + * + * @param[in] obj The object. + * @param[in] format The file format + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_file_text_format_set(Eo *obj, Elm_Text_Format format); + +/** + * @brief Set the language mode of the input panel. + * + * This API can be used if you want to show the alphabet keyboard mode. + * + * @param[in] obj The object. + * @param[in] lang Language to be set to the input panel. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_input_panel_language_set(Eo *obj, Elm_Input_Panel_Lang lang); + +/** + * @brief Get the language mode of the input panel. + * + * @param[in] obj The object. + * + * @return Language to be set to the input panel. + * + * @ingroup Elm_Entry + */ +EOAPI Elm_Input_Panel_Lang elm_obj_entry_input_panel_language_get(const Eo *obj); + +/** + * @brief This disabled the entry's selection handlers. + * + * @param[in] obj The object. + * @param[in] disabled If @c true, the selection handlers are disabled. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_selection_handler_disabled_set(Eo *obj, Eina_Bool disabled); + +/** + * @brief This returns whether the entry's selection handlers are disabled. + * + * @param[in] obj The object. + * + * @return If @c true, the selection handlers are disabled. + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_selection_handler_disabled_get(const Eo *obj); + +/** + * @brief Set the input panel layout variation of the entry + * + * @param[in] obj The object. + * @param[in] variation Layout variation type. + * + * @since 1.8 + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_input_panel_layout_variation_set(Eo *obj, int variation); + +/** + * @brief Get the input panel layout variation of the entry + * + * @param[in] obj The object. + * + * @return Layout variation type. + * + * @since 1.8 + * + * @ingroup Elm_Entry + */ +EOAPI int elm_obj_entry_input_panel_layout_variation_get(const Eo *obj); + +/** + * @brief Set the autocapitalization type on the immodule. + * + * @param[in] obj The object. + * @param[in] autocapital_type The type of autocapitalization. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_autocapital_type_set(Eo *obj, Elm_Autocapital_Type autocapital_type); + +/** + * @brief Get the autocapitalization type on the immodule. + * + * @param[in] obj The object. + * + * @return The type of autocapitalization. + * + * @ingroup Elm_Entry + */ +EOAPI Elm_Autocapital_Type elm_obj_entry_autocapital_type_get(const Eo *obj); + +/** + * @brief Sets if the entry is to be editable or not. + * + * By default, entries are editable and when focused, any text input by the + * user will be inserted at the current cursor position. But calling this + * function with @c editable as @c false will prevent the user from inputting + * text into the entry. + * + * The only way to change the text of a non-editable entry is to use @ref + * elm_object_text_set, @ref elm_entry_entry_insert and other related + * functions. + * + * @param[in] obj The object. + * @param[in] editable If @c true, user input will be inserted in the entry, if + * not, the entry is read-only and no user input is allowed. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_editable_set(Eo *obj, Eina_Bool editable); + +/** + * @brief Get whether the entry is editable or not. + * + * @param[in] obj The object. + * + * @return If @c true, user input will be inserted in the entry, if not, the + * entry is read-only and no user input is allowed. + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_editable_get(const Eo *obj); + +/** + * @brief Set the style that the hover should use + * + * When creating the popup hover, entry will request that it's themed according + * to @c style. + * + * Setting style no @c null means disabling automatic hover. + * + * @param[in] obj The object. + * @param[in] style The style to use for the underlying hover. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_anchor_hover_style_set(Eo *obj, const char *style); + +/** + * @brief Get the style that the hover should use. + * + * @param[in] obj The object. + * + * @return The style to use for the underlying hover. + * + * @ingroup Elm_Entry + */ +EOAPI const char *elm_obj_entry_anchor_hover_style_get(const Eo *obj); + +/** + * @brief Sets the entry to single line mode. + * + * In single line mode, entries don't ever wrap when the text reaches the edge, + * and instead they keep growing horizontally. Pressing the @c Enter key will + * generate an $"activate" event instead of adding a new line. + * + * When @c single_line is @c false, line wrapping takes effect again and + * pressing enter will break the text into a different line without generating + * any events. + * + * @param[in] obj The object. + * @param[in] single_line If @c true, the text in the entry will be on a single + * line. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_single_line_set(Eo *obj, Eina_Bool single_line); + +/** + * @brief Get whether the entry is set to be single line. + * + * @param[in] obj The object. + * + * @return If @c true, the text in the entry will be on a single line. + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_single_line_get(const Eo *obj); + +/** + * @brief Sets the entry to password mode. + * + * In password mode, entries are implicitly single line and the display of any + * text in them is replaced with asterisks (*). + * + * @param[in] obj The object. + * @param[in] password If @c true, password mode is enabled. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_password_set(Eo *obj, Eina_Bool password); + +/** + * @brief Get whether the entry is set to password mode. + * + * @param[in] obj The object. + * + * @return If @c true, password mode is enabled. + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_password_get(const Eo *obj); + +/** + * @brief Set the return key on the input panel to be disabled. + * + * @param[in] obj The object. + * @param[in] disabled The state to put in in: @c true for disabled, @c false + * for enabled. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_input_panel_return_key_disabled_set(Eo *obj, Eina_Bool disabled); + +/** + * @brief Get whether the return key on the input panel should be disabled or + * not. + * + * @param[in] obj The object. + * + * @return The state to put in in: @c true for disabled, @c false for enabled. + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_input_panel_return_key_disabled_get(const Eo *obj); + +/** + * @brief This sets the entry object to 'autosave' the loaded text file or not. + * + * @param[in] obj The object. + * @param[in] auto_save Autosave the loaded file or not. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_autosave_set(Eo *obj, Eina_Bool auto_save); + +/** + * @brief This gets the entry object's 'autosave' status. + * + * @param[in] obj The object. + * + * @return Autosave the loaded file or not. + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_autosave_get(const Eo *obj); + +/** + * @brief Set the parent of the hover popup + * + * Sets the parent object to use by the hover created by the entry when an + * anchor is clicked. + * + * @param[in] obj The object. + * @param[in] parent The object to use as parent for the hover. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_anchor_hover_parent_set(Eo *obj, Efl_Canvas_Object *parent); + +/** + * @brief Get the parent of the hover popup + * + * Get the object used as parent for the hover created by the entry widget. If + * no parent is set, the same entry object will be used. + * + * @param[in] obj The object. + * + * @return The object to use as parent for the hover. + * + * @ingroup Elm_Entry + */ +EOAPI Efl_Canvas_Object *elm_obj_entry_anchor_hover_parent_get(const Eo *obj); + +/** + * @brief Set whether the entry should allow to use the text prediction. + * + * @param[in] obj The object. + * @param[in] prediction Whether the entry should allow to use the text + * prediction. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_prediction_allow_set(Eo *obj, Eina_Bool prediction); + +/** + * @brief Get whether the entry should allow to use the text prediction. + * + * @param[in] obj The object. + * + * @return Whether the entry should allow to use the text prediction. + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_prediction_allow_get(const Eo *obj); + +/** + * @brief Sets the input hint which allows input methods to fine-tune their + * behavior. + * + * @param[in] obj The object. + * @param[in] hints Input hint. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_input_hint_set(Eo *obj, Elm_Input_Hints hints); + +/** + * @brief Gets the value of input hint. + * + * @param[in] obj The object. + * + * @return Input hint. + * + * @ingroup Elm_Entry + */ +EOAPI Elm_Input_Hints elm_obj_entry_input_hint_get(const Eo *obj); + +/** + * @brief Set the input panel layout of the entry. + * + * @param[in] obj The object. + * @param[in] layout Layout type. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_input_panel_layout_set(Eo *obj, Elm_Input_Panel_Layout layout); + +/** + * @brief Get the input panel layout of the entry. + * + * @param[in] obj The object. + * + * @return Layout type. + * + * @ingroup Elm_Entry + */ +EOAPI Elm_Input_Panel_Layout elm_obj_entry_input_panel_layout_get(const Eo *obj); + +/** + * @brief Set 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. + * + * Regardless of return key type, "activated" event will be generated when + * pressing return key in single line entry. + * + * @param[in] obj The object. + * @param[in] return_key_type The type of "return" key on the input panel. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_input_panel_return_key_type_set(Eo *obj, Elm_Input_Panel_Return_Key_Type return_key_type); + +/** + * @brief Get the "return" key type. + * + * @param[in] obj The object. + * + * @return The type of "return" key on the input panel. + * + * @ingroup Elm_Entry + */ +EOAPI Elm_Input_Panel_Return_Key_Type elm_obj_entry_input_panel_return_key_type_get(const Eo *obj); + +/** + * @brief Sets the attribute to show the input panel automatically. + * + * @param[in] obj The object. + * @param[in] enabled If @c true, the input panel is appeared when entry is + * clicked or has a focus. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_input_panel_enabled_set(Eo *obj, Eina_Bool enabled); + +/** + * @brief Get the attribute to show the input panel automatically. + * + * @param[in] obj The object. + * + * @return If @c true, the input panel is appeared when entry is clicked or has + * a focus. + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_input_panel_enabled_get(const Eo *obj); + +/** + * @brief Set the line wrap type to use on multi-line entries. + * + * Sets the wrap type used by the entry to any of the specified in + * Elm_Wrap_Type. This tells how the text will be implicitly cut into a new + * line (without inserting a line break or paragraph separator) when it reaches + * the far edge of the widget. + * + * Note that this only makes sense for multi-line entries. A widget set to be + * single line will never wrap. + * + * @param[in] obj The object. + * @param[in] wrap The wrap mode to use. See Elm_Wrap_Type for details on them. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_line_wrap_set(Eo *obj, Elm_Wrap_Type wrap); + +/** + * @brief Get the wrap mode the entry was set to use. + * + * @param[in] obj The object. + * + * @return The wrap mode to use. See Elm_Wrap_Type for details on them. + * + * @ingroup Elm_Entry + */ +EOAPI Elm_Wrap_Type elm_obj_entry_line_wrap_get(const Eo *obj); + +/** + * @brief Sets the cursor position in the entry to the given value + * + * The value in @c pos is the index of the character position within the + * contents of the string as returned by @ref elm_obj_entry_cursor_pos_get. + * + * @param[in] obj The object. + * @param[in] pos The position of the cursor. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_cursor_pos_set(Eo *obj, int pos); + +/** + * @brief Get the current position of the cursor in the entry. + * + * @param[in] obj The object. + * + * @return The position of the cursor. + * + * @ingroup Elm_Entry + */ +EOAPI int elm_obj_entry_cursor_pos_get(const Eo *obj); + +/** + * @brief Sets the visibility of the left-side widget of the entry, set by @ref + * elm_object_part_content_set. + * + * @param[in] obj The object. + * @param[in] setting @c true if the object should be displayed, @c false if + * not. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_icon_visible_set(Eo *obj, Eina_Bool setting); + +/** This moves the cursor to the end of the current line. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_cursor_line_end_set(Eo *obj); + +/** + * @brief This selects a region of text within the entry. + * + * @param[in] obj The object. + * @param[in] start The starting position. + * @param[in] end The end position. + * + * @since 1.9 + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_select_region_set(Eo *obj, int start, int end); + +/** + * @brief Get the current position of the selection cursors in the entry. + * + * @param[in] obj The object. + * @param[out] start The starting position. + * @param[out] end The end position. + * + * @since 1.18 + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_select_region_get(const Eo *obj, int *start, int *end); + +/** + * @brief Set whether the return key on the input panel is disabled + * automatically when entry has no text. + * + * If @c enabled is @c true, The return key on input panel is disabled when the + * entry has no text. The return key on the input panel is automatically + * enabled when the entry has text. The default value is @c false. + * + * @param[in] obj The object. + * @param[in] enabled If @c enabled is @c true, the return key is automatically + * disabled when the entry has no text. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_input_panel_return_key_autoenabled_set(Eo *obj, Eina_Bool enabled); + +/** + * @brief Sets the visibility of the end widget of the entry, set by @ref + * elm_object_part_content_set(ent, "end", content). + * + * @param[in] obj The object. + * @param[in] setting @c true if the object should be displayed, false if not. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_end_visible_set(Eo *obj, Eina_Bool setting); + +/** This moves the cursor to the beginning of the entry. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_cursor_begin_set(Eo *obj); + +/** This moves the cursor to the beginning of the current line. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_cursor_line_begin_set(Eo *obj); + +/** This moves the cursor to the end of the entry. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_cursor_end_set(Eo *obj); + +/** + * @brief Returns the actual textblock object of the entry. + * + * This function exposes the internal textblock object that actually contains + * and draws the text. This should be used for low-level manipulations that are + * otherwise not possible. + * + * Changing the textblock directly from here will not notify edje/elm to + * recalculate the textblock size automatically, so any modifications done to + * the textblock returned by this function should be followed by a call to @ref + * elm_entry_calc_force. + * + * The return value is marked as const as an additional warning. One should not + * use the returned object with any of the generic evas functions + * (geometry_get/resize/move and etc), but only with the textblock functions; + * The former will either not work at all, or break the correct functionality. + * + * IMPORTANT: Many functions may change (i.e delete and create a new one) the + * internal textblock object. Do NOT cache the returned object, and try not to + * mix calls on this object with regular elm_entry calls (which may change the + * internal textblock object). This applies to all cursors returned from + * textblock calls, and all the other derivative values. + * + * @param[in] obj The object. + * + * @return Textblock object + * + * @ingroup Elm_Entry + */ +EOAPI Efl_Canvas_Object *elm_obj_entry_textblock_get(const Eo *obj); + +/** + * @brief This function returns the geometry of the cursor. + * + * It's useful if you want to draw something on the cursor (or where it is), or + * for example in the case of scrolled entry where you want to show the cursor. + * + * @param[in] obj The object. + * @param[out] x X coordinate + * @param[out] y Y coordinate + * @param[out] w Width + * @param[out] h Height + * + * @return @c true on success, @c false otherwise + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_textblock_cursor_geometry_get(const Eo *obj, int *x, int *y, int *w, int *h); + +/** + * @brief Returns the input method context of the entry. + * + * This function exposes the internal input method context. + * + * IMPORTANT: Many functions may change (i.e delete and create a new one) the + * internal input method context. Do NOT cache the returned object. + * + * @param[in] obj The object. + * + * @return Input method context + * + * @ingroup Elm_Entry + */ +EOAPI void *elm_obj_entry_imf_context_get(const Eo *obj); + +/** + * @brief Get whether a format node exists at the current cursor position. + * + * A format node is anything that defines how the text is rendered. It can be a + * visible format node, such as a line break or a paragraph separator, or an + * invisible one, such as bold begin or end tag. This function returns whether + * any format node exists at the current cursor position. + * + * @param[in] obj The object. + * + * @return @c true if format node exists, @c false otherwise + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_cursor_is_format_get(const Eo *obj); + +/** + * @brief Get the character pointed by the cursor at its current position. + * + * This function returns a string with the utf8 character stored at the current + * cursor position. Only the text is returned, any format that may exist will + * not be part of the return value. You must free the string when done with + * @ref free. + * + * @param[in] obj The object. + * + * @return Character + * + * @ingroup Elm_Entry + */ +EOAPI char *elm_obj_entry_textblock_cursor_content_get(const Eo *obj) EINA_WARN_UNUSED_RESULT; + +/** + * @brief Get any selected text within the entry. + * + * If there's any selected text in the entry, this function returns it as a + * string in markup format. @c null is returned if no selection exists or if an + * error occurred. + * + * The returned value points to an internal string and should not be freed or + * modified in any way. If the @c entry object is deleted or its contents are + * changed, the returned pointer should be considered invalid. + * + * @param[in] obj The object. + * + * @return Selected string + * + * @ingroup Elm_Entry + */ +EOAPI const char *elm_obj_entry_selection_get(const Eo *obj); + +/** + * @brief Get if the current cursor position holds a visible format node. + * + * @param[in] obj The object. + * + * @return @c true if position has a visible format, @c false otherwise + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_cursor_is_visible_format_get(const Eo *obj); + +/** + * @brief Allow selection in the entry. + * + * @param[in] obj The object. + * @param[in] allow If @c allow is true, the text selection is allowed. + * + * @since 1.18 + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_select_allow_set(Eo *obj, Eina_Bool allow); + +/** + * @brief Allow selection in the entry. + * + * @param[in] obj The object. + * + * @return If @c allow is true, the text selection is allowed. + * + * @since 1.18 + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_select_allow_get(const Eo *obj); + +/** + * @brief This moves the cursor one place to the left within the entry. + * + * @param[in] obj The object. + * + * @return @c true on success, @c false otherwise + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_cursor_prev(Eo *obj); + +/** Remove the style in the top of user style stack. + * + * @since 1.7 + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_text_style_user_pop(Eo *obj); + +/** + * @brief This prepends a custom item provider to the list for that entry + * + * This prepends the given callback. + * + * @param[in] obj The object. + * @param[in] func The function called to provide the item object. + * @param[in] data The data passed to @c func. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_item_provider_prepend(Eo *obj, Elm_Entry_Item_Provider_Cb func, void *data); + +/** + * @brief Show the input panel (virtual keyboard) based on the input panel + * property of entry such as layout, autocapital types, and so on. + * + * Note that input panel is shown or hidden automatically according to the + * focus state of entry widget. This API can be used in the case of manually + * controlling by using @ref elm_obj_entry_input_panel_enabled_set(en, + * @c false). + * @param[in] obj The object. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_input_panel_show(Eo *obj); + +/** + * @brief Reset the input method context of the entry if needed. + * + * This can be necessary in the case where modifying the buffer would confuse + * on-going input method behavior. This will typically cause the Input Method + * Context to clear the preedit state. + * @param[in] obj The object. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_imf_context_reset(Eo *obj); + +/** + * @brief Ends the hover popup in the entry + * + * When an anchor is clicked, the entry widget will create a hover object to + * use as a popup with user provided content. This function terminates this + * popup, returning the entry to its normal state. + * @param[in] obj The object. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_anchor_hover_end(Eo *obj); + +/** This begins a selection within the entry as though the user were holding + * down the mouse button to make a selection. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_cursor_selection_begin(Eo *obj); + +/** + * @brief This moves the cursor one line down within the entry. + * + * @param[in] obj The object. + * + * @return @c true on success, @c false otherwise + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_cursor_down(Eo *obj); + +/** This function writes any changes made to the file set with @ref + * elm_entry_file_set. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_file_save(Eo *obj); + +/** This executes a "copy" action on the selected text in the entry. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_selection_copy(Eo *obj); + +/** + * @brief Push the style to the top of user style stack. If there is styles in + * the user style stack, the properties in the top style of user style stack + * will replace the properties in current theme. The input style is specified + * in format tag='property=value' (i.e. DEFAULT='font=Sans + * font_size=60'hilight=' + font_weight=Bold'). + * + * @param[in] obj The object. + * @param[in] style The style user to push. + * + * @since 1.7 + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_text_style_user_push(Eo *obj, const char *style); + +/** + * @brief This removes a custom item provider to the list for that entry + * + * This removes the given callback. See @ref elm_obj_entry_item_provider_append + * for more information + * + * @param[in] obj The object. + * @param[in] func The function called to provide the item object. + * @param[in] data The data passed to @c func. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_item_provider_remove(Eo *obj, Elm_Entry_Item_Provider_Cb func, void *data); + +/** + * @brief Get the style on the top of user style stack. + * + * See also @ref elm_obj_entry_text_style_user_push. + * + * @param[in] obj The object. + * + * @return Style + * + * @since 1.7 + * + * @ingroup Elm_Entry + */ +EOAPI const char *elm_obj_entry_text_style_user_peek(const Eo *obj); + +/** + * @brief This clears and frees the items in a entry's contextual (longpress) + * menu. + * + * See also @ref elm_obj_entry_context_menu_item_add. + * @param[in] obj The object. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_context_menu_clear(Eo *obj); + +/** + * @brief This moves the cursor one line up within the entry. + * + * @param[in] obj The object. + * + * @return @c true on success, @c false otherwise + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_cursor_up(Eo *obj); + +/** + * @brief Inserts the given text into the entry at the current cursor position. + * + * This inserts text at the cursor position as if it was typed by the user + * (note that this also allows markup which a user can't just "type" as it + * would be converted to escaped text, so this call can be used to insert + * things like emoticon items or bold push/pop tags, other font and color + * change tags etc.) + * + * If any selection exists, it will be replaced by the inserted text. + * + * The inserted text is subject to any filters set for the widget. + * + * See also @ref elm_obj_entry_markup_filter_append. + * + * @param[in] obj The object. + * @param[in] entry The text to insert. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_insert(Eo *obj, const char *entry); + +/** + * @brief Set 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] obj The object. + * @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. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_input_panel_imdata_set(Eo *obj, const void *data, int len); + +/** + * @brief Get the specific data of the current input panel. + * + * @param[in] obj The object. + * @param[out] data The specific data to be got from the input panel. + * @param[out] len The length of data. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_input_panel_imdata_get(const Eo *obj, void *data, int *len); + +/** This executes a "paste" action in the entry. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_selection_paste(Eo *obj); + +/** + * @brief This moves the cursor one place to the right within the entry. + * + * @param[in] obj The object. + * + * @return @c true on success, @c false otherwise + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_cursor_next(Eo *obj); + +/** This drops any existing text selection within the entry. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_select_none(Eo *obj); + +/** + * @brief Hide the input panel (virtual keyboard). + * + * Note that input panel is shown or hidden automatically according to the + * focus state of entry widget. This API can be used in the case of manually + * controlling by using @ref elm_obj_entry_input_panel_enabled_set(en, + * @c false) + * @param[in] obj The object. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_input_panel_hide(Eo *obj); + +/** This selects all text within the entry. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_select_all(Eo *obj); + +/** This ends a selection within the entry as though the user had just released + * the mouse button while making a selection. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_cursor_selection_end(Eo *obj); + +/** This executes a "cut" action on the selected text in the entry. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_selection_cut(Eo *obj); + +/** + * @brief Get whether the entry is empty. + * + * Empty means no text at all. If there are any markup tags, like an item tag + * for which no provider finds anything, and no text is displayed, this + * function still returns @c false. + * + * @param[in] obj The object. + * + * @return @c true if empty, @c false otherwise + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_is_empty(const Eo *obj); + +/** + * @brief Remove a markup filter from the list + * + * Removes the given callback from the filter list. See + * @ref elm_obj_entry_markup_filter_append for more information. + * + * @param[in] obj The object. + * @param[in] func The filter function to remove. + * @param[in] data The user data passed when adding the function. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_markup_filter_remove(Eo *obj, Elm_Entry_Filter_Cb func, void *data); + +/** + * @brief This appends a custom item provider to the list for that entry + * + * This appends the given callback. The list is walked from beginning to end + * with each function called given the item href string in the text. If the + * function returns an object handle other than @c null (it should create an + * object to do this), then this object is used to replace that item. If not + * the next provider is called until one provides an item object, or the + * default provider in entry does. + * + * See also @ref entry-items. + * + * @param[in] obj The object. + * @param[in] func The function called to provide the item object. + * @param[in] data The data passed to @c func. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_item_provider_append(Eo *obj, Elm_Entry_Item_Provider_Cb func, void *data); + +/** + * @brief Append a markup filter function for text inserted in the entry + * + * Append the given callback to the list. This functions will be called + * whenever any text is inserted into the entry, with the text to be inserted + * as a parameter. The type of given text is always markup. The callback + * function is free to alter the text in any way it wants, but it must remember + * to free the given pointer and update it. If the new text is to be discarded, + * the function can free it and set its text parameter to @c null. This will + * also prevent any following filters from being called. + * + * @param[in] obj The object. + * @param[in] func The function to use as text filter. + * @param[in] data User data to pass to @c func. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_markup_filter_append(Eo *obj, Elm_Entry_Filter_Cb func, void *data); + +/** + * @brief Appends @c str to the text of the entry. + * + * Adds the text in @c str to the end of any text already present in the + * widget. + * + * The appended text is subject to any filters set for the widget. + * + * See also @ref elm_obj_entry_markup_filter_append. + * + * @param[in] obj The object. + * @param[in] str The text to be appended. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_append(Eo *obj, const char *str); + +/** + * @brief This adds an item to the entry's contextual menu. + * + * A longpress on an entry will make the contextual menu show up, if this + * hasn't been disabled with @ref elm_obj_entry_context_menu_disabled_set. By + * default, this menu provides a few options like enabling selection mode, + * which is useful on embedded devices that need to be explicit about it, and + * when a selection exists it also shows the copy and cut actions. + * + * With this function, developers can add other options to this menu to perform + * any action they deem necessary. + * + * @param[in] obj The object. + * @param[in] label The item's text label. + * @param[in] icon_file The item's icon file. + * @param[in] icon_type The item's icon type. + * @param[in] func The callback to execute when the item is clicked. + * @param[in] data The data to associate with the item for related functions. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_context_menu_item_add(Eo *obj, const char *label, const char *icon_file, Elm_Icon_Type icon_type, Evas_Smart_Cb func, const void *data); + +/** + * @brief Prepend a markup filter function for text inserted in the entry + * + * Prepend the given callback to the list. + * + * @param[in] obj The object. + * @param[in] func The function to use as text filter. + * @param[in] data User data to pass to @c func. + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_markup_filter_prepend(Eo *obj, Elm_Entry_Filter_Cb func, void *data); + +/** + * @brief Sets the prediction hint to use an intelligent reply suggestion + * service. + * + * @param[in] obj The object. + * @param[in] prediction_hint The prediction hint text. + * + * @since 1.20 + * + * @ingroup Elm_Entry + */ +EOAPI void elm_obj_entry_prediction_hint_set(Eo *obj, const char *prediction_hint); + +/** + * @brief Sets the prediction hint data at the specified key. + * + * @param[in] obj The object. + * @param[in] key The key of the prediction hint. + * @param[in] value The data to replace. + * + * @return @c true on success, @c false otherwise + * + * @since 1.21 + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_prediction_hint_hash_set(Eo *obj, const char *key, const char *value); + +/** + * @brief Removes the prediction hint data identified by a key. + * + * @param[in] obj The object. + * @param[in] key The key of the prediction hint. + * + * @return @c true on success, @c false otherwise + * + * @since 1.21 + * + * @ingroup Elm_Entry + */ +EOAPI Eina_Bool elm_obj_entry_prediction_hint_hash_del(Eo *obj, const char *key); + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_ACTIVATED; + +/** Called when entry got activated + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_ACTIVATED (&(_ELM_ENTRY_EVENT_ACTIVATED)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_CHANGED; + +/** Called when entry changed + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_CHANGED (&(_ELM_ENTRY_EVENT_CHANGED)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_CHANGED_USER; + +/** Called when the object changed due to user interaction + * @return Elm_Entry_Change_Info + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_CHANGED_USER (&(_ELM_ENTRY_EVENT_CHANGED_USER)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_VALIDATE; + +/** Called when validating + * @return Elm_Validate_Content + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_VALIDATE (&(_ELM_ENTRY_EVENT_VALIDATE)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_CONTEXT_OPEN; + +/** Called when context menu was opened + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_CONTEXT_OPEN (&(_ELM_ENTRY_EVENT_CONTEXT_OPEN)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_ANCHOR_CLICKED; + +/** Called when anchor was clicked + * @return Elm_Entry_Anchor_Info + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_ANCHOR_CLICKED (&(_ELM_ENTRY_EVENT_ANCHOR_CLICKED)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_REJECTED; + +/** Called when entry was rejected + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_REJECTED (&(_ELM_ENTRY_EVENT_REJECTED)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_MAXLENGTH_REACHED; + +/** Called when maximum entry length has been reached + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_MAXLENGTH_REACHED (&(_ELM_ENTRY_EVENT_MAXLENGTH_REACHED)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_PREEDIT_CHANGED; + +/** Called when entry preedit changed + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_PREEDIT_CHANGED (&(_ELM_ENTRY_EVENT_PREEDIT_CHANGED)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_PRESS; + +/** Called when entry pressed + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_PRESS (&(_ELM_ENTRY_EVENT_PRESS)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_REDO_REQUEST; + +/** Called when redo was requested + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_REDO_REQUEST (&(_ELM_ENTRY_EVENT_REDO_REQUEST)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_UNDO_REQUEST; + +/** Called when undo was requested + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_UNDO_REQUEST (&(_ELM_ENTRY_EVENT_UNDO_REQUEST)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_TEXT_SET_DONE; + +/** Called when text set finished + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_TEXT_SET_DONE (&(_ELM_ENTRY_EVENT_TEXT_SET_DONE)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_ABORTED; + +/** Called when entry was aborted + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_ABORTED (&(_ELM_ENTRY_EVENT_ABORTED)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_ANCHOR_DOWN; + +/** Called on anchor down + * @return Elm_Entry_Anchor_Info + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_ANCHOR_DOWN (&(_ELM_ENTRY_EVENT_ANCHOR_DOWN)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_ANCHOR_HOVER_OPENED; + +/** Called when hover opened + * @return Elm_Entry_Anchor_Hover_Info + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_ANCHOR_HOVER_OPENED (&(_ELM_ENTRY_EVENT_ANCHOR_HOVER_OPENED)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_ANCHOR_IN; + +/** Called on anchor in + * @return Elm_Entry_Anchor_Info + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_ANCHOR_IN (&(_ELM_ENTRY_EVENT_ANCHOR_IN)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_ANCHOR_OUT; + +/** Called on anchor out + * @return Elm_Entry_Anchor_Info + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_ANCHOR_OUT (&(_ELM_ENTRY_EVENT_ANCHOR_OUT)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_ANCHOR_UP; + +/** called on anchor up + * @return Elm_Entry_Anchor_Info + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_ANCHOR_UP (&(_ELM_ENTRY_EVENT_ANCHOR_UP)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_CURSOR_CHANGED; + +/** Called on cursor changed + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_CURSOR_CHANGED (&(_ELM_ENTRY_EVENT_CURSOR_CHANGED)) + +EWAPI extern const Efl_Event_Description _ELM_ENTRY_EVENT_CURSOR_CHANGED_MANUAL; + +/** Called on manual cursor change + * + * @ingroup Elm_Entry + */ +#define ELM_ENTRY_EVENT_CURSOR_CHANGED_MANUAL (&(_ELM_ENTRY_EVENT_CURSOR_CHANGED_MANUAL)) + +#endif diff --git a/src/lib/elementary/elm_entry_eo.legacy.c b/src/lib/elementary/elm_entry_eo.legacy.c new file mode 100644 index 0000000..b5bf557 --- /dev/null +++ b/src/lib/elementary/elm_entry_eo.legacy.c @@ -0,0 +1,582 @@ + +EAPI void +elm_entry_scrollable_set(Elm_Entry *obj, Eina_Bool scroll) +{ + elm_obj_entry_scrollable_set(obj, scroll); +} + +EAPI Eina_Bool +elm_entry_scrollable_get(const Elm_Entry *obj) +{ + return elm_obj_entry_scrollable_get(obj); +} + +EAPI void +elm_entry_input_panel_show_on_demand_set(Elm_Entry *obj, Eina_Bool ondemand) +{ + elm_obj_entry_input_panel_show_on_demand_set(obj, ondemand); +} + +EAPI Eina_Bool +elm_entry_input_panel_show_on_demand_get(const Elm_Entry *obj) +{ + return elm_obj_entry_input_panel_show_on_demand_get(obj); +} + +EAPI void +elm_entry_context_menu_disabled_set(Elm_Entry *obj, Eina_Bool disabled) +{ + elm_obj_entry_context_menu_disabled_set(obj, disabled); +} + +EAPI Eina_Bool +elm_entry_context_menu_disabled_get(const Elm_Entry *obj) +{ + return elm_obj_entry_context_menu_disabled_get(obj); +} + +EAPI void +elm_entry_cnp_mode_set(Elm_Entry *obj, Elm_Cnp_Mode cnp_mode) +{ + elm_obj_entry_cnp_mode_set(obj, cnp_mode); +} + +EAPI Elm_Cnp_Mode +elm_entry_cnp_mode_get(const Elm_Entry *obj) +{ + return elm_obj_entry_cnp_mode_get(obj); +} + +EAPI void +elm_entry_file_text_format_set(Elm_Entry *obj, Elm_Text_Format format) +{ + elm_obj_entry_file_text_format_set(obj, format); +} + +EAPI void +elm_entry_input_panel_language_set(Elm_Entry *obj, Elm_Input_Panel_Lang lang) +{ + elm_obj_entry_input_panel_language_set(obj, lang); +} + +EAPI Elm_Input_Panel_Lang +elm_entry_input_panel_language_get(const Elm_Entry *obj) +{ + return elm_obj_entry_input_panel_language_get(obj); +} + +EAPI void +elm_entry_selection_handler_disabled_set(Elm_Entry *obj, Eina_Bool disabled) +{ + elm_obj_entry_selection_handler_disabled_set(obj, disabled); +} + +EAPI void +elm_entry_input_panel_layout_variation_set(Elm_Entry *obj, int variation) +{ + elm_obj_entry_input_panel_layout_variation_set(obj, variation); +} + +EAPI int +elm_entry_input_panel_layout_variation_get(const Elm_Entry *obj) +{ + return elm_obj_entry_input_panel_layout_variation_get(obj); +} + +EAPI void +elm_entry_autocapital_type_set(Elm_Entry *obj, Elm_Autocapital_Type autocapital_type) +{ + elm_obj_entry_autocapital_type_set(obj, autocapital_type); +} + +EAPI Elm_Autocapital_Type +elm_entry_autocapital_type_get(const Elm_Entry *obj) +{ + return elm_obj_entry_autocapital_type_get(obj); +} + +EAPI void +elm_entry_editable_set(Elm_Entry *obj, Eina_Bool editable) +{ + elm_obj_entry_editable_set(obj, editable); +} + +EAPI Eina_Bool +elm_entry_editable_get(const Elm_Entry *obj) +{ + return elm_obj_entry_editable_get(obj); +} + +EAPI void +elm_entry_anchor_hover_style_set(Elm_Entry *obj, const char *style) +{ + elm_obj_entry_anchor_hover_style_set(obj, style); +} + +EAPI const char * +elm_entry_anchor_hover_style_get(const Elm_Entry *obj) +{ + return elm_obj_entry_anchor_hover_style_get(obj); +} + +EAPI void +elm_entry_single_line_set(Elm_Entry *obj, Eina_Bool single_line) +{ + elm_obj_entry_single_line_set(obj, single_line); +} + +EAPI Eina_Bool +elm_entry_single_line_get(const Elm_Entry *obj) +{ + return elm_obj_entry_single_line_get(obj); +} + +EAPI void +elm_entry_password_set(Elm_Entry *obj, Eina_Bool password) +{ + elm_obj_entry_password_set(obj, password); +} + +EAPI Eina_Bool +elm_entry_password_get(const Elm_Entry *obj) +{ + return elm_obj_entry_password_get(obj); +} + +EAPI void +elm_entry_input_panel_return_key_disabled_set(Elm_Entry *obj, Eina_Bool disabled) +{ + elm_obj_entry_input_panel_return_key_disabled_set(obj, disabled); +} + +EAPI Eina_Bool +elm_entry_input_panel_return_key_disabled_get(const Elm_Entry *obj) +{ + return elm_obj_entry_input_panel_return_key_disabled_get(obj); +} + +EAPI void +elm_entry_autosave_set(Elm_Entry *obj, Eina_Bool auto_save) +{ + elm_obj_entry_autosave_set(obj, auto_save); +} + +EAPI Eina_Bool +elm_entry_autosave_get(const Elm_Entry *obj) +{ + return elm_obj_entry_autosave_get(obj); +} + +EAPI void +elm_entry_anchor_hover_parent_set(Elm_Entry *obj, Efl_Canvas_Object *parent) +{ + elm_obj_entry_anchor_hover_parent_set(obj, parent); +} + +EAPI Efl_Canvas_Object * +elm_entry_anchor_hover_parent_get(const Elm_Entry *obj) +{ + return elm_obj_entry_anchor_hover_parent_get(obj); +} + +EAPI void +elm_entry_prediction_allow_set(Elm_Entry *obj, Eina_Bool prediction) +{ + elm_obj_entry_prediction_allow_set(obj, prediction); +} + +EAPI Eina_Bool +elm_entry_prediction_allow_get(const Elm_Entry *obj) +{ + return elm_obj_entry_prediction_allow_get(obj); +} + +EAPI void +elm_entry_input_hint_set(Elm_Entry *obj, Elm_Input_Hints hints) +{ + elm_obj_entry_input_hint_set(obj, hints); +} + +EAPI Elm_Input_Hints +elm_entry_input_hint_get(const Elm_Entry *obj) +{ + return elm_obj_entry_input_hint_get(obj); +} + +EAPI void +elm_entry_input_panel_layout_set(Elm_Entry *obj, Elm_Input_Panel_Layout layout) +{ + elm_obj_entry_input_panel_layout_set(obj, layout); +} + +EAPI Elm_Input_Panel_Layout +elm_entry_input_panel_layout_get(const Elm_Entry *obj) +{ + return elm_obj_entry_input_panel_layout_get(obj); +} + +EAPI void +elm_entry_input_panel_return_key_type_set(Elm_Entry *obj, Elm_Input_Panel_Return_Key_Type return_key_type) +{ + elm_obj_entry_input_panel_return_key_type_set(obj, return_key_type); +} + +EAPI Elm_Input_Panel_Return_Key_Type +elm_entry_input_panel_return_key_type_get(const Elm_Entry *obj) +{ + return elm_obj_entry_input_panel_return_key_type_get(obj); +} + +EAPI void +elm_entry_input_panel_enabled_set(Elm_Entry *obj, Eina_Bool enabled) +{ + elm_obj_entry_input_panel_enabled_set(obj, enabled); +} + +EAPI Eina_Bool +elm_entry_input_panel_enabled_get(const Elm_Entry *obj) +{ + return elm_obj_entry_input_panel_enabled_get(obj); +} + +EAPI void +elm_entry_line_wrap_set(Elm_Entry *obj, Elm_Wrap_Type wrap) +{ + elm_obj_entry_line_wrap_set(obj, wrap); +} + +EAPI Elm_Wrap_Type +elm_entry_line_wrap_get(const Elm_Entry *obj) +{ + return elm_obj_entry_line_wrap_get(obj); +} + +EAPI void +elm_entry_cursor_pos_set(Elm_Entry *obj, int pos) +{ + elm_obj_entry_cursor_pos_set(obj, pos); +} + +EAPI int +elm_entry_cursor_pos_get(const Elm_Entry *obj) +{ + return elm_obj_entry_cursor_pos_get(obj); +} + +EAPI void +elm_entry_icon_visible_set(Elm_Entry *obj, Eina_Bool setting) +{ + elm_obj_entry_icon_visible_set(obj, setting); +} + +EAPI void +elm_entry_cursor_line_end_set(Elm_Entry *obj) +{ + elm_obj_entry_cursor_line_end_set(obj); +} + +EAPI void +elm_entry_select_region_set(Elm_Entry *obj, int start, int end) +{ + elm_obj_entry_select_region_set(obj, start, end); +} + +EAPI void +elm_entry_select_region_get(const Elm_Entry *obj, int *start, int *end) +{ + elm_obj_entry_select_region_get(obj, start, end); +} + +EAPI void +elm_entry_input_panel_return_key_autoenabled_set(Elm_Entry *obj, Eina_Bool enabled) +{ + elm_obj_entry_input_panel_return_key_autoenabled_set(obj, enabled); +} + +EAPI void +elm_entry_end_visible_set(Elm_Entry *obj, Eina_Bool setting) +{ + elm_obj_entry_end_visible_set(obj, setting); +} + +EAPI void +elm_entry_cursor_begin_set(Elm_Entry *obj) +{ + elm_obj_entry_cursor_begin_set(obj); +} + +EAPI void +elm_entry_cursor_line_begin_set(Elm_Entry *obj) +{ + elm_obj_entry_cursor_line_begin_set(obj); +} + +EAPI void +elm_entry_cursor_end_set(Elm_Entry *obj) +{ + elm_obj_entry_cursor_end_set(obj); +} + +EAPI Efl_Canvas_Object * +elm_entry_textblock_get(const Elm_Entry *obj) +{ + return elm_obj_entry_textblock_get(obj); +} + +EAPI Eina_Bool +elm_entry_cursor_geometry_get(const Elm_Entry *obj, int *x, int *y, int *w, int *h) +{ + return elm_obj_entry_textblock_cursor_geometry_get(obj, x, y, w, h); +} + +EAPI void * +elm_entry_imf_context_get(const Elm_Entry *obj) +{ + return elm_obj_entry_imf_context_get(obj); +} + +EAPI Eina_Bool +elm_entry_cursor_is_format_get(const Elm_Entry *obj) +{ + return elm_obj_entry_cursor_is_format_get(obj); +} + +EAPI char * +elm_entry_cursor_content_get(const Elm_Entry *obj) +{ + return elm_obj_entry_textblock_cursor_content_get(obj); +} + +EAPI const char * +elm_entry_selection_get(const Elm_Entry *obj) +{ + return elm_obj_entry_selection_get(obj); +} + +EAPI Eina_Bool +elm_entry_cursor_is_visible_format_get(const Elm_Entry *obj) +{ + return elm_obj_entry_cursor_is_visible_format_get(obj); +} + +EAPI void +elm_entry_select_allow_set(Elm_Entry *obj, Eina_Bool allow) +{ + elm_obj_entry_select_allow_set(obj, allow); +} + +EAPI Eina_Bool +elm_entry_select_allow_get(const Elm_Entry *obj) +{ + return elm_obj_entry_select_allow_get(obj); +} + +EAPI Eina_Bool +elm_entry_cursor_prev(Elm_Entry *obj) +{ + return elm_obj_entry_cursor_prev(obj); +} + +EAPI void +elm_entry_text_style_user_pop(Elm_Entry *obj) +{ + elm_obj_entry_text_style_user_pop(obj); +} + +EAPI void +elm_entry_item_provider_prepend(Elm_Entry *obj, Elm_Entry_Item_Provider_Cb func, void *data) +{ + elm_obj_entry_item_provider_prepend(obj, func, data); +} + +EAPI void +elm_entry_input_panel_show(Elm_Entry *obj) +{ + elm_obj_entry_input_panel_show(obj); +} + +EAPI void +elm_entry_imf_context_reset(Elm_Entry *obj) +{ + elm_obj_entry_imf_context_reset(obj); +} + +EAPI void +elm_entry_anchor_hover_end(Elm_Entry *obj) +{ + elm_obj_entry_anchor_hover_end(obj); +} + +EAPI void +elm_entry_cursor_selection_begin(Elm_Entry *obj) +{ + elm_obj_entry_cursor_selection_begin(obj); +} + +EAPI Eina_Bool +elm_entry_cursor_down(Elm_Entry *obj) +{ + return elm_obj_entry_cursor_down(obj); +} + +EAPI void +elm_entry_file_save(Elm_Entry *obj) +{ + elm_obj_entry_file_save(obj); +} + +EAPI void +elm_entry_selection_copy(Elm_Entry *obj) +{ + elm_obj_entry_selection_copy(obj); +} + +EAPI void +elm_entry_text_style_user_push(Elm_Entry *obj, const char *style) +{ + elm_obj_entry_text_style_user_push(obj, style); +} + +EAPI void +elm_entry_item_provider_remove(Elm_Entry *obj, Elm_Entry_Item_Provider_Cb func, void *data) +{ + elm_obj_entry_item_provider_remove(obj, func, data); +} + +EAPI const char * +elm_entry_text_style_user_peek(const Elm_Entry *obj) +{ + return elm_obj_entry_text_style_user_peek(obj); +} + +EAPI void +elm_entry_context_menu_clear(Elm_Entry *obj) +{ + elm_obj_entry_context_menu_clear(obj); +} + +EAPI Eina_Bool +elm_entry_cursor_up(Elm_Entry *obj) +{ + return elm_obj_entry_cursor_up(obj); +} + +EAPI void +elm_entry_entry_insert(Elm_Entry *obj, const char *entry) +{ + elm_obj_entry_insert(obj, entry); +} + +EAPI void +elm_entry_input_panel_imdata_set(Elm_Entry *obj, const void *data, int len) +{ + elm_obj_entry_input_panel_imdata_set(obj, data, len); +} + +EAPI void +elm_entry_input_panel_imdata_get(const Elm_Entry *obj, void *data, int *len) +{ + elm_obj_entry_input_panel_imdata_get(obj, data, len); +} + +EAPI void +elm_entry_selection_paste(Elm_Entry *obj) +{ + elm_obj_entry_selection_paste(obj); +} + +EAPI Eina_Bool +elm_entry_cursor_next(Elm_Entry *obj) +{ + return elm_obj_entry_cursor_next(obj); +} + +EAPI void +elm_entry_select_none(Elm_Entry *obj) +{ + elm_obj_entry_select_none(obj); +} + +EAPI void +elm_entry_input_panel_hide(Elm_Entry *obj) +{ + elm_obj_entry_input_panel_hide(obj); +} + +EAPI void +elm_entry_select_all(Elm_Entry *obj) +{ + elm_obj_entry_select_all(obj); +} + +EAPI void +elm_entry_cursor_selection_end(Elm_Entry *obj) +{ + elm_obj_entry_cursor_selection_end(obj); +} + +EAPI void +elm_entry_selection_cut(Elm_Entry *obj) +{ + elm_obj_entry_selection_cut(obj); +} + +EAPI Eina_Bool +elm_entry_is_empty(const Elm_Entry *obj) +{ + return elm_obj_entry_is_empty(obj); +} + +EAPI void +elm_entry_markup_filter_remove(Elm_Entry *obj, Elm_Entry_Filter_Cb func, void *data) +{ + elm_obj_entry_markup_filter_remove(obj, func, data); +} + +EAPI void +elm_entry_item_provider_append(Elm_Entry *obj, Elm_Entry_Item_Provider_Cb func, void *data) +{ + elm_obj_entry_item_provider_append(obj, func, data); +} + +EAPI void +elm_entry_markup_filter_append(Elm_Entry *obj, Elm_Entry_Filter_Cb func, void *data) +{ + elm_obj_entry_markup_filter_append(obj, func, data); +} + +EAPI void +elm_entry_entry_append(Elm_Entry *obj, const char *str) +{ + elm_obj_entry_append(obj, str); +} + +EAPI void +elm_entry_context_menu_item_add(Elm_Entry *obj, const char *label, const char *icon_file, Elm_Icon_Type icon_type, Evas_Smart_Cb func, const void *data) +{ + elm_obj_entry_context_menu_item_add(obj, label, icon_file, icon_type, func, data); +} + +EAPI void +elm_entry_markup_filter_prepend(Elm_Entry *obj, Elm_Entry_Filter_Cb func, void *data) +{ + elm_obj_entry_markup_filter_prepend(obj, func, data); +} + +EAPI void +elm_entry_prediction_hint_set(Elm_Entry *obj, const char *prediction_hint) +{ + elm_obj_entry_prediction_hint_set(obj, prediction_hint); +} + +EAPI Eina_Bool +elm_entry_prediction_hint_hash_set(Elm_Entry *obj, const char *key, const char *value) +{ + return elm_obj_entry_prediction_hint_hash_set(obj, key, value); +} + +EAPI Eina_Bool +elm_entry_prediction_hint_hash_del(Elm_Entry *obj, const char *key) +{ + return elm_obj_entry_prediction_hint_hash_del(obj, key); +} diff --git a/src/lib/elementary/elm_entry_eo.legacy.h b/src/lib/elementary/elm_entry_eo.legacy.h new file mode 100644 index 0000000..6fe0608 --- /dev/null +++ b/src/lib/elementary/elm_entry_eo.legacy.h @@ -0,0 +1,1252 @@ +#ifndef _ELM_ENTRY_EO_LEGACY_H_ +#define _ELM_ENTRY_EO_LEGACY_H_ + +#ifndef _ELM_ENTRY_EO_CLASS_TYPE +#define _ELM_ENTRY_EO_CLASS_TYPE + +typedef Eo Elm_Entry; + +#endif + +#ifndef _ELM_ENTRY_EO_TYPES +#define _ELM_ENTRY_EO_TYPES + + +#endif + +/** + * @brief Enable or disable scrolling in entry + * + * Normally the entry is not scrollable unless you enable it with this call. + * + * @param[in] obj The object. + * @param[in] scroll @c true if it is to be scrollable, @c false otherwise. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_scrollable_set(Elm_Entry *obj, Eina_Bool scroll); + +/** + * @brief Get the scrollable state of the entry + * + * Normally the entry is not scrollable. This gets the scrollable state of the + * entry. + * + * @param[in] obj The object. + * + * @return @c true if it is to be scrollable, @c false otherwise. + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_scrollable_get(const Elm_Entry *obj); + +/** + * @brief Set 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] obj The object. + * @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 + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_input_panel_show_on_demand_set(Elm_Entry *obj, Eina_Bool ondemand); + +/** + * @brief Get the attribute to show the input panel in case of only an user's + * explicit Mouse Up event. + * + * @param[in] obj The object. + * + * @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 + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_input_panel_show_on_demand_get(const Elm_Entry *obj); + +/** + * @brief This disables the entry's contextual (longpress) menu. + * + * @param[in] obj The object. + * @param[in] disabled If @c true, the menu is disabled. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_context_menu_disabled_set(Elm_Entry *obj, Eina_Bool disabled); + +/** + * @brief This returns whether the entry's contextual (longpress) menu is + * disabled. + * + * @param[in] obj The object. + * + * @return If @c true, the menu is disabled. + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_context_menu_disabled_get(const Elm_Entry *obj); + +/** + * @brief Control pasting of text and images for the widget. + * + * Normally the entry allows both text and images to be pasted. By setting + * cnp_mode to be #ELM_CNP_MODE_NO_IMAGE, this prevents images from being copy + * or past. By setting cnp_mode to be #ELM_CNP_MODE_PLAINTEXT, this remove all + * tags in text . + * + * @note This only changes the behaviour of text. + * + * @param[in] obj The object. + * @param[in] cnp_mode One of #Elm_Cnp_Mode: #ELM_CNP_MODE_MARKUP, + * #ELM_CNP_MODE_NO_IMAGE, #ELM_CNP_MODE_PLAINTEXT. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_cnp_mode_set(Elm_Entry *obj, Elm_Cnp_Mode cnp_mode); + +/** + * @brief Getting elm_entry text paste/drop mode. + * + * Normally the entry allows both text and images to be pasted. This gets the + * copy & paste mode of the entry. + * + * @param[in] obj The object. + * + * @return One of #Elm_Cnp_Mode: #ELM_CNP_MODE_MARKUP, #ELM_CNP_MODE_NO_IMAGE, + * #ELM_CNP_MODE_PLAINTEXT. + * + * @ingroup Elm_Entry_Group + */ +EAPI Elm_Cnp_Mode elm_entry_cnp_mode_get(const Elm_Entry *obj); + +/** + * @brief Text format used to load and save the file, which could be plain text + * or markup text. + * + * Default is @c ELM_TEXT_FORMAT_PLAIN_UTF8, if you want to use + * @c ELM_TEXT_FORMAT_MARKUP_UTF8 then you need to set the text format before + * calling @ref Efl.File.load. + * + * You could also set it before a call to @ref elm_entry_file_save in order to + * save with the given format. + * + * Use it before calling @ref Efl.File.load or @ref elm_entry_file_save. + * + * @param[in] obj The object. + * @param[in] format The file format + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_file_text_format_set(Elm_Entry *obj, Elm_Text_Format format); + +/** + * @brief Set the language mode of the input panel. + * + * This API can be used if you want to show the alphabet keyboard mode. + * + * @param[in] obj The object. + * @param[in] lang Language to be set to the input panel. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_input_panel_language_set(Elm_Entry *obj, Elm_Input_Panel_Lang lang); + +/** + * @brief Get the language mode of the input panel. + * + * @param[in] obj The object. + * + * @return Language to be set to the input panel. + * + * @ingroup Elm_Entry_Group + */ +EAPI Elm_Input_Panel_Lang elm_entry_input_panel_language_get(const Elm_Entry *obj); + +/** + * @brief This disabled the entry's selection handlers. + * + * @param[in] obj The object. + * @param[in] disabled If @c true, the selection handlers are disabled. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_selection_handler_disabled_set(Elm_Entry *obj, Eina_Bool disabled); + + +/** + * @brief Set the input panel layout variation of the entry + * + * @param[in] obj The object. + * @param[in] variation Layout variation type. + * + * @since 1.8 + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_input_panel_layout_variation_set(Elm_Entry *obj, int variation); + +/** + * @brief Get the input panel layout variation of the entry + * + * @param[in] obj The object. + * + * @return Layout variation type. + * + * @since 1.8 + * + * @ingroup Elm_Entry_Group + */ +EAPI int elm_entry_input_panel_layout_variation_get(const Elm_Entry *obj); + +/** + * @brief Set the autocapitalization type on the immodule. + * + * @param[in] obj The object. + * @param[in] autocapital_type The type of autocapitalization. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_autocapital_type_set(Elm_Entry *obj, Elm_Autocapital_Type autocapital_type); + +/** + * @brief Get the autocapitalization type on the immodule. + * + * @param[in] obj The object. + * + * @return The type of autocapitalization. + * + * @ingroup Elm_Entry_Group + */ +EAPI Elm_Autocapital_Type elm_entry_autocapital_type_get(const Elm_Entry *obj); + +/** + * @brief Sets if the entry is to be editable or not. + * + * By default, entries are editable and when focused, any text input by the + * user will be inserted at the current cursor position. But calling this + * function with @c editable as @c false will prevent the user from inputting + * text into the entry. + * + * The only way to change the text of a non-editable entry is to use @ref + * elm_object_text_set, @ref elm_entry_entry_insert and other related + * functions. + * + * @param[in] obj The object. + * @param[in] editable If @c true, user input will be inserted in the entry, if + * not, the entry is read-only and no user input is allowed. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_editable_set(Elm_Entry *obj, Eina_Bool editable); + +/** + * @brief Get whether the entry is editable or not. + * + * @param[in] obj The object. + * + * @return If @c true, user input will be inserted in the entry, if not, the + * entry is read-only and no user input is allowed. + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_editable_get(const Elm_Entry *obj); + +/** + * @brief Set the style that the hover should use + * + * When creating the popup hover, entry will request that it's themed according + * to @c style. + * + * Setting style no @c null means disabling automatic hover. + * + * @param[in] obj The object. + * @param[in] style The style to use for the underlying hover. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_anchor_hover_style_set(Elm_Entry *obj, const char *style); + +/** + * @brief Get the style that the hover should use. + * + * @param[in] obj The object. + * + * @return The style to use for the underlying hover. + * + * @ingroup Elm_Entry_Group + */ +EAPI const char *elm_entry_anchor_hover_style_get(const Elm_Entry *obj); + +/** + * @brief Sets the entry to single line mode. + * + * In single line mode, entries don't ever wrap when the text reaches the edge, + * and instead they keep growing horizontally. Pressing the @c Enter key will + * generate an $"activate" event instead of adding a new line. + * + * When @c single_line is @c false, line wrapping takes effect again and + * pressing enter will break the text into a different line without generating + * any events. + * + * @param[in] obj The object. + * @param[in] single_line If @c true, the text in the entry will be on a single + * line. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_single_line_set(Elm_Entry *obj, Eina_Bool single_line); + +/** + * @brief Get whether the entry is set to be single line. + * + * @param[in] obj The object. + * + * @return If @c true, the text in the entry will be on a single line. + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_single_line_get(const Elm_Entry *obj); + +/** + * @brief Sets the entry to password mode. + * + * In password mode, entries are implicitly single line and the display of any + * text in them is replaced with asterisks (*). + * + * @param[in] obj The object. + * @param[in] password If @c true, password mode is enabled. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_password_set(Elm_Entry *obj, Eina_Bool password); + +/** + * @brief Get whether the entry is set to password mode. + * + * @param[in] obj The object. + * + * @return If @c true, password mode is enabled. + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_password_get(const Elm_Entry *obj); + +/** + * @brief Set the return key on the input panel to be disabled. + * + * @param[in] obj The object. + * @param[in] disabled The state to put in in: @c true for disabled, @c false + * for enabled. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_input_panel_return_key_disabled_set(Elm_Entry *obj, Eina_Bool disabled); + +/** + * @brief Get whether the return key on the input panel should be disabled or + * not. + * + * @param[in] obj The object. + * + * @return The state to put in in: @c true for disabled, @c false for enabled. + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_input_panel_return_key_disabled_get(const Elm_Entry *obj); + +/** + * @brief This sets the entry object to 'autosave' the loaded text file or not. + * + * @param[in] obj The object. + * @param[in] auto_save Autosave the loaded file or not. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_autosave_set(Elm_Entry *obj, Eina_Bool auto_save); + +/** + * @brief This gets the entry object's 'autosave' status. + * + * @param[in] obj The object. + * + * @return Autosave the loaded file or not. + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_autosave_get(const Elm_Entry *obj); + +/** + * @brief Set the parent of the hover popup + * + * Sets the parent object to use by the hover created by the entry when an + * anchor is clicked. + * + * @param[in] obj The object. + * @param[in] parent The object to use as parent for the hover. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_anchor_hover_parent_set(Elm_Entry *obj, Efl_Canvas_Object *parent); + +/** + * @brief Get the parent of the hover popup + * + * Get the object used as parent for the hover created by the entry widget. If + * no parent is set, the same entry object will be used. + * + * @param[in] obj The object. + * + * @return The object to use as parent for the hover. + * + * @ingroup Elm_Entry_Group + */ +EAPI Efl_Canvas_Object *elm_entry_anchor_hover_parent_get(const Elm_Entry *obj); + +/** + * @brief Set whether the entry should allow to use the text prediction. + * + * @param[in] obj The object. + * @param[in] prediction Whether the entry should allow to use the text + * prediction. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_prediction_allow_set(Elm_Entry *obj, Eina_Bool prediction); + +/** + * @brief Get whether the entry should allow to use the text prediction. + * + * @param[in] obj The object. + * + * @return Whether the entry should allow to use the text prediction. + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_prediction_allow_get(const Elm_Entry *obj); + +/** + * @brief Sets the input hint which allows input methods to fine-tune their + * behavior. + * + * @param[in] obj The object. + * @param[in] hints Input hint. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_input_hint_set(Elm_Entry *obj, Elm_Input_Hints hints); + +/** + * @brief Gets the value of input hint. + * + * @param[in] obj The object. + * + * @return Input hint. + * + * @ingroup Elm_Entry_Group + */ +EAPI Elm_Input_Hints elm_entry_input_hint_get(const Elm_Entry *obj); + +/** + * @brief Set the input panel layout of the entry. + * + * @param[in] obj The object. + * @param[in] layout Layout type. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_input_panel_layout_set(Elm_Entry *obj, Elm_Input_Panel_Layout layout); + +/** + * @brief Get the input panel layout of the entry. + * + * @param[in] obj The object. + * + * @return Layout type. + * + * @ingroup Elm_Entry_Group + */ +EAPI Elm_Input_Panel_Layout elm_entry_input_panel_layout_get(const Elm_Entry *obj); + +/** + * @brief Set 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. + * + * Regardless of return key type, "activated" event will be generated when + * pressing return key in single line entry. + * + * @param[in] obj The object. + * @param[in] return_key_type The type of "return" key on the input panel. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_input_panel_return_key_type_set(Elm_Entry *obj, Elm_Input_Panel_Return_Key_Type return_key_type); + +/** + * @brief Get the "return" key type. + * + * @param[in] obj The object. + * + * @return The type of "return" key on the input panel. + * + * @ingroup Elm_Entry_Group + */ +EAPI Elm_Input_Panel_Return_Key_Type elm_entry_input_panel_return_key_type_get(const Elm_Entry *obj); + +/** + * @brief Sets the attribute to show the input panel automatically. + * + * @param[in] obj The object. + * @param[in] enabled If @c true, the input panel is appeared when entry is + * clicked or has a focus. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_input_panel_enabled_set(Elm_Entry *obj, Eina_Bool enabled); + +/** + * @brief Get the attribute to show the input panel automatically. + * + * @param[in] obj The object. + * + * @return If @c true, the input panel is appeared when entry is clicked or has + * a focus. + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_input_panel_enabled_get(const Elm_Entry *obj); + +/** + * @brief Set the line wrap type to use on multi-line entries. + * + * Sets the wrap type used by the entry to any of the specified in + * Elm_Wrap_Type. This tells how the text will be implicitly cut into a new + * line (without inserting a line break or paragraph separator) when it reaches + * the far edge of the widget. + * + * Note that this only makes sense for multi-line entries. A widget set to be + * single line will never wrap. + * + * @param[in] obj The object. + * @param[in] wrap The wrap mode to use. See Elm_Wrap_Type for details on them. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_line_wrap_set(Elm_Entry *obj, Elm_Wrap_Type wrap); + +/** + * @brief Get the wrap mode the entry was set to use. + * + * @param[in] obj The object. + * + * @return The wrap mode to use. See Elm_Wrap_Type for details on them. + * + * @ingroup Elm_Entry_Group + */ +EAPI Elm_Wrap_Type elm_entry_line_wrap_get(const Elm_Entry *obj); + +/** + * @brief Sets the cursor position in the entry to the given value + * + * The value in @c pos is the index of the character position within the + * contents of the string as returned by @ref elm_entry_cursor_pos_get. + * + * @param[in] obj The object. + * @param[in] pos The position of the cursor. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_cursor_pos_set(Elm_Entry *obj, int pos); + +/** + * @brief Get the current position of the cursor in the entry. + * + * @param[in] obj The object. + * + * @return The position of the cursor. + * + * @ingroup Elm_Entry_Group + */ +EAPI int elm_entry_cursor_pos_get(const Elm_Entry *obj); + +/** + * @brief Sets the visibility of the left-side widget of the entry, set by @ref + * elm_object_part_content_set. + * + * @param[in] obj The object. + * @param[in] setting @c true if the object should be displayed, @c false if + * not. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_icon_visible_set(Elm_Entry *obj, Eina_Bool setting); + +/** This moves the cursor to the end of the current line. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_cursor_line_end_set(Elm_Entry *obj); + +/** + * @brief This selects a region of text within the entry. + * + * @param[in] obj The object. + * @param[in] start The starting position. + * @param[in] end The end position. + * + * @since 1.9 + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_select_region_set(Elm_Entry *obj, int start, int end); + +/** + * @brief Get the current position of the selection cursors in the entry. + * + * @param[in] obj The object. + * @param[out] start The starting position. + * @param[out] end The end position. + * + * @since 1.18 + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_select_region_get(const Elm_Entry *obj, int *start, int *end); + +/** + * @brief Set whether the return key on the input panel is disabled + * automatically when entry has no text. + * + * If @c enabled is @c true, The return key on input panel is disabled when the + * entry has no text. The return key on the input panel is automatically + * enabled when the entry has text. The default value is @c false. + * + * @param[in] obj The object. + * @param[in] enabled If @c enabled is @c true, the return key is automatically + * disabled when the entry has no text. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_input_panel_return_key_autoenabled_set(Elm_Entry *obj, Eina_Bool enabled); + +/** + * @brief Sets the visibility of the end widget of the entry, set by @ref + * elm_object_part_content_set(ent, "end", content). + * + * @param[in] obj The object. + * @param[in] setting @c true if the object should be displayed, false if not. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_end_visible_set(Elm_Entry *obj, Eina_Bool setting); + +/** This moves the cursor to the beginning of the entry. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_cursor_begin_set(Elm_Entry *obj); + +/** This moves the cursor to the beginning of the current line. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_cursor_line_begin_set(Elm_Entry *obj); + +/** This moves the cursor to the end of the entry. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_cursor_end_set(Elm_Entry *obj); + +/** + * @brief Returns the actual textblock object of the entry. + * + * This function exposes the internal textblock object that actually contains + * and draws the text. This should be used for low-level manipulations that are + * otherwise not possible. + * + * Changing the textblock directly from here will not notify edje/elm to + * recalculate the textblock size automatically, so any modifications done to + * the textblock returned by this function should be followed by a call to @ref + * elm_entry_calc_force. + * + * The return value is marked as const as an additional warning. One should not + * use the returned object with any of the generic evas functions + * (geometry_get/resize/move and etc), but only with the textblock functions; + * The former will either not work at all, or break the correct functionality. + * + * IMPORTANT: Many functions may change (i.e delete and create a new one) the + * internal textblock object. Do NOT cache the returned object, and try not to + * mix calls on this object with regular elm_entry calls (which may change the + * internal textblock object). This applies to all cursors returned from + * textblock calls, and all the other derivative values. + * + * @param[in] obj The object. + * + * @return Textblock object + * + * @ingroup Elm_Entry_Group + */ +EAPI Efl_Canvas_Object *elm_entry_textblock_get(const Elm_Entry *obj); + +/** + * @brief This function returns the geometry of the cursor. + * + * It's useful if you want to draw something on the cursor (or where it is), or + * for example in the case of scrolled entry where you want to show the cursor. + * + * @param[in] obj The object. + * @param[out] x X coordinate + * @param[out] y Y coordinate + * @param[out] w Width + * @param[out] h Height + * + * @return @c true on success, @c false otherwise + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_cursor_geometry_get(const Elm_Entry *obj, int *x, int *y, int *w, int *h); + +/** + * @brief Returns the input method context of the entry. + * + * This function exposes the internal input method context. + * + * IMPORTANT: Many functions may change (i.e delete and create a new one) the + * internal input method context. Do NOT cache the returned object. + * + * @param[in] obj The object. + * + * @return Input method context + * + * @ingroup Elm_Entry_Group + */ +EAPI void *elm_entry_imf_context_get(const Elm_Entry *obj); + +/** + * @brief Get whether a format node exists at the current cursor position. + * + * A format node is anything that defines how the text is rendered. It can be a + * visible format node, such as a line break or a paragraph separator, or an + * invisible one, such as bold begin or end tag. This function returns whether + * any format node exists at the current cursor position. + * + * @param[in] obj The object. + * + * @return @c true if format node exists, @c false otherwise + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_cursor_is_format_get(const Elm_Entry *obj); + +/** + * @brief Get the character pointed by the cursor at its current position. + * + * This function returns a string with the utf8 character stored at the current + * cursor position. Only the text is returned, any format that may exist will + * not be part of the return value. You must free the string when done with + * @ref free. + * + * @param[in] obj The object. + * + * @return Character + * + * @ingroup Elm_Entry_Group + */ +EAPI char *elm_entry_cursor_content_get(const Elm_Entry *obj) EINA_WARN_UNUSED_RESULT; + +/** + * @brief Get any selected text within the entry. + * + * If there's any selected text in the entry, this function returns it as a + * string in markup format. @c null is returned if no selection exists or if an + * error occurred. + * + * The returned value points to an internal string and should not be freed or + * modified in any way. If the @c entry object is deleted or its contents are + * changed, the returned pointer should be considered invalid. + * + * @param[in] obj The object. + * + * @return Selected string + * + * @ingroup Elm_Entry_Group + */ +EAPI const char *elm_entry_selection_get(const Elm_Entry *obj); + +/** + * @brief Get if the current cursor position holds a visible format node. + * + * @param[in] obj The object. + * + * @return @c true if position has a visible format, @c false otherwise + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_cursor_is_visible_format_get(const Elm_Entry *obj); + +/** + * @brief Allow selection in the entry. + * + * @param[in] obj The object. + * @param[in] allow If @c allow is true, the text selection is allowed. + * + * @since 1.18 + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_select_allow_set(Elm_Entry *obj, Eina_Bool allow); + +/** + * @brief Allow selection in the entry. + * + * @param[in] obj The object. + * + * @return If @c allow is true, the text selection is allowed. + * + * @since 1.18 + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_select_allow_get(const Elm_Entry *obj); + +/** + * @brief This moves the cursor one place to the left within the entry. + * + * @param[in] obj The object. + * + * @return @c true on success, @c false otherwise + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_cursor_prev(Elm_Entry *obj); + +/** Remove the style in the top of user style stack. + * + * @since 1.7 + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_text_style_user_pop(Elm_Entry *obj); + +/** + * @brief This prepends a custom item provider to the list for that entry + * + * This prepends the given callback. + * + * @param[in] obj The object. + * @param[in] func The function called to provide the item object. + * @param[in] data The data passed to @c func. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_item_provider_prepend(Elm_Entry *obj, Elm_Entry_Item_Provider_Cb func, void *data); + +/** + * @brief Show the input panel (virtual keyboard) based on the input panel + * property of entry such as layout, autocapital types, and so on. + * + * Note that input panel is shown or hidden automatically according to the + * focus state of entry widget. This API can be used in the case of manually + * controlling by using @ref elm_entry_input_panel_enabled_set(en, @c false). + * @param[in] obj The object. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_input_panel_show(Elm_Entry *obj); + +/** + * @brief Reset the input method context of the entry if needed. + * + * This can be necessary in the case where modifying the buffer would confuse + * on-going input method behavior. This will typically cause the Input Method + * Context to clear the preedit state. + * @param[in] obj The object. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_imf_context_reset(Elm_Entry *obj); + +/** + * @brief Ends the hover popup in the entry + * + * When an anchor is clicked, the entry widget will create a hover object to + * use as a popup with user provided content. This function terminates this + * popup, returning the entry to its normal state. + * @param[in] obj The object. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_anchor_hover_end(Elm_Entry *obj); + +/** This begins a selection within the entry as though the user were holding + * down the mouse button to make a selection. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_cursor_selection_begin(Elm_Entry *obj); + +/** + * @brief This moves the cursor one line down within the entry. + * + * @param[in] obj The object. + * + * @return @c true on success, @c false otherwise + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_cursor_down(Elm_Entry *obj); + +/** This function writes any changes made to the file set with @ref + * elm_entry_file_set. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_file_save(Elm_Entry *obj); + +/** This executes a "copy" action on the selected text in the entry. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_selection_copy(Elm_Entry *obj); + +/** + * @brief Push the style to the top of user style stack. If there is styles in + * the user style stack, the properties in the top style of user style stack + * will replace the properties in current theme. The input style is specified + * in format tag='property=value' (i.e. DEFAULT='font=Sans + * font_size=60'hilight=' + font_weight=Bold'). + * + * @param[in] obj The object. + * @param[in] style The style user to push. + * + * @since 1.7 + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_text_style_user_push(Elm_Entry *obj, const char *style); + +/** + * @brief This removes a custom item provider to the list for that entry + * + * This removes the given callback. See @ref elm_entry_item_provider_append for + * more information + * + * @param[in] obj The object. + * @param[in] func The function called to provide the item object. + * @param[in] data The data passed to @c func. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_item_provider_remove(Elm_Entry *obj, Elm_Entry_Item_Provider_Cb func, void *data); + +/** + * @brief Get the style on the top of user style stack. + * + * See also @ref elm_entry_text_style_user_push. + * + * @param[in] obj The object. + * + * @return Style + * + * @since 1.7 + * + * @ingroup Elm_Entry_Group + */ +EAPI const char *elm_entry_text_style_user_peek(const Elm_Entry *obj); + +/** + * @brief This clears and frees the items in a entry's contextual (longpress) + * menu. + * + * See also @ref elm_entry_context_menu_item_add. + * @param[in] obj The object. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_context_menu_clear(Elm_Entry *obj); + +/** + * @brief This moves the cursor one line up within the entry. + * + * @param[in] obj The object. + * + * @return @c true on success, @c false otherwise + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_cursor_up(Elm_Entry *obj); + +/** + * @brief Inserts the given text into the entry at the current cursor position. + * + * This inserts text at the cursor position as if it was typed by the user + * (note that this also allows markup which a user can't just "type" as it + * would be converted to escaped text, so this call can be used to insert + * things like emoticon items or bold push/pop tags, other font and color + * change tags etc.) + * + * If any selection exists, it will be replaced by the inserted text. + * + * The inserted text is subject to any filters set for the widget. + * + * See also @ref elm_entry_markup_filter_append. + * + * @param[in] obj The object. + * @param[in] entry The text to insert. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_entry_insert(Elm_Entry *obj, const char *entry); + +/** + * @brief Set 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] obj The object. + * @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. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_input_panel_imdata_set(Elm_Entry *obj, const void *data, int len); + +/** + * @brief Get the specific data of the current input panel. + * + * @param[in] obj The object. + * @param[out] data The specific data to be got from the input panel. + * @param[out] len The length of data. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_input_panel_imdata_get(const Elm_Entry *obj, void *data, int *len); + +/** This executes a "paste" action in the entry. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_selection_paste(Elm_Entry *obj); + +/** + * @brief This moves the cursor one place to the right within the entry. + * + * @param[in] obj The object. + * + * @return @c true on success, @c false otherwise + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_cursor_next(Elm_Entry *obj); + +/** This drops any existing text selection within the entry. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_select_none(Elm_Entry *obj); + +/** + * @brief Hide the input panel (virtual keyboard). + * + * Note that input panel is shown or hidden automatically according to the + * focus state of entry widget. This API can be used in the case of manually + * controlling by using @ref elm_entry_input_panel_enabled_set(en, @c false) + * @param[in] obj The object. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_input_panel_hide(Elm_Entry *obj); + +/** This selects all text within the entry. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_select_all(Elm_Entry *obj); + +/** This ends a selection within the entry as though the user had just released + * the mouse button while making a selection. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_cursor_selection_end(Elm_Entry *obj); + +/** This executes a "cut" action on the selected text in the entry. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_selection_cut(Elm_Entry *obj); + +/** + * @brief Get whether the entry is empty. + * + * Empty means no text at all. If there are any markup tags, like an item tag + * for which no provider finds anything, and no text is displayed, this + * function still returns @c false. + * + * @param[in] obj The object. + * + * @return @c true if empty, @c false otherwise + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_is_empty(const Elm_Entry *obj); + +/** + * @brief Remove a markup filter from the list + * + * Removes the given callback from the filter list. See + * @ref elm_entry_markup_filter_append for more information. + * + * @param[in] obj The object. + * @param[in] func The filter function to remove. + * @param[in] data The user data passed when adding the function. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_markup_filter_remove(Elm_Entry *obj, Elm_Entry_Filter_Cb func, void *data); + +/** + * @brief This appends a custom item provider to the list for that entry + * + * This appends the given callback. The list is walked from beginning to end + * with each function called given the item href string in the text. If the + * function returns an object handle other than @c null (it should create an + * object to do this), then this object is used to replace that item. If not + * the next provider is called until one provides an item object, or the + * default provider in entry does. + * + * See also @ref entry-items. + * + * @param[in] obj The object. + * @param[in] func The function called to provide the item object. + * @param[in] data The data passed to @c func. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_item_provider_append(Elm_Entry *obj, Elm_Entry_Item_Provider_Cb func, void *data); + +/** + * @brief Append a markup filter function for text inserted in the entry + * + * Append the given callback to the list. This functions will be called + * whenever any text is inserted into the entry, with the text to be inserted + * as a parameter. The type of given text is always markup. The callback + * function is free to alter the text in any way it wants, but it must remember + * to free the given pointer and update it. If the new text is to be discarded, + * the function can free it and set its text parameter to @c null. This will + * also prevent any following filters from being called. + * + * @param[in] obj The object. + * @param[in] func The function to use as text filter. + * @param[in] data User data to pass to @c func. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_markup_filter_append(Elm_Entry *obj, Elm_Entry_Filter_Cb func, void *data); + +/** + * @brief Appends @c str to the text of the entry. + * + * Adds the text in @c str to the end of any text already present in the + * widget. + * + * The appended text is subject to any filters set for the widget. + * + * See also @ref elm_entry_markup_filter_append. + * + * @param[in] obj The object. + * @param[in] str The text to be appended. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_entry_append(Elm_Entry *obj, const char *str); + +/** + * @brief This adds an item to the entry's contextual menu. + * + * A longpress on an entry will make the contextual menu show up, if this + * hasn't been disabled with @ref elm_entry_context_menu_disabled_set. By + * default, this menu provides a few options like enabling selection mode, + * which is useful on embedded devices that need to be explicit about it, and + * when a selection exists it also shows the copy and cut actions. + * + * With this function, developers can add other options to this menu to perform + * any action they deem necessary. + * + * @param[in] obj The object. + * @param[in] label The item's text label. + * @param[in] icon_file The item's icon file. + * @param[in] icon_type The item's icon type. + * @param[in] func The callback to execute when the item is clicked. + * @param[in] data The data to associate with the item for related functions. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_context_menu_item_add(Elm_Entry *obj, const char *label, const char *icon_file, Elm_Icon_Type icon_type, Evas_Smart_Cb func, const void *data); + +/** + * @brief Prepend a markup filter function for text inserted in the entry + * + * Prepend the given callback to the list. + * + * @param[in] obj The object. + * @param[in] func The function to use as text filter. + * @param[in] data User data to pass to @c func. + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_markup_filter_prepend(Elm_Entry *obj, Elm_Entry_Filter_Cb func, void *data); + +/** + * @brief Sets the prediction hint to use an intelligent reply suggestion + * service. + * + * @param[in] obj The object. + * @param[in] prediction_hint The prediction hint text. + * + * @since 1.20 + * + * @ingroup Elm_Entry_Group + */ +EAPI void elm_entry_prediction_hint_set(Elm_Entry *obj, const char *prediction_hint); + +/** + * @brief Sets the prediction hint data at the specified key. + * + * @param[in] obj The object. + * @param[in] key The key of the prediction hint. + * @param[in] value The data to replace. + * + * @return @c true on success, @c false otherwise + * + * @since 1.21 + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_prediction_hint_hash_set(Elm_Entry *obj, const char *key, const char *value); + +/** + * @brief Removes the prediction hint data identified by a key. + * + * @param[in] obj The object. + * @param[in] key The key of the prediction hint. + * + * @return @c true on success, @c false otherwise + * + * @since 1.21 + * + * @ingroup Elm_Entry_Group + */ +EAPI Eina_Bool elm_entry_prediction_hint_hash_del(Elm_Entry *obj, const char *key); + +#endif diff --git a/src/lib/elementary/elm_entry_legacy.h b/src/lib/elementary/elm_entry_legacy.h index 7e54218..06b3f76 100644 --- a/src/lib/elementary/elm_entry_legacy.h +++ b/src/lib/elementary/elm_entry_legacy.h @@ -1,4 +1,4 @@ -#include "elm_entry.eo.legacy.h" +#include "elm_entry_eo.legacy.h" /** * This adds an entry to @p parent object. diff --git a/src/lib/elementary/elm_spinner.c b/src/lib/elementary/elm_spinner.c index b757cfa..ac38e58 100644 --- a/src/lib/elementary/elm_spinner.c +++ b/src/lib/elementary/elm_spinner.c @@ -15,7 +15,7 @@ #include "elm_priv.h" #include "elm_widget_spinner.h" -#include "elm_entry.eo.h" +#include "elm_entry_eo.h" #include "Eo.h" diff --git a/src/lib/elementary/elm_view_form.c b/src/lib/elementary/elm_view_form.c index d8f9a88..b011cf1 100644 --- a/src/lib/elementary/elm_view_form.c +++ b/src/lib/elementary/elm_view_form.c @@ -9,7 +9,7 @@ #include "elm_view_list.h" #include "elm_priv.h" -#include "elm_entry.eo.h" +#include "elm_entry_eo.h" #include "elm_thumb.eo.h" #include "elm_label.eo.h" diff --git a/src/lib/elementary/elm_widget_entry.h b/src/lib/elementary/elm_widget_entry.h index fedf09d..a551c94 100644 --- a/src/lib/elementary/elm_widget_entry.h +++ b/src/lib/elementary/elm_widget_entry.h @@ -3,7 +3,7 @@ #include "elm_interface_scrollable.h" #include "elm_widget_layout.h" -#include "elm_entry.eo.h" +#include "elm_entry_eo.h" /* DO NOT USE THIS HEADER UNLESS YOU ARE PREPARED FOR BREAKING OF YOUR * CODE. THIS IS ELEMENTARY'S INTERNAL WIDGET API (for now) AND IS NOT diff --git a/src/lib/elementary/meson.build b/src/lib/elementary/meson.build index 606fa50..bc36488 100644 --- a/src/lib/elementary/meson.build +++ b/src/lib/elementary/meson.build @@ -1,7 +1,6 @@ pub_legacy_eo_files = [ 'efl_ui_clock_legacy.eo', 'elm_interface_fileselector.eo', - 'elm_entry.eo', 'elm_fileselector.eo', 'elm_gengrid.eo', 'elm_gengrid_pan.eo', @@ -860,6 +859,8 @@ elementary_pub_headers = [ 'elm_diskselector_eo.legacy.h', 'elm_diskselector_item_eo.h', 'elm_diskselector_item_eo.legacy.h', + 'elm_entry_eo.h', + 'elm_entry_eo.legacy.h', 'elm_hoversel_eo.h', 'elm_hoversel_eo.legacy.h', 'elm_hoversel_item_eo.h', diff --git a/src/modules/elementary/prefs/elm_entry.c b/src/modules/elementary/prefs/elm_entry.c index b34102a..db01553 100644 --- a/src/modules/elementary/prefs/elm_entry.c +++ b/src/modules/elementary/prefs/elm_entry.c @@ -2,7 +2,7 @@ #include "elm_widget.h" #include #include -#include "elm_entry.eo.h" +#include "elm_entry_eo.h" #define BLINK_INTERVAL 0.1 -- 2.7.4