src/lib/elc_scrolled_entry.c

   1 /*
   2  * vim:ts=8:sw=3:sts=8:noexpandtab:cino=>5n-3f0^-2{2
   3  */
   4 #include <Elementary.h>
   5 #include "elm_priv.h"
   6
   7 /**
   8  * @defgroup Scrolled_Entry Scrolled_Entry
   9  * @ingroup Elementary
  10  *
  11  * A scrolled entry is a convenience widget which shows
  12  * a box that the user can enter text into.  Unlike an
  13  * @ref Entry widget, scrolled entries scroll with user
  14  * input so that the window will not expand if the length
  15  * of text inside the entry exceeds the initial size of the
  16  * widget.
  17  *
  18  * Signals that you can add callbacks for are:
  19  * - "changed" - The text within the entry was changed
  20  * - "activated" - The entry has received focus and the cursor
  21  * - "press" - The entry has been clicked
  22  * - "longpressed" - The entry has been clicked for a couple seconds
  23  * - "clicked" - The entry has been clicked
  24  * - "clicked,double" - The entry has been double clicked
  25  * - "focused" - The entry has received focus
  26  * - "unfocused" - The entry has lost focus
  27  * - "selection,paste" - A paste action has occurred
  28  * - "selection,copy" - A copy action has occurred
  29  * - "selection,cut" - A cut action has occurred
  30  * - "selection,start" - A selection has begun
  31  * - "selection,changed" - The selection has changed
  32  * - "selection,cleared" - The selection has been cleared
  33  * - "cursor,changed" - The cursor has changed
  34  * - "anchor,clicked" - The anchor has been clicked
  35  */
  36
  37 typedef struct _Widget_Data Widget_Data;
  38
  39 struct _Widget_Data
  40 {
  41    Evas_Object *scroller;
  42    Evas_Object *entry;
  43    Elm_Scroller_Policy policy_h, policy_v;
  44    Eina_Bool single_line : 1;
  45 };
  46
  47 static const char *widtype = NULL;
  48
  49 static const char SIG_CHANGED[] = "changed";
  50 static const char SIG_ACTIVATED[] = "activated";
  51 static const char SIG_PRESS[] = "press";
  52 static const char SIG_LONGPRESSED[] = "longpressed";
  53 static const char SIG_CLICKED[] = "clicked";
  54 static const char SIG_CLICKED_DOUBLE[] = "clicked,double";
  55 static const char SIG_FOCUSED[] = "focused";
  56 static const char SIG_UNFOCUSED[] = "unfocused";
  57 static const char SIG_SELECTION_PASTE[] = "selection,paste";
  58 static const char SIG_SELECTION_COPY[] = "selection,copy";
  59 static const char SIG_SELECTION_CUT[] = "selection,cut";
  60 static const char SIG_SELECTION_START[] = "selection,start";
  61 static const char SIG_SELECTION_CHANGED[] = "selection,changed";
  62 static const char SIG_SELECTION_CLEARED[] = "selection,cleared";
  63 static const char SIG_CURSOR_CHANGED[] = "cursor,changed";
  64 static const char SIG_ANCHOR_CLICKED[] = "anchor,clicked";
  65 static const Evas_Smart_Cb_Description _signals[] = {
  66   {SIG_CHANGED, ""},
  67   {SIG_ACTIVATED, ""},
  68   {SIG_PRESS, ""},
  69   {SIG_LONGPRESSED, ""},
  70   {SIG_CLICKED, ""},
  71   {SIG_CLICKED_DOUBLE, ""},
  72   {SIG_FOCUSED, ""},
  73   {SIG_UNFOCUSED, ""},
  74   {SIG_SELECTION_PASTE, ""},
  75   {SIG_SELECTION_COPY, ""},
  76   {SIG_SELECTION_CUT, ""},
  77   {SIG_SELECTION_START, ""},
  78   {SIG_SELECTION_CHANGED, ""},
  79   {SIG_SELECTION_CLEARED, ""},
  80   {SIG_CURSOR_CHANGED, ""},
  81   {SIG_ANCHOR_CLICKED, ""},
  82   {NULL, NULL}
  83 };
  84
  85 static void
  86 _del_hook(Evas_Object *obj)
  87 {
  88    Widget_Data *wd = elm_widget_data_get(obj);
  89    if (!wd) return;
  90    free(wd);
  91 }
  92
  93 static void
  94 _theme_hook(Evas_Object *obj)
  95 {
  96    Widget_Data *wd = elm_widget_data_get(obj);
  97    if (!wd) return;
  98    elm_object_style_set(wd->entry, elm_widget_style_get(obj));
  99    elm_object_style_set(wd->scroller, elm_widget_style_get(obj));
 100 }
 101
 102 static void
 103 _sizing_eval(Evas_Object *obj)
 104 {
 105    Widget_Data *wd = elm_widget_data_get(obj);
 106    Evas_Coord minw, minh, minw_scr, minh_scr;
 107    if (!wd) return;
 108
 109    evas_object_size_hint_min_get(obj, &minw, &minh);
 110    evas_object_size_hint_min_get(wd->scroller, &minw_scr, &minh_scr);
 111    if (minw < minw_scr) minw = minw_scr;
 112    if (minh < minh_scr) minh = minh_scr;
 113
 114    evas_object_size_hint_min_set(obj, minw, minh);
 115
 116    if (wd->single_line)
 117      evas_object_size_hint_max_set(obj, -1, minh);
 118    else
 119      evas_object_size_hint_max_set(obj, -1, -1);
 120 }
 121
 122 static void
 123 _on_focus_hook(void *data __UNUSED__, Evas_Object *obj)
 124 {
 125    Widget_Data *wd = elm_widget_data_get(obj);
 126    if (!wd) return;
 127    if (elm_widget_focus_get(obj))
 128      elm_widget_focus_steal(wd->entry);
 129 }
 130
 131 static void
 132 _disable_hook(Evas_Object *obj)
 133 {
 134    Widget_Data *wd = elm_widget_data_get(obj);
 135    if (!wd) return;
 136    elm_object_disabled_set(wd->entry, elm_widget_disabled_get(obj));
 137 }
 138
 139 static void
 140 _entry_changed(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 141 {
 142    _sizing_eval(data);
 143    evas_object_smart_callback_call(data, SIG_CHANGED, NULL);
 144 }
 145
 146 static void
 147 _entry_activated(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 148 {
 149    evas_object_smart_callback_call(data, SIG_ACTIVATED, NULL);
 150 }
 151
 152 static void
 153 _entry_press(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 154 {
 155    evas_object_smart_callback_call(data, SIG_PRESS, NULL);
 156 }
 157
 158 static void
 159 _entry_clicked(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 160 {
 161    evas_object_smart_callback_call(data, SIG_CLICKED, NULL);
 162 }
 163
 164 static void
 165 _entry_clicked_double(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 166 {
 167    evas_object_smart_callback_call(data, SIG_CLICKED_DOUBLE, NULL);
 168 }
 169
 170 static void
 171 _entry_cursor_changed(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 172 {
 173    evas_object_smart_callback_call(data, SIG_CURSOR_CHANGED, NULL);
 174 }
 175
 176 static void
 177 _entry_anchor_clicked(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 178 {
 179    evas_object_smart_callback_call(data, SIG_ANCHOR_CLICKED, NULL);
 180 }
 181
 182 static void
 183 _entry_selection_start(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 184 {
 185    evas_object_smart_callback_call(data, SIG_SELECTION_START, NULL);
 186 }
 187
 188 static void
 189 _entry_selection_changed(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 190 {
 191    evas_object_smart_callback_call(data, SIG_SELECTION_CHANGED, NULL);
 192 }
 193
 194 static void
 195 _entry_selection_cleared(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 196 {
 197    evas_object_smart_callback_call(data, SIG_SELECTION_CLEARED, NULL);
 198 }
 199
 200 static void
 201 _entry_selection_paste(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 202 {
 203    evas_object_smart_callback_call(data, SIG_SELECTION_PASTE, NULL);
 204 }
 205
 206 static void
 207 _entry_selection_copy(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 208 {
 209    evas_object_smart_callback_call(data, SIG_SELECTION_COPY, NULL);
 210 }
 211
 212 static void
 213 _entry_selection_cut(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 214 {
 215    evas_object_smart_callback_call(data, SIG_SELECTION_CUT, NULL);
 216 }
 217
 218 static void
 219 _entry_longpressed(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 220 {
 221    evas_object_smart_callback_call(data, SIG_LONGPRESSED, NULL);
 222 }
 223
 224 static void
 225 _entry_focused(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 226 {
 227    evas_object_smart_callback_call(data, SIG_FOCUSED, NULL);
 228 }
 229
 230 static void
 231 _entry_unfocused(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 232 {
 233    evas_object_smart_callback_call(data, SIG_UNFOCUSED, NULL);
 234 }
 235
 236
 237 /**
 238  * This adds a scrolled entry to @p parent object.
 239  *
 240  * @param parent The parent object
 241  * @return The new object or NULL if it cannot be created
 242  *
 243  * @ingroup Scrolled_Entry
 244  */
 245 EAPI Evas_Object *
 246 elm_scrolled_entry_add(Evas_Object *parent)
 247 {
 248    Evas_Object *obj;
 249    Evas *e;
 250    Widget_Data *wd;
 251
 252    wd = ELM_NEW(Widget_Data);
 253    e = evas_object_evas_get(parent);
 254    obj = elm_widget_add(e);
 255    ELM_SET_WIDTYPE(widtype, "scrolled_entry");
 256    elm_widget_type_set(obj, "scrolled_entry");
 257    elm_widget_sub_object_add(parent, obj);
 258    elm_widget_on_focus_hook_set(obj, _on_focus_hook, NULL);
 259    elm_widget_data_set(obj, wd);
 260    elm_widget_del_hook_set(obj, _del_hook);
 261    elm_widget_disable_hook_set(obj, _disable_hook);
 262    elm_widget_can_focus_set(obj, 1);
 263    elm_widget_theme_hook_set(obj, _theme_hook);
 264
 265    wd->scroller = elm_scroller_add(parent);
 266    elm_widget_resize_object_set(obj, wd->scroller);
 267    elm_scroller_bounce_set(wd->scroller, 0, 0);
 268
 269    wd->entry = elm_entry_add(parent);
 270    evas_object_size_hint_weight_set(wd->entry, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 271    evas_object_size_hint_align_set(wd->entry, EVAS_HINT_FILL, EVAS_HINT_FILL);
 272    elm_scroller_content_set(wd->scroller, wd->entry);
 273    evas_object_show(wd->entry);
 274
 275    evas_object_smart_callback_add(wd->entry, "changed", _entry_changed, obj);
 276    evas_object_smart_callback_add(wd->entry, "activated", _entry_activated, obj);
 277    evas_object_smart_callback_add(wd->entry, "press", _entry_press, obj);
 278    evas_object_smart_callback_add(wd->entry, "clicked", _entry_clicked, obj);
 279    evas_object_smart_callback_add(wd->entry, "clicked,double", _entry_clicked_double, obj);
 280    evas_object_smart_callback_add(wd->entry, "cursor,changed", _entry_cursor_changed, obj);
 281    evas_object_smart_callback_add(wd->entry, "anchor,clicked", _entry_anchor_clicked, obj);
 282    evas_object_smart_callback_add(wd->entry, "selection,start", _entry_selection_start, obj);
 283    evas_object_smart_callback_add(wd->entry, "selection,changed", _entry_selection_changed, obj);
 284    evas_object_smart_callback_add(wd->entry, "selection,cleared", _entry_selection_cleared, obj);
 285    evas_object_smart_callback_add(wd->entry, "selection,paste", _entry_selection_paste, obj);
 286    evas_object_smart_callback_add(wd->entry, "selection,copy", _entry_selection_copy, obj);
 287    evas_object_smart_callback_add(wd->entry, "selection,cut", _entry_selection_cut, obj);
 288    evas_object_smart_callback_add(wd->entry, "longpressed", _entry_longpressed, obj);
 289    evas_object_smart_callback_add(wd->entry, "focused", _entry_focused, obj);
 290    evas_object_smart_callback_add(wd->entry, "unfocused", _entry_unfocused, obj);
 291
 292    _sizing_eval(obj);
 293
 294    // TODO: convert Elementary to subclassing of Evas_Smart_Class
 295    // TODO: and save some bytes, making descriptions per-class and not instance!
 296    evas_object_smart_callbacks_descriptions_set(obj, _signals);
 297    return obj;
 298 }
 299
 300 /**
 301  * This sets the scrolled entry object not to line wrap.  All input will
 302  * be on a single line, and the entry box will scroll with user input.
 303  *
 304  * @param obj The scrolled entry object
 305  * @param single_line If true, the text in the scrolled entry
 306  * will be on a single line.
 307  *
 308  * @ingroup Scrolled_Entry
 309  */
 310 EAPI void
 311 elm_scrolled_entry_single_line_set(Evas_Object *obj, Eina_Bool single_line)
 312 {
 313    ELM_CHECK_WIDTYPE(obj, widtype);
 314    Widget_Data *wd = elm_widget_data_get(obj);
 315    if (!wd) return;
 316    if (wd->single_line == single_line) return;
 317    elm_entry_single_line_set(wd->entry, single_line);
 318    wd->single_line = single_line;
 319    if (single_line)
 320      {
 321         elm_scroller_policy_set(wd->scroller, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_OFF);
 322         elm_scroller_content_min_limit(wd->scroller, 0, 1);
 323      }
 324    else
 325      {
 326         elm_scroller_policy_set(wd->scroller, wd->policy_h, wd->policy_v);
 327         elm_scroller_content_min_limit(wd->scroller, 0, 0);
 328      }
 329    _sizing_eval(obj);
 330 }
 331
 332 /**
 333  * This returns true if the scrolled entry has been set to single line mode.
 334  * See also elm_scrolled_entry_single_line_set().
 335  *
 336  * @param obj The scrolled entry object
 337  * @return single_line If true, the text in the scrolled entry is set to display
 338  * on a single line.
 339  *
 340  * @ingroup Scrolled_Entry
 341  */
 342 EAPI Eina_Bool
 343 elm_scrolled_entry_single_line_get(const Evas_Object *obj)
 344 {
 345    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 346    Widget_Data *wd = elm_widget_data_get(obj);
 347    if (!wd) return EINA_FALSE;
 348    return elm_entry_single_line_get(wd->entry);
 349 }
 350
 351
 352 /**
 353  * This sets the scrolled entry object to password mode.  All text entered
 354  * and/or displayed within the widget will be replaced with asterisks (*).
 355  *
 356  * @param obj The scrolled entry object
 357  * @param password If true, password mode is enabled.
 358  *
 359  * @ingroup Scrolled_Entry
 360  */
 361 EAPI void
 362 elm_scrolled_entry_password_set(Evas_Object *obj, Eina_Bool password)
 363 {
 364    ELM_CHECK_WIDTYPE(obj, widtype);
 365    Widget_Data *wd = elm_widget_data_get(obj);
 366    if (!wd) return;
 367    elm_entry_password_set(wd->entry, password);
 368 }
 369
 370 /**
 371  * This returns whether password mode is enabled.
 372  * See also elm_scrolled_entry_password_set().
 373  *
 374  * @param obj The scrolled entry object
 375  * @return If true, the scrolled entry is set to display all characters
 376  * as asterisks (*).
 377  *
 378  * @ingroup Scrolled_Entry
 379  */
 380 EAPI Eina_Bool
 381 elm_scrolled_entry_password_get(const Evas_Object *obj)
 382 {
 383    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 384    Widget_Data *wd = elm_widget_data_get(obj);
 385    if (!wd) return EINA_FALSE;
 386    return elm_entry_password_get(wd->entry);
 387 }
 388
 389
 390 /**
 391  * This sets the text displayed within the scrolled entry to @p entry.
 392  *
 393  * @param obj The scrolled entry object
 394  * @param entry The text to be displayed
 395  *
 396  * @ingroup Scrolled_Entry
 397  */
 398 EAPI void
 399 elm_scrolled_entry_entry_set(Evas_Object *obj, const char *entry)
 400 {
 401    ELM_CHECK_WIDTYPE(obj, widtype);
 402    Widget_Data *wd = elm_widget_data_get(obj);
 403    if (!wd) return;
 404    elm_entry_entry_set(wd->entry, entry);
 405 }
 406
 407 /**
 408  * This returns the text currently shown in object @p entry.
 409  * See also elm_scrolled_entry_entry_set().
 410  *
 411  * @param obj The scrolled entry object
 412  * @return The currently displayed text or NULL on failure
 413  *
 414  * @ingroup Scrolled_Entry
 415  */
 416 EAPI const char *
 417 elm_scrolled_entry_entry_get(const Evas_Object *obj)
 418 {
 419    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 420    Widget_Data *wd = elm_widget_data_get(obj);
 421    if (!wd) return NULL;
 422    return elm_entry_entry_get(wd->entry);
 423 }
 424
 425 /**
 426  * This returns all selected text within the scrolled entry.
 427  *
 428  * @param obj The scrolled entry object
 429  * @return The selected text within the scrolled entry or NULL on failure
 430  *
 431  * @ingroup Scrolled_Entry
 432  */
 433 EAPI const char *
 434 elm_scrolled_entry_selection_get(const Evas_Object *obj)
 435 {
 436    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 437    Widget_Data *wd = elm_widget_data_get(obj);
 438    if (!wd) return NULL;
 439    return elm_entry_selection_get(wd->entry);
 440 }
 441
 442 /**
 443  * This inserts text in @p entry at the beginning of the scrolled entry
 444  * object.
 445  *
 446  * @param obj The scrolled entry object
 447  * @param entry The text to insert
 448  *
 449  * @ingroup Scrolled_Entry
 450  */
 451 EAPI void
 452 elm_scrolled_entry_entry_insert(Evas_Object *obj, const char *entry)
 453 {
 454    ELM_CHECK_WIDTYPE(obj, widtype);
 455    Widget_Data *wd = elm_widget_data_get(obj);
 456    if (!wd) return;
 457    elm_entry_entry_insert(wd->entry, entry);
 458 }
 459
 460 /**
 461  * This enables word line wrapping in the scrolled entry object.  It is the opposite
 462  * of elm_scrolled_entry_single_line_set().  Additionally, setting this disables
 463  * character line wrapping.
 464  * See also elm_scrolled_entry_line_char_wrap_set().
 465  *
 466  * @param obj The scrolled entry object
 467  * @param wrap If true, the scrolled entry will be wrapped once it reaches the end
 468  * of the object. Wrapping will occur at the end of the word before the end of the
 469  * object.
 470  *
 471  * @ingroup Scrolled_Entry
 472  */
 473 EAPI void
 474 elm_scrolled_entry_line_wrap_set(Evas_Object *obj, Eina_Bool wrap)
 475 {
 476    ELM_CHECK_WIDTYPE(obj, widtype);
 477    Widget_Data *wd = elm_widget_data_get(obj);
 478    if (!wd) return;
 479    elm_entry_line_wrap_set(wd->entry, wrap);
 480 }
 481
 482 /**
 483  * This enables character line wrapping in the scrolled entry object.  It is the opposite
 484  * of elm_scrolled_entry_single_line_set().  Additionally, setting this disables
 485  * word line wrapping.
 486  * See also elm_scrolled_entry_line_wrap_set().
 487  *
 488  * @param obj The scrolled entry object
 489  * @param wrap If true, the scrolled entry will be wrapped once it reaches the end
 490  * of the object. Wrapping will occur immediately upon reaching the end of the object.
 491  *
 492  * @ingroup Scrolled_Entry
 493  */
 494 EAPI void
 495 elm_scrolled_entry_line_char_wrap_set(Evas_Object *obj, Eina_Bool wrap)
 496 {
 497    ELM_CHECK_WIDTYPE(obj, widtype);
 498    Widget_Data *wd = elm_widget_data_get(obj);
 499    if (!wd) return;
 500    elm_entry_line_char_wrap_set(wd->entry, wrap);
 501 }
 502
 503 /**
 504  * This sets the editable attribute of the scrolled entry.
 505  *
 506  * @param obj The scrolled entry object
 507  * @param editable If true, the scrolled entry will be editable by the user.
 508  * If false, it will be set to the disabled state.
 509  *
 510  * @ingroup Scrolled_Entry
 511  */
 512 EAPI void
 513 elm_scrolled_entry_editable_set(Evas_Object *obj, Eina_Bool editable)
 514 {
 515    ELM_CHECK_WIDTYPE(obj, widtype);
 516    Widget_Data *wd = elm_widget_data_get(obj);
 517    if (!wd) return;
 518    elm_entry_editable_set(wd->entry, editable);
 519 }
 520
 521 /**
 522  * This gets the editable attribute of the scrolled entry.
 523  * See also elm_scrolled_entry_editable_set().
 524  *
 525  * @param obj The scrolled entry object
 526  * @return If true, the scrolled entry is editable by the user.
 527  * If false, it is not editable by the user
 528  *
 529  * @ingroup Scrolled_Entry
 530  */
 531 EAPI Eina_Bool
 532 elm_scrolled_entry_editable_get(const Evas_Object *obj)
 533 {
 534    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 535    Widget_Data *wd = elm_widget_data_get(obj);
 536    if (!wd) return EINA_FALSE;
 537    return elm_entry_editable_get(wd->entry);
 538 }
 539
 540
 541 /**
 542  * This drops any existing text selection within the scrolled entry.
 543  *
 544  * @param obj The scrolled entry object
 545  *
 546  * @ingroup Scrolled_Entry
 547  */
 548 EAPI void
 549 elm_scrolled_entry_select_none(Evas_Object *obj)
 550 {
 551    ELM_CHECK_WIDTYPE(obj, widtype);
 552    Widget_Data *wd = elm_widget_data_get(obj);
 553    if (!wd) return;
 554    elm_entry_select_none(wd->entry);
 555 }
 556
 557 /**
 558  * This selects all text within the scrolled entry.
 559  *
 560  * @param obj The scrolled entry object
 561  *
 562  * @ingroup Scrolled_Entry
 563  */
 564 EAPI void
 565 elm_scrolled_entry_select_all(Evas_Object *obj)
 566 {
 567    ELM_CHECK_WIDTYPE(obj, widtype);
 568    Widget_Data *wd = elm_widget_data_get(obj);
 569    if (!wd) return;
 570    elm_entry_select_all(wd->entry);
 571 }
 572
 573 /**
 574  * This moves the cursor one place to the right within the entry.
 575  *
 576  * @param obj The scrolled entry object
 577  * @return EINA_TRUE upon success, EINA_FALSE upon failure
 578  *
 579  * @ingroup Scrolled_Entry
 580  */
 581 EAPI Eina_Bool
 582 elm_scrolled_entry_cursor_next(Evas_Object *obj)
 583 {
 584    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 585    Widget_Data *wd = elm_widget_data_get(obj);
 586    if (!wd) return EINA_FALSE;
 587    return elm_entry_cursor_next(wd->entry);
 588 }
 589
 590 /**
 591  * This moves the cursor one place to the left within the entry.
 592  *
 593  * @param obj The scrolled entry object
 594  * @return EINA_TRUE upon success, EINA_FALSE upon failure
 595  *
 596  * @ingroup Scrolled_Entry
 597  */
 598 EAPI Eina_Bool
 599 elm_scrolled_entry_cursor_prev(Evas_Object *obj)
 600 {
 601    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 602    Widget_Data *wd = elm_widget_data_get(obj);
 603    if (!wd) return EINA_FALSE;
 604    return elm_entry_cursor_prev(wd->entry);
 605 }
 606
 607 /**
 608  * This moves the cursor one line up within the entry.
 609  *
 610  * @param obj The scrolled entry object
 611  * @return EINA_TRUE upon success, EINA_FALSE upon failure
 612  *
 613  * @ingroup Scrolled_Entry
 614  */
 615 EAPI Eina_Bool
 616 elm_scrolled_entry_cursor_up(Evas_Object *obj)
 617 {
 618    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 619    Widget_Data *wd = elm_widget_data_get(obj);
 620    if (!wd) return EINA_FALSE;
 621    return elm_entry_cursor_up(wd->entry);
 622 }
 623
 624 /**
 625  * This moves the cursor one line down within the entry.
 626  *
 627  * @param obj The scrolled entry object
 628  * @return EINA_TRUE upon success, EINA_FALSE upon failure
 629  *
 630  * @ingroup Scrolled_Entry
 631  */
 632 EAPI Eina_Bool
 633 elm_scrolled_entry_cursor_down(Evas_Object *obj)
 634 {
 635    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 636    Widget_Data *wd = elm_widget_data_get(obj);
 637    if (!wd) return EINA_FALSE;
 638    return elm_entry_cursor_down(wd->entry);
 639 }
 640
 641 /**
 642  * This moves the cursor to the beginning of the entry.
 643  *
 644  * @param obj The scrolled entry object
 645  *
 646  * @ingroup Scrolled_Entry
 647  */
 648 EAPI void
 649 elm_scrolled_entry_cursor_begin_set(Evas_Object *obj)
 650 {
 651    ELM_CHECK_WIDTYPE(obj, widtype);
 652    Widget_Data *wd = elm_widget_data_get(obj);
 653    if (!wd) return;
 654    elm_entry_cursor_begin_set(wd->entry);
 655 }
 656
 657 /**
 658  * This moves the cursor to the end of the entry.
 659  *
 660  * @param obj The scrolled entry object
 661  *
 662  * @ingroup Scrolled_Entry
 663  */
 664 EAPI void
 665 elm_scrolled_entry_cursor_end_set(Evas_Object *obj)
 666 {
 667    ELM_CHECK_WIDTYPE(obj, widtype);
 668    Widget_Data *wd = elm_widget_data_get(obj);
 669    if (!wd) return;
 670    elm_entry_cursor_end_set(wd->entry);
 671 }
 672
 673 /**
 674  * This moves the cursor to the beginning of the current line.
 675  *
 676  * @param obj The scrolled entry object
 677  *
 678  * @ingroup Scrolled_Entry
 679  */
 680 EAPI void
 681 elm_scrolled_entry_cursor_line_begin_set(Evas_Object *obj)
 682 {
 683    ELM_CHECK_WIDTYPE(obj, widtype);
 684    Widget_Data *wd = elm_widget_data_get(obj);
 685    if (!wd) return;
 686    elm_entry_cursor_line_begin_set(wd->entry);
 687 }
 688
 689 /**
 690  * This moves the cursor to the end of the current line.
 691  *
 692  * @param obj The scrolled entry object
 693  *
 694  * @ingroup Scrolled_Entry
 695  */
 696 EAPI void
 697 elm_scrolled_entry_cursor_line_end_set(Evas_Object *obj)
 698 {
 699    ELM_CHECK_WIDTYPE(obj, widtype);
 700    Widget_Data *wd = elm_widget_data_get(obj);
 701    if (!wd) return;
 702    elm_entry_cursor_line_end_set(wd->entry);
 703 }
 704
 705 /**
 706  * This begins a selection within the scrolled entry as though
 707  * the user were holding down the mouse button to make a selection.
 708  *
 709  * @param obj The scrolled entry object
 710  *
 711  * @ingroup Scrolled_Entry
 712  */
 713 EAPI void
 714 elm_scrolled_entry_cursor_selection_begin(Evas_Object *obj)
 715 {
 716    ELM_CHECK_WIDTYPE(obj, widtype);
 717    Widget_Data *wd = elm_widget_data_get(obj);
 718    if (!wd) return;
 719    elm_entry_cursor_selection_begin(wd->entry);
 720 }
 721
 722 /**
 723  * This ends a selection within the scrolled entry as though
 724  * the user had just released the mouse button while making a selection.
 725  *
 726  * @param obj The scrolled entry object
 727  *
 728  * @ingroup Scrolled_Entry
 729  */
 730 EAPI void
 731 elm_scrolled_entry_cursor_selection_end(Evas_Object *obj)
 732 {
 733    ELM_CHECK_WIDTYPE(obj, widtype);
 734    Widget_Data *wd = elm_widget_data_get(obj);
 735    if (!wd) return;
 736    elm_entry_cursor_selection_end(wd->entry);
 737 }
 738
 739 /**
 740  * TODO: fill this in
 741  *
 742  * @param obj The scrolled entry object
 743  * @return TODO: fill this in
 744  *
 745  * @ingroup Scrolled_Entry
 746  */
 747 EAPI Eina_Bool
 748 elm_scrolled_entry_cursor_is_format_get(const Evas_Object *obj)
 749 {
 750    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 751    Widget_Data *wd = elm_widget_data_get(obj);
 752    if (!wd) return EINA_FALSE;
 753    return elm_entry_cursor_is_format_get(wd->entry);
 754 }
 755
 756 /**
 757  * This returns whether the cursor is visible.
 758  *
 759  * @param obj The scrolled entry object
 760  * @return If true, the cursor is visible.
 761  *
 762  * @ingroup Scrolled_Entry
 763  */
 764 EAPI Eina_Bool
 765 elm_scrolled_entry_cursor_is_visible_format_get(const Evas_Object *obj)
 766 {
 767    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 768    Widget_Data *wd = elm_widget_data_get(obj);
 769    if (!wd) return EINA_FALSE;
 770    return elm_entry_cursor_is_visible_format_get(wd->entry);
 771 }
 772
 773 /**
 774  * TODO: fill this in
 775  *
 776  * @param obj The scrolled entry object
 777  * @return TODO: fill this in
 778  *
 779  * @ingroup Scrolled_Entry
 780  */
 781 EAPI const char *
 782 elm_scrolled_entry_cursor_content_get(const Evas_Object *obj)
 783 {
 784    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 785    Widget_Data *wd = elm_widget_data_get(obj);
 786    if (!wd) return NULL;
 787    return elm_entry_cursor_content_get(wd->entry);
 788 }
 789
 790 /**
 791  * This executes a "cut" action on the selected text in the scrolled entry.
 792  *
 793  * @param obj The scrolled entry object
 794  *
 795  * @ingroup Scrolled_Entry
 796  */
 797 EAPI void
 798 elm_scrolled_entry_selection_cut(Evas_Object *obj)
 799 {
 800    ELM_CHECK_WIDTYPE(obj, widtype);
 801    Widget_Data *wd = elm_widget_data_get(obj);
 802    if (!wd) return;
 803    elm_entry_selection_cut(wd->entry);
 804 }
 805
 806 /**
 807  * This executes a "copy" action on the selected text in the scrolled entry.
 808  *
 809  * @param obj The scrolled entry object
 810  *
 811  * @ingroup Scrolled_Entry
 812  */
 813 EAPI void
 814 elm_scrolled_entry_selection_copy(Evas_Object *obj)
 815 {
 816    ELM_CHECK_WIDTYPE(obj, widtype);
 817    Widget_Data *wd = elm_widget_data_get(obj);
 818    if (!wd) return;
 819    elm_entry_selection_copy(wd->entry);
 820 }
 821
 822 /**
 823  * This executes a "paste" action in the scrolled entry.
 824  *
 825  * @param obj The scrolled entry object
 826  *
 827  * @ingroup Scrolled_Entry
 828  */
 829 EAPI void
 830 elm_scrolled_entry_selection_paste(Evas_Object *obj)
 831 {
 832    ELM_CHECK_WIDTYPE(obj, widtype);
 833    Widget_Data *wd = elm_widget_data_get(obj);
 834    if (!wd) return;
 835    elm_entry_selection_paste(wd->entry);
 836 }
 837
 838 /**
 839  * This clears and frees the items in a scrolled entry's contextual (right click) menu.
 840  *
 841  * @param obj The scrolled entry object
 842  *
 843  * @ingroup Scrolled_Entry
 844  */
 845 EAPI void
 846 elm_scrolled_entry_context_menu_clear(Evas_Object *obj)
 847 {
 848    ELM_CHECK_WIDTYPE(obj, widtype);
 849    Widget_Data *wd = elm_widget_data_get(obj);
 850    if (!wd) return;
 851    elm_entry_context_menu_clear(wd->entry);
 852 }
 853
 854 /**
 855  * This adds an item to the scrolled entry's contextual menu.
 856  *
 857  * @param obj The scrolled entry object
 858  * @param label The item's text label
 859  * @param icon_file The item's icon file
 860  * @param icon_type The item's icon type
 861  * @param func The callback to execute when the item is clicked
 862  * @param data The data to associate with the item for related functions
 863  *
 864  * @ingroup Scrolled_Entry
 865  */
 866 EAPI void
 867 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)
 868 {
 869    ELM_CHECK_WIDTYPE(obj, widtype);
 870    Widget_Data *wd = elm_widget_data_get(obj);
 871    if (!wd) return;
 872    elm_entry_context_menu_item_add(wd->entry, label, icon_file, icon_type, func, data);
 873 }
 874
 875 /**
 876  * This disables the scrolled entry's contextual (right click) menu.
 877  *
 878  * @param obj The scrolled entry object
 879  * @param disabled If true, the menu is disabled
 880  *
 881  * @ingroup Scrolled_Entry
 882  */
 883 EAPI void
 884 elm_scrolled_entry_context_menu_disabled_set(Evas_Object *obj, Eina_Bool disabled)
 885 {
 886    ELM_CHECK_WIDTYPE(obj, widtype);
 887    Widget_Data *wd = elm_widget_data_get(obj);
 888    if (!wd) return;
 889    elm_entry_context_menu_disabled_set(wd->entry, disabled);
 890 }
 891
 892 /**
 893  * This returns whether the scrolled entry's contextual (right click) menu is disabled.
 894  *
 895  * @param obj The scrolled entry object
 896  * @return If true, the menu is disabled
 897  *
 898  * @ingroup Scrolled_Entry
 899  */
 900 EAPI Eina_Bool
 901 elm_scrolled_entry_context_menu_disabled_get(const Evas_Object *obj)
 902 {
 903    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 904    Widget_Data *wd = elm_widget_data_get(obj);
 905    if (!wd) return EINA_FALSE;
 906    return elm_entry_context_menu_disabled_get(wd->entry);
 907 }
 908
 909 /**
 910  * This sets the scrolled entry's scrollbar policy (ie. enabling/disabling them).
 911  *
 912  * @param obj The scrolled entry object
 913  * @param h The horizontal scrollbar policy to apply
 914  * @param v The vertical scrollbar policy to apply
 915  *
 916  * @ingroup Scrolled_Entry
 917  */
 918 EAPI void
 919 elm_scrolled_entry_scrollbar_policy_set(Evas_Object *obj, Elm_Scroller_Policy h, Elm_Scroller_Policy v)
 920 {
 921    ELM_CHECK_WIDTYPE(obj, widtype);
 922    Widget_Data *wd = elm_widget_data_get(obj);
 923    if (!wd) return;
 924    wd->policy_h = h;
 925    wd->policy_v = v;
 926    elm_scroller_policy_set(wd->scroller, h, v);
 927 }
 928
 929 /**
 930  * This enables/disables bouncing within the entry.
 931  *
 932  * @param obj The scrolled entry object
 933  * @param h The horizontal bounce state
 934  * @param v The vertical bounce state
 935  *
 936  * @ingroup Scrolled_Entry
 937  */
 938 EAPI void
 939 elm_scrolled_entry_bounce_set(Evas_Object *obj, Eina_Bool h_bounce, Eina_Bool v_bounce)
 940 {
 941    ELM_CHECK_WIDTYPE(obj, widtype);
 942    Widget_Data *wd = elm_widget_data_get(obj);
 943    if (!wd) return;
 944    elm_scroller_bounce_set(wd->scroller, h_bounce, v_bounce);
 945 }
 946 /**
 947  * This set's the maximum bytes that can be added in to scrolled entry.
 948  *
 949  * @param obj The  scrolled entry object
 950  * @param max_no_of_bytes Maximum number of bytes scrolled entry can have.
 951  *
 952  * @ingroup Scrolled_Entry
 953  */
 954 EAPI void
 955 elm_scrolled_entry_maximum_bytes_set(Evas_Object *obj, int max_no_of_bytes)
 956 {
 957    ELM_CHECK_WIDTYPE(obj, widtype);
 958    Widget_Data *wd = elm_widget_data_get(obj);
 959    if (!wd) return;
 960    elm_entry_maximum_bytes_set(wd->entry,max_no_of_bytes);
 961 }
 962
 963 /**
 964  * This set's the scrolled entry in password mode with out masking the last character entered by user,
 965  * and later masking the character after 2 seconds.
 966  *
 967  * @param obj The scrolled entry object
 968  * @param show_last_character The show_last_character flag (1 for "password mode along with showing last character"
 969  * 0 for default)
 970  *
 971  * @ingroup Scrolled_Entry
 972  */
 973 EAPI void
 974 elm_scrolled_entry_password_show_last_character_set(Evas_Object *obj, Eina_Bool show_last_character)
 975 {
 976    ELM_CHECK_WIDTYPE(obj, widtype);
 977    Widget_Data *wd = elm_widget_data_get(obj);
 978    if (!wd) return;
 979    elm_entry_password_show_last_character_set(wd->entry, show_last_character);
 980 }
 981
 982 /**
 983  * Get the input method context in the scrolled entry widget
 984  *
 985  * @param obj The scrolled entry object
 986  * @return The input method context
 987  *
 988  * @ingroup Scrolled_Entry
 989  */
 990 EAPI Ecore_IMF_Context *elm_scrolled_entry_imf_context_get(Evas_Object *obj)
 991 {
 992    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 993    Widget_Data *wd = elm_widget_data_get(obj);
 994    if (!wd || !wd->entry) return NULL;
 995
 996    return elm_entry_imf_context_get(wd->entry);
 997 }
 998
 999 /**
1000  * This sets the attribute to show the input panel automatically.
1001  *
1002  * @param obj The scrolled entry object
1003  * @param enabled If true, the input panel is appeared when entry is clicked or has a focus
1004  *
1005  * @ingroup Scrolled_Entry
1006  */
1007 EAPI void
1008 elm_scrolled_entry_input_panel_enabled_set(Evas_Object *obj, Eina_Bool enabled)
1009 {
1010    ELM_CHECK_WIDTYPE(obj, widtype);
1011    Widget_Data *wd = elm_widget_data_get(obj);
1012    if (!wd || !wd->entry) return;
1013
1014    elm_entry_input_panel_enabled_set(wd->entry, enabled);
1015 }
1016
1017 /**
1018  * Set the input panel layout of the scrolled entry
1019  *
1020  * @param obj The scrolled entry object
1021  * @param layout the layout to set
1022  *
1023  * @ingroup Scrolled_Entry
1024  */
1025 EAPI void
1026 elm_scrolled_entry_input_panel_layout_set(Evas_Object *obj, Elm_Input_Panel_Layout layout)
1027 {
1028    ELM_CHECK_WIDTYPE(obj, widtype);
1029    Widget_Data *wd = elm_widget_data_get(obj);
1030    if (!wd || !wd->entry) return;
1031
1032    elm_entry_input_panel_layout_set(wd->entry, layout);
1033 }
1034