src/lib/elm_entry.h

   1 <<<<<<< HEAD
   2 typedef enum
   3 {
   4    ELM_TEXT_FORMAT_PLAIN_UTF8,
   5    ELM_TEXT_FORMAT_MARKUP_UTF8
   6 } Elm_Text_Format;
   7
   8 /**
   9  * Line wrapping types.
  10  */
  11 typedef enum
  12 {
  13    ELM_WRAP_NONE = 0, /**< No wrap - value is zero */
  14    ELM_WRAP_CHAR, /**< Char wrap - wrap between characters */
  15    ELM_WRAP_WORD, /**< Word wrap - wrap in allowed wrapping points (as defined in the unicode standard) */
  16    ELM_WRAP_MIXED, /**< Mixed wrap - Word wrap, and if that fails, char wrap. */
  17    ELM_WRAP_LAST
  18 } Elm_Wrap_Type; /**< Type of word or character wrapping to use */
  19
  20 typedef enum
  21 {
  22    ELM_INPUT_PANEL_LAYOUT_NORMAL, /**< Default layout */
  23    ELM_INPUT_PANEL_LAYOUT_NUMBER, /**< Number layout */
  24    ELM_INPUT_PANEL_LAYOUT_EMAIL, /**< Email layout */
  25    ELM_INPUT_PANEL_LAYOUT_URL, /**< URL layout */
  26    ELM_INPUT_PANEL_LAYOUT_PHONENUMBER, /**< Phone Number layout */
  27    ELM_INPUT_PANEL_LAYOUT_IP, /**< IP layout */
  28    ELM_INPUT_PANEL_LAYOUT_MONTH, /**< Month layout */
  29    ELM_INPUT_PANEL_LAYOUT_NUMBERONLY, /**< Number Only layout */
  30    ELM_INPUT_PANEL_LAYOUT_INVALID, /**< Never use this */
  31    ELM_INPUT_PANEL_LAYOUT_HEX, /**< Hexadecimal layout */
  32    ELM_INPUT_PANEL_LAYOUT_TERMINAL, /**< Command-line terminal layout */
  33    ELM_INPUT_PANEL_LAYOUT_PASSWORD /**< Like normal, but no auto-correct, no auto-capitalization etc. */
  34 } Elm_Input_Panel_Layout; /**< Type of input panel (virtual keyboard) to use - this is a hint and may not provide exactly what is desired. */
  35
  36 typedef enum
  37 {
  38    ELM_INPUT_PANEL_LANG_AUTOMATIC,    /**< Automatic */
  39    ELM_INPUT_PANEL_LANG_ALPHABET      /**< Alphabet */
  40 } Elm_Input_Panel_Lang;
  41
  42 typedef enum
  43 {
  44    ELM_AUTOCAPITAL_TYPE_NONE, /**< No auto-capitalization when typing */
  45    ELM_AUTOCAPITAL_TYPE_WORD, /**< Autocapitalize each word typed */
  46    ELM_AUTOCAPITAL_TYPE_SENTENCE, /**< Autocapitalize the start of each sentence */
  47    ELM_AUTOCAPITAL_TYPE_ALLCHARACTER, /**< Autocapitalize all letters */
  48 } Elm_Autocapital_Type; /**< Choose method of auto-capitalization */
  49
  50 typedef enum
  51 {
  52    ELM_INPUT_PANEL_RETURN_KEY_TYPE_DEFAULT,
  53    ELM_INPUT_PANEL_RETURN_KEY_TYPE_DONE,
  54    ELM_INPUT_PANEL_RETURN_KEY_TYPE_GO,
  55    ELM_INPUT_PANEL_RETURN_KEY_TYPE_JOIN,
  56    ELM_INPUT_PANEL_RETURN_KEY_TYPE_LOGIN,
  57    ELM_INPUT_PANEL_RETURN_KEY_TYPE_NEXT,
  58    ELM_INPUT_PANEL_RETURN_KEY_TYPE_SEARCH,
  59    ELM_INPUT_PANEL_RETURN_KEY_TYPE_SEND
  60 } Elm_Input_Panel_Return_Key_Type;
  61
  62 /**
  63     * @enum _Elm_CNP_Mode
  64     * @typedef Elm_CNP_Mode
  65     * Enum of entry's copy & paste policy.
  66     *
  67     * @see elm_entry_cnp_mode_set()
  68     * @see elm_entry_cnp_mode_get()
  69     */
  70    typedef enum _Elm_CNP_Mode {
  71       ELM_CNP_MODE_MARKUP = 0,       /**< copy & paste text with markup tag */
  72       ELM_CNP_MODE_NO_IMAGE = 1,     /**< copy & paste text without item(image) tag */
  73       ELM_CNP_MODE_PLAINTEXT = 2     /**< copy & paste text without markup tag */
  74    } Elm_CNP_Mode;
  75
  76 =======
  77 >>>>>>> remotes/origin/upstream
  78 /**
  79  * @defgroup Entry Entry
  80  *
  81  * @image html img/widget/entry/preview-00.png
  82  * @image latex img/widget/entry/preview-00.eps width=\textwidth
  83  * @image html img/widget/entry/preview-01.png
  84  * @image latex img/widget/entry/preview-01.eps width=\textwidth
  85  * @image html img/widget/entry/preview-02.png
  86  * @image latex img/widget/entry/preview-02.eps width=\textwidth
  87  * @image html img/widget/entry/preview-03.png
  88  * @image latex img/widget/entry/preview-03.eps width=\textwidth
  89  *
  90  * An entry is a convenience widget which shows a box that the user can
  91  * enter text into. Entries by default don't scroll, so they grow to
  92 <<<<<<< HEAD
  93  * accomodate the entire text, resizing the parent window as needed. This
  94 =======
  95  * accommodate the entire text, resizing the parent window as needed. This
  96 >>>>>>> remotes/origin/upstream
  97  * can be changed with the elm_entry_scrollable_set() function.
  98  *
  99  * They can also be single line or multi line (the default) and when set
 100  * to multi line mode they support text wrapping in any of the modes
 101 <<<<<<< HEAD
 102  * indicated by Elm_Wrap_Type.
 103  *
 104  * Other features include password mode, filtering of inserted text with
 105  * elm_entry_text_filter_append() and related functions, inline "items" and
 106 =======
 107  * indicated by #Elm_Wrap_Type.
 108  *
 109  * Other features include password mode, filtering of inserted text with
 110  * elm_entry_markup_filter_append() and related functions, inline "items" and
 111 >>>>>>> remotes/origin/upstream
 112  * formatted markup text.
 113  *
 114  * @section entry-markup Formatted text
 115  *
 116  * The markup tags supported by the Entry are defined by the theme, but
 117  * even when writing new themes or extensions it's a good idea to stick to
 118  * a sane default, to maintain coherency and avoid application breakages.
 119  * Currently defined by the default theme are the following tags:
 120  * @li \<br\>: Inserts a line break.
 121  * @li \<ps\>: Inserts a paragraph separator. This is preferred over line
 122  * breaks.
 123  * @li \<tab\>: Inserts a tab.
 124  * @li \<em\>...\</em\>: Emphasis. Sets the @em oblique style for the
 125  * enclosed text.
 126  * @li \<b\>...\</b\>: Sets the @b bold style for the enclosed text.
 127  * @li \<link\>...\</link\>: Underlines the enclosed text.
 128 <<<<<<< HEAD
 129  * @li \<hilight\>...\</hilight\>: Hilights the enclosed text.
 130 =======
 131  * @li \<hilight\>...\</hilight\>: Highlights the enclosed text.
 132 >>>>>>> remotes/origin/upstream
 133  *
 134  * @section entry-special Special markups
 135  *
 136  * Besides those used to format text, entries support two special markup
 137 <<<<<<< HEAD
 138  * tags used to insert clickable portions of text or items inlined within
 139 =======
 140  * tags used to insert click-able portions of text or items inlined within
 141 >>>>>>> remotes/origin/upstream
 142  * the text.
 143  *
 144  * @subsection entry-anchors Anchors
 145  *
 146  * Anchors are similar to HTML anchors. Text can be surrounded by \<a\> and
 147  * \</a\> tags and an event will be generated when this text is clicked,
 148  * like this:
 149  *
 150  * @code
 151  * This text is outside <a href=anc-01>but this one is an anchor</a>
 152  * @endcode
 153  *
 154  * The @c href attribute in the opening tag gives the name that will be
 155  * used to identify the anchor and it can be any valid utf8 string.
 156  *
 157  * When an anchor is clicked, an @c "anchor,clicked" signal is emitted with
 158  * an #Elm_Entry_Anchor_Info in the @c event_info parameter for the
 159  * callback function. The same applies for "anchor,in" (mouse in), "anchor,out"
 160  * (mouse out), "anchor,down" (mouse down), and "anchor,up" (mouse up) events on
 161  * an anchor.
 162  *
 163  * @subsection entry-items Items
 164  *
 165  * Inlined in the text, any other @c Evas_Object can be inserted by using
 166  * \<item\> tags this way:
 167  *
 168  * @code
 169  * <item size=16x16 vsize=full href=emoticon/haha></item>
 170  * @endcode
 171  *
 172  * Just like with anchors, the @c href identifies each item, but these need,
 173  * in addition, to indicate their size, which is done using any one of
 174  * @c size, @c absize or @c relsize attributes. These attributes take their
 175  * value in the WxH format, where W is the width and H the height of the
 176  * item.
 177  *
 178  * @li absize: Absolute pixel size for the item. Whatever value is set will
 179  * be the item's size regardless of any scale value the object may have
 180  * been set to. The final line height will be adjusted to fit larger items.
 181  * @li size: Similar to @c absize, but it's adjusted to the scale value set
 182  * for the object.
 183  * @li relsize: Size is adjusted for the item to fit within the current
 184  * line height.
 185  *
 186 <<<<<<< HEAD
 187  * Besides their size, items are specificed a @c vsize value that affects
 188 =======
 189  * Besides their size, items are specified a @c vsize value that affects
 190 >>>>>>> remotes/origin/upstream
 191  * how their final size and position are calculated. The possible values
 192  * are:
 193  * @li ascent: Item will be placed within the line's baseline and its
 194  * ascent. That is, the height between the line where all characters are
 195  * positioned and the highest point in the line. For @c size and @c absize
 196  * items, the descent value will be added to the total line height to make
 197  * them fit. @c relsize items will be adjusted to fit within this space.
 198  * @li full: Items will be placed between the descent and ascent, or the
 199  * lowest point in the line and its highest.
 200  *
 201  * The next image shows different configurations of items and how
 202  * the previously mentioned options affect their sizes. In all cases,
 203  * the green line indicates the ascent, blue for the baseline and red for
 204  * the descent.
 205  *
 206  * @image html entry_item.png
 207  * @image latex entry_item.eps width=\textwidth
 208  *
 209  * And another one to show how size differs from absize. In the first one,
 210  * the scale value is set to 1.0, while the second one is using one of 2.0.
 211  *
 212  * @image html entry_item_scale.png
 213  * @image latex entry_item_scale.eps width=\textwidth
 214  *
 215  * After the size for an item is calculated, the entry will request an
 216  * object to place in its space. For this, the functions set with
 217  * elm_entry_item_provider_append() and related functions will be called
 218  * in order until one of them returns a @c non-NULL value. If no providers
 219  * are available, or all of them return @c NULL, then the entry falls back
 220  * to one of the internal defaults, provided the name matches with one of
 221  * them.
 222  *
 223  * All of the following are currently supported:
 224  *
 225  * - emoticon/angry
 226  * - emoticon/angry-shout
 227  * - emoticon/crazy-laugh
 228  * - emoticon/evil-laugh
 229  * - emoticon/evil
 230  * - emoticon/goggle-smile
 231  * - emoticon/grumpy
 232  * - emoticon/grumpy-smile
 233  * - emoticon/guilty
 234  * - emoticon/guilty-smile
 235  * - emoticon/haha
 236  * - emoticon/half-smile
 237  * - emoticon/happy-panting
 238  * - emoticon/happy
 239  * - emoticon/indifferent
 240  * - emoticon/kiss
 241  * - emoticon/knowing-grin
 242  * - emoticon/laugh
 243  * - emoticon/little-bit-sorry
 244  * - emoticon/love-lots
 245  * - emoticon/love
 246  * - emoticon/minimal-smile
 247  * - emoticon/not-happy
 248  * - emoticon/not-impressed
 249  * - emoticon/omg
 250  * - emoticon/opensmile
 251  * - emoticon/smile
 252  * - emoticon/sorry
 253  * - emoticon/squint-laugh
 254  * - emoticon/surprised
 255  * - emoticon/suspicious
 256  * - emoticon/tongue-dangling
 257  * - emoticon/tongue-poke
 258  * - emoticon/uh
 259  * - emoticon/unhappy
 260  * - emoticon/very-sorry
 261  * - emoticon/what
 262  * - emoticon/wink
 263  * - emoticon/worried
 264  * - emoticon/wtf
 265  *
 266  * Alternatively, an item may reference an image by its path, using
 267  * the URI form @c file:///path/to/an/image.png and the entry will then
 268  * use that image for the item.
 269  *
 270  * @section entry-files Loading and saving files
 271  *
 272 <<<<<<< HEAD
 273  * Entries have convinience functions to load text from a file and save
 274 =======
 275  * Entries have convenience functions to load text from a file and save
 276 >>>>>>> remotes/origin/upstream
 277  * changes back to it after a short delay. The automatic saving is enabled
 278  * by default, but can be disabled with elm_entry_autosave_set() and files
 279  * can be loaded directly as plain text or have any markup in them
 280  * recognized. See elm_entry_file_set() for more details.
 281  *
 282  * @section entry-signals Emitted signals
 283  *
 284  * This widget emits the following signals:
 285  *
 286  * @li "changed": The text within the entry was changed.
 287  * @li "changed,user": The text within the entry was changed because of user interaction.
 288  * @li "activated": The enter key was pressed on a single line entry.
 289  * @li "press": A mouse button has been pressed on the entry.
 290  * @li "longpressed": A mouse button has been pressed and held for a couple
 291  * seconds.
 292  * @li "clicked": The entry has been clicked (mouse press and release).
 293  * @li "clicked,double": The entry has been double clicked.
 294  * @li "clicked,triple": The entry has been triple clicked.
 295  * @li "focused": The entry has received focus.
 296  * @li "unfocused": The entry has lost focus.
 297  * @li "selection,paste": A paste of the clipboard contents was requested.
 298  * @li "selection,copy": A copy of the selected text into the clipboard was
 299  * requested.
 300  * @li "selection,cut": A cut of the selected text into the clipboard was
 301  * requested.
 302  * @li "selection,start": A selection has begun and no previous selection
 303  * existed.
 304  * @li "selection,changed": The current selection has changed.
 305  * @li "selection,cleared": The current selection has been cleared.
 306  * @li "cursor,changed": The cursor has changed position.
 307  * @li "anchor,clicked": An anchor has been clicked. The event_info
 308  * parameter for the callback will be an #Elm_Entry_Anchor_Info.
 309  * @li "anchor,in": Mouse cursor has moved into an anchor. The event_info
 310  * parameter for the callback will be an #Elm_Entry_Anchor_Info.
 311  * @li "anchor,out": Mouse cursor has moved out of an anchor. The event_info
 312  * parameter for the callback will be an #Elm_Entry_Anchor_Info.
 313  * @li "anchor,up": Mouse button has been unpressed on an anchor. The event_info
 314  * parameter for the callback will be an #Elm_Entry_Anchor_Info.
 315  * @li "anchor,down": Mouse button has been pressed on an anchor. The event_info
 316  * parameter for the callback will be an #Elm_Entry_Anchor_Info.
 317  * @li "preedit,changed": The preedit string has changed.
 318  * @li "language,changed": Program language changed.
 319  *
 320 <<<<<<< HEAD
 321  * Default contents parts of the entry items that you can use for are:
 322 =======
 323  * Default content parts of the entry items that you can use for are:
 324 >>>>>>> remotes/origin/upstream
 325  * @li "icon" - An icon in the entry
 326  * @li "end" - A content in the end of the entry
 327  *
 328  * Default text parts of the entry that you can use for are:
 329  * @li "default" - text of the entry
 330  *
 331  * Supported elm_object common APIs.
 332  * @li elm_object_signal_emit
 333  * @li elm_object_part_text_set
 334  * @li elm_object_part_text_get
 335  * @li elm_object_part_content_set
 336  * @li elm_object_part_content_get
 337  * @li elm_object_part_content_unset
 338  * @li elm_object_signal_callback_add
 339  * @li elm_object_signal_callback_del
 340  * @li elm_object_disabled_set
 341  * @li elm_object_disabled_get
 342  *
 343  * @section entry-examples
 344  *
 345  * An overview of the Entry API can be seen in @ref entry_example_01
 346  *
 347  * @{
 348  */
 349
 350 /**
 351 <<<<<<< HEAD
 352 =======
 353  * @enum _Elm_Text_Format
 354  * @typedef Elm_Text_Format
 355  *
 356  * Text Format types.
 357  *
 358  * @see elm_entry_file_set()
 359  */
 360 typedef enum
 361 {
 362    ELM_TEXT_FORMAT_PLAIN_UTF8,  /**< Plain UTF8 type */
 363    ELM_TEXT_FORMAT_MARKUP_UTF8  /**< Markup UTF8 type */
 364 } Elm_Text_Format;
 365
 366 /**
 367  * @enum _Elm_Wrap_Type
 368  * @typedef Elm_Wrap_Type
 369  *
 370  * Line wrapping types.
 371  *
 372  * @see elm_entry_line_wrap_set()
 373  */
 374 typedef enum
 375 {
 376    ELM_WRAP_NONE = 0, /**< No wrap - value is zero */
 377    ELM_WRAP_CHAR,     /**< Char wrap - wrap between characters */
 378    ELM_WRAP_WORD,     /**< Word wrap - wrap in allowed wrapping points (as defined in the unicode standard) */
 379    ELM_WRAP_MIXED,    /**< Mixed wrap - Word wrap, and if that fails, char wrap. */
 380    ELM_WRAP_LAST
 381 } Elm_Wrap_Type; /**< Type of word or character wrapping to use */
 382
 383 /**
 384  * @enum _Elm_Input_Panel_Layout
 385  * @typedef Elm_Input_Panel_Layout
 386  *
 387  * Input panel (virtual keyboard) layout types.
 388  *
 389  * @see elm_entry_input_panel_layout_set()
 390  */
 391 typedef enum
 392 {
 393    ELM_INPUT_PANEL_LAYOUT_NORMAL,      /**< Default layout */
 394    ELM_INPUT_PANEL_LAYOUT_NUMBER,      /**< Number layout */
 395    ELM_INPUT_PANEL_LAYOUT_EMAIL,       /**< Email layout */
 396    ELM_INPUT_PANEL_LAYOUT_URL,         /**< URL layout */
 397    ELM_INPUT_PANEL_LAYOUT_PHONENUMBER, /**< Phone Number layout */
 398    ELM_INPUT_PANEL_LAYOUT_IP,          /**< IP layout */
 399    ELM_INPUT_PANEL_LAYOUT_MONTH,       /**< Month layout */
 400    ELM_INPUT_PANEL_LAYOUT_NUMBERONLY,  /**< Number Only layout */
 401    ELM_INPUT_PANEL_LAYOUT_INVALID,     /**< Never use this */
 402    ELM_INPUT_PANEL_LAYOUT_HEX,         /**< Hexadecimal layout */
 403    ELM_INPUT_PANEL_LAYOUT_TERMINAL,    /**< Command-line terminal layout */
 404    ELM_INPUT_PANEL_LAYOUT_PASSWORD     /**< Like normal, but no auto-correct, no auto-capitalization etc. */
 405 } Elm_Input_Panel_Layout; /**< Type of input panel (virtual keyboard) to use - this is a hint and may not provide exactly what is desired. */
 406
 407 /**
 408  * @enum _Elm_Input_Panel_Lang
 409  * @typedef Elm_Input_Panel_Lang
 410  *
 411  * Input panel (virtual keyboard) language modes.
 412  *
 413  * @see elm_entry_input_panel_language_set()
 414  */
 415 typedef enum
 416 {
 417    ELM_INPUT_PANEL_LANG_AUTOMATIC,    /**< Automatic */
 418    ELM_INPUT_PANEL_LANG_ALPHABET      /**< Alphabet */
 419 } Elm_Input_Panel_Lang;
 420
 421 /**
 422  * @enum _Elm_Autocapital_Type
 423  * @typedef Elm_Autocapital_Type
 424  *
 425  * Autocapitalization Types.
 426  *
 427  * @see elm_entry_autocapital_type_set()
 428  */
 429 typedef enum
 430 {
 431    ELM_AUTOCAPITAL_TYPE_NONE,         /**< No auto-capitalization when typing */
 432    ELM_AUTOCAPITAL_TYPE_WORD,         /**< Autocapitalize each word typed */
 433    ELM_AUTOCAPITAL_TYPE_SENTENCE,     /**< Autocapitalize the start of each sentence */
 434    ELM_AUTOCAPITAL_TYPE_ALLCHARACTER, /**< Autocapitalize all letters */
 435 } Elm_Autocapital_Type; /**< Choose method of auto-capitalization */
 436
 437 /**
 438  * @enum _Elm_Input_Panel_Return_Key_Type
 439  * @typedef Elm_Input_Panel_Return_Key_Type
 440  *
 441  * "Return" Key types on the input panel (virtual keyboard).
 442  *
 443  * @see elm_entry_input_panel_return_key_type_set()
 444  */
 445 typedef enum
 446 {
 447    ELM_INPUT_PANEL_RETURN_KEY_TYPE_DEFAULT, /**< Default */
 448    ELM_INPUT_PANEL_RETURN_KEY_TYPE_DONE,    /**< Done */
 449    ELM_INPUT_PANEL_RETURN_KEY_TYPE_GO,      /**< Go */
 450    ELM_INPUT_PANEL_RETURN_KEY_TYPE_JOIN,    /**< Join */
 451    ELM_INPUT_PANEL_RETURN_KEY_TYPE_LOGIN,   /**< Login */
 452    ELM_INPUT_PANEL_RETURN_KEY_TYPE_NEXT,    /**< Next */
 453    ELM_INPUT_PANEL_RETURN_KEY_TYPE_SEARCH,  /**< Search string or magnifier icon */
 454    ELM_INPUT_PANEL_RETURN_KEY_TYPE_SEND     /**< Send */
 455 } Elm_Input_Panel_Return_Key_Type;
 456
 457 /**
 458 >>>>>>> remotes/origin/upstream
 459  * @typedef Elm_Entry_Anchor_Info
 460  *
 461  * The info sent in the callback for the "anchor,clicked" signals emitted
 462  * by entries.
 463  */
 464 typedef struct _Elm_Entry_Anchor_Info Elm_Entry_Anchor_Info;
 465
 466 /**
 467  * @struct _Elm_Entry_Anchor_Info
 468  *
 469  * The info sent in the callback for the "anchor,clicked" signals emitted
 470  * by entries.
 471  */
 472 struct _Elm_Entry_Anchor_Info
 473 {
 474    const char *name; /**< The name of the anchor, as stated in its href */
 475    int         button; /**< The mouse button used to click on it */
 476    Evas_Coord  x, /**< Anchor geometry, relative to canvas */
 477                y, /**< Anchor geometry, relative to canvas */
 478                w, /**< Anchor geometry, relative to canvas */
 479                h; /**< Anchor geometry, relative to canvas */
 480 };
 481
 482 /**
 483 <<<<<<< HEAD
 484 =======
 485  * @typedef Elm_Entry_Anchor_Hover_Info
 486  *
 487  * The info sent in the callback for "anchor,clicked" signals emitted by
 488  * the Anchor_Hover widget.
 489  */
 490 typedef struct _Elm_Entry_Anchor_Hover_Info Elm_Entry_Anchor_Hover_Info;
 491
 492 /**
 493  * @struct _Elm_Entry_Anchor_Hover_Info
 494  *
 495  * The info sent in the callback for "anchor,clicked" signals emitted by
 496  * the Anchor_Hover widget.
 497  */
 498 struct _Elm_Entry_Anchor_Hover_Info
 499 {
 500    const Elm_Entry_Anchor_Info *anchor_info; /**< The actual anchor info. */
 501    Evas_Object *hover; /**< The hover object to use for the popup */
 502    struct
 503    {
 504       Evas_Coord x, y, w, h;
 505    } hover_parent; /**< Geometry of the object used as parent by the
 506                         hover */
 507    Eina_Bool    hover_left : 1; /**< Hint indicating if there's space
 508                                      for content on the left side of
 509                                      the hover. Before calling the
 510                                      callback, the widget will make the
 511                                      necessary calculations to check
 512                                      which sides are fit to be set with
 513                                      content, based on the position the
 514                                      hover is activated and its distance
 515                                      to the edges of its parent object
 516                                  */
 517    Eina_Bool    hover_right : 1; /**< Hint indicating content fits on
 518                                       the right side of the hover.
 519                                       See @ref hover_left */
 520    Eina_Bool    hover_top : 1; /**< Hint indicating content fits on top
 521                                     of the hover. See @ref hover_left */
 522    Eina_Bool    hover_bottom : 1; /**< Hint indicating content fits
 523                                        below the hover. See @ref
 524                                        hover_left */
 525 };
 526
 527 /**
 528  * @typedef Elm_Entry_Item_Provider_Cb
 529  * This callback type is used to provide items.
 530  * If it returns an object handle other than NULL (it should create an
 531  * object to do this), then this object is used to replace the current item.
 532  * If not the next provider is called until one provides an item object, or the
 533  * default provider in entry does.
 534  * @param data The data specified as the last param when adding the provider
 535  * @param entry The entry object
 536  * @param text A pointer to the item href string in the text
 537  * @return The object to be placed in the entry like an icon, or other element
 538  * @see elm_entry_item_provider_append
 539  * @see elm_entry_item_provider_prepend
 540  * @see elm_entry_item_provider_remove
 541  */
 542 typedef Evas_Object * (*Elm_Entry_Item_Provider_Cb)(void *data, Evas_Object * entry, const char *item);
 543
 544 /**
 545 >>>>>>> remotes/origin/upstream
 546  * @typedef Elm_Entry_Filter_Cb
 547  * This callback type is used by entry filters to modify text.
 548  * @param data The data specified as the last param when adding the filter
 549  * @param entry The entry object
 550 <<<<<<< HEAD
 551  * @param text A pointer to the location of the text being filtered. This data can be modified,
 552  * but any additional allocations must be managed by the user.
 553  * @see elm_entry_text_filter_append
 554  * @see elm_entry_text_filter_prepend
 555 =======
 556  * @param text A pointer to the location of the text being filtered. The type of text is always markup. This data can be modified, but any additional allocations must be managed by the user.
 557  * @see elm_entry_markup_filter_append
 558  * @see elm_entry_markup_filter_prepend
 559  * @see elm_entry_markup_filter_remove
 560 >>>>>>> remotes/origin/upstream
 561  */
 562 typedef void (*Elm_Entry_Filter_Cb)(void *data, Evas_Object *entry, char **text);
 563
 564 /**
 565  * @typedef Elm_Entry_Change_Info
 566  * This corresponds to Edje_Entry_Change_Info. Includes information about
 567  * a change in the entry.
 568  */
 569 typedef Edje_Entry_Change_Info Elm_Entry_Change_Info;
 570
 571 /**
 572  * This adds an entry to @p parent object.
 573  *
 574  * By default, entries are:
 575  * @li not scrolled
 576  * @li multi-line
 577  * @li word wrapped
 578  * @li autosave is enabled
 579  *
 580  * @param parent The parent object
 581  * @return The new object or NULL if it cannot be created
 582  */
 583 EAPI Evas_Object       *elm_entry_add(Evas_Object *parent);
 584
 585 /**
 586  * Sets the entry to single line mode.
 587  *
 588  * In single line mode, entries don't ever wrap when the text reaches the
 589  * edge, and instead they keep growing horizontally. Pressing the @c Enter
 590  * key will generate an @c "activate" event instead of adding a new line.
 591  *
 592  * When @p single_line is @c EINA_FALSE, line wrapping takes effect again
 593  * and pressing enter will break the text into a different line
 594  * without generating any events.
 595  *
 596  * @param obj The entry object
 597  * @param single_line If true, the text in the entry
 598  * will be on a single line.
 599  */
 600 EAPI void               elm_entry_single_line_set(Evas_Object *obj, Eina_Bool single_line);
 601
 602 /**
 603  * Gets whether the entry is set to be single line.
 604  *
 605  * @param obj The entry object
 606  * @return single_line If true, the text in the entry is set to display
 607  * on a single line.
 608  *
 609  * @see elm_entry_single_line_set()
 610  */
 611 EAPI Eina_Bool          elm_entry_single_line_get(const Evas_Object *obj);
 612
 613 /**
 614  * Sets the entry to password mode.
 615  *
 616  * In password mode, entries are implicitly single line and the display of
 617  * any text in them is replaced with asterisks (*).
 618  *
 619  * @param obj The entry object
 620  * @param password If true, password mode is enabled.
 621  */
 622 EAPI void               elm_entry_password_set(Evas_Object *obj, Eina_Bool password);
 623
 624 /**
 625  * Gets whether the entry is set to password mode.
 626  *
 627  * @param obj The entry object
 628  * @return If true, the entry is set to display all characters
 629  * as asterisks (*).
 630  *
 631  * @see elm_entry_password_set()
 632  */
 633 EAPI Eina_Bool          elm_entry_password_get(const Evas_Object *obj);
 634
 635 /**
 636  * This sets the text displayed within the entry to @p entry.
 637  *
 638  * @param obj The entry object
 639  * @param entry The text to be displayed
 640  *
 641  * @note Using this function bypasses text filters
 642  */
 643 EAPI void               elm_entry_entry_set(Evas_Object *obj, const char *entry);
 644
 645 /**
 646  * This returns the text currently shown in object @p entry.
 647  * See also elm_entry_entry_set().
 648  *
 649  * @param obj The entry object
 650  * @return The currently displayed text or NULL on failure
 651  */
 652 EAPI const char        *elm_entry_entry_get(const Evas_Object *obj);
 653
 654 /**
 655  * Appends @p entry to the text of the entry.
 656  *
 657  * Adds the text in @p entry to the end of any text already present in the
 658  * widget.
 659  *
 660  * The appended text is subject to any filters set for the widget.
 661  *
 662  * @param obj The entry object
 663  * @param entry The text to be displayed
 664  *
 665 <<<<<<< HEAD
 666  * @see elm_entry_text_filter_append()
 667 =======
 668  * @see elm_entry_markup_filter_append()
 669 >>>>>>> remotes/origin/upstream
 670  */
 671 EAPI void               elm_entry_entry_append(Evas_Object *obj, const char *entry);
 672
 673 /**
 674  * Gets whether the entry is empty.
 675  *
 676  * Empty means no text at all. If there are any markup tags, like an item
 677  * tag for which no provider finds anything, and no text is displayed, this
 678  * function still returns EINA_FALSE.
 679  *
 680  * @param obj The entry object
 681  * @return EINA_TRUE if the entry is empty, EINA_FALSE otherwise.
 682  */
 683 EAPI Eina_Bool          elm_entry_is_empty(const Evas_Object *obj);
 684
 685 /**
 686  * Gets any selected text within the entry.
 687  *
 688  * If there's any selected text in the entry, this function returns it as
 689  * a string in markup format. NULL is returned if no selection exists or
 690  * if an error occurred.
 691  *
 692  * The returned value points to an internal string and should not be freed
 693  * or modified in any way. If the @p entry object is deleted or its
 694  * contents are changed, the returned pointer should be considered invalid.
 695  *
 696  * @param obj The entry object
 697  * @return The selected text within the entry or NULL on failure
 698  */
 699 EAPI const char        *elm_entry_selection_get(const Evas_Object *obj);
 700
 701 /**
 702  * Returns the actual textblock object of the entry.
 703  *
 704  * This function exposes the internal textblock object that actually
 705  * contains and draws the text. This should be used for low-level
 706  * manipulations that are otherwise not possible.
 707  *
 708  * Changing the textblock directly from here will not notify edje/elm to
 709  * recalculate the textblock size automatically, so any modifications
 710  * done to the textblock returned by this function should be followed by
 711  * a call to elm_entry_calc_force().
 712  *
 713  * The return value is marked as const as an additional warning.
 714  * One should not use the returned object with any of the generic evas
 715  * functions (geometry_get/resize/move and etc), but only with the textblock
 716  * functions; The former will either not work at all, or break the correct
 717  * functionality.
 718  *
 719  * IMPORTANT: Many functions may change (i.e delete and create a new one)
 720  * the internal textblock object. Do NOT cache the returned object, and try
 721  * not to mix calls on this object with regular elm_entry calls (which may
 722  * change the internal textblock object). This applies to all cursors
 723  * returned from textblock calls, and all the other derivative values.
 724  *
 725  * @param obj The entry object
 726  * @return The textblock object.
 727  */
 728 EAPI Evas_Object *      elm_entry_textblock_get(Evas_Object *obj);
 729
 730 /**
 731  * Forces calculation of the entry size and text layouting.
 732  *
 733  * This should be used after modifying the textblock object directly. See
 734  * elm_entry_textblock_get() for more information.
 735  *
 736  * @param obj The entry object
 737  *
 738  * @see elm_entry_textblock_get()
 739  */
 740 EAPI void               elm_entry_calc_force(Evas_Object *obj);
 741
 742 /**
 743  * Inserts the given text into the entry at the current cursor position.
 744  *
 745  * This inserts text at the cursor position as if it was typed
 746  * by the user (note that this also allows markup which a user
 747  * can't just "type" as it would be converted to escaped text, so this
 748  * call can be used to insert things like emoticon items or bold push/pop
 749  * tags, other font and color change tags etc.)
 750  *
 751  * If any selection exists, it will be replaced by the inserted text.
 752  *
 753  * The inserted text is subject to any filters set for the widget.
 754  *
 755  * @param obj The entry object
 756  * @param entry The text to insert
 757  *
 758 <<<<<<< HEAD
 759  * @see elm_entry_text_filter_append()
 760 =======
 761  * @see elm_entry_markup_filter_append()
 762 >>>>>>> remotes/origin/upstream
 763  */
 764 EAPI void               elm_entry_entry_insert(Evas_Object *obj, const char *entry);
 765
 766 /**
 767  * Set the line wrap type to use on multi-line entries.
 768  *
 769  * Sets the wrap type used by the entry to any of the specified in
 770  * Elm_Wrap_Type. This tells how the text will be implicitly cut into a new
 771  * line (without inserting a line break or paragraph separator) when it
 772  * reaches the far edge of the widget.
 773  *
 774  * Note that this only makes sense for multi-line entries. A widget set
 775  * to be single line will never wrap.
 776  *
 777  * @param obj The entry object
 778  * @param wrap The wrap mode to use. See Elm_Wrap_Type for details on them
 779  */
 780 EAPI void               elm_entry_line_wrap_set(Evas_Object *obj, Elm_Wrap_Type wrap);
 781
 782 /**
 783  * Gets the wrap mode the entry was set to use.
 784  *
 785  * @param obj The entry object
 786  * @return Wrap type
 787  *
 788  * @see also elm_entry_line_wrap_set()
 789  */
 790 EAPI Elm_Wrap_Type      elm_entry_line_wrap_get(const Evas_Object *obj);
 791
 792 /**
 793  * Sets if the entry is to be editable or not.
 794  *
 795  * By default, entries are editable and when focused, any text input by the
 796  * user will be inserted at the current cursor position. But calling this
 797  * function with @p editable as EINA_FALSE will prevent the user from
 798  * inputting text into the entry.
 799  *
 800  * The only way to change the text of a non-editable entry is to use
 801  * elm_object_text_set(), elm_entry_entry_insert() and other related
 802  * functions.
 803  *
 804  * @param obj The entry object
 805  * @param editable If EINA_TRUE, user input will be inserted in the entry,
 806  * if not, the entry is read-only and no user input is allowed.
 807  */
 808 EAPI void               elm_entry_editable_set(Evas_Object *obj, Eina_Bool editable);
 809
 810 /**
 811  * Gets whether the entry is editable or not.
 812  *
 813  * @param obj The entry object
 814  * @return If true, the entry is editable by the user.
 815  * If false, it is not editable by the user
 816  *
 817  * @see elm_entry_editable_set()
 818  */
 819 EAPI Eina_Bool          elm_entry_editable_get(const Evas_Object *obj);
 820
 821 /**
 822  * This drops any existing text selection within the entry.
 823  *
 824  * @param obj The entry object
 825  */
 826 EAPI void               elm_entry_select_none(Evas_Object *obj);
 827
 828 /**
 829  * This selects all text within the entry.
 830  *
 831  * @param obj The entry object
 832  */
 833 EAPI void               elm_entry_select_all(Evas_Object *obj);
 834
 835 /**
 836  * This moves the cursor one place to the right within the entry.
 837  *
 838  * @param obj The entry object
 839  * @return EINA_TRUE upon success, EINA_FALSE upon failure
 840  */
 841 EAPI Eina_Bool          elm_entry_cursor_next(Evas_Object *obj);
 842
 843 /**
 844  * This moves the cursor one place to the left within the entry.
 845  *
 846  * @param obj The entry object
 847  * @return EINA_TRUE upon success, EINA_FALSE upon failure
 848  */
 849 EAPI Eina_Bool          elm_entry_cursor_prev(Evas_Object *obj);
 850
 851 /**
 852  * This moves the cursor one line up within the entry.
 853  *
 854  * @param obj The entry object
 855  * @return EINA_TRUE upon success, EINA_FALSE upon failure
 856  */
 857 EAPI Eina_Bool          elm_entry_cursor_up(Evas_Object *obj);
 858
 859 /**
 860  * This moves the cursor one line down within the entry.
 861  *
 862  * @param obj The entry object
 863  * @return EINA_TRUE upon success, EINA_FALSE upon failure
 864  */
 865 EAPI Eina_Bool          elm_entry_cursor_down(Evas_Object *obj);
 866
 867 /**
 868  * This moves the cursor to the beginning of the entry.
 869  *
 870  * @param obj The entry object
 871  */
 872 EAPI void               elm_entry_cursor_begin_set(Evas_Object *obj);
 873
 874 /**
 875  * This moves the cursor to the end of the entry.
 876  *
 877  * @param obj The entry object
 878  */
 879 EAPI void               elm_entry_cursor_end_set(Evas_Object *obj);
 880
 881 /**
 882  * This moves the cursor to the beginning of the current line.
 883  *
 884  * @param obj The entry object
 885  */
 886 EAPI void               elm_entry_cursor_line_begin_set(Evas_Object *obj);
 887
 888 /**
 889  * This moves the cursor to the end of the current line.
 890  *
 891  * @param obj The entry object
 892  */
 893 EAPI void               elm_entry_cursor_line_end_set(Evas_Object *obj);
 894
 895 /**
 896  * This begins a selection within the entry as though
 897  * the user were holding down the mouse button to make a selection.
 898  *
 899  * @param obj The entry object
 900  */
 901 EAPI void               elm_entry_cursor_selection_begin(Evas_Object *obj);
 902
 903 /**
 904  * This ends a selection within the entry as though
 905  * the user had just released the mouse button while making a selection.
 906  *
 907  * @param obj The entry object
 908  */
 909 EAPI void               elm_entry_cursor_selection_end(Evas_Object *obj);
 910
 911 /**
 912  * Gets whether a format node exists at the current cursor position.
 913  *
 914  * A format node is anything that defines how the text is rendered. It can
 915  * be a visible format node, such as a line break or a paragraph separator,
 916  * or an invisible one, such as bold begin or end tag.
 917  * This function returns whether any format node exists at the current
 918  * cursor position.
 919  *
 920  * @param obj The entry object
 921  * @return EINA_TRUE if the current cursor position contains a format node,
 922  * EINA_FALSE otherwise.
 923  *
 924  * @see elm_entry_cursor_is_visible_format_get()
 925  */
 926 EAPI Eina_Bool          elm_entry_cursor_is_format_get(const Evas_Object *obj);
 927
 928 /**
 929  * Gets if the current cursor position holds a visible format node.
 930  *
 931  * @param obj The entry object
 932  * @return EINA_TRUE if the current cursor is a visible format, EINA_FALSE
 933  * if it's an invisible one or no format exists.
 934  *
 935  * @see elm_entry_cursor_is_format_get()
 936  */
 937 EAPI Eina_Bool          elm_entry_cursor_is_visible_format_get(const Evas_Object *obj);
 938
 939 /**
 940  * Gets the character pointed by the cursor at its current position.
 941  *
 942  * This function returns a string with the utf8 character stored at the
 943  * current cursor position.
 944  * Only the text is returned, any format that may exist will not be part
 945  * of the return value. You must free the string when done with free().
 946  *
 947  * @param obj The entry object
 948  * @return The text pointed by the cursors.
 949  */
 950 EAPI char              *elm_entry_cursor_content_get(const Evas_Object *obj);
 951
 952 /**
 953  * This function returns the geometry of the cursor.
 954  *
 955  * It's useful if you want to draw something on the cursor (or where it is),
 956  * or for example in the case of scrolled entry where you want to show the
 957  * cursor.
 958  *
 959  * @param obj The entry object
 960  * @param x returned geometry
 961  * @param y returned geometry
 962  * @param w returned geometry
 963  * @param h returned geometry
 964  * @return EINA_TRUE upon success, EINA_FALSE upon failure
 965  */
 966 EAPI Eina_Bool          elm_entry_cursor_geometry_get(const Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h);
 967
 968 /**
 969  * Sets the cursor position in the entry to the given value
 970  *
 971  * The value in @p pos is the index of the character position within the
 972  * contents of the string as returned by elm_entry_cursor_pos_get().
 973  *
 974  * @param obj The entry object
 975  * @param pos The position of the cursor
 976  */
 977 EAPI void               elm_entry_cursor_pos_set(Evas_Object *obj, int pos);
 978
 979 /**
 980  * Retrieves the current position of the cursor in the entry
 981  *
 982  * @param obj The entry object
 983  * @return The cursor position
 984  */
 985 EAPI int                elm_entry_cursor_pos_get(const Evas_Object *obj);
 986
 987 /**
 988  * This executes a "cut" action on the selected text in the entry.
 989  *
 990  * @param obj The entry object
 991  */
 992 EAPI void               elm_entry_selection_cut(Evas_Object *obj);
 993
 994 /**
 995  * This executes a "copy" action on the selected text in the entry.
 996  *
 997  * @param obj The entry object
 998  */
 999 EAPI void               elm_entry_selection_copy(Evas_Object *obj);
