path: root/src/lib/elementary/elm_entry.eo

import elm_general;
import elm_icon;

type Elm_Entry_Item_Provider_Cb: __undefined_type;
type Elm_Entry_Filter_Cb: __undefined_type;

enum Elm.Text_Format
{
   [[Text Format types.

     See also @Elm.Entry.file_text_format.
   ]]
   plain_utf8, [[ Plain UTF8 type ]]
   markup_utf8 [[ Markup UTF8 type ]]
}

enum Elm.Input.Panel.Layout
{
   [[Input panel (virtual keyboard) layout types.
     Type of input panel (virtual keyboard) to use - this is a hint and may not provide exactly what is desired.
     See also @Elm.Entry.input_panel_layout.set.
   ]]
   normal,      [[Default layout.]]
   number,      [[Number layout.]]
   email,       [[Email layout.]]
   url,         [[URL layout.]]
   phonenumber, [[Phone Number layout.]]
   ip,          [[IP layout.]]
   month,       [[Month layout.]]
   numberonly,  [[Number Only layout.]]
   invalid,     [[Never use this.]]
   hex,         [[Hexadecimal layout.]]
   terminal,    [[Command-line terminal layout including esc, alt, ctrl key, so on (no auto-correct, no auto-capitalization).]]
   password,    [[Like normal, but no auto-correct, no auto-capitalization etc.]]
   datetime,    [[Date and time layout

                  @since 1.8]]
   emoticon     [[Emoticon layout

                  @since 1.10]]
}

enum Elm.Input.Panel.Lang
{
   [[Input panel (virtual keyboard) language modes.

      See also @Elm.Entry.input_panel_language.set.
   ]]
   automatic,    [[Automatic]]
   alphabet      [[Alphabet]]
}

enum Elm.Autocapital.Type
{
   [[Autocapitalization Types.
     Choose method of auto-capitalization.

     See also @Elm.Entry.autocapital_type.set.
   ]]
   none,         [[No auto-capitalization when typing.]]
   word,         [[Autocapitalize each word typed.]]
   sentence,     [[Autocapitalize the start of each sentence.]]
   allcharacter  [[Autocapitalize all letters.]]
}

enum Elm.Input.Panel.Return_Key.Type
{
   [["Return" Key types on the input panel (virtual keyboard).
     See also @Elm.Entry.input_panel_return_key_type.set.

   ]]
   default, [[Default.]]
   done,    [[Done.]]
   go,      [[Go.]]
   join,    [[Join.]]
   login,   [[Login.]]
   next,    [[Next.]]
   search,  [[Search string or magnifier icon.]]
   send,    [[Send.]]
   signin   [[Sign-in

              @since 1.8]]
}

enum Elm.Input.Hints
{
   [[Enumeration that defines the types of Input Hints.

     @since 1.12
   ]]
   legacy: elm_input_hint;
   none                = 0,        [[No active hints

                                     @since 1.12]]
   auto_complete       = 1 << 0,   [[Suggest word auto completion

                                     @since 1.12]]
   sensitive_data      = 1 << 1,   [[Typed text should not be stored.

                                     @since 1.12]]
}


enum Elm.Cnp_Mode
{
   [[
     Enum of entry's copy & paste policy.

     See also @Elm.Entry.cnp_mode.set,
     @Elm.Entry.cnp_mode.get.
   ]]
   markup,    [[ copy & paste text with markup tag ]]
   no_image,  [[ copy & paste text without item(image) tag ]]
   plaintext, [[ copy & paste text without markup tag ]]
}

class Elm.Entry (Elm.Layout, Elm.Interface_Scrollable, Evas.Clickable_Interface,
                 Elm.Interface_Atspi_Text, Elm.Interface_Atspi_Editable_Text, Efl.File,
                 Evas.Selectable_Interface, Evas.Scrollable_Interface)
{
   eo_prefix: elm_obj_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.file.set.

           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.file.set 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: const(char)* @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: Evas.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.
            ]]
         }
         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: Evas.Object *;
         }
      }
      @property 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: bool;
         }
         values {
            x: Evas.Coord; [[returned geometry.]]
            y: Evas.Coord; [[returned geometry.]]
            w: Evas.Coord; [[returned geometry.]]
            h: Evas.Coord; [[returned geometry.]]
         }
      }
      @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 *;
         }
      }
      @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;
         }
      }
      @property 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.
            ]]
            return: own(char *) @warn_unused;
         }
      }
      @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: const(char)*;
         }
      }
      @property cursor_is_visible_format {
         get {
            [[Get if the current cursor position holds a visible format node.]]
            return: bool;
         }
      }
      cursor_prev {
         [[This moves the cursor one place to the left within the entry.]]
         return: bool;
      }
      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 * @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.
         ]]
      }
      calc_force {
         [[Forces calculation of the entry size and text layouting.

           This should be used after modifying the textblock object directly. See
           @.textblock.get for more information.
         ]]
      }
      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;
      }
      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: const(char)*; [[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 * @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: const(char)*;
      }
      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;
      }
      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: const(char)*; [[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)*; [[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;
      }
      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);
      }
      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 * @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 * @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 * @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: const(char)*; [[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: const(char)* @optional; [[The item's text label.]]
            @in icon_file: const(char)* @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)* @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 * @optional; [[User data to pass to $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_Accessible.state_set.get;
      Elm.Interface_Atspi_Accessible.name.get;
      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;
      Efl.File.file.set;
      Efl.File.file.get;
   }
   events {
      activated;
      changed;
      changed,user;
      validate;
      context,open;
      anchor,clicked;
      rejected;
      maxlength,reached;
      preedit,changed;
      press;
      redo,request;
      undo,request;
      text,set,done;
      aborted;
      anchor,down;
      anchor,hover,opened;
      anchor,in;
      anchor,out;
      anchor,up;
      cursor,changed;
      cursor,changed,manual;
   }

}