diff --git a/src/Makefile_Elementary.am b/src/Makefile_Elementary.am index 866017b83a..2823878ba5 100644 --- a/src/Makefile_Elementary.am +++ b/src/Makefile_Elementary.am @@ -187,7 +187,6 @@ elm_private_eolian_files = \ elm_legacy_eolian_files = \ 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 \ @@ -345,6 +344,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 @@ -428,6 +429,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 cf3b1484d0..dde8927a8c 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 c67e948143..67c9a59de4 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 c64642f084..0194921308 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 348c8770fc..8d377b6aed 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 ba4d39e816..4a67f07725 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 096f02ca0a..03ff26b725 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 4b84254e93..9004408b25 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 6aa9b94673..009d612538 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 ccc7624b02..0334881fbf 100644 --- a/src/lib/elementary/elm_entry.c +++ b/src/lib/elementary/elm_entry.c @@ -6230,4 +6230,4 @@ ELM_LAYOUT_TEXT_ALIASES_IMPLEMENT(MY_CLASS_PFX) ELM_LAYOUT_TEXT_ALIASES_OPS(MY_CLASS_PFX), \ ELM_LAYOUT_SIZING_EVAL_OPS(elm_entry) -#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 fb903db52a..0000000000 --- a/src/lib/elementary/elm_entry.eo +++ /dev/null @@ -1,928 +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]] - } - } - @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.Part.part_get; - } - 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 0000000000..6df71f9e0a --- /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 8d7fab352c..f762563fa7 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 0000000000..b5bf557b88 --- /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 0000000000..6fe06089be --- /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 7e54218d07..06b3f76eb7 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 ab94ea65d1..e00f0d38f6 100644 --- a/src/lib/elementary/elm_spinner.c +++ b/src/lib/elementary/elm_spinner.c @@ -12,7 +12,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 d8f9a88b0f..b011cf1439 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 a40df5183b..0ac48282b4 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 33a15ce816..dbc68cf4bf 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', @@ -740,6 +739,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 b34102aa15..db0155335f 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