efl/legacy/elementary/src/lib/elm_entry.eo

class Elm_Entry (Elm_Layout, Elm_Interface_Scrollable, Evas.Clickable_Interface,
                 Elm_Interface_Atspi_Text, Elm_Interface_Atspi_Editable_Text)
{
   eo_prefix: elm_obj_entry;
   properties {
      scrollable {
         set {
            /*@
            Enable or disable scrolling in entry

            Normally the entry is not scrollable unless you enable it with this call.

            @ingroup Entry */
         }
         get {
            /*@
            Get the scrollable state of the entry

            Normally the entry is not scrollable. This gets the scrollable state
            of the entry. See elm_entry_scrollable_set() for more information.

            @return The scrollable state

            @ingroup Entry */
         }
         values {
            bool scroll; /*@ EINA_TRUE if it is to be scrollable, EINA_FALSE otherwise */
         }
      }
      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.

            @ingroup Entry */
         }
         get {
            /*@
            Get the attribute to show the input panel in case of only an user's explicit Mouse Up event.

            @return @c EINA_TRUE if the input panel will be shown in case of only Mouse up event.
            @since 1.9

            @ingroup Entry */
         }
         values {
            bool ondemand; /*@ If true, the input panel will be shown in case of only Mouse up event.
            (Focus event will be ignored.)
            @since 1.9 */
         }
      }
      context_menu_disabled {
         set {
            /*@
            This disables the entry's contextual (longpress) menu.

            @ingroup Entry */
         }
         get {
            /*@
            This returns whether the entry's contextual (longpress) menu is
            disabled.

            @return If true, the menu is disabled

            @ingroup Entry */
         }
         values {
            bool disabled; /*@ If true, the menu is disabled */
         }
      }
      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.

            @ingroup Entry */
         }
         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.

            @return mode One of #Elm_Cnp_Mode: #ELM_CNP_MODE_MARKUP, #ELM_CNP_MODE_NO_IMAGE, #ELM_CNP_MODE_PLAINTEXT.

            @ingroup Entry */
         }
         values {
            Elm_Cnp_Mode cnp_mode; /*@ One of #Elm_Cnp_Mode: #ELM_CNP_MODE_MARKUP, #ELM_CNP_MODE_NO_IMAGE, #ELM_CNP_MODE_PLAINTEXT. */
         }
      }
      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.

            @ingroup Entry */
         }
         get {
            /*@
            Get the language mode of the input panel.

            See @ref elm_entry_input_panel_language_set for more details.

            @return input panel language type

            @ingroup Entry */
         }
         values {
            Elm_Input_Panel_Lang lang; /*@ language to be set to the input panel. */
         }
      }
      selection_handler_disabled {
         set {
            /*@
            This disabled the entry's selection handlers.

            @ingroup Entry */
         }
         get {
            /*@ This returns whether the entry's selection handlers are disabled. */
            legacy: null;
         }
         values {
            bool disabled; /*@ If true, the selection handlers are disabled. */
         }
      }
      input_panel_layout_variation {
         set {
            /*@
            Set the input panel layout variation of the entry

            @ingroup Entry
            @since 1.8 */
         }
         get {
            /*@
            Get the input panel layout variation of the entry

            @return layout variation type

            @see elm_entry_input_panel_layout_variation_set

            @ingroup Entry
            @since 1.8 */
         }
         values {
            int variation; /*@ layout variation type */
         }
      }
      autocapital_type {
         set {
            /*@
            Set the autocapitalization type on the immodule.

            @ingroup Entry */
         }
         get {
            /*@
            Get the autocapitalization type on the immodule.

            @return autocapitalization type

            @ingroup Entry */
         }
         values {
            Elm_Autocapital_Type autocapital_type; /*@ The type of autocapitalization */
         }
      }
      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 @p editable as EINA_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
            elm_object_text_set(), elm_entry_entry_insert() and other related
            functions.

            @ingroup Entry */
         }
         get {
            /*@
            Get whether the entry is editable or not.

            @return If true, the entry is editable by the user.
            If false, it is not editable by the user

            @see elm_entry_editable_set()

            @ingroup Entry */
         }
         values {
            bool editable; /*@ If EINA_TRUE, user input will be inserted in the entry,
            if not, the entry is read-only and no user input is allowed. */
         }
      }
      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 @p style.

            Setting style no @c NULL means disabling automatic hover.

            @see elm_object_style_set()

            @ingroup Entry */
         }
         get {
            /*@
            Get the style that the hover should use

            Get the style, the hover created by entry will use.

            @return The style to use by the hover. @c NULL means the default is used.

            @see elm_object_style_set()

            @ingroup Entry */
         }
         values {
            const(char)* style; /*@ The style to use for the underlying hover */
         }
      }
      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 @c Enter
            key will generate an @c "activate" event instead of adding a new line.

            When @p single_line is @c EINA_FALSE, line wrapping takes effect again
            and pressing enter will break the text into a different line
            without generating any events.

            @ingroup Entry */
         }
         get {
            /*@
            Get whether the entry is set to be single line.

            @return single_line If true, the text in the entry is set to display
            on a single line.

            @see elm_entry_single_line_set()

            @ingroup Entry */
         }
         values {
            bool single_line; /*@ If true, the text in the entry
            will be on a single line. */
         }
      }
      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 (*).

            @ingroup Entry */
         }
         get {
            /*@
            Get whether the entry is set to password mode.

            @return If true, the entry is set to display all characters
            as asterisks (*).

            @see elm_entry_password_set()

            @ingroup Entry */
         }
         values {
            bool password; /*@ If true, password mode is enabled. */
         }
      }
      file {
         set {
            /*@
            This sets the file (and implicitly loads it) for the text to display and
            then edit. All changes are written back to the file after a short delay if
            the entry object is set to autosave (which is the default).

            If the entry had any other file set previously, any changes made to it
            will be saved if the autosave feature is enabled, otherwise, the file
            will be silently discarded and any non-saved changes will be lost.

            @return @c EINA_TRUE on success, @c EINA_FALSE otherwise

            @ingroup Entry */
            return: bool;
         }
         get {
            /*@
            Get the file being edited by the entry.

            This function can be used to retrieve any file set on the entry for
            edition, along with the format used to load and save it.

            @ingroup Entry */
         }
         values {
            const(char)* file; /*@ The path to the file to load and save */
            Elm_Text_Format format; /*@ The file format */
         }
      }
      input_panel_return_key_disabled {
         set {
            /*@
            Set the return key on the input panel to be disabled.

            @ingroup Entry */
         }
         get {
            /*@
            Get whether the return key on the input panel should be disabled or not.

            @return EINA_TRUE if it should be disabled

            @ingroup Entry */
         }
         values {
            bool disabled; /*@ The state to put in in: @c EINA_TRUE for
            disabled, @c EINA_FALSE for enabled */
         }
      }
      autosave {
         set {
            /*@
            This sets the entry object to 'autosave' the loaded text file or not.

            @see elm_entry_file_set()

            @ingroup Entry */
         }
         get {
            /*@
            This gets the entry object's 'autosave' status.

            @return Autosave the loaded file or not

            @see elm_entry_file_set()

            @ingroup Entry */
         }
         values {
            bool auto_save; /*@ Autosave the loaded file or not */
         }
      }
      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. See @ref Hover for more details on this.

            @ingroup Entry */
         }
         get {
            /*@
            Get the parent of the hover popup

            Get the object used as parent for the hover created by the entry
            widget. See @ref Hover for more details on this.
            If no parent is set, the same entry object will be used.

            @return The object used as parent for the hover, NULL if none is set.

            @ingroup Entry */
         }
         values {
            Evas_Object *parent; /*@ The object to use as parent for the hover */
         }
      }
      prediction_allow {
         set {
            /*@
            Set whether the entry should allow to use the text prediction.

            @ingroup Entry */
         }
         get {
            /*@
            Get whether the entry should allow to use the text prediction.

            @return EINA_TRUE if it allows to use the text prediction, otherwise EINA_FALSE.

            @ingroup Entry */
         }
         values {
            bool prediction; /*@ Whether the entry should allow to use the text prediction. */
         }
      }
      input_hint {
         set {
            /*@
            Sets the input hint which allows input methods to fine-tune their behavior.

            @ingroup Entry */
         }
         get {
            /*@
            Gets the value of input hint.

            @return the value of input hint.

            @see elm_entry_input_hint_set

            @ingroup Entry */
         }
         values {
            Elm_Input_Hints hints; /*@ input hint. */
         }
      }
      input_panel_layout {
         set {
            /*@
            Set the input panel layout of the entry

            @ingroup Entry */
         }
         get {
            /*@
            Get the input panel layout of the entry

            @return layout type

            @see elm_entry_input_panel_layout_set

            @ingroup Entry */
         }
         values {
            Elm_Input_Panel_Layout layout; /*@ layout type */
         }
      }
      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

            @ingroup Entry */
         }
         get {
            /*@
            Get the "return" key type.

            @see elm_entry_input_panel_return_key_type_set() for more details

            @return The type of "return" key on the input panel

            @ingroup Entry */
         }
         values {
            Elm_Input_Panel_Return_Key_Type return_key_type; /*@ The type of "return" key on the input panel */
         }
      }
      input_panel_enabled {
         set {
            /*@
            Sets the attribute to show the input panel automatically.

            @ingroup Entry */
         }
         get {
            /*@
            Get the attribute to show the input panel automatically.

            @return EINA_TRUE if input panel will be appeared when the entry is clicked or has a focus, EINA_FALSE otherwise

            @ingroup Entry */
         }
         values {
            bool enabled; /*@ If true, the input panel is appeared when entry is clicked or has a focus */
         }
      }
      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.

            @ingroup Entry */
         }
         get {
            /*@
            Get the wrap mode the entry was set to use.

            @return Wrap type

            @see also elm_entry_line_wrap_set()

            @ingroup Entry */
         }
         values {
            Elm_Wrap_Type wrap; /*@ The wrap mode to use. See Elm_Wrap_Type for details on them */
         }
      }
      cursor_pos {
         set {
            /*@
            Sets the cursor position in the entry to the given value

            The value in @p pos is the index of the character position within the
            contents of the string as returned by elm_entry_cursor_pos_get().

            @ingroup Entry */
         }
         get {
            /*@
            Get the current position of the cursor in the entry

            @return The cursor position

            @ingroup Entry */
         }
         values {
            int pos; /*@ The position of the cursor */
         }
      }
      icon_visible {
         set {
            /*@
            Sets the visibility of the left-side widget of the entry,
            set by elm_object_part_content_set().

            @ingroup Entry */
         }
         values {
            bool setting; /*@ EINA_TRUE if the object should be displayed,
            EINA_FALSE if not. */
         }
      }
      cursor_line_end {
         set {
            /*@
            This moves the cursor to the end of the current line.

            @ingroup Entry */
         }
      }
      select_region {
         set {
            /*@
            This selects a region of text within the entry.

            @ingroup Entry
            @since 1.9 */
         }
         values {
            int start; /*@ The starting position */
            int end; /*@ The end position */
         }
      }
      input_panel_return_key_autoenabled {
         set {
            /*@
            Set whether the return key on the input panel is disabled automatically when entry has no text.

            If @p enabled is EINA_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 EINA_FALSE.

            @ingroup Entry */
         }
         values {
            bool enabled; /*@ If @p enabled is EINA_TRUE, the return key is automatically disabled when the entry has no text. */
         }
      }
      end_visible {
         set {
            /*@
            Sets the visibility of the end widget of the entry, set by
            elm_object_part_content_set(ent, "end", content).

            @ingroup Entry */
         }
         values {
            bool setting; /*@ EINA_TRUE if the object should be displayed,
            EINA_FALSE if not. */
         }
      }
      cursor_begin {
         set {
            /*@
            This moves the cursor to the beginning of the entry.

            @ingroup Entry */
         }
      }
      cursor_line_begin {
         set {
            /*@
            This moves the cursor to the beginning of the current line.

            @ingroup Entry */
         }
      }
      cursor_end {
         set {
            /*@
            This moves the cursor to the end of the entry.

            @ingroup Entry */
         }
      }
      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 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 The textblock object.

            @ingroup Entry */
            return: Evas_Object *;
         }
      }
      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.

            @return EINA_TRUE upon success, EINA_FALSE upon failure

            @ingroup Entry */
            return: bool;
         }
         values {
            Evas_Coord x; /*@ returned geometry */
            Evas_Coord y; /*@ returned geometry */
            Evas_Coord w; /*@ returned geometry */
            Evas_Coord h; /*@ returned geometry */
         }
      }
      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 The input method context (Ecore_IMF_Context *) in entry.

            @ingroup Entry */
            return: void *;
         }
      }
      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 EINA_TRUE if the current cursor position contains a format node,
            EINA_FALSE otherwise.

            @see elm_entry_cursor_is_visible_format_get()

            @ingroup Entry */
            return: bool;
         }
      }
      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 free().

            @return The text pointed by the cursors.

            @ingroup Entry */
            return: char *;
         }
      }
      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 @p entry object is deleted or its
            contents are changed, the returned pointer should be considered invalid.

            @return The selected text within the entry or NULL on failure

            @ingroup Entry */
            return: const(char)*;
         }
      }
      cursor_is_visible_format {
         get {
            /*@
            Get if the current cursor position holds a visible format node.

            @return EINA_TRUE if the current cursor is a visible format, EINA_FALSE
            if it's an invisible one or no format exists.

            @see elm_entry_cursor_is_format_get()

            @ingroup Entry */
            return: bool;
         }
      }
   }
   methods {
      cursor_prev {
         /*@
         This moves the cursor one place to the left within the entry.

         @return EINA_TRUE upon success, EINA_FALSE upon failure

         @ingroup Entry */

         return: bool;
      }
      text_style_user_pop {
         /*@
         Remove the style in the top of user style stack.

         @see elm_entry_text_style_user_push()

         @ingroup Entry
         @since 1.7 */

      }
      item_provider_prepend {
         /*@
         This prepends a custom item provider to the list for that entry

         This prepends the given callback. See elm_entry_item_provider_append() for
         more information

         @ingroup Entry */

         params {
            @in Elm_Entry_Item_Provider_Cb func; /*@ The function called to provide the item object */
            @in void *data; /*@ The data passed to @p 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 elm_entry_input_panel_enabled_set(en, EINA_FALSE).

         @ingroup Entry */

      }
      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.
         @ingroup Entry */

      }
      calc_force {
         /*@
         Forces calculation of the entry size and text layouting.

         This should be used after modifying the textblock object directly. See
         elm_entry_textblock_get() for more information.

         @see elm_entry_textblock_get()

         @ingroup Entry */

      }
      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.

         @ingroup Entry */

      }
      cursor_selection_begin {
         /*@
         This begins a selection within the entry as though
         the user were holding down the mouse button to make a selection.

         @ingroup Entry */

      }
      cursor_down {
         /*@
         This moves the cursor one line down within the entry.

         @return EINA_TRUE upon success, EINA_FALSE upon failure

         @ingroup Entry */

         return: bool;
      }
      file_save {
         /*@
         This function writes any changes made to the file set with
         elm_entry_file_set()

         @ingroup Entry */

      }
      selection_copy {
         /*@
         This executes a "copy" action on the selected text in the entry.

         @ingroup 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').

         @ingroup Entry
         @since 1.7 */

         params {
            @in const(char)* style; /*@ 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 elm_entry_item_provider_append() for
         more information

         @ingroup Entry */

         params {
            @in Elm_Entry_Item_Provider_Cb func; /*@ The function called to provide the item object */
            @in void *data; /*@ The data passed to @p func */
         }
      }
      text_style_user_peek @const {
         /*@
         Get the style on the top of user style stack.

         @return style on the top of user style stack if exist, otherwise NULL.

         @see elm_entry_text_style_user_push()

         @ingroup Entry
         @since 1.7 */
         return: const(char)*;
      }
      context_menu_clear {
         /*@
         This clears and frees the items in a entry's contextual (longpress)
         menu.

         @see elm_entry_context_menu_item_add()

         @ingroup Entry */

      }
      cursor_up {
         /*@
         This moves the cursor one line up within the entry.

         @return EINA_TRUE upon success, EINA_FALSE upon failure

         @ingroup Entry */

         return: bool;
      }
      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 elm_entry_markup_filter_append()

         @ingroup Entry */

         params {
            @in const(char)* entry; /*@ 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.

         @ingroup Entry */

         params {
            @in const(void)* data; /*@ The specific data to be set to the input panel. */
            @in int len; /*@ 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.

         See @ref elm_entry_input_panel_imdata_set for more details.

         @ingroup Entry */
         params {
            @out void data; /*@ The specific data to be got from the input panel */
            @out int len; /*@ The length of data */
         }
      }
      selection_paste {
         /*@
         This executes a "paste" action in the entry.

         @ingroup Entry */

      }
      cursor_next {
         /*@
         This moves the cursor one place to the right within the entry.

         @return EINA_TRUE upon success, EINA_FALSE upon failure

         @ingroup Entry */

         return: bool;
      }
      select_none {
         /*@
         This drops any existing text selection within the entry.

         @ingroup 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 elm_entry_input_panel_enabled_set(en, EINA_FALSE)

         @ingroup Entry */

      }
      select_all {
         /*@
         This selects all text within the entry.

         @ingroup 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.

         @ingroup Entry */

      }
      selection_cut {
         /*@
         This executes a "cut" action on the selected text in the entry.

         @ingroup 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 EINA_FALSE.

         @return EINA_TRUE if the entry is empty, EINA_FALSE otherwise.

         @ingroup Entry */
         return: bool;
      }
      markup_filter_remove {
         /*@
         Remove a markup filter from the list

         Removes the given callback from the filter list. See
         elm_entry_markup_filter_append() for more information.

         @ingroup Entry */

         params {
            @in Elm_Entry_Filter_Cb func; /*@ The filter function to remove */
            @in void *data; /*@ 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 @ref entry-items

         @ingroup Entry */

         params {
            @in Elm_Entry_Item_Provider_Cb func; /*@ The function called to provide the item object */
            @in void *data; /*@ The data passed to @p 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.

         @ingroup Entry */

         params {
            @in Elm_Entry_Filter_Cb func; /*@ The function to use as text filter */
            @in void *data; /*@ User data to pass to @p func */
         }
      }
      entry_append {
         /*@
         Appends @p str to the text of the entry.

         Adds the text in @p 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 elm_entry_markup_filter_append()

         @ingroup Entry */

         params {
            @in const(char)* str; /*@ 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 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.

         @ingroup Entry */

         params {
            @in const(char)* label; /*@ The item's text label */
            @in const(char)* icon_file; /*@ The item's icon file */
            @in Elm_Icon_Type icon_type; /*@ The item's icon type */
            @in Evas_Smart_Cb func; /*@ The callback to execute when the item is clicked */
            @in const(void)* data; /*@ 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. See elm_entry_markup_filter_append()
         for more information

         @ingroup Entry */

         params {
            @in Elm_Entry_Filter_Cb func; /*@ The function to use as text filter */
            @in void *data; /*@ User data to pass to @p func */
         }
      }
   }
   implements {
      class.constructor;
      Eo.Base.constructor;
      Evas.Object_Smart.move;
      Evas.Object_Smart.member_add;
      Evas.Object_Smart.add;
      Evas.Object_Smart.resize;
      Evas.Object_Smart.del;
      Evas.Object_Smart.show;
      Evas.Object_Smart.hide;
      Elm_Widget.activate;
      Elm_Widget.focus_direction_manager_is;
      Elm_Widget.theme_apply;
      Elm_Widget.on_focus;
      Elm_Widget.on_focus_region;
      Elm_Widget.disable;
      Elm_Widget.sub_object_del;
      Elm_Widget.focus_next_manager_is;
      Elm_Container.content_unset;
      Elm_Container.content_set;
      Elm_Layout.theme_enable;
      Elm_Layout.sizing_eval;
      Elm_Layout.text_get;
      Elm_Layout.signal_callback_add;
      Elm_Layout.signal_callback_del;
      Elm_Layout.signal_emit;
      Elm_Layout.text_set;
      Elm_Layout.content_aliases.get;
      Elm_Interface_Scrollable.policy.set;
      Elm_Interface_Scrollable.bounce_allow.set;
      Elm_Interface_Atspi_Text.text.get;
      Elm_Interface_Atspi_Text.string.get;
      Elm_Interface_Atspi_Text.attribute.get;
      Elm_Interface_Atspi_Text.attributes.get;
      Elm_Interface_Atspi_Text.default_attributes.get;
      Elm_Interface_Atspi_Text.caret_offset.get;
      Elm_Interface_Atspi_Text.caret_offset.set;
      Elm_Interface_Atspi_Text.character.get;
      Elm_Interface_Atspi_Text.character_extents.get;
      Elm_Interface_Atspi_Text.character_count.get;
      Elm_Interface_Atspi_Text.offset_at_point.get;
      Elm_Interface_Atspi_Text.bounded_ranges.get;
      Elm_Interface_Atspi_Text.range_extents.get;
      Elm_Interface_Atspi_Text.selection.get;
      Elm_Interface_Atspi_Text.selections_count.get;
      Elm_Interface_Atspi_Text.selection_add;
      Elm_Interface_Atspi_Text.selection_remove;
      Elm_Interface_Atspi_Text.selection.set;
      Elm_Interface_Atspi_Editable_Text.content.set;
      Elm_Interface_Atspi_Editable_Text.insert;
      Elm_Interface_Atspi_Editable_Text.copy;
      Elm_Interface_Atspi_Editable_Text.cut;
      Elm_Interface_Atspi_Editable_Text.delete;
      Elm_Interface_Atspi_Editable_Text.paste;
   }
   events {
      language,changed;
      access,changed;
      activated;
      changed;
      changed,user;
   }

}