src/lib/elc_scrolled_entry.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3
   4 /**
   5  * @defgroup Scrolled_Entry Scrolled_Entry
   6  *
   7  * A scrolled entry is a convenience widget which shows
   8  * a box that the user can enter text into.  Unlike an
   9  * @ref Entry widget, scrolled entries scroll with user
  10  * input so that the window will not expand if the length
  11  * of text inside the entry exceeds the initial size of the
  12  * widget.
  13  *
  14  * Signals that you can add callbacks for are:
  15  * - "changed" - The text within the entry was changed
  16  * - "activated" - The entry has received focus and the cursor
  17  * - "press" - The entry has been clicked
  18  * - "longpressed" - The entry has been clicked for a couple seconds
  19  * - "clicked" - The entry has been clicked
  20  * - "clicked,double" - The entry has been double clicked
  21  * - "focused" - The entry has received focus
  22  * - "unfocused" - The entry has lost focus
  23  * - "selection,paste" - A paste action has occurred
  24  * - "selection,copy" - A copy action has occurred
  25  * - "selection,cut" - A cut action has occurred
  26  * - "selection,start" - A selection has begun
  27  * - "selection,changed" - The selection has changed
  28  * - "selection,cleared" - The selection has been cleared
  29  * - "cursor,changed" - The cursor has changed
  30  * - "anchor,clicked" - The anchor has been clicked
  31  */
  32
  33 typedef struct _Widget_Data Widget_Data;
  34 typedef struct _Elm_Entry_Context_Menu_Item Elm_Entry_Context_Menu_Item;
  35 typedef struct _Elm_Entry_Item_Provider Elm_Entry_Item_Provider;
  36 typedef struct _Elm_Entry_Text_Filter Elm_Entry_Text_Filter;
  37
  38 struct _Widget_Data
  39 {
  40    Evas_Object *scroller;
  41    Evas_Object *entry;
  42    Evas_Object *icon;
  43    Evas_Object *end;
  44    Elm_Scroller_Policy policy_h, policy_v;
  45    Eina_List *items;
  46    Eina_List *item_providers;
  47    Eina_List *text_filters;
  48    Eina_Bool single_line : 1;
  49 };
  50
  51 struct _Elm_Entry_Context_Menu_Item
  52 {
  53    Evas_Object *obj;
  54    Evas_Smart_Cb func;
  55    void *data;
  56 };
  57
  58 struct _Elm_Entry_Item_Provider
  59 {
  60    Evas_Object *(*func) (void *data, Evas_Object *entry, const char *item);
  61    void *data;
  62 };
  63
  64 struct _Elm_Entry_Text_Filter
  65 {
  66    void (*func) (void *data, Evas_Object *entry, char **text);
  67    void *data;
  68 };
  69
  70 static const char *widtype = NULL;
  71
  72 static const char SIG_CHANGED[] = "changed";
  73 static const char SIG_ACTIVATED[] = "activated";
  74 static const char SIG_PRESS[] = "press";
  75 static const char SIG_LONGPRESSED[] = "longpressed";
  76 static const char SIG_CLICKED[] = "clicked";
  77 static const char SIG_CLICKED_DOUBLE[] = "clicked,double";
  78 static const char SIG_FOCUSED[] = "focused";
  79 static const char SIG_UNFOCUSED[] = "unfocused";
  80 static const char SIG_SELECTION_PASTE[] = "selection,paste";
  81 static const char SIG_SELECTION_COPY[] = "selection,copy";
  82 static const char SIG_SELECTION_CUT[] = "selection,cut";
  83 static const char SIG_SELECTION_START[] = "selection,start";
  84 static const char SIG_SELECTION_CHANGED[] = "selection,changed";
  85 static const char SIG_SELECTION_CLEARED[] = "selection,cleared";
  86 static const char SIG_CURSOR_CHANGED[] = "cursor,changed";
  87 static const char SIG_ANCHOR_CLICKED[] = "anchor,clicked";
  88 static const Evas_Smart_Cb_Description _signals[] = {
  89   {SIG_CHANGED, ""},
  90   {SIG_ACTIVATED, ""},
  91   {SIG_PRESS, ""},
  92   {SIG_LONGPRESSED, ""},
  93   {SIG_CLICKED, ""},
  94   {SIG_CLICKED_DOUBLE, ""},
  95   {SIG_FOCUSED, ""},
  96   {SIG_UNFOCUSED, ""},
  97   {SIG_SELECTION_PASTE, ""},
  98   {SIG_SELECTION_COPY, ""},
  99   {SIG_SELECTION_CUT, ""},
 100   {SIG_SELECTION_START, ""},
 101   {SIG_SELECTION_CHANGED, ""},
 102   {SIG_SELECTION_CLEARED, ""},
 103   {SIG_CURSOR_CHANGED, ""},
 104   {SIG_ANCHOR_CLICKED, ""},
 105   {NULL, NULL}
 106 };
 107
 108 static void
 109 _del_hook(Evas_Object *obj)
 110 {
 111    Elm_Entry_Context_Menu_Item *ci;
 112    Elm_Entry_Item_Provider *ip;
 113    Elm_Entry_Text_Filter *tf;
 114
 115    Widget_Data *wd = elm_widget_data_get(obj);
 116
 117    EINA_LIST_FREE(wd->items, ci)
 118       free(ci);
 119    EINA_LIST_FREE(wd->item_providers, ip)
 120       free(ip);
 121    EINA_LIST_FREE(wd->text_filters, tf)
 122       free(tf);
 123
 124    if (!wd) return;
 125    free(wd);
 126 }
 127
 128 static void
 129 _sizing_eval(Evas_Object *obj)
 130 {
 131    Widget_Data *wd;
 132    Evas_Coord minw, minh, minw_scr, minh_scr;
 133    wd = elm_widget_data_get(obj);
 134    if (!wd) return;
 135
 136    evas_object_size_hint_min_get(obj, &minw, &minh);
 137    evas_object_size_hint_min_get(wd->scroller, &minw_scr, &minh_scr);
 138    if (minw < minw_scr) minw = minw_scr;
 139    if (minh < minh_scr) minh = minh_scr;
 140
 141    evas_object_size_hint_min_set(obj, minw, minh);
 142    if (wd->single_line)
 143      evas_object_size_hint_max_set(obj, -1, minh);
 144    else
 145      evas_object_size_hint_max_set(obj, -1, -1);
 146 }
 147
 148 static void
 149 _theme_hook(Evas_Object *obj)
 150 {
 151    Widget_Data *wd = elm_widget_data_get(obj);
 152    if (!wd) return;
 153    elm_object_style_set(wd->entry, elm_widget_style_get(obj));
 154    elm_object_style_set(wd->scroller, elm_widget_style_get(obj));
 155    elm_object_disabled_set(wd->entry, elm_widget_disabled_get(obj));
 156    elm_object_disabled_set(wd->scroller, elm_widget_disabled_get(obj));
 157    _sizing_eval(obj);
 158 }
 159
 160 static void
 161 _on_focus_hook(void *data __UNUSED__, Evas_Object *obj)
 162 {
 163    Widget_Data *wd = elm_widget_data_get(obj);
 164    if (!wd) return;
 165    if (elm_widget_focus_get(obj))
 166      elm_widget_focus_steal(wd->entry);
 167 }
 168
 169 static void
 170 _disable_hook(Evas_Object *obj)
 171 {
 172    Widget_Data *wd = elm_widget_data_get(obj);
 173    if (!wd) return;
 174    elm_object_disabled_set(wd->entry, elm_widget_disabled_get(obj));
 175 }
 176
 177 static void
 178 _signal_emit_hook(Evas_Object *obj, const char *emission, const char *source)
 179 {
 180    Widget_Data *wd = elm_widget_data_get(obj);
 181    if (!wd) return;
 182    elm_object_signal_emit(wd->entry, emission, source);
 183    elm_object_signal_emit(wd->scroller, emission, source);
 184 }
 185
 186 static void
 187 _signal_callback_add_hook(Evas_Object *obj, const char *emission, const char *source, void (*func_cb) (void *data, Evas_Object *o, const char *emission, const char *source), void *data)
 188 {
 189    Widget_Data *wd = elm_widget_data_get(obj);
 190    if (!wd) return;
 191    elm_object_signal_callback_add(wd->entry, emission, source, func_cb, data);
 192    elm_object_signal_callback_add(wd->scroller, emission, source, func_cb,
 193          data);
 194 }
 195
 196 static void
 197 _signal_callback_del_hook(Evas_Object *obj, const char *emission, const char *source, void (*func_cb) (void *data, Evas_Object *o, const char *emission, const char *source), void *data __UNUSED__)
 198 {
 199    Widget_Data *wd = elm_widget_data_get(obj);
 200    elm_object_signal_callback_del(wd->entry, emission, source, func_cb);
 201    elm_object_signal_callback_del(wd->scroller, emission, source, func_cb);
 202 }
 203
 204 static void
 205 _on_focus_region_hook(const Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h)
 206 {
 207    Widget_Data *wd = elm_widget_data_get(obj);
 208    elm_widget_focus_region_get(wd->entry, x, y, w, h);
 209 }
 210
 211 static void
 212 _changed_size_hints(void *data __UNUSED__, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
 213 {
 214    _sizing_eval(obj);
 215 }
 216
 217 static void
 218 _entry_changed(void *data, Evas_Object *obj __UNUSED__, void *event_info)
 219 {
 220    _sizing_eval(data);
 221    evas_object_smart_callback_call(data, SIG_CHANGED, event_info);
 222 }
 223
 224 static void
 225 _entry_activated(void *data, Evas_Object *obj __UNUSED__, void *event_info)
 226 {
 227    evas_object_smart_callback_call(data, SIG_ACTIVATED, event_info);
 228 }
 229
 230 static void
 231 _entry_press(void *data, Evas_Object *obj __UNUSED__, void *event_info)
 232 {
 233    evas_object_smart_callback_call(data, SIG_PRESS, event_info);
 234 }
 235
 236 static void
 237 _entry_clicked(void *data, Evas_Object *obj __UNUSED__, void *event_info)
 238 {
 239    evas_object_smart_callback_call(data, SIG_CLICKED, event_info);
 240 }
 241
 242 static void
 243 _entry_clicked_double(void *data, Evas_Object *obj __UNUSED__, void *event_info)
 244 {
 245    evas_object_smart_callback_call(data, SIG_CLICKED_DOUBLE, event_info);
 246 }
 247
 248 static void
 249 _entry_cursor_changed(void *data, Evas_Object *obj __UNUSED__, void *event_info)
 250 {
 251    evas_object_smart_callback_call(data, SIG_CURSOR_CHANGED, event_info);
 252 }
 253
 254 static void
 255 _entry_anchor_clicked(void *data, Evas_Object *obj __UNUSED__, void *event_info)
 256 {
 257    evas_object_smart_callback_call(data, SIG_ANCHOR_CLICKED, event_info);
 258 }
 259
 260 static void
 261 _entry_selection_start(void *data, Evas_Object *obj __UNUSED__, void *event_info)
 262 {
 263    evas_object_smart_callback_call(data, SIG_SELECTION_START, event_info);
 264 }
 265
 266 static void
 267 _entry_selection_changed(void *data, Evas_Object *obj __UNUSED__, void *event_info)
 268 {
 269    evas_object_smart_callback_call(data, SIG_SELECTION_CHANGED, event_info);
 270 }
 271
 272 static void
 273 _entry_selection_cleared(void *data, Evas_Object *obj __UNUSED__, void *event_info)
 274 {
 275    evas_object_smart_callback_call(data, SIG_SELECTION_CLEARED, event_info);
 276 }
 277
 278 static void
 279 _entry_selection_paste(void *data, Evas_Object *obj __UNUSED__, void *event_info)
 280 {
 281    evas_object_smart_callback_call(data, SIG_SELECTION_PASTE, event_info);
 282 }
 283
 284 static void
 285 _entry_selection_copy(void *data, Evas_Object *obj __UNUSED__, void *event_info)
 286 {
 287    evas_object_smart_callback_call(data, SIG_SELECTION_COPY, event_info);
 288 }
 289
 290 static void
 291 _entry_selection_cut(void *data, Evas_Object *obj __UNUSED__, void *event_info)
 292 {
 293    evas_object_smart_callback_call(data, SIG_SELECTION_CUT, event_info);
 294 }
 295
 296 static void
 297 _entry_longpressed(void *data, Evas_Object *obj __UNUSED__, void *event_info)
 298 {
 299    evas_object_smart_callback_call(data, SIG_LONGPRESSED, event_info);
 300 }
 301
 302 static void
 303 _entry_focused(void *data, Evas_Object *obj __UNUSED__, void *event_info)
 304 {
 305    evas_object_smart_callback_call(data, SIG_FOCUSED, event_info);
 306 }
 307
 308 static void
 309 _entry_unfocused(void *data, Evas_Object *obj __UNUSED__, void *event_info)
 310 {
 311    evas_object_smart_callback_call(data, SIG_UNFOCUSED, event_info);
 312 }
 313
 314 static void
 315 _context_item_wrap_cb(void *data, Evas_Object *obj __UNUSED__, void *event_info)
 316 {
 317    Elm_Entry_Context_Menu_Item *ci = data;
 318    ci->func(ci->data, ci->obj, event_info);
 319 }
 320
 321 static Evas_Object *
 322 _item_provider_wrap_cb(void *data, Evas_Object *obj __UNUSED__, const char *item)
 323 {
 324    Widget_Data *wd = elm_widget_data_get(data);
 325    Eina_List *l;
 326    Elm_Entry_Item_Provider *ip;
 327
 328    EINA_LIST_FOREACH(wd->item_providers, l, ip)
 329      {
 330         Evas_Object *o;
 331         o = ip->func(ip->data, data, item);
 332         if (o) return o;
 333      }
 334    return NULL;
 335 }
 336
 337 static void
 338 _text_filter_wrap_cb(void *data, Evas_Object *obj __UNUSED__, char **text)
 339 {
 340    Widget_Data *wd = elm_widget_data_get(data);
 341    Eina_List *l;
 342    Elm_Entry_Text_Filter *tf;
 343
 344    EINA_LIST_FOREACH(wd->text_filters, l, tf)
 345      {
 346         tf->func(tf->data, data, text);
 347         if (!*text) break;
 348      }
 349 }
 350
 351 /**
 352  * This adds a scrolled entry to @p parent object.
 353  *
 354  * @param parent The parent object
 355  * @return The new object or NULL if it cannot be created
 356  *
 357  * @ingroup Scrolled_Entry
 358  */
 359 EAPI Evas_Object *
 360 elm_scrolled_entry_add(Evas_Object *parent)
 361 {
 362    Evas_Object *obj;
 363    Evas *e;
 364    Widget_Data *wd;
 365
 366    EINA_SAFETY_ON_NULL_RETURN_VAL(parent, NULL);
 367
 368    wd = ELM_NEW(Widget_Data);
 369    e = evas_object_evas_get(parent);
 370    if (!e) return NULL;
 371    obj = elm_widget_add(e);
 372    ELM_SET_WIDTYPE(widtype, "scrolled_entry");
 373    elm_widget_type_set(obj, "scrolled_entry");
 374    elm_widget_sub_object_add(parent, obj);
 375    elm_widget_on_focus_hook_set(obj, _on_focus_hook, NULL);
 376    elm_widget_data_set(obj, wd);
 377    elm_widget_del_hook_set(obj, _del_hook);
 378    elm_widget_disable_hook_set(obj, _disable_hook);
 379    elm_widget_can_focus_set(obj, EINA_TRUE);
 380    elm_widget_theme_hook_set(obj, _theme_hook);
 381    elm_widget_on_focus_region_hook_set(obj, _on_focus_region_hook);
 382    elm_widget_signal_emit_hook_set(obj, _signal_emit_hook);
 383    elm_widget_signal_callback_add_hook_set(obj, _signal_callback_add_hook);
 384    elm_widget_signal_callback_del_hook_set(obj, _signal_callback_del_hook);
 385
 386    wd->scroller = elm_scroller_add(obj);
 387    //elm_scroller_custom_widget_base_theme_set(wd->scroller, "scroller", "entry");
 388    elm_widget_resize_object_set(obj, wd->scroller);
 389    evas_object_size_hint_weight_set(wd->scroller, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 390    evas_object_size_hint_align_set(wd->scroller, EVAS_HINT_FILL, EVAS_HINT_FILL);
 391    elm_scroller_bounce_set(wd->scroller, EINA_FALSE, EINA_FALSE);
 392    elm_scroller_propagate_events_set(wd->scroller, EINA_TRUE);
 393    evas_object_show(wd->scroller);
 394
 395    wd->entry = elm_entry_add(obj);
 396    evas_object_size_hint_weight_set(wd->entry, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 397    evas_object_size_hint_align_set(wd->entry, EVAS_HINT_FILL, EVAS_HINT_FILL);
 398    elm_scroller_content_set(wd->scroller, wd->entry);
 399    evas_object_show(wd->entry);
 400
 401    elm_entry_text_filter_prepend(wd->entry, _text_filter_wrap_cb, obj);
 402    elm_entry_item_provider_prepend(wd->entry, _item_provider_wrap_cb, obj);
 403
 404    evas_object_smart_callback_add(wd->entry, "changed", _entry_changed, obj);
 405    evas_object_smart_callback_add(wd->entry, "activated", _entry_activated, obj);
 406    evas_object_smart_callback_add(wd->entry, "press", _entry_press, obj);
 407    evas_object_smart_callback_add(wd->entry, "clicked", _entry_clicked, obj);
 408    evas_object_smart_callback_add(wd->entry, "clicked,double", _entry_clicked_double, obj);
 409    evas_object_smart_callback_add(wd->entry, "cursor,changed", _entry_cursor_changed, obj);
 410    evas_object_smart_callback_add(wd->entry, "anchor,clicked", _entry_anchor_clicked, obj);
 411    evas_object_smart_callback_add(wd->entry, "selection,start", _entry_selection_start, obj);
 412    evas_object_smart_callback_add(wd->entry, "selection,changed", _entry_selection_changed, obj);
 413    evas_object_smart_callback_add(wd->entry, "selection,cleared", _entry_selection_cleared, obj);
 414    evas_object_smart_callback_add(wd->entry, "selection,paste", _entry_selection_paste, obj);
 415    evas_object_smart_callback_add(wd->entry, "selection,copy", _entry_selection_copy, obj);
 416    evas_object_smart_callback_add(wd->entry, "selection,cut", _entry_selection_cut, obj);
 417    evas_object_smart_callback_add(wd->entry, "longpressed", _entry_longpressed, obj);
 418    evas_object_smart_callback_add(wd->entry, "focused", _entry_focused, obj);
 419    evas_object_smart_callback_add(wd->entry, "unfocused", _entry_unfocused, obj);
 420
 421    evas_object_event_callback_add(obj, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
 422                                   _changed_size_hints, NULL);
 423
 424    _sizing_eval(obj);
 425
 426    // TODO: convert Elementary to subclassing of Evas_Smart_Class
 427    // TODO: and save some bytes, making descriptions per-class and not instance!
 428    evas_object_smart_callbacks_descriptions_set(obj, _signals);
 429    return obj;
 430 }
 431
 432 /**
 433  * This sets a widget to be displayed to the left of a scrolled entry.
 434  *
 435  * @param obj The scrolled entry object
 436  * @param icon The widget to display on the left side of the scrolled
 437  * entry.
 438  *
 439  * @note A previously set widget will be destroyed.
 440  * @note If the object being set does not have minimum size hints set,
 441  * it won't get properly displayed.
 442  *
 443  * @ingroup Scrolled_Entry
 444  * @see elm_scrolled_entry_end_set
 445  */
 446 EAPI void
 447 elm_scrolled_entry_icon_set(Evas_Object *obj, Evas_Object *icon)
 448 {
 449    ELM_CHECK_WIDTYPE(obj, widtype);
 450    Widget_Data *wd = elm_widget_data_get(obj);
 451    Evas_Object *edje;
 452    if (!wd) return;
 453    EINA_SAFETY_ON_NULL_RETURN(icon);
 454    if (wd->icon == icon) return;
 455    if (wd->icon) evas_object_del(wd->icon);
 456    wd->icon = icon;
 457    edje = _elm_scroller_edje_object_get(wd->scroller);
 458    if (!edje) return;
 459    edje_object_part_swallow(edje, "elm.swallow.icon", wd->icon);
 460    edje_object_signal_emit(edje, "elm,action,show,icon", "elm");
 461    _sizing_eval(obj);
 462 }
 463
 464 /**
 465  * Gets the leftmost widget of the scrolled entry. This object is
 466  * owned by the scrolled entry and should not be modified.
 467  *
 468  * @param obj The scrolled entry object
 469  * @return the left widget inside the scroller
 470  *
 471  * @ingroup Scrolled_Entry
 472  */
 473 EAPI Evas_Object *
 474 elm_scrolled_entry_icon_get(const Evas_Object *obj)
 475 {
 476    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 477    Widget_Data *wd = elm_widget_data_get(obj);
 478    if (!wd) return NULL;
 479    return wd->icon;
 480 }
 481
 482 /**
 483  * Unset the leftmost widget of the scrolled entry, unparenting and
 484  * returning it.
 485  *
 486  * @param obj The scrolled entry object
 487  * @return the previously set icon sub-object of this entry, on
 488  * success.
 489  *
 490  * @see elm_scrolled_entry_icon_set()
 491  *
 492  * @ingroup Scrolled_Entry
 493  */
 494 EAPI Evas_Object *
 495 elm_scrolled_entry_icon_unset(Evas_Object *obj)
 496 {
 497    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 498    Widget_Data *wd = elm_widget_data_get(obj);
 499    Evas_Object *ret = NULL;
 500    if (!wd) return NULL;
 501    if (wd->icon)
 502      {
 503        Evas_Object *edje = _elm_scroller_edje_object_get(wd->scroller);
 504        if (!edje) return NULL;
 505        ret = wd->icon;
 506        edje_object_part_unswallow(edje, wd->icon);
 507        edje_object_signal_emit(edje, "elm,action,hide,icon", "elm");
 508        wd->icon = NULL;
 509        _sizing_eval(obj);
 510      }
 511    return ret;
 512 }
 513
 514 /**
 515  * Sets the visibility of the left-side widget of the scrolled entry,
 516  * set by @elm_scrolled_entry_icon_set().
 517  *
 518  * @param obj The scrolled entry object
 519  * @param setting EINA_TRUE if the object should be displayed,
 520  * EINA_FALSE if not.
 521  *
 522  * @ingroup Scrolled_Entry
 523  */
 524 EAPI void
 525 elm_scrolled_entry_icon_visible_set(Evas_Object *obj, Eina_Bool setting)
 526 {
 527    ELM_CHECK_WIDTYPE(obj, widtype);
 528    Widget_Data *wd = elm_widget_data_get(obj);
 529    if ((!wd) || (!wd->icon)) return;
 530    if (setting)
 531      evas_object_hide(wd->icon);
 532    else
 533      evas_object_show(wd->icon);
 534    _sizing_eval(obj);
 535 }
 536
 537 /**
 538  * This sets a widget to be displayed to the end of a scrolled entry.
 539  *
 540  * @param obj The scrolled entry object
 541  * @param end The widget to display on the right side of the scrolled
 542  * entry.
 543  *
 544  * @note A previously set widget will be destroyed.
 545  * @note If the object being set does not have minimum size hints set,
 546  * it won't get properly displayed.
 547  *
 548  * @ingroup Scrolled_Entry
 549  * @see elm_scrolled_entry_icon_set
 550  */
 551 EAPI void
 552 elm_scrolled_entry_end_set(Evas_Object *obj, Evas_Object *end)
 553 {
 554    ELM_CHECK_WIDTYPE(obj, widtype);
 555    Widget_Data *wd = elm_widget_data_get(obj);
 556    Evas_Object *edje;
 557    if (!wd) return;
 558    EINA_SAFETY_ON_NULL_RETURN(end);
 559    if (wd->end == end) return;
 560    if (wd->end) evas_object_del(wd->end);
 561    wd->end = end;
 562    edje = _elm_scroller_edje_object_get(wd->scroller);
 563    if (!edje) return;
 564    edje_object_part_swallow(edje, "elm.swallow.end", wd->end);
 565    edje_object_signal_emit(edje, "elm,action,show,end", "elm");
 566    _sizing_eval(obj);
 567 }
 568
 569 /**
 570  * Gets the endmost widget of the scrolled entry. This object is owned
 571  * by the scrolled entry and should not be modified.
 572  *
 573  * @param obj The scrolled entry object
 574  * @return the right widget inside the scroller
 575  *
 576  * @ingroup Scrolled_Entry
 577  */
 578 EAPI Evas_Object *
 579 elm_scrolled_entry_end_get(const Evas_Object *obj)
 580 {
 581    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 582    Widget_Data *wd = elm_widget_data_get(obj);
 583    if (!wd) return NULL;
 584    return wd->end;
 585 }
 586
 587 /**
 588  * Unset the endmost widget of the scrolled entry, unparenting and
 589  * returning it.
 590  *
 591  * @param obj The scrolled entry object
 592  * @return the previously set icon sub-object of this entry, on
 593  * success.
 594  *
 595  * @see elm_scrolled_entry_icon_set()
 596  *
 597  * @ingroup Scrolled_Entry
 598  */
 599 EAPI Evas_Object *
 600 elm_scrolled_entry_end_unset(Evas_Object *obj)
 601 {
 602    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 603    Widget_Data *wd = elm_widget_data_get(obj);
 604    Evas_Object *ret = NULL;
 605    if (!wd) return NULL;
 606    if (wd->end)
 607      {
 608        Evas_Object *edje = _elm_scroller_edje_object_get(wd->scroller);
 609        if (!edje) return NULL;
 610        ret = wd->end;
 611        edje_object_part_unswallow(edje, wd->end);
 612        edje_object_signal_emit(edje, "elm,action,hide,end", "elm");
 613        wd->end = NULL;
 614        _sizing_eval(obj);
 615      }
 616    return ret;
 617 }
 618
 619 /**
 620  * Sets the visibility of the end widget of the scrolled entry, set by
 621  * @elm_scrolled_entry_end_set().
 622  *
 623  * @param obj The scrolled entry object
 624  * @param setting EINA_TRUE if the object should be displayed,
 625  * EINA_FALSE if not.
 626  *
 627  * @ingroup Scrolled_Entry
 628  */
 629 EAPI void
 630 elm_scrolled_entry_end_visible_set(Evas_Object *obj, Eina_Bool setting)
 631 {
 632    ELM_CHECK_WIDTYPE(obj, widtype);
 633    Widget_Data *wd = elm_widget_data_get(obj);
 634    if ((!wd) || (!wd->end)) return;
 635    if (setting)
 636      evas_object_hide(wd->end);
 637    else
 638      evas_object_show(wd->end);
 639    _sizing_eval(obj);
 640 }
 641
 642 /**
 643  * This sets the scrolled entry object not to line wrap.  All input will
 644  * be on a single line, and the entry box will scroll with user input.
 645  *
 646  * @param obj The scrolled entry object
 647  * @param single_line If true, the text in the scrolled entry
 648  * will be on a single line.
 649  *
 650  * @ingroup Scrolled_Entry
 651  */
 652 EAPI void
 653 elm_scrolled_entry_single_line_set(Evas_Object *obj, Eina_Bool single_line)
 654 {
 655    ELM_CHECK_WIDTYPE(obj, widtype);
 656    Widget_Data *wd = elm_widget_data_get(obj);
 657    if (!wd) return;
 658    if (wd->single_line == single_line) return;
 659    elm_entry_single_line_set(wd->entry, single_line);
 660    wd->single_line = single_line;
 661    if (single_line)
 662      {
 663         elm_scroller_policy_set(wd->scroller, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_OFF);
 664         elm_scroller_content_min_limit(wd->scroller, 0, 1);
 665      }
 666    else
 667      {
 668         elm_scroller_policy_set(wd->scroller, wd->policy_h, wd->policy_v);
 669         elm_scroller_content_min_limit(wd->scroller, 0, 0);
 670      }
 671    _sizing_eval(obj);
 672 }
 673
 674 /**
 675  * This returns true if the scrolled entry has been set to single line mode.
 676  * See also elm_scrolled_entry_single_line_set().
 677  *
 678  * @param obj The scrolled entry object
 679  * @return single_line If true, the text in the scrolled entry is set to display
 680  * on a single line.
 681  *
 682  * @ingroup Scrolled_Entry
 683  */
 684 EAPI Eina_Bool
 685 elm_scrolled_entry_single_line_get(const Evas_Object *obj)
 686 {
 687    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 688    Widget_Data *wd = elm_widget_data_get(obj);
 689    if (!wd) return EINA_FALSE;
 690    return elm_entry_single_line_get(wd->entry);
 691 }
 692
 693
 694 /**
 695  * This sets the scrolled entry object to password mode.  All text entered
 696  * and/or displayed within the widget will be replaced with asterisks (*).
 697  *
 698  * @param obj The scrolled entry object
 699  * @param password If true, password mode is enabled.
 700  *
 701  * @ingroup Scrolled_Entry
 702  */
 703 EAPI void
 704 elm_scrolled_entry_password_set(Evas_Object *obj, Eina_Bool password)
 705 {
 706    ELM_CHECK_WIDTYPE(obj, widtype);
 707    Widget_Data *wd = elm_widget_data_get(obj);
 708    if (!wd) return;
 709    elm_entry_password_set(wd->entry, password);
 710 }
 711
 712 /**
 713  * This returns whether password mode is enabled.
 714  * See also elm_scrolled_entry_password_set().
 715  *
 716  * @param obj The scrolled entry object
 717  * @return If true, the scrolled entry is set to display all characters
 718  * as asterisks (*).
 719  *
 720  * @ingroup Scrolled_Entry
 721  */
 722 EAPI Eina_Bool
 723 elm_scrolled_entry_password_get(const Evas_Object *obj)
 724 {
 725    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 726    Widget_Data *wd = elm_widget_data_get(obj);
 727    if (!wd) return EINA_FALSE;
 728    return elm_entry_password_get(wd->entry);
 729 }
 730
 731
 732 /**
 733  * This sets the text displayed within the scrolled entry to @p entry.
 734  *
 735  * @param obj The scrolled entry object
 736  * @param entry The text to be displayed
 737  *
 738  * @ingroup Scrolled_Entry
 739  */
 740 EAPI void
 741 elm_scrolled_entry_entry_set(Evas_Object *obj, const char *entry)
 742 {
 743    ELM_CHECK_WIDTYPE(obj, widtype);
 744    Widget_Data *wd = elm_widget_data_get(obj);
 745    if (!wd) return;
 746    elm_entry_entry_set(wd->entry, entry);
 747 }
 748
 749 /**
 750  * This returns the text currently shown in object @p entry.
 751  * See also elm_scrolled_entry_entry_set().
 752  *
 753  * @param obj The scrolled entry object
 754  * @return The currently displayed text or NULL on failure
 755  *
 756  * @ingroup Scrolled_Entry
 757  */
 758 EAPI const char *
 759 elm_scrolled_entry_entry_get(const Evas_Object *obj)
 760 {
 761    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 762    Widget_Data *wd = elm_widget_data_get(obj);
 763    if (!wd) return NULL;
 764    return elm_entry_entry_get(wd->entry);
 765 }
 766
 767 /**
 768  * This returns all selected text within the scrolled entry.
 769  *
 770  * @param obj The scrolled entry object
 771  * @return The selected text within the scrolled entry or NULL on failure
 772  *
 773  * @ingroup Scrolled_Entry
 774  */
 775 EAPI const char *
 776 elm_scrolled_entry_selection_get(const Evas_Object *obj)
 777 {
 778    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 779    Widget_Data *wd = elm_widget_data_get(obj);
 780    if (!wd) return NULL;
 781    return elm_entry_selection_get(wd->entry);
 782 }
 783
 784 /**
 785  * This inserts text in @p entry at the beginning of the scrolled entry
 786  * object.
 787  *
 788  * @param obj The scrolled entry object
 789  * @param entry The text to insert
 790  *
 791  * @ingroup Scrolled_Entry
 792  */
 793 EAPI void
 794 elm_scrolled_entry_entry_insert(Evas_Object *obj, const char *entry)
 795 {
 796    ELM_CHECK_WIDTYPE(obj, widtype);
 797    Widget_Data *wd = elm_widget_data_get(obj);
 798    if (!wd) return;
 799    elm_entry_entry_insert(wd->entry, entry);
 800 }
 801
 802 /**
 803  * This enables word line wrapping in the scrolled entry object.  It is the opposite
 804  * of elm_scrolled_entry_single_line_set().  Additionally, setting this disables
 805  * character line wrapping.
 806  * See also elm_scrolled_entry_line_char_wrap_set().
 807  *
 808  * @param obj The scrolled entry object
 809  * @param wrap If true, the scrolled entry will be wrapped once it reaches the end
 810  * of the object. Wrapping will occur at the end of the word before the end of the
 811  * object.
 812  *
 813  * @ingroup Scrolled_Entry
 814  */
 815 EAPI void
 816 elm_scrolled_entry_line_wrap_set(Evas_Object *obj, Eina_Bool wrap)
 817 {
 818    ELM_CHECK_WIDTYPE(obj, widtype);
 819    Widget_Data *wd = elm_widget_data_get(obj);
 820    if (!wd) return;
 821    elm_entry_line_wrap_set(wd->entry, wrap);
 822 }
 823
 824 /**
 825  * This enables character line wrapping in the scrolled entry object.  It is the opposite
 826  * of elm_scrolled_entry_single_line_set().  Additionally, setting this disables
 827  * word line wrapping.
 828  * See also elm_scrolled_entry_line_wrap_set().
 829  *
 830  * @param obj The scrolled entry object
 831  * @param wrap If true, the scrolled entry will be wrapped once it reaches the end
 832  * of the object. Wrapping will occur immediately upon reaching the end of the object.
 833  *
 834  * @ingroup Scrolled_Entry
 835  */
 836 EAPI void
 837 elm_scrolled_entry_line_char_wrap_set(Evas_Object *obj, Eina_Bool wrap)
 838 {
 839    ELM_CHECK_WIDTYPE(obj, widtype);
 840    Widget_Data *wd = elm_widget_data_get(obj);
 841    if (!wd) return;
 842    elm_entry_line_char_wrap_set(wd->entry, wrap);
 843 }
 844
 845 /**
 846  * This sets the editable attribute of the scrolled entry.
 847  *
 848  * @param obj The scrolled entry object
 849  * @param editable If true, the scrolled entry will be editable by the user.
 850  * If false, it will be set to the disabled state.
 851  *
 852  * @ingroup Scrolled_Entry
 853  */
 854 EAPI void
 855 elm_scrolled_entry_editable_set(Evas_Object *obj, Eina_Bool editable)
 856 {
 857    ELM_CHECK_WIDTYPE(obj, widtype);
 858    Widget_Data *wd = elm_widget_data_get(obj);
 859    if (!wd) return;
 860    elm_entry_editable_set(wd->entry, editable);
 861 }
 862
 863 /**
 864  * This gets the editable attribute of the scrolled entry.
 865  * See also elm_scrolled_entry_editable_set().
 866  *
 867  * @param obj The scrolled entry object
 868  * @return If true, the scrolled entry is editable by the user.
 869  * If false, it is not editable by the user
 870  *
 871  * @ingroup Scrolled_Entry
 872  */
 873 EAPI Eina_Bool
 874 elm_scrolled_entry_editable_get(const Evas_Object *obj)
 875 {
 876    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 877    Widget_Data *wd = elm_widget_data_get(obj);
 878    if (!wd) return EINA_FALSE;
 879    return elm_entry_editable_get(wd->entry);
 880 }
 881
 882
 883 /**
 884  * This drops any existing text selection within the scrolled entry.
 885  *
 886  * @param obj The scrolled entry object
 887  *
 888  * @ingroup Scrolled_Entry
 889  */
 890 EAPI void
 891 elm_scrolled_entry_select_none(Evas_Object *obj)
 892 {
 893    ELM_CHECK_WIDTYPE(obj, widtype);
 894    Widget_Data *wd = elm_widget_data_get(obj);
 895    if (!wd) return;
 896    elm_entry_select_none(wd->entry);
 897 }
 898
 899 /**
 900  * This selects all text within the scrolled entry.
 901  *
 902  * @param obj The scrolled entry object
 903  *
 904  * @ingroup Scrolled_Entry
 905  */
 906 EAPI void
 907 elm_scrolled_entry_select_all(Evas_Object *obj)
 908 {
 909    ELM_CHECK_WIDTYPE(obj, widtype);
 910    Widget_Data *wd = elm_widget_data_get(obj);
 911    if (!wd) return;
 912    elm_entry_select_all(wd->entry);
 913 }
 914
 915 /**
 916  * This moves the cursor one place to the right within the entry.
 917  *
 918  * @param obj The scrolled entry object
 919  * @return EINA_TRUE upon success, EINA_FALSE upon failure
 920  *
 921  * @ingroup Scrolled_Entry
 922  */
 923 EAPI Eina_Bool
 924 elm_scrolled_entry_cursor_next(Evas_Object *obj)
 925 {
 926    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 927    Widget_Data *wd = elm_widget_data_get(obj);
 928    if (!wd) return EINA_FALSE;
 929    return elm_entry_cursor_next(wd->entry);
 930 }
 931
 932 /**
 933  * This moves the cursor one place to the left within the entry.
 934  *
 935  * @param obj The scrolled entry object
 936  * @return EINA_TRUE upon success, EINA_FALSE upon failure
 937  *
 938  * @ingroup Scrolled_Entry
 939  */
 940 EAPI Eina_Bool
 941 elm_scrolled_entry_cursor_prev(Evas_Object *obj)
 942 {
 943    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 944    Widget_Data *wd = elm_widget_data_get(obj);
 945    if (!wd) return EINA_FALSE;
 946    return elm_entry_cursor_prev(wd->entry);
 947 }
 948
 949 /**
 950  * This moves the cursor one line up within the entry.
 951  *
 952  * @param obj The scrolled entry object
 953  * @return EINA_TRUE upon success, EINA_FALSE upon failure
 954  *
 955  * @ingroup Scrolled_Entry
 956  */
 957 EAPI Eina_Bool
 958 elm_scrolled_entry_cursor_up(Evas_Object *obj)
 959 {
 960    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 961    Widget_Data *wd = elm_widget_data_get(obj);
 962    if (!wd) return EINA_FALSE;
 963    return elm_entry_cursor_up(wd->entry);
 964 }
 965
 966 /**
 967  * This moves the cursor one line down within the entry.
 968  *
 969  * @param obj The scrolled entry object
 970  * @return EINA_TRUE upon success, EINA_FALSE upon failure
 971  *
 972  * @ingroup Scrolled_Entry
 973  */
 974 EAPI Eina_Bool
 975 elm_scrolled_entry_cursor_down(Evas_Object *obj)
 976 {
 977    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 978    Widget_Data *wd = elm_widget_data_get(obj);
 979    if (!wd) return EINA_FALSE;
 980    return elm_entry_cursor_down(wd->entry);
 981 }
 982
 983 /**
 984  * This moves the cursor to the beginning of the entry.
 985  *
 986  * @param obj The scrolled entry object
 987  *
 988  * @ingroup Scrolled_Entry
 989  */
 990 EAPI void
 991 elm_scrolled_entry_cursor_begin_set(Evas_Object *obj)
 992 {
 993    ELM_CHECK_WIDTYPE(obj, widtype);
 994    Widget_Data *wd = elm_widget_data_get(obj);
 995    if (!wd) return;
 996    elm_entry_cursor_begin_set(wd->entry);
 997 }
 998
 999 /**
1000  * This moves the cursor to the end of the entry.
1001  *
1002  * @param obj The scrolled entry object
1003  *
1004  * @ingroup Scrolled_Entry
1005  */
1006 EAPI void
1007 elm_scrolled_entry_cursor_end_set(Evas_Object *obj)
1008 {
1009    ELM_CHECK_WIDTYPE(obj, widtype);
1010    Widget_Data *wd = elm_widget_data_get(obj);
1011    if (!wd) return;
1012    Evas_Coord x, y, w, h;
1013    elm_entry_cursor_end_set(wd->entry);
1014    elm_widget_show_region_get(wd->entry, &x, &y, &w, &h);
1015    elm_scroller_region_show(wd->scroller, x, y, w, h);
1016 }
1017
1018 /**
1019  * This moves the cursor to the beginning of the current line.
1020  *
1021  * @param obj The scrolled entry object
1022  *
1023  * @ingroup Scrolled_Entry
1024  */
1025 EAPI void
1026 elm_scrolled_entry_cursor_line_begin_set(Evas_Object *obj)
1027 {
1028    ELM_CHECK_WIDTYPE(obj, widtype);
1029    Widget_Data *wd = elm_widget_data_get(obj);
1030    if (!wd) return;
1031    elm_entry_cursor_line_begin_set(wd->entry);
1032 }
1033
1034 /**
1035  * This moves the cursor to the end of the current line.
1036  *
1037  * @param obj The scrolled entry object
1038  *
1039  * @ingroup Scrolled_Entry
1040  */
1041 EAPI void
1042 elm_scrolled_entry_cursor_line_end_set(Evas_Object *obj)
1043 {
1044    ELM_CHECK_WIDTYPE(obj, widtype);
1045    Widget_Data *wd = elm_widget_data_get(obj);
1046    if (!wd) return;
1047    elm_entry_cursor_line_end_set(wd->entry);
1048 }
1049
1050 /**
1051  * This begins a selection within the scrolled entry as though
1052  * the user were holding down the mouse button to make a selection.
1053  *
1054  * @param obj The scrolled entry object
1055  *
1056  * @ingroup Scrolled_Entry
1057  */
1058 EAPI void
1059 elm_scrolled_entry_cursor_selection_begin(Evas_Object *obj)
1060 {
1061    ELM_CHECK_WIDTYPE(obj, widtype);
1062    Widget_Data *wd = elm_widget_data_get(obj);
1063    if (!wd) return;
1064    elm_entry_cursor_selection_begin(wd->entry);
1065 }
1066
1067 /**
1068  * This ends a selection within the scrolled entry as though
1069  * the user had just released the mouse button while making a selection.
1070  *
1071  * @param obj The scrolled entry object
1072  *
1073  * @ingroup Scrolled_Entry
1074  */
1075 EAPI void
1076 elm_scrolled_entry_cursor_selection_end(Evas_Object *obj)
1077 {
1078    ELM_CHECK_WIDTYPE(obj, widtype);
1079    Widget_Data *wd = elm_widget_data_get(obj);
1080    if (!wd) return;
1081    elm_entry_cursor_selection_end(wd->entry);
1082 }
1083
1084 /**
1085  * TODO: fill this in
1086  *
1087  * @param obj The scrolled entry object
1088  * @return TODO: fill this in
1089  *
1090  * @ingroup Scrolled_Entry
1091  */
1092 EAPI Eina_Bool
1093 elm_scrolled_entry_cursor_is_format_get(const Evas_Object *obj)
1094 {
1095    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1096    Widget_Data *wd = elm_widget_data_get(obj);
1097    if (!wd) return EINA_FALSE;
1098    return elm_entry_cursor_is_format_get(wd->entry);
1099 }
1100
1101 /**
1102  * This returns whether the cursor is visible.
1103  *
1104  * @param obj The scrolled entry object
1105  * @return If true, the cursor is visible.
1106  *
1107  * @ingroup Scrolled_Entry
1108  */
1109 EAPI Eina_Bool
1110 elm_scrolled_entry_cursor_is_visible_format_get(const Evas_Object *obj)
1111 {
1112    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1113    Widget_Data *wd = elm_widget_data_get(obj);
1114    if (!wd) return EINA_FALSE;
1115    return elm_entry_cursor_is_visible_format_get(wd->entry);
1116 }
1117
1118 /**
1119  * TODO: fill this in
1120  *
1121  * @param obj The scrolled entry object
1122  * @return TODO: fill this in
1123  *
1124  * @ingroup Scrolled_Entry
1125  */
1126 EAPI const char *
1127 elm_scrolled_entry_cursor_content_get(const Evas_Object *obj)
1128 {
1129    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1130    Widget_Data *wd = elm_widget_data_get(obj);
1131    if (!wd) return NULL;
1132    return elm_entry_cursor_content_get(wd->entry);
1133 }
1134
1135 /**
1136  * This executes a "cut" action on the selected text in the scrolled entry.
1137  *
1138  * @param obj The scrolled entry object
1139  *
1140  * @ingroup Scrolled_Entry
1141  */
1142 EAPI void
1143 elm_scrolled_entry_selection_cut(Evas_Object *obj)
1144 {
1145    ELM_CHECK_WIDTYPE(obj, widtype);
1146    Widget_Data *wd = elm_widget_data_get(obj);
1147    if (!wd) return;
1148    elm_entry_selection_cut(wd->entry);
1149 }
1150
1151 /**
1152  * This executes a "copy" action on the selected text in the scrolled entry.
1153  *
1154  * @param obj The scrolled entry object
1155  *
1156  * @ingroup Scrolled_Entry
1157  */
1158 EAPI void
1159 elm_scrolled_entry_selection_copy(Evas_Object *obj)
1160 {
1161    ELM_CHECK_WIDTYPE(obj, widtype);
1162    Widget_Data *wd = elm_widget_data_get(obj);
1163    if (!wd) return;
1164    elm_entry_selection_copy(wd->entry);
1165 }
1166
1167 /**
1168  * This executes a "paste" action in the scrolled entry.
1169  *
1170  * @param obj The scrolled entry object
1171  *
1172  * @ingroup Scrolled_Entry
1173  */
1174 EAPI void
1175 elm_scrolled_entry_selection_paste(Evas_Object *obj)
1176 {
1177    ELM_CHECK_WIDTYPE(obj, widtype);
1178    Widget_Data *wd = elm_widget_data_get(obj);
1179    if (!wd) return;
1180    elm_entry_selection_paste(wd->entry);
1181 }
1182
1183 /**
1184  * This clears and frees the items in a scrolled entry's contextual (right click) menu.
1185  *
1186  * @param obj The scrolled entry object
1187  *
1188  * @ingroup Scrolled_Entry
1189  */
1190 EAPI void
1191 elm_scrolled_entry_context_menu_clear(Evas_Object *obj)
1192 {
1193    ELM_CHECK_WIDTYPE(obj, widtype);
1194    Widget_Data *wd = elm_widget_data_get(obj);
1195    if (!wd) return;
1196    elm_entry_context_menu_clear(wd->entry);
1197 }
1198
1199 /**
1200  * This adds an item to the scrolled entry's contextual menu.
1201  *
1202  * @param obj The scrolled entry object
1203  * @param label The item's text label
1204  * @param icon_file The item's icon file
1205  * @param icon_type The item's icon type
1206  * @param func The callback to execute when the item is clicked
1207  * @param data The data to associate with the item for related functions
1208  *
1209  * @ingroup Scrolled_Entry
1210  */
1211 EAPI void
1212 elm_scrolled_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)
1213 {
1214    Elm_Entry_Context_Menu_Item *ci;
1215    ELM_CHECK_WIDTYPE(obj, widtype);
1216    Widget_Data *wd = elm_widget_data_get(obj);
1217    if (!wd) return;
1218
1219    ci = malloc(sizeof(Elm_Entry_Context_Menu_Item));
1220    if (!ci) return;
1221    ci->func = func;
1222    ci->data = (void *)data;
1223    ci->obj = obj;
1224    wd->items = eina_list_append(wd->items, ci);
1225    elm_entry_context_menu_item_add(wd->entry, label, icon_file, icon_type, _context_item_wrap_cb, ci);
1226 }
1227
1228 /**
1229  * This disables the scrolled entry's contextual (right click) menu.
1230  *
1231  * @param obj The scrolled entry object
1232  * @param disabled If true, the menu is disabled
1233  *
1234  * @ingroup Scrolled_Entry
1235  */
1236 EAPI void
1237 elm_scrolled_entry_context_menu_disabled_set(Evas_Object *obj, Eina_Bool disabled)
1238 {
1239    ELM_CHECK_WIDTYPE(obj, widtype);
1240    Widget_Data *wd = elm_widget_data_get(obj);
1241    if (!wd) return;
1242    elm_entry_context_menu_disabled_set(wd->entry, disabled);
1243 }
1244
1245 /**
1246  * This returns whether the scrolled entry's contextual (right click) menu is disabled.
1247  *
1248  * @param obj The scrolled entry object
1249  * @return If true, the menu is disabled
1250  *
1251  * @ingroup Scrolled_Entry
1252  */
1253 EAPI Eina_Bool
1254 elm_scrolled_entry_context_menu_disabled_get(const Evas_Object *obj)
1255 {
1256    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1257    Widget_Data *wd = elm_widget_data_get(obj);
1258    if (!wd) return EINA_FALSE;
1259    return elm_entry_context_menu_disabled_get(wd->entry);
1260 }
1261
1262 /**
1263  * This sets the scrolled entry's scrollbar policy (ie. enabling/disabling them).
1264  *
1265  * @param obj The scrolled entry object
1266  * @param h The horizontal scrollbar policy to apply
1267  * @param v The vertical scrollbar policy to apply
1268  *
1269  * @ingroup Scrolled_Entry
1270  */
1271 EAPI void
1272 elm_scrolled_entry_scrollbar_policy_set(Evas_Object *obj, Elm_Scroller_Policy h, Elm_Scroller_Policy v)
1273 {
1274    ELM_CHECK_WIDTYPE(obj, widtype);
1275    Widget_Data *wd = elm_widget_data_get(obj);
1276    if (!wd) return;
1277    wd->policy_h = h;
1278    wd->policy_v = v;
1279    elm_scroller_policy_set(wd->scroller, h, v);
1280 }
1281
1282 /**
1283  * This enables/disables bouncing within the entry.
1284  *
1285  * @param obj The scrolled entry object
1286  * @param h The horizontal bounce state
1287  * @param v The vertical bounce state
1288  *
1289  * @ingroup Scrolled_Entry
1290  */
1291 EAPI void
1292 elm_scrolled_entry_bounce_set(Evas_Object *obj, Eina_Bool h_bounce, Eina_Bool v_bounce)
1293 {
1294    ELM_CHECK_WIDTYPE(obj, widtype);
1295    Widget_Data *wd = elm_widget_data_get(obj);
1296    if (!wd) return;
1297    elm_scroller_bounce_set(wd->scroller, h_bounce, v_bounce);
1298 }
1299
1300 /**
1301  * This set's the maximum bytes that can be added in to scrolled entry.
1302  *
1303  * @param obj The  scrolled entry object
1304  * @param max_no_of_bytes Maximum number of bytes scrolled entry can have.
1305  *
1306  * @ingroup Scrolled_Entry
1307  */
1308 EAPI void
1309 elm_scrolled_entry_maximum_bytes_set(Evas_Object *obj, int max_no_of_bytes)
1310 {
1311    ELM_CHECK_WIDTYPE(obj, widtype);
1312    Widget_Data *wd = elm_widget_data_get(obj);
1313    if (!wd) return;
1314    elm_entry_maximum_bytes_set(wd->entry,max_no_of_bytes);
1315 }
1316
1317 /**
1318  * Get the bounce mode
1319  *
1320  * @param obj The Scrolled_Entry object
1321  * @param h_bounce Allow bounce horizontally
1322  * @param v_bounce Allow bounce vertically
1323  *
1324  * @ingroup Scrolled_Entry
1325  */
1326 EAPI void
1327 elm_scrolled_entry_bounce_get(const Evas_Object *obj, Eina_Bool *h_bounce, Eina_Bool *v_bounce)
1328 {
1329    ELM_CHECK_WIDTYPE(obj, widtype);
1330    Widget_Data *wd = elm_widget_data_get(obj);
1331    if (!wd) return;
1332    elm_scroller_bounce_get(wd->scroller, h_bounce, v_bounce);
1333 }
1334
1335 /**
1336  * This appends a custom item provider to the list for that entry
1337  *
1338  * This appends the given callback. The list is walked from beginning to end
1339  * with each function called given the item href string in the text. If the
1340  * function returns an object handle other than NULL (it should create an
1341  * and object to do this), then this object is used to replace that item. If
1342  * not the next provider is called until one provides an item object, or the
1343  * default provider in entry does.
1344  *
1345  * @param obj The entry object
1346  * @param func The function called to provide the item object
1347  * @param data The data passed to @p func
1348  *
1349  * @ingroup Scrolled_Entry
1350  */
1351 EAPI void
1352 elm_scrolled_entry_item_provider_append(Evas_Object *obj, Evas_Object *(*func) (void *data, Evas_Object *entry, const char *item), void *data)
1353 {
1354    ELM_CHECK_WIDTYPE(obj, widtype);
1355    Widget_Data *wd = elm_widget_data_get(obj);
1356    if (!wd) return;
1357    EINA_SAFETY_ON_NULL_RETURN(func);
1358    Elm_Entry_Item_Provider *ip = calloc(1, sizeof(Elm_Entry_Item_Provider));
1359    if (!ip) return;
1360    ip->func = func;
1361    ip->data = data;
1362    wd->item_providers = eina_list_append(wd->item_providers, ip);
1363 }
1364
1365 /**
1366  * This prepends a custom item provider to the list for that entry
1367  *
1368  * This prepends the given callback. See elm_scrolled_entry_item_provider_append() for
1369  * more information
1370  *
1371  * @param obj The entry object
1372  * @param func The function called to provide the item object
1373  * @param data The data passed to @p func
1374  *
1375  * @ingroup Scrolled_Entry
1376  */
1377 EAPI void
1378 elm_scrolled_entry_item_provider_prepend(Evas_Object *obj, Evas_Object *(*func) (void *data, Evas_Object *entry, const char *item), void *data)
1379 {
1380    ELM_CHECK_WIDTYPE(obj, widtype);
1381    Widget_Data *wd = elm_widget_data_get(obj);
1382    if (!wd) return;
1383    EINA_SAFETY_ON_NULL_RETURN(func);
1384    Elm_Entry_Item_Provider *ip = calloc(1, sizeof(Elm_Entry_Item_Provider));
1385    if (!ip) return;
1386    ip->func = func;
1387    ip->data = data;
1388    wd->item_providers = eina_list_prepend(wd->item_providers, ip);
1389 }
1390
1391 /**
1392  * This removes a custom item provider to the list for that entry
1393  *
1394  * This removes the given callback. See elm_scrolled_entry_item_provider_append() for
1395  * more information
1396  *
1397  * @param obj The entry object
1398  * @param func The function called to provide the item object
1399  * @param data The data passed to @p func
1400  *
1401  * @ingroup Scrolled_Entry
1402  */
1403 EAPI void
1404 elm_scrolled_entry_item_provider_remove(Evas_Object *obj, Evas_Object *(*func) (void *data, Evas_Object *entry, const char *item), void *data)
1405 {
1406    ELM_CHECK_WIDTYPE(obj, widtype);
1407    Widget_Data *wd = elm_widget_data_get(obj);
1408    Eina_List *l;
1409    Elm_Entry_Item_Provider *ip;
1410    if (!wd) return;
1411    EINA_SAFETY_ON_NULL_RETURN(func);
1412    EINA_LIST_FOREACH(wd->item_providers, l, ip)
1413      {
1414         if ((ip->func == func) && (ip->data == data))
1415           {
1416              wd->item_providers = eina_list_remove_list(wd->item_providers, l);
1417              free(ip);
1418              return;
1419           }
1420      }
1421 }
1422
1423 /**
1424  * Append a filter function for text inserted in the entry
1425  *
1426  * Append the given callback to the list. This functions will be called
1427  * whenever any text is inserted into the entry, with the text to be inserted
1428  * as a parameter. The callback function is free to alter the text in any way
1429  * it wants, but it must remember to free the given pointer and update it.
1430  * If the new text is to be discarded, the function can free it and set it text
1431  * parameter to NULL. This will also prevent any following filters from being
1432  * called.
1433  *
1434  * @param obj The entry object
1435  * @param func The function to use as text filter
1436  * @param data User data to pass to @p func
1437  *
1438  * @ingroup Scrolled_Entry
1439  */
1440 EAPI void
1441 elm_scrolled_entry_text_filter_append(Evas_Object *obj, void (*func) (void *data, Evas_Object *entry, char **text), void *data)
1442 {
1443    Widget_Data *wd;
1444    Elm_Entry_Text_Filter *tf;
1445    ELM_CHECK_WIDTYPE(obj, widtype);
1446
1447    wd = elm_widget_data_get(obj);
1448
1449    EINA_SAFETY_ON_NULL_RETURN(func);
1450
1451    tf = ELM_NEW(Elm_Entry_Text_Filter);
1452    if (!tf) return;
1453    tf->func = func;
1454    tf->data = data;
1455    wd->text_filters = eina_list_append(wd->text_filters, tf);
1456 }
1457
1458 /**
1459  * Prepend a filter function for text insdrted in the entry
1460  *
1461  * Prepend the given callback to the list. See elm_scrolled_entry_text_filter_append()
1462  * for more information
1463  *
1464  * @param obj The entry object
1465  * @param func The function to use as text filter
1466  * @param data User data to pass to @p func
1467  *
1468  * @ingroup Scrolled_Entry
1469  */
1470 EAPI void
1471 elm_scrolled_entry_text_filter_prepend(Evas_Object *obj, void (*func) (void *data, Evas_Object *entry, char **text), void *data)
1472 {
1473    Widget_Data *wd;
1474    Elm_Entry_Text_Filter *tf;
1475    ELM_CHECK_WIDTYPE(obj, widtype);
1476
1477    wd = elm_widget_data_get(obj);
1478
1479    EINA_SAFETY_ON_NULL_RETURN(func);
1480
1481    tf = ELM_NEW(Elm_Entry_Text_Filter);
1482    if (!tf) return;
1483    tf->func = func;
1484    tf->data = data;
1485    wd->text_filters = eina_list_prepend(wd->text_filters, tf);
1486 }
1487
1488 /**
1489  * Remove a filter from the list
1490  *
1491  * Removes the given callback from the filter list. See elm_scrolled_entry_text_filter_append()
1492  * for more information.
1493  *
1494  * @param obj The entry object
1495  * @param func The filter function to remove
1496  * @param data The user data passed when adding the function
1497  *
1498  * @ingroup Scrolled_Entry
1499  */
1500 EAPI void
1501 elm_scrolled_entry_text_filter_remove(Evas_Object *obj, void (*func) (void *data, Evas_Object *entry, char **text), void *data)
1502 {
1503    Widget_Data *wd;
1504    Eina_List *l;
1505    Elm_Entry_Text_Filter *tf;
1506    ELM_CHECK_WIDTYPE(obj, widtype);
1507
1508    wd = elm_widget_data_get(obj);
1509
1510    EINA_SAFETY_ON_NULL_RETURN(func);
1511
1512    EINA_LIST_FOREACH(wd->text_filters, l, tf)
1513      {
1514         if ((tf->func == func) && (tf->data == data))
1515           {
1516              wd->text_filters = eina_list_remove_list(wd->text_filters, l);
1517              free(tf);
1518              return;
1519           }
1520      }
1521 }
1522
1523 /**
1524  * This sets the file (and implicitly loads it) for the text to display and
1525  * then edit. All changes are written back to the file after a short delay if
1526  * the entry object is set to autosave.
1527  *
1528  * @param obj The scrolled entry object
1529  * @param file The path to the file to load and save
1530  * @param format The file format
1531  *
1532  * @ingroup Scrolled_Entry
1533  */
1534 EAPI void
1535 elm_scrolled_entry_file_set(Evas_Object *obj, const char *file, Elm_Text_Format format)
1536 {
1537    ELM_CHECK_WIDTYPE(obj, widtype);
1538    Widget_Data *wd = elm_widget_data_get(obj);
1539    if (!wd) return;
1540    elm_entry_file_set(wd->entry, file, format);
1541 }
1542
1543 /**
1544  * Gets the file to load and save and the file format
1545  *
1546  * @param obj The scrolled entry object
1547  * @param file The path to the file to load and save
1548  * @param format The file format
1549  *
1550  * @ingroup Scrolled_Entry
1551  */
1552 EAPI void
1553 elm_scrolled_entry_file_get(const Evas_Object *obj, const char **file, Elm_Text_Format *format)
1554 {
1555    ELM_CHECK_WIDTYPE(obj, widtype);
1556    Widget_Data *wd = elm_widget_data_get(obj);
1557    if (!wd) return;
1558    elm_entry_file_get(wd->entry, file, format);
1559 }
1560
1561 /**
1562  * This function writes any changes made to the file set with
1563  * elm_scrolled_entry_file_set()
1564  *
1565  * @param obj The scrolled entry object
1566  *
1567  * @ingroup Scrolled_Entry
1568  */
1569 EAPI void
1570 elm_scrolled_entry_file_save(Evas_Object *obj)
1571 {
1572    ELM_CHECK_WIDTYPE(obj, widtype);
1573    Widget_Data *wd = elm_widget_data_get(obj);
1574    if (!wd) return;
1575    elm_entry_file_save(wd->entry);
1576 }
1577
1578 /**
1579  * This sets the entry object to 'autosave' the loaded text file or not.
1580  *
1581  * @param obj The scrolled entry object
1582  * @param autosave Autosave the loaded file or not
1583  *
1584  * @ingroup Scrolled_Entry
1585  */
1586 EAPI void
1587 elm_scrolled_entry_autosave_set(Evas_Object *obj, Eina_Bool autosave)
1588 {
1589    ELM_CHECK_WIDTYPE(obj, widtype);
1590    Widget_Data *wd = elm_widget_data_get(obj);
1591    if (!wd) return;
1592    elm_entry_autosave_set(wd->entry, autosave);
1593 }
1594
1595 /**
1596  * This gets the entry object's 'autosave' status.
1597  *
1598  * @param obj The scrolled entry object
1599  * @return Autosave the loaded file or not
1600  *
1601  * @ingroup Scrolled_Entry
1602  */
1603 EAPI Eina_Bool
1604 elm_scrolled_entry_autosave_get(const Evas_Object *obj)
1605 {
1606    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1607    Widget_Data *wd = elm_widget_data_get(obj);
1608    if (!wd) return EINA_FALSE;
1609    return elm_entry_autosave_get(wd->entry);
1610 }
1611
1612 /**
1613  * Get the input method context in the scrolled entry widget
1614  *
1615  * @param obj The scrolled entry object
1616  * @return The input method context
1617  *
1618  * @ingroup Scrolled_Entry
1619  */
1620 EAPI Ecore_IMF_Context *elm_scrolled_entry_imf_context_get(Evas_Object *obj)
1621 {
1622    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1623    Widget_Data *wd = elm_widget_data_get(obj);
1624    if (!wd || !wd->entry) return NULL;
1625
1626    return elm_entry_imf_context_get(wd->entry);
1627 }
1628
1629 /**
1630  * This sets the attribute to show the input panel automatically.
1631  *
1632  * @param obj The scrolled entry object
1633  * @param enabled If true, the input panel is appeared when entry is clicked or has a focus
1634  *
1635  * @ingroup Scrolled_Entry
1636  */
1637 EAPI void
1638 elm_scrolled_entry_input_panel_enabled_set(Evas_Object *obj, Eina_Bool enabled)
1639 {
1640    ELM_CHECK_WIDTYPE(obj, widtype);
1641    Widget_Data *wd = elm_widget_data_get(obj);
1642    if (!wd || !wd->entry) return;
1643
1644    elm_entry_input_panel_enabled_set(wd->entry, enabled);
1645 }
1646
1647 /**
1648  * Set the input panel layout of the scrolled entry
1649  *
1650  * @param obj The scrolled entry object
1651  * @param layout the layout to set
1652  *
1653  * @ingroup Scrolled_Entry
1654  */
1655 EAPI void
1656 elm_scrolled_entry_input_panel_layout_set(Evas_Object *obj, Elm_Input_Panel_Layout layout)
1657 {
1658    ELM_CHECK_WIDTYPE(obj, widtype);
1659    Widget_Data *wd = elm_widget_data_get(obj);
1660    if (!wd || !wd->entry) return;
1661
1662    elm_entry_input_panel_layout_set(wd->entry, layout);
1663 }
1664
1665 /**
1666  * Set whether scrolled entry should support auto capitalization
1667  *
1668  * @param obj The entry object
1669  * @param on If true, scrolled entry suports auto capitalization.
1670  *
1671  * @ingroup Scrolled_Entry
1672  */
1673 EAPI void
1674 elm_scrolled_entry_autocapitalization_set(Evas_Object *obj, Eina_Bool autocap)
1675 {
1676    ELM_CHECK_WIDTYPE(obj, widtype);
1677    Widget_Data *wd = elm_widget_data_get(obj);
1678    if (!wd || !wd->entry) return;
1679
1680    elm_entry_autocapitalization_set(wd->entry, autocap);
1681 }
1682
1683 /**
1684  * Set whether scrolled entry should support auto period
1685  *
1686  * @param obj The entry object
1687  * @param on If true, scrolled entry suports auto period.
1688  *
1689  * @ingroup Scrolled_Entry
1690  */
1691 EAPI void
1692 elm_scrolled_entry_autoperiod_set(Evas_Object *obj, Eina_Bool autoperiod)
1693 {
1694    ELM_CHECK_WIDTYPE(obj, widtype);
1695    Widget_Data *wd = elm_widget_data_get(obj);
1696    if (!wd || !wd->entry) return;
1697
1698    elm_entry_autoperiod_set(wd->entry, autoperiod);
1699 }