1000
1001 /**
1002  * This executes a "paste" action in the entry.
1003  *
1004  * @param obj The entry object
1005  */
1006 EAPI void               elm_entry_selection_paste(Evas_Object *obj);
1007
1008 /**
1009  * This clears and frees the items in a entry's contextual (longpress)
1010  * menu.
1011  *
1012  * @param obj The entry object
1013  *
1014  * @see elm_entry_context_menu_item_add()
1015  */
1016 EAPI void               elm_entry_context_menu_clear(Evas_Object *obj);
1017
1018 /**
1019  * This adds an item to the entry's contextual menu.
1020  *
1021  * A longpress on an entry will make the contextual menu show up, if this
1022  * hasn't been disabled with elm_entry_context_menu_disabled_set().
1023  * By default, this menu provides a few options like enabling selection mode,
1024  * which is useful on embedded devices that need to be explicit about it,
1025  * and when a selection exists it also shows the copy and cut actions.
1026  *
1027  * With this function, developers can add other options to this menu to
1028  * perform any action they deem necessary.
1029  *
1030  * @param obj The entry object
1031  * @param label The item's text label
1032  * @param icon_file The item's icon file
1033  * @param icon_type The item's icon type
1034  * @param func The callback to execute when the item is clicked
1035  * @param data The data to associate with the item for related functions
1036  */
1037 EAPI void               elm_entry_context_menu_item_add(Evas_Object *obj, const char *label, const char *icon_file, Elm_Icon_Type icon_type, Evas_Smart_Cb func, const void *data);
1038
1039 /**
1040  * This disables the entry's contextual (longpress) menu.
1041  *
1042  * @param obj The entry object
1043  * @param disabled If true, the menu is disabled
1044  */
1045 EAPI void               elm_entry_context_menu_disabled_set(Evas_Object *obj, Eina_Bool disabled);
1046
1047 /**
1048  * This returns whether the entry's contextual (longpress) menu is
1049  * disabled.
1050  *
1051  * @param obj The entry object
1052  * @return If true, the menu is disabled
1053  */
1054 EAPI Eina_Bool          elm_entry_context_menu_disabled_get(const Evas_Object *obj);
1055
1056 /**
1057 <<<<<<< HEAD
1058  * This disables the entry's magnifer feature.
1059  *
1060  * @param obj The entry object
1061  * @param disabled If true, the magnifier is not displayed
1062  */
1063
1064 EAPI void         elm_entry_magnifier_disabled_set(Evas_Object *obj, Eina_Bool disabled);
1065 /**
1066  * This returns whether the entry's magnifier feature is disabled.
1067  *
1068  * @param obj The entry object
1069  * @return If true, the feature is disabled
1070  */
1071 EAPI Eina_Bool    elm_entry_magnifier_disabled_get(const Evas_Object *obj);
1072
1073 /**
1074 =======
1075 >>>>>>> remotes/origin/upstream
1076  * This appends a custom item provider to the list for that entry
1077  *
1078  * This appends the given callback. The list is walked from beginning to end
1079  * with each function called given the item href string in the text. If the
1080  * function returns an object handle other than NULL (it should create an
1081  * object to do this), then this object is used to replace that item. If
1082  * not the next provider is called until one provides an item object, or the
1083  * default provider in entry does.
1084  *
1085  * @param obj The entry object
1086  * @param func The function called to provide the item object
1087  * @param data The data passed to @p func
1088  *
1089  * @see @ref entry-items
1090  */
1091 <<<<<<< HEAD
1092 EAPI void               elm_entry_item_provider_append(Evas_Object *obj, Evas_Object * (*func)(void *data, Evas_Object * entry, const char *item), void *data);
1093 =======
1094 EAPI void               elm_entry_item_provider_append(Evas_Object *obj, Elm_Entry_Item_Provider_Cb func, void *data);
1095 >>>>>>> remotes/origin/upstream
1096
1097 /**
1098  * This prepends a custom item provider to the list for that entry
1099  *
1100  * This prepends the given callback. See elm_entry_item_provider_append() for
1101  * more information
1102  *
1103  * @param obj The entry object
1104  * @param func The function called to provide the item object
1105  * @param data The data passed to @p func
1106  */
1107 <<<<<<< HEAD
1108 EAPI void               elm_entry_item_provider_prepend(Evas_Object *obj, Evas_Object * (*func)(void *data, Evas_Object * entry, const char *item), void *data);
1109 =======
1110 EAPI void               elm_entry_item_provider_prepend(Evas_Object *obj, Elm_Entry_Item_Provider_Cb func, void *data);
1111 >>>>>>> remotes/origin/upstream
1112
1113 /**
1114  * This removes a custom item provider to the list for that entry
1115  *
1116  * This removes the given callback. See elm_entry_item_provider_append() for
1117  * more information
1118  *
1119  * @param obj The entry object
1120  * @param func The function called to provide the item object
1121  * @param data The data passed to @p func
1122  */
1123 <<<<<<< HEAD
1124 EAPI void               elm_entry_item_provider_remove(Evas_Object *obj, Evas_Object * (*func)(void *data, Evas_Object * entry, const char *item), void *data);
1125
1126 /**
1127  * Append a filter function for text inserted in the entry
1128  *
1129  * Append the given callback to the list. This functions will be called
1130  * whenever any text is inserted into the entry, with the text to be inserted
1131  * as a parameter. The callback function is free to alter the text in any way
1132  * it wants, but it must remember to free the given pointer and update it.
1133 =======
1134 EAPI void               elm_entry_item_provider_remove(Evas_Object *obj, Elm_Entry_Item_Provider_Cb func, void *data);
1135
1136 /**
1137  * Append a markup filter function for text inserted in the entry
1138  *
1139  * Append the given callback to the list. This functions will be called
1140  * whenever any text is inserted into the entry, with the text to be inserted
1141  * as a parameter. The type of given text is always markup.
1142  * The callback function is free to alter the text in any way it wants, but
1143  * it must remember to free the given pointer and update it.
1144 >>>>>>> remotes/origin/upstream
1145  * If the new text is to be discarded, the function can free it and set its
1146  * text parameter to NULL. This will also prevent any following filters from
1147  * being called.
1148  *
1149  * @param obj The entry object
1150  * @param func The function to use as text filter
1151  * @param data User data to pass to @p func
1152  */
1153 <<<<<<< HEAD
1154 EAPI void               elm_entry_text_filter_append(Evas_Object *obj, Elm_Entry_Filter_Cb func, void *data);
1155
1156 /**
1157  * Prepend a filter function for text insdrted in the entry
1158  *
1159  * Prepend the given callback to the list. See elm_entry_text_filter_append()
1160 =======
1161 EAPI void               elm_entry_markup_filter_append(Evas_Object *obj, Elm_Entry_Filter_Cb func, void *data);
1162
1163 /**
1164  * Prepend a markup filter function for text inserted in the entry
1165  *
1166  * Prepend the given callback to the list. See elm_entry_markup_filter_append()
1167 >>>>>>> remotes/origin/upstream
1168  * for more information
1169  *
1170  * @param obj The entry object
1171  * @param func The function to use as text filter
1172  * @param data User data to pass to @p func
1173  */
1174 <<<<<<< HEAD
1175 EAPI void               elm_entry_text_filter_prepend(Evas_Object *obj, Elm_Entry_Filter_Cb func, void *data);
1176
1177 /**
1178  * Remove a filter from the list
1179  *
1180  * Removes the given callback from the filter list. See
1181  * elm_entry_text_filter_append() for more information.
1182 =======
1183 EAPI void               elm_entry_markup_filter_prepend(Evas_Object *obj, Elm_Entry_Filter_Cb func, void *data);
1184
1185 /**
1186  * Remove a markup filter from the list
1187  *
1188  * Removes the given callback from the filter list. See
1189  * elm_entry_markup_filter_append() for more information.
1190 >>>>>>> remotes/origin/upstream
1191  *
1192  * @param obj The entry object
1193  * @param func The filter function to remove
1194  * @param data The user data passed when adding the function
1195  */
1196 <<<<<<< HEAD
1197 EAPI void               elm_entry_text_filter_remove(Evas_Object *obj, Elm_Entry_Filter_Cb func, void *data);
1198 =======
1199 EAPI void               elm_entry_markup_filter_remove(Evas_Object *obj, Elm_Entry_Filter_Cb func, void *data);
1200 >>>>>>> remotes/origin/upstream
1201
1202 /**
1203  * This converts a markup (HTML-like) string into UTF-8.
1204  *
1205  * The returned string is a malloc'ed buffer and it should be freed when
1206  * not needed anymore.
1207  *
1208  * @param s The string (in markup) to be converted
1209  * @return The converted string (in UTF-8). It should be freed.
1210  */
1211 EAPI char              *elm_entry_markup_to_utf8(const char *s);
1212
1213 /**
1214  * This converts a UTF-8 string into markup (HTML-like).
1215  *
1216  * The returned string is a malloc'ed buffer and it should be freed when
1217  * not needed anymore.
1218  *
1219  * @param s The string (in UTF-8) to be converted
1220  * @return The converted string (in markup). It should be freed.
1221  */
1222 EAPI char              *elm_entry_utf8_to_markup(const char *s);
1223
1224 /**
1225  * This sets the file (and implicitly loads it) for the text to display and
1226  * then edit. All changes are written back to the file after a short delay if
1227  * the entry object is set to autosave (which is the default).
1228  *
1229  * If the entry had any other file set previously, any changes made to it
1230  * will be saved if the autosave feature is enabled, otherwise, the file
1231  * will be silently discarded and any non-saved changes will be lost.
1232  *
1233  * @param obj The entry object
1234  * @param file The path to the file to load and save
1235  * @param format The file format
1236 <<<<<<< HEAD
1237  */
1238 EAPI void               elm_entry_file_set(Evas_Object *obj, const char *file, Elm_Text_Format format);
1239 =======
1240  * @return @c EINA_TRUE on success, @c EINA_FALSE otherwise
1241  */
1242 EAPI Eina_Bool          elm_entry_file_set(Evas_Object *obj, const char *file, Elm_Text_Format format);
1243 >>>>>>> remotes/origin/upstream
1244
1245 /**
1246  * Gets the file being edited by the entry.
1247  *
1248  * This function can be used to retrieve any file set on the entry for
1249  * edition, along with the format used to load and save it.
1250  *
1251  * @param obj The entry object
1252  * @param file The path to the file to load and save
1253  * @param format The file format
1254  */
1255 EAPI void               elm_entry_file_get(const Evas_Object *obj, const char **file, Elm_Text_Format *format);
1256
1257 /**
1258  * This function writes any changes made to the file set with
1259  * elm_entry_file_set()
1260  *
1261  * @param obj The entry object
1262  */
1263 EAPI void               elm_entry_file_save(Evas_Object *obj);
1264
1265 /**
1266  * This sets the entry object to 'autosave' the loaded text file or not.
1267  *
1268  * @param obj The entry object
1269  * @param autosave Autosave the loaded file or not
1270  *
1271  * @see elm_entry_file_set()
1272  */
1273 EAPI void               elm_entry_autosave_set(Evas_Object *obj, Eina_Bool autosave);
1274
1275 /**
1276  * This gets the entry object's 'autosave' status.
1277  *
1278  * @param obj The entry object
1279  * @return Autosave the loaded file or not
1280  *
1281  * @see elm_entry_file_set()
1282  */
1283 EAPI Eina_Bool          elm_entry_autosave_get(const Evas_Object *obj);
1284
1285 /**
1286 <<<<<<< HEAD
1287  * Control pasting of text and images for the widget.
1288  *
1289  * Normally the entry allows both text and images to be pasted.
1290  * By setting textonly to be ELM_CNP_MODE_NO_IMAGE, this prevents images from being copy or past.
1291  * By setting textonly to be ELM_CNP_MODE_PLAINTEXT, this remove all tags in text .
1292  *
1293  * @note this only changes the behaviour of text.
1294  *
1295  * @param obj The entry object
1296  * @param mode One of #Elm_CNP_Mode: #ELM_CNP_MODE_MARKUP,
1297  * #ELM_CNP_MODE_NO_IMAGE, #ELM_CNP_MODE_PLAINTEXT.
1298  */
1299 EAPI void         elm_entry_cnp_mode_set(Evas_Object *obj, Elm_CNP_Mode cnp_mode);
1300
1301 /**
1302  * Getting elm_entry text paste/drop mode.
1303  *
1304  * Normally the entry allows both text and images to be pasted.
1305  * This gets the copy & paste mode of the entry.
1306  *
1307  * @param obj The entry object
1308  * @return mode One of #Elm_CNP_Mode: #ELM_CNP_MODE_MARKUP,
1309  * #ELM_CNP_MODE_NO_IMAGE, #ELM_CNP_MODE_PLAINTEXT.
1310  */
1311 EAPI Elm_CNP_Mode elm_entry_cnp_mode_get(const Evas_Object *obj);
1312
1313 /**
1314  * Control pasting of text and images for the widget.
1315  *
1316  * Normally the entry allows both text and images to be pasted.  By setting
1317  * textonly to be true, this prevents images from being pasted.
1318  *
1319  * Note this only changes the behaviour of text.
1320  *
1321  * @param obj The entry object
1322  * @param textonly paste mode - EINA_TRUE is text only, EINA_FALSE is
1323  * text+image+other.
1324  */
1325
1326 /**
1327  * Control pasting of text and images for the widget.
1328  *
1329  * Normally the entry allows both text and images to be pasted.  By setting
1330  * textonly to be true, this prevents images from being pasted.
1331  *
1332  * Note this only changes the behaviour of text.
1333  *
1334  * @param obj The entry object
1335  * @param textonly paste mode - EINA_TRUE is text only, EINA_FALSE is
1336  * text+image+other.
1337  */
1338 EAPI void               elm_entry_cnp_textonly_set(Evas_Object *obj, Eina_Bool textonly);
1339
1340 /**
1341  * Getting elm_entry text paste/drop mode.
1342  *
1343  * In textonly mode, only text may be pasted or dropped into the widget.
1344  *
1345  * @param obj The entry object
1346  * @return If the widget only accepts text from pastes.
1347  */
1348 EAPI Eina_Bool          elm_entry_cnp_textonly_get(const Evas_Object *obj);
1349
1350 /**
1351 =======
1352 >>>>>>> remotes/origin/upstream
1353  * Enable or disable scrolling in entry
1354  *
1355  * Normally the entry is not scrollable unless you enable it with this call.
1356  *
1357  * @param obj The entry object
1358  * @param scroll EINA_TRUE if it is to be scrollable, EINA_FALSE otherwise
1359  */
1360 EAPI void               elm_entry_scrollable_set(Evas_Object *obj, Eina_Bool scroll);
1361
1362 /**
1363  * Get the scrollable state of the entry
1364  *
1365  * Normally the entry is not scrollable. This gets the scrollable state
1366  * of the entry. See elm_entry_scrollable_set() for more information.
1367  *
1368  * @param obj The entry object
1369  * @return The scrollable state
1370  */
1371 EAPI Eina_Bool          elm_entry_scrollable_get(const Evas_Object *obj);
1372
1373 /**
1374 <<<<<<< HEAD
1375  * Sets the visibility of the left-side widget of the scrolled entry,
1376  * set by elm_entry_icon_set().
1377  *
1378  * @param obj The scrolled entry object
1379 =======
1380  * Sets the visibility of the left-side widget of the entry,
1381  * set by elm_entry_icon_set().
1382  *
1383  * @param obj The entry object
1384 >>>>>>> remotes/origin/upstream
1385  * @param setting EINA_TRUE if the object should be displayed,
1386  * EINA_FALSE if not.
1387  */
1388 EAPI void               elm_entry_icon_visible_set(Evas_Object *obj, Eina_Bool setting);
1389
1390 /**
1391 <<<<<<< HEAD
1392  * Sets the visibility of the end widget of the scrolled entry, set by
1393  * elm_object_part_content_set(ent, "end", content).
1394  *
1395  * @param obj The scrolled entry object
1396 =======
1397  * Sets the visibility of the end widget of the entry, set by
1398  * elm_object_part_content_set(ent, "end", content).
1399  *
1400  * @param obj The entry object
1401 >>>>>>> remotes/origin/upstream
1402  * @param setting EINA_TRUE if the object should be displayed,
1403  * EINA_FALSE if not.
1404  */
1405 EAPI void               elm_entry_end_visible_set(Evas_Object *obj, Eina_Bool setting);
1406
1407 /**
1408 <<<<<<< HEAD
1409  * This sets the scrolled entry's scrollbar policy (ie. enabling/disabling
1410 =======
1411  * This sets the entry's scrollbar policy (i.e. enabling/disabling
1412 >>>>>>> remotes/origin/upstream
1413  * them).
1414  *
1415  * Setting an entry to single-line mode with elm_entry_single_line_set()
1416  * will automatically disable the display of scrollbars when the entry
1417  * moves inside its scroller.
1418  *
1419 <<<<<<< HEAD
1420  * @param obj The scrolled entry object
1421 =======
1422  * @param obj The entry object
1423 >>>>>>> remotes/origin/upstream
1424  * @param h The horizontal scrollbar policy to apply
1425  * @param v The vertical scrollbar policy to apply
1426  */
1427 EAPI void               elm_entry_scrollbar_policy_set(Evas_Object *obj, Elm_Scroller_Policy h, Elm_Scroller_Policy v);
1428
1429 /**
1430  * This enables/disables bouncing within the entry.
1431  *
1432  * This function sets whether the entry will bounce when scrolling reaches
1433  * the end of the contained entry.
1434  *
1435 <<<<<<< HEAD
1436  * @param obj The scrolled entry object
1437 =======
1438  * @param obj The entry object
1439 >>>>>>> remotes/origin/upstream
1440  * @param h_bounce The horizontal bounce state
1441  * @param v_bounce The vertical bounce state
1442  */
1443 EAPI void               elm_entry_bounce_set(Evas_Object *obj, Eina_Bool h_bounce, Eina_Bool v_bounce);
1444
1445 /**
1446  * Get the bounce mode
1447  *
1448  * @param obj The Entry object
1449  * @param h_bounce Allow bounce horizontally
1450  * @param v_bounce Allow bounce vertically
1451  */
1452 EAPI void               elm_entry_bounce_get(const Evas_Object *obj, Eina_Bool *h_bounce, Eina_Bool *v_bounce);
1453
1454 /**
1455  * Set the input panel layout of the entry
1456  *
1457  * @param obj The entry object
1458  * @param layout layout type
1459  */
1460 EAPI void                   elm_entry_input_panel_layout_set(Evas_Object *obj, Elm_Input_Panel_Layout layout);
1461
1462 /**
1463  * Get the input panel layout of the entry
1464  *
1465  * @param obj The entry object
1466  * @return layout type
1467  *
1468  * @see elm_entry_input_panel_layout_set
1469  */
1470 EAPI Elm_Input_Panel_Layout elm_entry_input_panel_layout_get(const Evas_Object *obj);
1471
1472 /**
1473  * Set the autocapitalization type on the immodule.
1474  *
1475  * @param obj The entry object
1476  * @param autocapital_type The type of autocapitalization
1477  */
1478 EAPI void                   elm_entry_autocapital_type_set(Evas_Object *obj, Elm_Autocapital_Type autocapital_type);
1479
1480 /**
1481  * Retrieve the autocapitalization type on the immodule.
1482  *
1483  * @param obj The entry object
1484  * @return autocapitalization type
1485  */
1486 EAPI Elm_Autocapital_Type   elm_entry_autocapital_type_get(const Evas_Object *obj);
1487
1488 /**
1489  * Sets the attribute to show the input panel automatically.
1490  *
1491  * @param obj The entry object
1492  * @param enabled If true, the input panel is appeared when entry is clicked or has a focus
1493  */
1494 EAPI void                   elm_entry_input_panel_enabled_set(Evas_Object *obj, Eina_Bool enabled);
1495
1496 /**
1497  * Retrieve the attribute to show the input panel automatically.
1498  *
1499  * @param obj The entry object
1500  * @return EINA_TRUE if input panel will be appeared when the entry is clicked or has a focus, EINA_FALSE otherwise
1501  */
1502 EAPI Eina_Bool              elm_entry_input_panel_enabled_get(const Evas_Object *obj);
1503
1504 /**
1505  * Show the input panel (virtual keyboard) based on the input panel property of entry such as layout, autocapital types, and so on.
1506  *
1507  * Note that input panel is shown or hidden automatically according to the focus state of entry widget.
1508 <<<<<<< HEAD
1509  * This API can be used in the case of manually controling by using elm_entry_input_panel_enabled_set(en, EINA_FALSE)
1510 =======
1511  * This API can be used in the case of manually controlling by using elm_entry_input_panel_enabled_set(en, EINA_FALSE).
1512 >>>>>>> remotes/origin/upstream
1513  *
1514  * @param obj The entry object
1515  */
1516 EAPI void                   elm_entry_input_panel_show(Evas_Object *obj);
1517
1518 /**
1519  * Hide the input panel (virtual keyboard).
1520  *
1521  * Note that input panel is shown or hidden automatically according to the focus state of entry widget.
1522 <<<<<<< HEAD
1523  * This API can be used in the case of manually controling by using elm_entry_input_panel_enabled_set(en, EINA_FALSE)
1524 =======
1525  * This API can be used in the case of manually controlling by using elm_entry_input_panel_enabled_set(en, EINA_FALSE)
1526 >>>>>>> remotes/origin/upstream
1527  *
1528  * @param obj The entry object
1529  */
1530 EAPI void                   elm_entry_input_panel_hide(Evas_Object *obj);
1531
1532 /**
1533  * Set the language mode of the input panel.
1534  *
1535  * This API can be used if you want to show the alphabet keyboard mode.
1536  *
1537  * @param obj The entry object
1538  * @param lang language to be set to the input panel.
1539  */
1540 EAPI void                   elm_entry_input_panel_language_set(Evas_Object *obj, Elm_Input_Panel_Lang lang);
1541
1542 /**
1543  * Get the language mode of the input panel.
1544  *
1545  * See @ref elm_entry_input_panel_language_set for more details.
1546  *
1547  * @param obj The entry object
1548  * @return input panel language type
1549  */
1550 EAPI Elm_Input_Panel_Lang   elm_entry_input_panel_language_get(const Evas_Object *obj);
1551
1552 /**
1553  * Set the input panel-specific data to deliver to the input panel.
1554  *
1555  * This API is used by applications to deliver specific data to the input panel.
1556  * The data format MUST be negotiated by both application and the input panel.
1557  * The size and format of data are defined by the input panel.
1558  *
1559  * @param obj The entry object
1560  * @param data The specific data to be set to the input panel.
1561  * @param len the length of data, in bytes, to send to the input panel
1562  */
1563 EAPI void                   elm_entry_input_panel_imdata_set(Evas_Object *obj, const void *data, int len);
1564
1565 /**
1566  * Get the specific data of the current input panel.
1567  *
1568  * See @ref elm_entry_input_panel_imdata_set for more details.
1569  *
1570  * @param obj The entry object
1571  * @param data The specific data to be got from the input panel
1572  * @param len The length of data
1573  */
1574 EAPI void                   elm_entry_input_panel_imdata_get(const Evas_Object *obj, void *data, int *len);
1575
1576 /**
1577  * Set the "return" key type. This type is used to set string or icon on the "return" key of the input panel.
1578  *
1579  * An input panel displays the string or icon associated with this type
1580  *
1581  * @param obj The entry object
1582  * @param return_key_type The type of "return" key on the input panel
1583  */
1584 EAPI void                   elm_entry_input_panel_return_key_type_set(Evas_Object *obj, Elm_Input_Panel_Return_Key_Type return_key_type);
1585
1586 /**
1587  * Get the "return" key type.
1588  *
1589  * @see elm_entry_input_panel_return_key_type_set() for more details
1590  *
1591  * @param obj The entry object
1592  * @return The type of "return" key on the input panel
1593  */
1594 EAPI Elm_Input_Panel_Return_Key_Type elm_entry_input_panel_return_key_type_get(const Evas_Object *obj);
1595
1596 /**
1597  * Set the return key on the input panel to be disabled.
1598  *
1599  * @param obj The entry object
1600  * @param disabled The state to put in in: @c EINA_TRUE for
1601  *        disabled, @c EINA_FALSE for enabled
1602  */
1603 EAPI void                   elm_entry_input_panel_return_key_disabled_set(Evas_Object *obj, Eina_Bool disabled);
1604
1605 /**
1606  * Get whether the return key on the input panel should be disabled or not.
1607  *
1608  * @param obj The entry object
1609  * @return EINA_TRUE if it should be disabled
1610  */
1611 EAPI Eina_Bool              elm_entry_input_panel_return_key_disabled_get(const Evas_Object *obj);
1612
1613 /**
1614  * Set whether the return key on the input panel is disabled automatically when entry has no text.
1615  *
1616 <<<<<<< HEAD
1617  * If @p on is EINA_TRUE, The return key on input panel is disabled when the entry has no text.
1618  * The return Key on the input panel is automatically enabled when the entry has text.
1619  * The default value is EINA_FALSE.
1620  *
1621  * @param obj The entry object
1622  * @param on If @p on is EINA_TRUE, the return key is automatically disabled when the entry has no text.
1623  */
1624 EAPI void                   elm_entry_input_panel_return_key_autoenabled_set(Evas_Object *obj, Eina_Bool on);
1625 =======
1626  * If @p enabled is EINA_TRUE, The return key on input panel is disabled when the entry has no text.
1627  * The return key on the input panel is automatically enabled when the entry has text.
1628  * The default value is EINA_FALSE.
1629  *
1630  * @param obj The entry object
1631  * @param enabled If @p enabled is EINA_TRUE, the return key is automatically disabled when the entry has no text.
1632  */
1633 EAPI void                   elm_entry_input_panel_return_key_autoenabled_set(Evas_Object *obj, Eina_Bool enabled);
1634 >>>>>>> remotes/origin/upstream
1635
1636 /**
1637  * Reset the input method context of the entry if needed.
1638  *
1639  * This can be necessary in the case where modifying the buffer would confuse on-going input method behavior
1640  * @param obj The entry object
1641  */
1642 EAPI void                   elm_entry_imf_context_reset(Evas_Object *obj);
1643
1644 /**
1645  * Set whether the entry should allow to use the text prediction.
1646  *
1647  * @param obj The entry object
1648  * @param prediction Whether the entry should allow to use the text prediction.
1649  */
1650 EAPI void                   elm_entry_prediction_allow_set(Evas_Object *obj, Eina_Bool prediction);
1651
1652 /**
1653  * Get whether the entry should allow to use the text prediction.
1654  *
1655  * @param obj The entry object
1656  * @return EINA_TRUE if it allows to use the text prediction, otherwise EINA_FALSE.
1657  */
1658 EAPI Eina_Bool              elm_entry_prediction_allow_get(const Evas_Object *obj);
1659
1660 /* pre-made filters for entries */
1661
1662 /**
1663  * @typedef Elm_Entry_Filter_Limit_Size
1664  *
1665  * Data for the elm_entry_filter_limit_size() entry filter.
1666  */
1667 typedef struct _Elm_Entry_Filter_Limit_Size Elm_Entry_Filter_Limit_Size;
1668
1669 /**
1670  * @struct _Elm_Entry_Filter_Limit_Size
1671  *
1672  * Data for the elm_entry_filter_limit_size() entry filter.
1673  */
1674 struct _Elm_Entry_Filter_Limit_Size
1675 {
1676    int max_char_count;      /**< The maximum number of characters allowed. */
1677    int max_byte_count;      /**< The maximum number of bytes allowed*/
1678 };
1679
1680 /**
1681  * Filter inserted text based on user defined character and byte limits
1682  *
1683  * Add this filter to an entry to limit the characters that it will accept
1684  * based the the contents of the provided #Elm_Entry_Filter_Limit_Size.
1685 <<<<<<< HEAD
1686  * The funtion works on the UTF-8 representation of the string, converting
1687 =======
1688  * The function works on the UTF-8 representation of the string, converting
1689 >>>>>>> remotes/origin/upstream
1690  * it from the set markup, thus not accounting for any format in it.
1691  *
1692  * The user must create an #Elm_Entry_Filter_Limit_Size structure and pass
1693  * it as data when setting the filter. In it, it's possible to set limits
1694  * by character count or bytes (any of them is disabled if 0), and both can
1695  * be set at the same time. In that case, it first checks for characters,
1696 <<<<<<< HEAD
1697  * then bytes.
1698 =======
1699  * then bytes. The #Elm_Entry_Filter_Limit_Size structure must be alive and
1700  * valid for as long as the entry is alive AND the elm_entry_filter_limit_size
1701  * filter is set.
1702 >>>>>>> remotes/origin/upstream
1703  *
1704  * The function will cut the inserted text in order to allow only the first
1705  * number of characters that are still allowed. The cut is made in
1706  * characters, even when limiting by bytes, in order to always contain
1707  * valid ones and avoid half unicode characters making it in.
1708  *
1709  * This filter, like any others, does not apply when setting the entry text
1710  * directly with elm_object_text_set().
1711  */
1712 EAPI void elm_entry_filter_limit_size(void *data, Evas_Object *entry, char **text);
1713
1714 /**
1715  * @typedef Elm_Entry_Filter_Accept_Set
1716  *
1717  * Data for the elm_entry_filter_accept_set() entry filter.
1718  */
1719 typedef struct _Elm_Entry_Filter_Accept_Set Elm_Entry_Filter_Accept_Set;
1720
1721 /**
1722  * @struct _Elm_Entry_Filter_Accept_Set
1723  *
1724  * Data for the elm_entry_filter_accept_set() entry filter.
1725  */
1726 struct _Elm_Entry_Filter_Accept_Set
1727 {
1728    const char *accepted;      /**< Set of characters accepted in the entry. */
1729    const char *rejected;      /**< Set of characters rejected from the entry. */
1730 };
1731
1732 /**
1733  * Filter inserted text based on accepted or rejected sets of characters
1734  *
1735  * Add this filter to an entry to restrict the set of accepted characters
1736  * based on the sets in the provided #Elm_Entry_Filter_Accept_Set.
1737  * This structure contains both accepted and rejected sets, but they are
1738 <<<<<<< HEAD
1739  * mutually exclusive.
1740 =======
1741  * mutually exclusive. This structure must be available for as long as
1742  * the entry is alive AND the elm_entry_filter_accept_set is being used.
1743 >>>>>>> remotes/origin/upstream
1744  *
1745  * The @c accepted set takes preference, so if it is set, the filter will
1746  * only work based on the accepted characters, ignoring anything in the
1747  * @c rejected value. If @c accepted is @c NULL, then @c rejected is used.
1748  *
1749  * In both cases, the function filters by matching utf8 characters to the
1750  * raw markup text, so it can be used to remove formatting tags.
1751  *
1752  * This filter, like any others, does not apply when setting the entry text
1753  * directly with elm_object_text_set()
1754  */
1755 EAPI void                   elm_entry_filter_accept_set(void *data, Evas_Object *entry, char **text);
1756
1757 <<<<<<< HEAD
1758 EAPI Ecore_IMF_Context     *elm_entry_imf_context_get(Evas_Object *obj);
1759 EAPI void                   elm_entry_magnifier_type_set(Evas_Object *obj, int type);
1760 =======
1761 /**
1762  * Returns the input method context of the entry.
1763  *
1764  * This function exposes the internal input method context.
1765  *
1766  * IMPORTANT: Many functions may change (i.e delete and create a new one)
1767  * the internal input method context. Do NOT cache the returned object.
1768  *
1769  * @param obj The entry object
1770  * @return The input method context (Ecore_IMF_Context *) in entry.
1771  */
1772 EAPI void                  *elm_entry_imf_context_get(Evas_Object *obj);
1773
1774 /**
1775  * @enum _Elm_Cnp_Mode
1776  * @typedef Elm_Cnp_Mode
1777  * Enum of entry's copy & paste policy.
1778  *
1779  * @see elm_entry_cnp_mode_set()
1780  * @see elm_entry_cnp_mode_get()
1781  */
1782 typedef enum _Elm_Cnp_Mode {
1783    ELM_CNP_MODE_MARKUP,   /**< copy & paste text with markup tag */
1784    ELM_CNP_MODE_NO_IMAGE, /**< copy & paste text without item(image) tag */
1785    ELM_CNP_MODE_PLAINTEXT /**< copy & paste text without markup tag */
1786 } Elm_Cnp_Mode;
1787
1788 /**
1789  * Control pasting of text and images for the widget.
1790  *
1791  * Normally the entry allows both text and images to be pasted.
1792  * By setting cnp_mode to be ELM_CNP_MODE_NO_IMAGE, this prevents images from being copy or past.
1793  * By setting cnp_mode to be ELM_CNP_MODE_PLAINTEXT, this remove all tags in text .
1794  *
1795  * @note this only changes the behaviour of text.
1796  *
1797  * @param obj The entry object
1798  * @param mode One of #Elm_Cnp_Mode: #ELM_CNP_MODE_MARKUP,
1799  * #ELM_CNP_MODE_NO_IMAGE, #ELM_CNP_MODE_PLAINTEXT.
1800  */
1801 EAPI void         elm_entry_cnp_mode_set(Evas_Object *obj, Elm_Cnp_Mode cnp_mode);
1802
1803 /**
1804  * Getting elm_entry text paste/drop mode.
1805  *
1806  * Normally the entry allows both text and images to be pasted.
1807  * This gets the copy & paste mode of the entry.
1808  *
1809  * @param obj The entry object
1810  * @return mode One of #Elm_Cnp_Mode: #ELM_CNP_MODE_MARKUP,
1811  * #ELM_CNP_MODE_NO_IMAGE, #ELM_CNP_MODE_PLAINTEXT.
1812  */
1813 EAPI Elm_Cnp_Mode elm_entry_cnp_mode_get(const Evas_Object *obj);
1814
1815 /**
1816  * Set the parent of the hover popup
1817  *
1818  * Sets the parent object to use by the hover created by the entry
1819  * when an anchor is clicked. See @ref Hover for more details on this.
1820  *
1821  * @param obj The entry object
1822  * @param parent The object to use as parent for the hover
1823  */
1824 EAPI void                        elm_entry_anchor_hover_parent_set(Evas_Object *obj, Evas_Object *parent);
1825
1826 /**
1827  * Get the parent of the hover popup
1828  *
1829  * Get the object used as parent for the hover created by the entry
1830  * widget. See @ref Hover for more details on this.
1831  * If no parent is set, the same entry object will be used.
1832  *
1833  * @param obj The entry object
1834  * @return The object used as parent for the hover, NULL if none is set.
1835  */
1836 EAPI Evas_Object                *elm_entry_anchor_hover_parent_get(const Evas_Object *obj);
1837
1838 /**
1839  * Set the style that the hover should use
1840  *
1841  * When creating the popup hover, entry will request that it's
1842  * themed according to @p style.
1843  *
1844  * Setting style no NULL means disabling automatic hover.
1845  *
1846  * @param obj The entry object
1847  * @param style The style to use for the underlying hover
1848  *
1849  * @see elm_object_style_set()
1850  */
1851 EAPI void                        elm_entry_anchor_hover_style_set(Evas_Object *obj, const char *style);
1852
1853 /**
1854  * Get the style that the hover should use
1855  *
1856  * Get the style, the hover created by entry will use.
1857  *
1858  * @param obj The entry object
1859  * @return The style to use by the hover. NULL means the default is used.
1860  *
1861  * @see elm_object_style_set()
1862  */
1863 EAPI const char                 *elm_entry_anchor_hover_style_get(const Evas_Object *obj);
1864
1865 /**
1866  * Ends the hover popup in the entry
1867  *
1868  * When an anchor is clicked, the entry widget will create a hover
1869  * object to use as a popup with user provided content. This function
1870  * terminates this popup, returning the entry to its normal state.
1871  *
1872  * @param obj The entry object
1873  */
1874 EAPI void                        elm_entry_anchor_hover_end(Evas_Object *obj);
1875 >>>>>>> remotes/origin/upstream
1876
1877 /**
1878  * @}
1879  */