src/lib/elm_entry.c

   1 #include <Elementary.h>
   2 #include <Elementary_Cursor.h>
   3 #include "elm_priv.h"
   4 #include "els_scroller.h"
   5
   6
   7 /* Maximum chunk size to be inserted to the entry at once
   8  * FIXME: This size is arbitrary, should probably choose a better size.
   9  * Possibly also find a way to set it to a low value for weak computers,
  10  * and to a big value for better computers. */
  11 #define _CHUNK_SIZE 10000
  12
  13 typedef struct _Mod_Api Mod_Api;
  14
  15 typedef struct _Widget_Data Widget_Data;
  16 typedef struct _Elm_Entry_Context_Menu_Item Elm_Entry_Context_Menu_Item;
  17 typedef struct _Elm_Entry_Item_Provider Elm_Entry_Item_Provider;
  18 typedef struct _Elm_Entry_Markup_Filter Elm_Entry_Markup_Filter;
  19
  20 struct _Widget_Data
  21 {
  22    Evas_Object *ent, *scroller;
  23    Evas_Object *hoversel;
  24    Ecore_Job *deferred_recalc_job;
  25    Ecore_Event_Handler *sel_notify_handler;
  26    Ecore_Event_Handler *sel_clear_handler;
  27    Ecore_Timer *longpress_timer;
  28    Ecore_Timer *delay_write;
  29    /* for deferred appending */
  30    Ecore_Idler *append_text_idler;
  31    char *append_text_left;
  32    int append_text_position;
  33    int append_text_len;
  34    /* Only for clipboard */
  35    const char *cut_sel;
  36    const char *text;
  37    const char *file;
  38    Elm_Text_Format format;
  39    Evas_Coord lastw, entmw, entmh;
  40    Evas_Coord downx, downy;
  41    Eina_List *items;
  42    Eina_List *item_providers;
  43    Eina_List *text_filters;
  44    Eina_List *markup_filters;
  45    Ecore_Job *hovdeljob;
  46    Mod_Api *api; // module api if supplied
  47    int cursor_pos;
  48    Elm_Scroller_Policy policy_h, policy_v;
  49    Elm_Wrap_Type linewrap;
  50    Elm_Input_Panel_Layout input_panel_layout;
  51    Elm_Autocapital_Type autocapital_type;
  52    Elm_Input_Panel_Lang input_panel_lang;
  53    Elm_Input_Panel_Return_Key_Type input_panel_return_key_type;
  54    void *input_panel_imdata;
  55    int input_panel_imdata_len;
  56    Eina_Bool changed : 1;
  57    Eina_Bool single_line : 1;
  58    Eina_Bool password : 1;
  59    Eina_Bool editable : 1;
  60    Eina_Bool selection_asked : 1;
  61    Eina_Bool have_selection : 1;
  62    Eina_Bool selmode : 1;
  63    Eina_Bool deferred_cur : 1;
  64    Eina_Bool cur_changed : 1;
  65    Eina_Bool disabled : 1;
  66    Eina_Bool context_menu : 1;
  67    Eina_Bool drag_selection_asked : 1;
  68    Eina_Bool can_write : 1;
  69    Eina_Bool autosave : 1;
  70    Eina_Bool textonly : 1;
  71    Eina_Bool usedown : 1;
  72    Eina_Bool scroll : 1;
  73    Eina_Bool h_bounce : 1;
  74    Eina_Bool v_bounce : 1;
  75    Eina_Bool input_panel_enable : 1;
  76    Eina_Bool prediction_allow : 1;
  77    Eina_Bool input_panel_return_key_disabled : 1;
  78 };
  79
  80 struct _Elm_Entry_Context_Menu_Item
  81 {
  82    Evas_Object *obj;
  83    const char *label;
  84    const char *icon_file;
  85    const char *icon_group;
  86    Elm_Icon_Type icon_type;
  87    Evas_Smart_Cb func;
  88    void *data;
  89 };
  90
  91 struct _Elm_Entry_Item_Provider
  92 {
  93    Evas_Object *(*func) (void *data, Evas_Object *entry, const char *item);
  94    void *data;
  95 };
  96
  97 struct _Elm_Entry_Markup_Filter
  98 {
  99    Elm_Entry_Filter_Cb func;
 100    void *data;
 101 };
 102
 103 typedef enum _Length_Unit
 104 {
 105    LENGTH_UNIT_CHAR,
 106    LENGTH_UNIT_BYTE,
 107    LENGTH_UNIT_LAST
 108 } Length_Unit;
 109
 110 static const char *widtype = NULL;
 111
 112 #ifdef HAVE_ELEMENTARY_X
 113 static Eina_Bool _drag_drop_cb(void *data, Evas_Object *obj, Elm_Selection_Data *);
 114 #endif
 115 static void _del_hook(Evas_Object *obj);
 116 static void _mirrored_set(Evas_Object *obj, Eina_Bool rtl);
 117 static void _theme_hook(Evas_Object *obj);
 118 static void _disable_hook(Evas_Object *obj);
 119 static void _sizing_eval(Evas_Object *obj);
 120 static void _on_focus_hook(void *data, Evas_Object *obj);
 121 static void _content_set_hook(Evas_Object *obj, const char *part, Evas_Object *content);
 122 static Evas_Object *_content_unset_hook(Evas_Object *obj, const char *part);
 123 static Evas_Object *_content_get_hook(const Evas_Object *obj, const char *part);
 124 static void _resize(void *data, Evas *e, Evas_Object *obj, void *event_info);
 125 static const char *_getbase(Evas_Object *obj);
 126 static void _signal_entry_changed(void *data, Evas_Object *obj, const char *emission, const char *source);
 127 static void _signal_selection_start(void *data, Evas_Object *obj, const char *emission, const char *source);
 128 static void _signal_selection_changed(void *data, Evas_Object *obj, const char *emission, const char *source);
 129 static void _signal_selection_cleared(void *data, Evas_Object *obj, const char *emission, const char *source);
 130 static void _signal_entry_paste_request(void *data, Evas_Object *obj, const char *emission, const char *source);
 131 static void _signal_entry_copy_notify(void *data, Evas_Object *obj, const char *emission, const char *source);
 132 static void _signal_entry_cut_notify(void *data, Evas_Object *obj, const char *emission, const char *source);
 133 static void _signal_cursor_changed(void *data, Evas_Object *obj, const char *emission, const char *source);
 134 static void _add_chars_till_limit(Evas_Object *obj, char **text, int can_add, Length_Unit unit);
 135
 136 static const char SIG_CHANGED[] = "changed";
 137 static const char SIG_CHANGED_USER[] = "changed,user";
 138 static const char SIG_ACTIVATED[] = "activated";
 139 static const char SIG_PRESS[] = "press";
 140 static const char SIG_LONGPRESSED[] = "longpressed";
 141 static const char SIG_CLICKED[] = "clicked";
 142 static const char SIG_CLICKED_DOUBLE[] = "clicked,double";
 143 static const char SIG_CLICKED_TRIPLE[] = "clicked,triple";
 144 static const char SIG_FOCUSED[] = "focused";
 145 static const char SIG_UNFOCUSED[] = "unfocused";
 146 static const char SIG_SELECTION_PASTE[] = "selection,paste";
 147 static const char SIG_SELECTION_COPY[] = "selection,copy";
 148 static const char SIG_SELECTION_CUT[] = "selection,cut";
 149 static const char SIG_SELECTION_START[] = "selection,start";
 150 static const char SIG_SELECTION_CHANGED[] = "selection,changed";
 151 static const char SIG_SELECTION_CLEARED[] = "selection,cleared";
 152 static const char SIG_CURSOR_CHANGED[] = "cursor,changed";
 153 static const char SIG_CURSOR_CHANGED_MANUAL[] = "cursor,changed,manual";
 154 static const char SIG_ANCHOR_CLICKED[] = "anchor,clicked";
 155 static const char SIG_ANCHOR_DOWN[] = "anchor,down";
 156 static const char SIG_ANCHOR_UP[] = "anchor,up";
 157 static const char SIG_ANCHOR_IN[] = "anchor,in";
 158 static const char SIG_ANCHOR_OUT[] = "anchor,out";
 159 static const char SIG_PREEDIT_CHANGED[] = "preedit,changed";
 160 static const char SIG_UNDO_REQUEST[] = "undo,request";
 161 static const char SIG_REDO_REQUEST[] = "redo,request";
 162 static const Evas_Smart_Cb_Description _signals[] = {
 163        {SIG_CHANGED, ""},
 164        {SIG_ACTIVATED, ""},
 165        {SIG_PRESS, ""},
 166        {SIG_LONGPRESSED, ""},
 167        {SIG_CLICKED, ""},
 168        {SIG_CLICKED_DOUBLE, ""},
 169        {SIG_CLICKED_TRIPLE, ""},
 170        {SIG_FOCUSED, ""},
 171        {SIG_UNFOCUSED, ""},
 172        {SIG_SELECTION_PASTE, ""},
 173        {SIG_SELECTION_COPY, ""},
 174        {SIG_SELECTION_CUT, ""},
 175        {SIG_SELECTION_START, ""},
 176        {SIG_SELECTION_CHANGED, ""},
 177        {SIG_SELECTION_CLEARED, ""},
 178        {SIG_CURSOR_CHANGED, ""},
 179        {SIG_CURSOR_CHANGED_MANUAL, ""},
 180        {SIG_ANCHOR_CLICKED, ""},
 181        {SIG_ANCHOR_DOWN, ""},
 182        {SIG_ANCHOR_UP, ""},
 183        {SIG_ANCHOR_IN, ""},
 184        {SIG_ANCHOR_OUT, ""},
 185        {SIG_PREEDIT_CHANGED, ""},
 186        {SIG_CHANGED_USER, ""},
 187        {SIG_UNDO_REQUEST, ""},
 188        {SIG_REDO_REQUEST, ""},
 189        {NULL, NULL}
 190 };
 191
 192 static Eina_List *entries = NULL;
 193
 194 struct _Mod_Api
 195 {
 196    void (*obj_hook) (Evas_Object *obj);
 197    void (*obj_unhook) (Evas_Object *obj);
 198    void (*obj_longpress) (Evas_Object *obj);
 199 };
 200
 201 static Mod_Api *
 202 _module(Evas_Object *obj __UNUSED__)
 203 {
 204    static Elm_Module *m = NULL;
 205    if (m) goto ok; // already found - just use
 206    if (!(m = _elm_module_find_as("entry/api"))) return NULL;
 207    // get module api
 208    m->api = malloc(sizeof(Mod_Api));
 209    if (!m->api) return NULL;
 210    ((Mod_Api *)(m->api)      )->obj_hook = // called on creation
 211       _elm_module_symbol_get(m, "obj_hook");
 212    ((Mod_Api *)(m->api)      )->obj_unhook = // called on deletion
 213       _elm_module_symbol_get(m, "obj_unhook");
 214    ((Mod_Api *)(m->api)      )->obj_longpress = // called on long press menu
 215       _elm_module_symbol_get(m, "obj_longpress");
 216 ok: // ok - return api
 217    return m->api;
 218 }
 219
 220 static char *
 221 _buf_append(char *buf, const char *str, int *len, int *alloc)
 222 {
 223    int len2 = strlen(str);
 224    if ((*len + len2) >= *alloc)
 225      {
 226         char *buf2 = realloc(buf, *alloc + len2 + 512);
 227         if (!buf2) return NULL;
 228         buf = buf2;
 229         *alloc += (512 + len2);
 230      }
 231    strcpy(buf + *len, str);
 232    *len += len2;
 233    return buf;
 234 }
 235
 236 static char *
 237 _load_file(const char *file)
 238 {
 239    FILE *f;
 240    size_t size;
 241    int alloc = 0, len = 0;
 242    char *text = NULL, buf[16384 + 1];
 243
 244    f = fopen(file, "rb");
 245    if (!f) return NULL;
 246    while ((size = fread(buf, 1, sizeof(buf) - 1, f)))
 247      {
 248         char *tmp_text;
 249         buf[size] = 0;
 250         tmp_text = _buf_append(text, buf, &len, &alloc);
 251         if (!tmp_text) break;
 252         text = tmp_text;
 253      }
 254    fclose(f);
 255    return text;
 256 }
 257
 258 static char *
 259 _load_plain(const char *file)
 260 {
 261    char *text;
 262
 263    text = _load_file(file);
 264    if (text)
 265      {
 266         char *text2;
 267
 268         text2 = elm_entry_utf8_to_markup(text);
 269         free(text);
 270         return text2;
 271      }
 272    return NULL;
 273 }
 274
 275 static void
 276 _load(Evas_Object *obj)
 277 {
 278    Widget_Data *wd = elm_widget_data_get(obj);
 279    char *text;
 280    if (!wd) return;
 281    if (!wd->file)
 282      {
 283         elm_object_text_set(obj, "");
 284         return;
 285      }
 286    switch (wd->format)
 287      {
 288       case ELM_TEXT_FORMAT_PLAIN_UTF8:
 289          text = _load_plain(wd->file);
 290          break;
 291       case ELM_TEXT_FORMAT_MARKUP_UTF8:
 292          text = _load_file(wd->file);
 293          break;
 294       default:
 295          text = NULL;
 296          break;
 297      }
 298    if (text)
 299      {
 300         elm_object_text_set(obj, text);
 301         free(text);
 302      }
 303    else
 304      elm_object_text_set(obj, "");
 305 }
 306
 307 static void
 308 _save_markup_utf8(const char *file, const char *text)
 309 {
 310    FILE *f;
 311
 312    if ((!text) || (!text[0]))
 313      {
 314         ecore_file_unlink(file);
 315         return;
 316      }
 317    f = fopen(file, "wb");
 318    if (!f)
 319      {
 320         // FIXME: report a write error
 321         return;
 322      }
 323    fputs(text, f); // FIXME: catch error
 324    fclose(f);
 325 }
 326
 327 static void
 328 _save_plain_utf8(const char *file, const char *text)
 329 {
 330    char *text2;
 331
 332    text2 = elm_entry_markup_to_utf8(text);
 333    if (!text2)
 334      return;
 335    _save_markup_utf8(file, text2);
 336    free(text2);
 337 }
 338
 339 static void
 340 _save(Evas_Object *obj)
 341 {
 342    Widget_Data *wd = elm_widget_data_get(obj);
 343    if (!wd) return;
 344    if (!wd->file) return;
 345    switch (wd->format)
 346      {
 347       case ELM_TEXT_FORMAT_PLAIN_UTF8:
 348          _save_plain_utf8(wd->file, elm_object_text_get(obj));
 349          break;
 350       case ELM_TEXT_FORMAT_MARKUP_UTF8:
 351          _save_markup_utf8(wd->file, elm_object_text_get(obj));
 352          break;
 353       default:
 354          break;
 355      }
 356 }
 357
 358 static Eina_Bool
 359 _delay_write(void *data)
 360 {
 361    Widget_Data *wd = elm_widget_data_get(data);
 362    if (!wd) return ECORE_CALLBACK_CANCEL;
 363    _save(data);
 364    wd->delay_write = NULL;
 365    return ECORE_CALLBACK_CANCEL;
 366 }
 367
 368 static Elm_Entry_Markup_Filter *
 369 _filter_new(Elm_Entry_Filter_Cb func, void *data)
 370 {
 371    Elm_Entry_Markup_Filter *tf = ELM_NEW(Elm_Entry_Markup_Filter);
 372    if (!tf) return NULL;
 373
 374    tf->func = func;
 375    if (func == elm_entry_filter_limit_size)
 376      {
 377         Elm_Entry_Filter_Limit_Size *lim = data, *lim2;
 378
 379         if (!data)
 380           {
 381              free(tf);
 382              return NULL;
 383           }
 384         lim2 = malloc(sizeof(Elm_Entry_Filter_Limit_Size));
 385         if (!lim2)
 386           {
 387              free(tf);
 388              return NULL;
 389           }
 390         memcpy(lim2, lim, sizeof(Elm_Entry_Filter_Limit_Size));
 391         tf->data = lim2;
 392      }
 393    else if (func == elm_entry_filter_accept_set)
 394      {
 395         Elm_Entry_Filter_Accept_Set *as = data, *as2;
 396
 397         if (!data)
 398           {
 399              free(tf);
 400              return NULL;
 401           }
 402         as2 = malloc(sizeof(Elm_Entry_Filter_Accept_Set));
 403         if (!as2)
 404           {
 405              free(tf);
 406              return NULL;
 407           }
 408         if (as->accepted)
 409           as2->accepted = eina_stringshare_add(as->accepted);
 410         else
 411           as2->accepted = NULL;
 412         if (as->rejected)
 413           as2->rejected = eina_stringshare_add(as->rejected);
 414         else
 415           as2->rejected = NULL;
 416         tf->data = as2;
 417      }
 418    else
 419      tf->data = data;
 420    return tf;
 421 }
 422
 423 static void
 424 _filter_free(Elm_Entry_Markup_Filter *tf)
 425 {
 426    if (tf->func == elm_entry_filter_limit_size)
 427      {
 428         Elm_Entry_Filter_Limit_Size *lim = tf->data;
 429         if (lim) free(lim);
 430      }
 431    else if (tf->func == elm_entry_filter_accept_set)
 432      {
 433         Elm_Entry_Filter_Accept_Set *as = tf->data;
 434         if (as)
 435           {
 436              if (as->accepted) eina_stringshare_del(as->accepted);
 437              if (as->rejected) eina_stringshare_del(as->rejected);
 438              free(as);
 439           }
 440      }
 441    free(tf);
 442 }
 443
 444 static void
 445 _del_pre_hook(Evas_Object *obj)
 446 {
 447    Widget_Data *wd = elm_widget_data_get(obj);
 448    if (!wd) return;
 449    if (wd->delay_write)
 450      {
 451         ecore_timer_del(wd->delay_write);
 452         wd->delay_write = NULL;
 453         if (wd->autosave) _save(obj);
 454      }
 455 }
 456
 457 static void
 458 _del_hook(Evas_Object *obj)
 459 {
 460    Widget_Data *wd = elm_widget_data_get(obj);
 461    Elm_Entry_Context_Menu_Item *it;
 462    Elm_Entry_Item_Provider *ip;
 463    Elm_Entry_Markup_Filter *tf;
 464
 465    evas_event_freeze(evas_object_evas_get(obj));
 466
 467    if (wd->file) eina_stringshare_del(wd->file);
 468
 469    if (wd->hovdeljob) ecore_job_del(wd->hovdeljob);
 470    if ((wd->api) && (wd->api->obj_unhook)) wd->api->obj_unhook(obj); // module - unhook
 471
 472    entries = eina_list_remove(entries, obj);
 473 #ifdef HAVE_ELEMENTARY_X
 474    if (wd->sel_notify_handler)
 475      ecore_event_handler_del(wd->sel_notify_handler);
 476    if (wd->sel_clear_handler)
 477      ecore_event_handler_del(wd->sel_clear_handler);
 478 #endif
 479    if (wd->cut_sel) eina_stringshare_del(wd->cut_sel);
 480    if (wd->text) eina_stringshare_del(wd->text);
 481    if (wd->deferred_recalc_job) ecore_job_del(wd->deferred_recalc_job);
 482    if (wd->append_text_idler)
 483      {
 484         ecore_idler_del(wd->append_text_idler);
 485         free(wd->append_text_left);
 486         wd->append_text_left = NULL;
 487         wd->append_text_idler = NULL;
 488      }
 489    if (wd->longpress_timer) ecore_timer_del(wd->longpress_timer);
 490    EINA_LIST_FREE(wd->items, it)
 491      {
 492         eina_stringshare_del(it->label);
 493         eina_stringshare_del(it->icon_file);
 494         eina_stringshare_del(it->icon_group);
 495         free(it);
 496      }
 497    EINA_LIST_FREE(wd->item_providers, ip)
 498      {
 499         free(ip);
 500      }
 501    EINA_LIST_FREE(wd->text_filters, tf)
 502      {
 503         _filter_free(tf);
 504      }
 505    EINA_LIST_FREE(wd->markup_filters, tf)
 506      {
 507         _filter_free(tf);
 508      }
 509    if (wd->delay_write) ecore_timer_del(wd->delay_write);
 510    if (wd->input_panel_imdata) free(wd->input_panel_imdata);
 511    free(wd);
 512
 513    evas_event_thaw(evas_object_evas_get(obj));
 514    evas_event_thaw_eval(evas_object_evas_get(obj));
 515 }
 516
 517 static void
 518 _mirrored_set(Evas_Object *obj, Eina_Bool rtl)
 519 {
 520    Widget_Data *wd = elm_widget_data_get(obj);
 521    edje_object_mirrored_set(wd->ent, rtl);
 522 }
 523
 524 static void
 525 _theme_hook(Evas_Object *obj)
 526 {
 527    Widget_Data *wd = elm_widget_data_get(obj);
 528    const char *t;
 529
 530    evas_event_freeze(evas_object_evas_get(obj));
 531    _elm_widget_mirrored_reload(obj);
 532    _mirrored_set(obj, elm_widget_mirrored_get(obj));
 533
 534    t = eina_stringshare_add(elm_object_text_get(obj));
 535    _elm_theme_object_set(obj, wd->ent, "entry", _getbase(obj), elm_widget_style_get(obj));
 536    if (_elm_config->desktop_entry)
 537      edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_TRUE);
 538    elm_object_text_set(obj, t);
 539    eina_stringshare_del(t);
 540    if (elm_widget_disabled_get(obj))
 541      edje_object_signal_emit(wd->ent, "elm,state,disabled", "elm");
 542    edje_object_part_text_input_panel_layout_set(wd->ent, "elm.text", wd->input_panel_layout);
 543    edje_object_part_text_autocapital_type_set(wd->ent, "elm.text", wd->autocapital_type);
 544    edje_object_part_text_prediction_allow_set(wd->ent, "elm.text", wd->prediction_allow);
 545    edje_object_part_text_input_panel_enabled_set(wd->ent, "elm.text", wd->input_panel_enable);
 546    edje_object_part_text_input_panel_imdata_set(wd->ent, "elm.text", wd->input_panel_imdata, wd->input_panel_imdata_len);
 547    edje_object_part_text_input_panel_return_key_type_set(wd->ent, "elm.text", wd->input_panel_return_key_type);
 548    edje_object_part_text_input_panel_return_key_disabled_set(wd->ent, "elm.text", wd->input_panel_return_key_disabled);
 549
 550    if (wd->cursor_pos != 0)
 551      elm_entry_cursor_pos_set(obj, wd->cursor_pos);
 552    if (elm_widget_focus_get(obj))
 553      edje_object_signal_emit(wd->ent, "elm,action,focus", "elm");
 554    edje_object_message_signal_process(wd->ent);
 555    edje_object_scale_set(wd->ent, elm_widget_scale_get(obj) * _elm_config->scale);
 556    if (wd->scroll)
 557      {
 558         const char *str;
 559         Evas_Object *edj;
 560
 561         elm_smart_scroller_mirrored_set(wd->scroller, elm_widget_mirrored_get(obj));
 562         elm_smart_scroller_object_theme_set(obj, wd->scroller, "scroller", "entry",
 563                                        elm_widget_style_get(obj));
 564         edj = elm_smart_scroller_edje_object_get(wd->scroller);
 565         str = edje_object_data_get(edj, "focus_highlight");
 566         if ((str) && (!strcmp(str, "on")))
 567           elm_widget_highlight_in_theme_set(obj, EINA_TRUE);
 568         else
 569           elm_widget_highlight_in_theme_set(obj, EINA_FALSE);
 570      }
 571    _sizing_eval(obj);
 572    evas_event_thaw(evas_object_evas_get(obj));
 573    evas_event_thaw_eval(evas_object_evas_get(obj));
 574 }
 575
 576 static void
 577 _disable_hook(Evas_Object *obj)
 578 {
 579    Widget_Data *wd = elm_widget_data_get(obj);
 580
 581    if (elm_widget_disabled_get(obj))
 582      {
 583         edje_object_signal_emit(wd->ent, "elm,state,disabled", "elm");
 584         wd->disabled = EINA_TRUE;
 585      }
 586    else
 587      {
 588         edje_object_signal_emit(wd->ent, "elm,state,enabled", "elm");
 589         wd->disabled = EINA_FALSE;
 590      }
 591 }
 592
 593 static void
 594 _recalc_cursor_geometry(Evas_Object *obj)
 595 {
 596    Widget_Data *wd = elm_widget_data_get(obj);
 597    if (!wd) return;
 598    evas_object_smart_callback_call(obj, SIG_CURSOR_CHANGED, NULL);
 599    if (!wd->deferred_recalc_job)
 600      {
 601         Evas_Coord cx, cy, cw, ch;
 602         edje_object_part_text_cursor_geometry_get(wd->ent, "elm.text",
 603                                                   &cx, &cy, &cw, &ch);
 604         if (wd->cur_changed)
 605           {
 606              elm_widget_show_region_set(obj, cx, cy, cw, ch, EINA_FALSE);
 607              wd->cur_changed = EINA_FALSE;
 608           }
 609      }
 610    else
 611      wd->deferred_cur = EINA_TRUE;
 612 }
 613
 614 static void
 615 _elm_deferred_recalc_job(void *data)
 616 {
 617    Widget_Data *wd = elm_widget_data_get(data);
 618    Evas_Coord minh = -1, resw = -1, minw = -1, fw = 0, fh = 0;
 619    if (!wd) return;
 620    wd->deferred_recalc_job = NULL;
 621
 622    evas_object_geometry_get(wd->ent, NULL, NULL, &resw, NULL);
 623    edje_object_size_min_restricted_calc(wd->ent, &minw, &minh, resw, 0);
 624    elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 625    /* This is a hack to workaround the way min size hints are treated.
 626     * If the minimum width is smaller than the restricted width, it means
 627     * the mininmum doesn't matter. */
 628    if (minw <= resw)
 629      {
 630         Evas_Coord ominw = -1;
 631         evas_object_size_hint_min_get(data, &ominw, NULL);
 632         minw = ominw;
 633      }
 634
 635    wd->entmw = minw;
 636    wd->entmh = minh;
 637
 638    elm_coords_finger_size_adjust(1, &fw, 1, &fh);
 639    if (wd->scroll)
 640      {
 641         Evas_Coord vmw = 0, vmh = 0;
 642
 643         edje_object_size_min_calc
 644            (elm_smart_scroller_edje_object_get(wd->scroller),
 645                &vmw, &vmh);
 646         if (wd->single_line)
 647           {
 648              evas_object_size_hint_min_set(data, vmw, minh + vmh);
 649              evas_object_size_hint_max_set(data, -1, minh + vmh);
 650           }
 651         else
 652           {
 653              evas_object_size_hint_min_set(data, vmw, vmh);
 654              evas_object_size_hint_max_set(data, -1, -1);
 655           }
 656      }
 657    else
 658      {
 659         if (wd->single_line)
 660           {
 661              evas_object_size_hint_min_set(data, minw, minh);
 662              evas_object_size_hint_max_set(data, -1, minh);
 663           }
 664         else
 665           {
 666              evas_object_size_hint_min_set(data, fw, minh);
 667              evas_object_size_hint_max_set(data, -1, -1);
 668           }
 669      }
 670
 671    if (wd->deferred_cur)
 672      {
 673         Evas_Coord cx, cy, cw, ch;
 674         edje_object_part_text_cursor_geometry_get(wd->ent, "elm.text",
 675                                                   &cx, &cy, &cw, &ch);
 676         if (wd->cur_changed)
 677           {
 678              elm_widget_show_region_set(data, cx, cy, cw, ch, EINA_FALSE);
 679              wd->cur_changed = EINA_FALSE;
 680           }
 681      }
 682 }
 683
 684 static void
 685 _sizing_eval(Evas_Object *obj)
 686 {
 687    Widget_Data *wd = elm_widget_data_get(obj);
 688    Evas_Coord minw = -1, minh = -1;
 689    Evas_Coord resw, resh;
 690    if (!wd) return;
 691
 692    evas_object_geometry_get(obj, NULL, NULL, &resw, &resh);
 693    if (wd->linewrap)
 694      {
 695         if ((resw == wd->lastw) && (!wd->changed)) return;
 696         evas_event_freeze(evas_object_evas_get(obj));
 697         wd->changed = EINA_FALSE;
 698         wd->lastw = resw;
 699         if (wd->scroll)
 700           {
 701              Evas_Coord vw = 0, vh = 0, vmw = 0, vmh = 0, w = -1, h = -1;
 702
 703              evas_object_resize(wd->scroller, resw, resh);
 704              edje_object_size_min_calc
 705                 (elm_smart_scroller_edje_object_get(wd->scroller),
 706                  &vmw, &vmh);
 707              elm_smart_scroller_child_viewport_size_get(wd->scroller, &vw, &vh);
 708              edje_object_size_min_restricted_calc(wd->ent, &minw, &minh, vw, 0);
 709              elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 710              /* This is a hack to workaround the way min size hints are treated.
 711               * If the minimum width is smaller than the restricted width, it means
 712               * the mininmum doesn't matter. */
 713              if (minw <= vw)
 714                {
 715                   Evas_Coord ominw = -1;
 716                   evas_object_size_hint_min_get(wd->ent, &ominw, NULL);
 717                   minw = ominw;
 718                }
 719              wd->entmw = minw;
 720              wd->entmh = minh;
 721
 722              if ((minw > 0) && (vw < minw)) vw = minw;
 723              if (minh > vh) vh = minh;
 724
 725              if (wd->single_line) h = vmh + minh;
 726              else h = vmh;
 727              evas_object_resize(wd->ent, vw, vh);
 728              evas_object_size_hint_min_set(obj, w, h);
 729              if (wd->single_line)
 730                evas_object_size_hint_max_set(obj, -1, h);
 731              else
 732                evas_object_size_hint_max_set(obj, -1, -1);
 733           }
 734         else
 735           {
 736              if (wd->deferred_recalc_job) ecore_job_del(wd->deferred_recalc_job);
 737              wd->deferred_recalc_job = ecore_job_add(_elm_deferred_recalc_job, obj);
 738           }
 739         evas_event_thaw(evas_object_evas_get(obj));
 740         evas_event_thaw_eval(evas_object_evas_get(obj));
 741      }
 742    else
 743      {
 744         if (!wd->changed) return;
 745         evas_event_freeze(evas_object_evas_get(obj));
 746         wd->changed = EINA_FALSE;
 747         wd->lastw = resw;
 748         if (wd->scroll)
 749           {
 750              Evas_Coord vw = 0, vh = 0, vmw = 0, vmh = 0, w = -1, h = -1;
 751
 752              edje_object_size_min_calc(wd->ent, &minw, &minh);
 753              wd->entmw = minw;
 754              wd->entmh = minh;
 755              elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 756
 757              elm_smart_scroller_child_viewport_size_get(wd->scroller, &vw, &vh);
 758
 759              if (minw > vw) vw = minw;
 760              if (minh > vh) vh = minh;
 761
 762              evas_object_resize(wd->ent, vw, vh);
 763              edje_object_size_min_calc
 764                 (elm_smart_scroller_edje_object_get(wd->scroller),
 765                  &vmw, &vmh);
 766              if (wd->single_line) h = vmh + minh;
 767              else h = vmh;
 768              evas_object_size_hint_min_set(obj, w, h);
 769              if (wd->single_line)
 770                evas_object_size_hint_max_set(obj, -1, h);
 771              else
 772                evas_object_size_hint_max_set(obj, -1, -1);
 773           }
 774         else
 775           {
 776              edje_object_size_min_calc(wd->ent, &minw, &minh);
 777              wd->entmw = minw;
 778              wd->entmh = minh;
 779              elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 780              evas_object_size_hint_min_set(obj, minw, minh);
 781              if (wd->single_line)
 782                evas_object_size_hint_max_set(obj, -1, minh);
 783              else
 784                evas_object_size_hint_max_set(obj, -1, -1);
 785           }
 786         evas_event_thaw(evas_object_evas_get(obj));
 787         evas_event_thaw_eval(evas_object_evas_get(obj));
 788      }
 789
 790    _recalc_cursor_geometry(obj);
 791 }
 792
 793 static void
 794 _on_focus_hook(void *data __UNUSED__, Evas_Object *obj)
 795 {
 796    Widget_Data *wd = elm_widget_data_get(obj);
 797    Evas_Object *top = elm_widget_top_get(obj);
 798    if (!wd) return;
 799    if (!wd->editable) return;
 800    if (elm_widget_focus_get(obj))
 801      {
 802         evas_object_focus_set(wd->ent, EINA_TRUE);
 803         edje_object_signal_emit(wd->ent, "elm,action,focus", "elm");
 804         if (top && wd->input_panel_enable)
 805           elm_win_keyboard_mode_set(top, ELM_WIN_KEYBOARD_ON);
 806         evas_object_smart_callback_call(obj, SIG_FOCUSED, NULL);
 807      }
 808    else
 809      {
 810         edje_object_signal_emit(wd->ent, "elm,action,unfocus", "elm");
 811         evas_object_focus_set(wd->ent, EINA_FALSE);
 812         if (top && wd->input_panel_enable)
 813           elm_win_keyboard_mode_set(top, ELM_WIN_KEYBOARD_OFF);
 814         evas_object_smart_callback_call(obj, SIG_UNFOCUSED, NULL);
 815      }
 816 }
 817
 818 static void
 819 _content_set_hook(Evas_Object *obj, const char *part, Evas_Object *content)
 820 {
 821    Widget_Data *wd = elm_widget_data_get(obj);
 822    Evas_Object *edje;
 823    if ((!wd) || (!content)) return;
 824
 825    if (wd->scroll)
 826       edje = elm_smart_scroller_edje_object_get(wd->scroller);
 827    else
 828       edje = wd->ent;
 829
 830    /* Delete the currently swallowed object */
 831    Evas_Object *cswallow;
 832
 833    if (!part || !strcmp(part, "icon"))
 834      {
 835         cswallow = edje_object_part_swallow_get(edje, "elm.swallow.icon");
 836         edje_object_signal_emit(edje, "elm,action,show,icon", "elm");
 837      }
 838    else if (!strcmp(part, "end"))
 839      {
 840         cswallow = edje_object_part_swallow_get(edje, "elm.swallow.end");
 841         edje_object_signal_emit(edje, "elm,action,show,end", "elm");
 842      }
 843    else
 844      cswallow = edje_object_part_swallow_get(edje, part);
 845
 846    if (cswallow) evas_object_del(cswallow);
 847
 848    evas_event_freeze(evas_object_evas_get(obj));
 849    elm_widget_sub_object_add(obj, content);
 850
 851    if (!part || !strcmp(part, "icon"))
 852      edje_object_part_swallow(edje, "elm.swallow.icon", content);
 853    else if (!strcmp(part, "end"))
 854      edje_object_part_swallow(edje, "elm.swallow.end", content);
 855    else
 856      edje_object_part_swallow(edje, part, content);
 857
 858    _sizing_eval(obj);
 859    evas_event_thaw(evas_object_evas_get(obj));
 860    evas_event_thaw_eval(evas_object_evas_get(obj));
 861 }
 862
 863 static Evas_Object *
 864 _content_unset_hook(Evas_Object *obj, const char *part)
 865 {
 866    Widget_Data *wd = elm_widget_data_get(obj);
 867    Evas_Object *content, *edje;
 868    if (!wd) return NULL;
 869
 870    if (wd->scroll)
 871       edje = elm_smart_scroller_edje_object_get(wd->scroller);
 872    else
 873       edje = wd->ent;
 874
 875    if (!part || !strcmp(part, "icon"))
 876      {
 877         edje_object_signal_emit(edje, "elm,action,hide,icon", "elm");
 878         content = edje_object_part_swallow_get(edje, "elm.swallow.icon");
 879      }
 880    else if (!strcmp(part, "end"))
 881      {
 882         edje_object_signal_emit(edje, "elm,action,hide,end", "elm");
 883         content = edje_object_part_swallow_get(edje, "elm.swallow.end");
 884      }
 885    else
 886      content = edje_object_part_swallow_get(edje, part);
 887
 888    edje_object_part_swallow(edje, part, NULL);
 889    if (!content) return NULL;
 890    evas_event_freeze(evas_object_evas_get(obj));
 891    elm_widget_sub_object_del(obj, content);
 892    edje_object_part_unswallow(wd->ent, content);
 893    _sizing_eval(obj);
 894    evas_event_thaw(evas_object_evas_get(obj));
 895    evas_event_thaw_eval(evas_object_evas_get(obj));
 896
 897    return content;
 898 }
 899
 900 static Evas_Object *
 901 _content_get_hook(const Evas_Object *obj, const char *part)
 902 {
 903    Widget_Data *wd = elm_widget_data_get(obj);
 904    Evas_Object *content = NULL, *edje;
 905    if (!wd) return NULL;
 906
 907    if (wd->scroll)
 908       edje = elm_smart_scroller_edje_object_get(wd->scroller);
 909    else
 910       edje = wd->ent;
 911
 912    if (!edje) return NULL;
 913
 914    if (!part || !strcmp(part, "icon"))
 915      content = edje_object_part_swallow_get(edje, "elm.swallow.icon");
 916    else if (!strcmp(part, "end"))
 917      content = edje_object_part_swallow_get(edje, "elm.swallow.end");
 918    else
 919      content = edje_object_part_swallow_get(edje, part);
 920
 921    return content;
 922 }
 923
 924 static void
 925 _translate_hook(Evas_Object *obj)
 926 {
 927    evas_object_smart_callback_call(obj, "language,changed", NULL);
 928 }
 929
 930 static void
 931 _signal_emit_hook(Evas_Object *obj, const char *emission, const char *source)
 932 {
 933    Widget_Data *wd = elm_widget_data_get(obj);
 934    if (!wd) return;
 935    edje_object_signal_emit(wd->ent, emission, source);
 936    if (wd->scroller)
 937      edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scroller),
 938                              emission, source);
 939 }
 940
 941 static void
 942 _signal_callback_add_hook(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func_cb, void *data)
 943 {
 944    Widget_Data *wd = elm_widget_data_get(obj);
 945    if (!wd) return;
 946    edje_object_signal_callback_add(wd->ent, emission, source, func_cb, data);
 947    if (wd->scroller)
 948      edje_object_signal_callback_add(elm_smart_scroller_edje_object_get(wd->scroller),
 949                                      emission, source, func_cb, data);
 950 }
 951
 952 static void
 953 _signal_callback_del_hook(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func_cb, void *data)
 954 {
 955    Widget_Data *wd = elm_widget_data_get(obj);
 956    edje_object_signal_callback_del_full(wd->ent, emission, source, func_cb,
 957                                         data);
 958    if (wd->scroller)
 959      edje_object_signal_callback_del_full(elm_smart_scroller_edje_object_get(wd->scroller),
 960                                           emission, source, func_cb, data);
 961 }
 962
 963 static void
 964 _on_focus_region_hook(const Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h)
 965 {
 966    Widget_Data *wd = elm_widget_data_get(obj);
 967    edje_object_part_text_cursor_geometry_get(wd->ent, "elm.text", x, y, w, h);
 968 }
 969
 970 static void
 971 _focus_region_hook(Evas_Object *obj, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h)
 972 {
 973    Widget_Data *wd = elm_widget_data_get(obj);
 974    if (wd->scroll)
 975      elm_smart_scroller_child_region_show(wd->scroller, x, y, w, h);
 976 }
 977
 978 static void
 979 _show_region_hook(void *data, Evas_Object *obj)
 980 {
 981    Widget_Data *wd = elm_widget_data_get(data);
 982    Evas_Coord x, y, w, h;
 983    if (!wd) return;
 984    elm_widget_show_region_get(obj, &x, &y, &w, &h);
 985    if (wd->scroll)
 986      elm_smart_scroller_child_region_show(wd->scroller, x, y, w, h);
 987 }
 988
 989 static void
 990 _sub_del(void *data, Evas_Object *obj, void *event_info)
 991 {
 992    Widget_Data *wd = data;
 993    Evas_Object *sub = event_info;
 994    Evas_Object *edje;
 995
 996    if (wd->scroll)
 997       edje = elm_smart_scroller_edje_object_get(wd->scroller);
 998    else
 999       edje = wd->ent;
1000
1001    if (sub == edje_object_part_swallow_get(edje, "elm.swallow.icon"))
1002      {
1003         edje_object_part_unswallow(edje, sub);
1004         if (edje)
1005           edje_object_signal_emit(edje, "elm,action,hide,icon", "elm");
1006      }
1007    else if (sub == edje_object_part_swallow_get(edje, "elm.swallow.end"))
1008      {
1009         edje_object_part_unswallow(edje, sub);
1010         if (edje)
1011           edje_object_signal_emit(edje, "elm,action,hide,end", "elm");
1012      }
1013    _sizing_eval(obj);
1014 }
1015
1016 static void
1017 _hoversel_position(Evas_Object *obj)
1018 {
1019    Widget_Data *wd = elm_widget_data_get(obj);
1020    Evas_Coord cx, cy, cw, ch, x, y, mw, mh;
1021    if (!wd) return;
1022
1023    cx = cy = 0;
1024    cw = ch = 1;
1025    evas_object_geometry_get(wd->ent, &x, &y, NULL, NULL);
1026    if (wd->usedown)
1027      {
1028         cx = wd->downx - x;
1029         cy = wd->downy - y;
1030         cw = 1;
1031         ch = 1;
1032      }
1033    else
1034      edje_object_part_text_cursor_geometry_get(wd->ent, "elm.text",
1035                                                &cx, &cy, &cw, &ch);
1036    evas_object_size_hint_min_get(wd->hoversel, &mw, &mh);
1037    if (cw < mw)
1038      {
1039         cx += (cw - mw) / 2;
1040         cw = mw;
1041      }
1042    if (ch < mh)
1043      {
1044         cy += (ch - mh) / 2;
1045         ch = mh;
1046      }
1047    evas_object_move(wd->hoversel, x + cx, y + cy);
1048    evas_object_resize(wd->hoversel, cw, ch);
1049 }
1050
1051 static void
1052 _move(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1053 {
1054    Widget_Data *wd = elm_widget_data_get(data);
1055
1056    if (wd->hoversel) _hoversel_position(data);
1057 }
1058
1059 static void
1060 _resize(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1061 {
1062    Widget_Data *wd = elm_widget_data_get(data);
1063    if (!wd) return;
1064
1065    if (wd->linewrap)
1066      {
1067         _sizing_eval(data);
1068      }
1069    else if (wd->scroll)
1070      {
1071         Evas_Coord vw = 0, vh = 0;
1072
1073         elm_smart_scroller_child_viewport_size_get(wd->scroller, &vw, &vh);
1074         if (vw < wd->entmw) vw = wd->entmw;
1075         if (vh < wd->entmh) vh = wd->entmh;
1076         evas_object_resize(wd->ent, vw, vh);
1077      }
1078    if (wd->hoversel) _hoversel_position(data);
1079 }
1080
1081 static void
1082 _hover_del(void *data)
1083 {
1084    Widget_Data *wd = elm_widget_data_get(data);
1085    if (!wd) return;
1086
1087    if (wd->hoversel)
1088      {
1089         evas_object_del(wd->hoversel);
1090         wd->hoversel = NULL;
1091      }
1092    wd->hovdeljob = NULL;
1093 }
1094
1095 static void
1096 _dismissed(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1097 {
1098    Widget_Data *wd = elm_widget_data_get(data);
1099    if (!wd) return;
1100    wd->usedown = 0;
1101    if (wd->hoversel) evas_object_hide(wd->hoversel);
1102    if (wd->selmode)
1103      {
1104         if (!_elm_config->desktop_entry)
1105           {
1106              if (!wd->password)
1107                edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_TRUE);
1108           }
1109      }
1110    elm_widget_scroll_freeze_pop(data);
1111    if (wd->hovdeljob) ecore_job_del(wd->hovdeljob);
1112    wd->hovdeljob = ecore_job_add(_hover_del, data);
1113 }
1114
1115 static void
1116 _select(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1117 {
1118    Widget_Data *wd = elm_widget_data_get(data);
1119    if (!wd) return;
1120    wd->selmode = EINA_TRUE;
1121    edje_object_part_text_select_none(wd->ent, "elm.text");
1122    if (!_elm_config->desktop_entry)
1123      {
1124         if (!wd->password)
1125           edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_TRUE);
1126      }
1127    edje_object_signal_emit(wd->ent, "elm,state,select,on", "elm");
1128    if (!_elm_config->desktop_entry)
1129      elm_widget_scroll_hold_push(data);
1130 }
1131
1132 void
1133 _elm_entry_entry_paste(Evas_Object *obj, const char *entry)
1134 {
1135    Elm_Entry_Change_Info info;
1136    info.merge = EINA_FALSE;
1137    info.insert = EINA_TRUE;
1138    info.change.insert.pos = elm_entry_cursor_pos_get(obj);
1139    info.change.insert.content = eina_stringshare_add(entry);
1140      {
1141         char *tmp;
1142         tmp = evas_textblock_text_markup_to_utf8(elm_entry_textblock_get(obj),
1143               info.change.insert.content);
1144         info.change.insert.plain_length = eina_unicode_utf8_get_len(tmp);
1145         free(tmp);
1146      }
1147
1148    elm_entry_entry_insert(obj, entry);
1149    evas_object_smart_callback_call(obj, SIG_CHANGED_USER, &info);
1150
1151    eina_stringshare_del(info.change.insert.content);
1152 }
1153
1154 static void
1155 _paste(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1156 {
1157    Widget_Data *wd = elm_widget_data_get(data);
1158    if (!wd) return;
1159    evas_object_smart_callback_call(data, SIG_SELECTION_PASTE, NULL);
1160    if (wd->sel_notify_handler)
1161      {
1162 #ifdef HAVE_ELEMENTARY_X
1163         Elm_Sel_Format formats;
1164         wd->selection_asked = EINA_TRUE;
1165         formats = ELM_SEL_FORMAT_MARKUP;
1166         if (!wd->textonly)
1167           formats |= ELM_SEL_FORMAT_IMAGE;
1168         elm_cnp_selection_get(ELM_SEL_TYPE_CLIPBOARD, formats, data, NULL, NULL);
1169 #endif
1170      }
1171 }
1172
1173 static void
1174 _store_selection(Elm_Sel_Type seltype, Evas_Object *obj)
1175 {
1176    Widget_Data *wd = elm_widget_data_get(obj);
1177    const char *sel;
1178
1179    if (!wd) return;
1180    sel = edje_object_part_text_selection_get(wd->ent, "elm.text");
1181    if ((!sel) || (!sel[0])) return; /* avoid deleting our own selection */
1182    elm_cnp_selection_set(seltype, obj, ELM_SEL_FORMAT_MARKUP, sel, strlen(sel));
1183    if (seltype == ELM_SEL_TYPE_CLIPBOARD)
1184      eina_stringshare_replace(&wd->cut_sel, sel);
1185 }
1186
1187 static void
1188 _cut(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1189 {
1190    Widget_Data *wd = elm_widget_data_get(data);
1191
1192    /* Store it */
1193    wd->selmode = EINA_FALSE;
1194    if (!_elm_config->desktop_entry)
1195      edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_FALSE);
1196    edje_object_signal_emit(wd->ent, "elm,state,select,off", "elm");
1197    if (!_elm_config->desktop_entry)
1198      elm_widget_scroll_hold_pop(data);
1199    _store_selection(ELM_SEL_TYPE_CLIPBOARD, data);
1200    edje_object_part_text_insert(wd->ent, "elm.text", "");
1201    edje_object_part_text_select_none(wd->ent, "elm.text");
1202    _sizing_eval(data);
1203 }
1204
1205 static void
1206 _copy(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1207 {
1208    Widget_Data *wd = elm_widget_data_get(data);
1209    if (!wd) return;
1210    wd->selmode = EINA_FALSE;
1211    if (!_elm_config->desktop_entry)
1212      {
1213         edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_FALSE);
1214         edje_object_signal_emit(wd->ent, "elm,state,select,off", "elm");
1215         elm_widget_scroll_hold_pop(data);
1216      }
1217    _store_selection(ELM_SEL_TYPE_CLIPBOARD, data);
1218    //   edje_object_part_text_select_none(wd->ent, "elm.text");
1219 }
1220
1221 static void
1222 _cancel(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1223 {
1224    Widget_Data *wd = elm_widget_data_get(data);
1225    if (!wd) return;
1226    wd->selmode = EINA_FALSE;
1227    if (!_elm_config->desktop_entry)
1228      edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_FALSE);
1229    edje_object_signal_emit(wd->ent, "elm,state,select,off", "elm");
1230    if (!_elm_config->desktop_entry)
1231      elm_widget_scroll_hold_pop(data);
1232    edje_object_part_text_select_none(wd->ent, "elm.text");
1233 }
1234
1235 static void
1236 _item_clicked(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1237 {
1238    Elm_Entry_Context_Menu_Item *it = data;
1239    Evas_Object *obj2 = it->obj;
1240    if (it->func) it->func(it->data, obj2, NULL);
1241 }
1242
1243 static void
1244 _menu_press(Evas_Object *obj)
1245 {
1246    Widget_Data *wd = elm_widget_data_get(obj);
1247    Evas_Object *top;
1248    const Eina_List *l;
1249    const Elm_Entry_Context_Menu_Item *it;
1250    if (!wd) return;
1251    if ((wd->api) && (wd->api->obj_longpress))
1252      {
1253         wd->api->obj_longpress(obj);
1254      }
1255    else if (wd->context_menu)
1256      {
1257         const char *context_menu_orientation;
1258
1259         if (wd->hoversel) evas_object_del(wd->hoversel);
1260         else elm_widget_scroll_freeze_push(obj);
1261         wd->hoversel = elm_hoversel_add(obj);
1262         context_menu_orientation = edje_object_data_get
1263            (wd->ent, "context_menu_orientation");
1264         if ((context_menu_orientation) &&
1265             (!strcmp(context_menu_orientation, "horizontal")))
1266           elm_hoversel_horizontal_set(wd->hoversel, EINA_TRUE);
1267         elm_object_style_set(wd->hoversel, "entry");
1268         elm_widget_sub_object_add(obj, wd->hoversel);
1269         elm_object_text_set(wd->hoversel, "Text");
1270         top = elm_widget_top_get(obj);
1271         if (top) elm_hoversel_hover_parent_set(wd->hoversel, top);
1272         evas_object_smart_callback_add(wd->hoversel, "dismissed", _dismissed, obj);
1273         if (wd->have_selection)
1274           {
1275              if (!wd->password)
1276                {
1277                   if (wd->have_selection)
1278                     {
1279                        elm_hoversel_item_add(wd->hoversel, E_("Copy"), NULL, ELM_ICON_NONE,
1280                                              _copy, obj);
1281                        if (wd->editable)
1282                          elm_hoversel_item_add(wd->hoversel, E_("Cut"), NULL, ELM_ICON_NONE,
1283                                                _cut, obj);
1284                     }
1285                   elm_hoversel_item_add(wd->hoversel, E_("Cancel"), NULL, ELM_ICON_NONE,
1286                                         _cancel, obj);
1287                }
1288           }
1289         else
1290           {
1291              if (!wd->selmode)
1292                {
1293                   if (!_elm_config->desktop_entry)
1294                     {
1295                        if (!wd->password)
1296                          elm_hoversel_item_add(wd->hoversel, E_("Select"), NULL, ELM_ICON_NONE,
1297                                                _select, obj);
1298                     }
1299                   if (elm_selection_selection_has_owner())
1300                     {
1301                        if (wd->editable)
1302                          elm_hoversel_item_add(wd->hoversel, E_("Paste"), NULL, ELM_ICON_NONE,
1303                                                _paste, obj);
1304                     }
1305                }
1306           }
1307         EINA_LIST_FOREACH(wd->items, l, it)
1308           {
1309              elm_hoversel_item_add(wd->hoversel, it->label, it->icon_file,
1310                                    it->icon_type, _item_clicked, it);
1311           }
1312         if (wd->hoversel)
1313           {
1314              _hoversel_position(obj);
1315              evas_object_show(wd->hoversel);
1316              elm_hoversel_hover_begin(wd->hoversel);
1317           }
1318         if (!_elm_config->desktop_entry)
1319           {
1320              edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_FALSE);
1321              edje_object_part_text_select_abort(wd->ent, "elm.text");
1322           }
1323      }
1324 }
1325
1326 static Eina_Bool
1327 _long_press(void *data)
1328 {
1329    Widget_Data *wd = elm_widget_data_get(data);
1330    if (!wd) return ECORE_CALLBACK_CANCEL;
1331    _menu_press(data);
1332    wd->longpress_timer = NULL;
1333    evas_object_smart_callback_call(data, SIG_LONGPRESSED, NULL);
1334    return ECORE_CALLBACK_CANCEL;
1335 }
1336
1337 static void
1338 _mouse_down(void *data, Evas *evas __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
1339 {
1340    Widget_Data *wd = elm_widget_data_get(data);
1341    Evas_Event_Mouse_Down *ev = event_info;
1342    if (!wd) return;
1343    if (wd->disabled) return;
1344    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
1345    wd->downx = ev->canvas.x;
1346    wd->downy = ev->canvas.y;
1347    if (ev->button == 1)
1348      {
1349         if (wd->longpress_timer) ecore_timer_del(wd->longpress_timer);
1350         wd->longpress_timer = ecore_timer_add(_elm_config->longpress_timeout, _long_press, data);
1351      }
1352 }
1353
1354 static void
1355 _mouse_up(void *data, Evas *evas __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
1356 {
1357    Widget_Data *wd = elm_widget_data_get(data);
1358    Evas_Event_Mouse_Up *ev = event_info;
1359    if (!wd) return;
1360    if (wd->disabled) return;
1361    if (ev->button == 1)
1362      {
1363         if (wd->longpress_timer)
1364           {
1365              ecore_timer_del(wd->longpress_timer);
1366              wd->longpress_timer = NULL;
1367           }
1368      }
1369    else if (ev->button == 3)
1370      {
1371         wd->usedown = 1;
1372         _menu_press(data);
1373      }
1374 }
1375
1376 static void
1377 _mouse_move(void *data, Evas *evas __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
1378 {
1379    Widget_Data *wd = elm_widget_data_get(data);
1380    Evas_Event_Mouse_Move *ev = event_info;
1381    if (!wd) return;
1382    if (wd->disabled) return;
1383    if (!wd->selmode)
1384      {
1385         if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
1386           {
1387              if (wd->longpress_timer)
1388                {
1389                   ecore_timer_del(wd->longpress_timer);
1390                   wd->longpress_timer = NULL;
1391                }
1392           }
1393         else if (wd->longpress_timer)
1394           {
1395              Evas_Coord dx, dy;
1396
1397              dx = wd->downx - ev->cur.canvas.x;
1398              dx *= dx;
1399              dy = wd->downy - ev->cur.canvas.y;
1400              dy *= dy;
1401              if ((dx + dy) >
1402                  ((_elm_config->finger_size / 2) *
1403                   (_elm_config->finger_size / 2)))
1404                {
1405                   ecore_timer_del(wd->longpress_timer);
1406                   wd->longpress_timer = NULL;
1407                }
1408           }
1409      }
1410    else if (wd->longpress_timer)
1411      {
1412         Evas_Coord dx, dy;
1413
1414         dx = wd->downx - ev->cur.canvas.x;
1415         dx *= dx;
1416         dy = wd->downy - ev->cur.canvas.y;
1417         dy *= dy;
1418         if ((dx + dy) >
1419             ((_elm_config->finger_size / 2) *
1420              (_elm_config->finger_size / 2)))
1421           {
1422              ecore_timer_del(wd->longpress_timer);
1423              wd->longpress_timer = NULL;
1424           }
1425      }
1426 }
1427
1428 static const char *
1429 _getbase(Evas_Object *obj)
1430 {
1431    Widget_Data *wd = elm_widget_data_get(obj);
1432    if (!wd) return "base";
1433    if (wd->editable)
1434      {
1435         if (wd->password) return "base-password";
1436         else
1437           {
1438              if (wd->single_line) return "base-single";
1439              else
1440                {
1441                   switch (wd->linewrap)
1442                     {
1443                      case ELM_WRAP_CHAR:
1444                         return "base-charwrap";
1445                      case ELM_WRAP_WORD:
1446                         return "base";
1447                      case ELM_WRAP_MIXED:
1448                         return "base-mixedwrap";
1449                      case ELM_WRAP_NONE:
1450                      default:
1451                         return "base-nowrap";
1452                     }
1453                }
1454           }
1455      }
1456    else
1457      {
1458         if (wd->password) return "base-password";
1459         else
1460           {
1461              if (wd->single_line) return "base-single-noedit";
1462              else
1463                {
1464                   switch (wd->linewrap)
1465                     {
1466                      case ELM_WRAP_CHAR:
1467                         return "base-noedit-charwrap";
1468                      case ELM_WRAP_WORD:
1469                         return "base-noedit";
1470                      case ELM_WRAP_MIXED:
1471                         return "base-noedit-mixedwrap";
1472                      case ELM_WRAP_NONE:
1473                      default:
1474                         return "base-nowrap-noedit";
1475                     }
1476                }
1477           }
1478      }
1479 }
1480
1481 static void
1482 _entry_changed_common_handling(void *data, const char *event)
1483 {
1484    Widget_Data *wd = elm_widget_data_get(data);
1485    Evas_Coord minh;
1486    if (!wd) return;
1487    evas_event_freeze(evas_object_evas_get(data));
1488    wd->changed = EINA_TRUE;
1489    /* Reset the size hints which are no more relevant.
1490     * Keep the height, this is a hack, but doesn't really matter
1491     * cause we'll re-eval in a moment. */
1492    evas_object_size_hint_min_get(data, NULL, &minh);
1493    evas_object_size_hint_min_set(data, -1, minh);
1494    _sizing_eval(data);
1495    if (wd->text) eina_stringshare_del(wd->text);
1496    wd->text = NULL;
1497    if (wd->delay_write)
1498      {
1499         ecore_timer_del(wd->delay_write);
1500         wd->delay_write = NULL;
1501      }
1502    evas_event_thaw(evas_object_evas_get(data));
1503    evas_event_thaw_eval(evas_object_evas_get(data));
1504    if ((wd->autosave) && (wd->file))
1505      wd->delay_write = ecore_timer_add(2.0, _delay_write, data);
1506    /* callback - this could call callbacks that delete the entry... thus...
1507     * any access to wd after this could be invalid */
1508    evas_object_smart_callback_call(data, event, NULL);
1509 }
1510
1511 static void
1512 _signal_entry_changed(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1513 {
1514    _entry_changed_common_handling(data, SIG_CHANGED);
1515 }
1516
1517 static void
1518 _signal_entry_changed_user(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1519 {
1520    Elm_Entry_Change_Info info;
1521    Edje_Entry_Change_Info *edje_info = (Edje_Entry_Change_Info *)
1522       edje_object_signal_callback_extra_data_get();
1523    if (edje_info)
1524      {
1525         memcpy(&info, edje_info, sizeof(info));
1526         evas_object_smart_callback_call(data, SIG_CHANGED_USER, &info);
1527      }
1528    else
1529      {
1530         evas_object_smart_callback_call(data, SIG_CHANGED_USER, NULL);
1531      }
1532 }
1533
1534 static void
1535 _signal_preedit_changed(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1536 {
1537    _entry_changed_common_handling(data, SIG_PREEDIT_CHANGED);
1538 }
1539
1540 static void
1541 _signal_undo_request(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1542 {
1543    evas_object_smart_callback_call(data, SIG_UNDO_REQUEST, NULL);
1544 }
1545
1546 static void
1547 _signal_redo_request(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1548 {
1549    evas_object_smart_callback_call(data, SIG_REDO_REQUEST, NULL);
1550 }
1551
1552 static void
1553 _signal_selection_start(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1554 {
1555    Widget_Data *wd = elm_widget_data_get(data);
1556    const Eina_List *l;
1557    Evas_Object *entry;
1558    if (!wd) return;
1559    EINA_LIST_FOREACH(entries, l, entry)
1560      {
1561         if (entry != data) elm_entry_select_none(entry);
1562      }
1563    wd->have_selection = EINA_TRUE;
1564    evas_object_smart_callback_call(data, SIG_SELECTION_START, NULL);
1565 #ifdef HAVE_ELEMENTARY_X
1566    if (wd->sel_notify_handler)
1567      {
1568         const char *txt = elm_entry_selection_get(data);
1569         Evas_Object *top;
1570
1571         top = elm_widget_top_get(data);
1572         if (txt && top && (elm_win_xwindow_get(top)))
1573           elm_cnp_selection_set(ELM_SEL_TYPE_PRIMARY, data,
1574                                 ELM_SEL_FORMAT_MARKUP, txt, strlen(txt));
1575      }
1576 #endif
1577 }
1578
1579 static void
1580 _signal_selection_all(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1581 {
1582    Widget_Data *wd = elm_widget_data_get(data);
1583    if (!wd) return;
1584    elm_entry_select_all(data);
1585 }
1586
1587 static void
1588 _signal_selection_none(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1589 {
1590    Widget_Data *wd = elm_widget_data_get(data);
1591    if (!wd) return;
1592    elm_entry_select_none(data);
1593 }
1594
1595 static void
1596 _signal_selection_changed(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1597 {
1598    Widget_Data *wd = elm_widget_data_get(data);
1599    if (!wd) return;
1600    wd->have_selection = EINA_TRUE;
1601    evas_object_smart_callback_call(data, SIG_SELECTION_CHANGED, NULL);
1602    _store_selection(ELM_SEL_TYPE_PRIMARY, data);
1603 }
1604
1605 static void
1606 _signal_selection_cleared(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1607 {
1608    Widget_Data *wd = elm_widget_data_get(data);
1609    if (!wd) return;
1610    if (!wd->have_selection) return;
1611    wd->have_selection = EINA_FALSE;
1612    evas_object_smart_callback_call(data, SIG_SELECTION_CLEARED, NULL);
1613    if (wd->sel_notify_handler)
1614      {
1615         if (wd->cut_sel)
1616           {
1617 #ifdef HAVE_ELEMENTARY_X
1618              Evas_Object *top;
1619
1620              top = elm_widget_top_get(data);
1621              if ((top) && (elm_win_xwindow_get(top)))
1622                elm_cnp_selection_set(ELM_SEL_TYPE_PRIMARY, data,
1623                                      ELM_SEL_FORMAT_MARKUP, wd->cut_sel,
1624                                      strlen(wd->cut_sel));
1625 #endif
1626              eina_stringshare_del(wd->cut_sel);
1627              wd->cut_sel = NULL;
1628           }
1629         else
1630           {
1631 #ifdef HAVE_ELEMENTARY_X
1632              Evas_Object *top;
1633
1634              top = elm_widget_top_get(data);
1635              if ((top) && (elm_win_xwindow_get(top)))
1636                elm_cnp_selection_clear(ELM_SEL_TYPE_PRIMARY, data);
1637 #endif
1638           }
1639      }
1640 }
1641
1642 static void
1643 _signal_entry_paste_request(void *data, Evas_Object *obj __UNUSED__, const char *emission, const char *source __UNUSED__)
1644 {
1645    Widget_Data *wd = elm_widget_data_get(data);
1646    Elm_Sel_Type type = (emission[sizeof("ntry,paste,request,")] == '1') ?
1647      ELM_SEL_TYPE_PRIMARY : ELM_SEL_TYPE_CLIPBOARD;
1648    if (!wd) return;
1649    evas_object_smart_callback_call(data, SIG_SELECTION_PASTE, NULL);
1650    if (wd->sel_notify_handler)
1651      {
1652 #ifdef HAVE_ELEMENTARY_X
1653         Evas_Object *top;
1654
1655         top = elm_widget_top_get(data);
1656         if ((top) && (elm_win_xwindow_get(top)))
1657           {
1658              wd->selection_asked = EINA_TRUE;
1659              elm_cnp_selection_get(type, ELM_SEL_FORMAT_MARKUP, data,
1660                                NULL, NULL);
1661           }
1662 #endif
1663      }
1664 }
1665
1666 static void
1667 _signal_entry_copy_notify(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1668 {
1669    evas_object_smart_callback_call(data, SIG_SELECTION_COPY, NULL);
1670    _copy(data, NULL, NULL);
1671 }
1672
1673 static void
1674 _signal_entry_cut_notify(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1675 {
1676    evas_object_smart_callback_call(data, SIG_SELECTION_CUT, NULL);
1677    _cut(data, NULL, NULL);
1678 }
1679
1680 static void
1681 _signal_cursor_changed(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1682 {
1683    Widget_Data *wd = elm_widget_data_get(data);
1684    if (!wd) return;
1685    wd->cursor_pos = edje_object_part_text_cursor_pos_get(wd->ent, "elm.text", EDJE_CURSOR_MAIN);
1686    wd->cur_changed = EINA_TRUE;
1687    _recalc_cursor_geometry(data);
1688 }
1689
1690 static void
1691 _signal_cursor_changed_manual(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1692 {
1693    evas_object_smart_callback_call(data, SIG_CURSOR_CHANGED_MANUAL, NULL);
1694 }
1695
1696
1697 static void
1698 _signal_anchor_geoms_do_things_with(Widget_Data *wd, Elm_Entry_Anchor_Info *ei)
1699 {
1700    const Eina_List *geoms, *l;
1701    Evas_Textblock_Rectangle *r;
1702    Evas_Coord px, py, x, y;
1703
1704    geoms = edje_object_part_text_anchor_geometry_get(wd->ent, "elm.text", ei->name);
1705    if (!geoms) return;
1706
1707
1708    evas_object_geometry_get(wd->ent, &x, &y, NULL, NULL);
1709    evas_pointer_canvas_xy_get(evas_object_evas_get(wd->ent), &px, &py);
1710    EINA_LIST_FOREACH(geoms, l, r)
1711      {
1712         if (((r->x + x) <= px) && ((r->y + y) <= py) &&
1713             ((r->x + x + r->w) > px) && ((r->y + y + r->h) > py))
1714           {
1715              ei->x = r->x + x;
1716              ei->y = r->y + y;
1717              ei->w = r->w;
1718              ei->h = r->h;
1719              break;
1720           }
1721      }
1722 }
1723
1724 static void
1725 _signal_anchor_down(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1726 {
1727    Widget_Data *wd = elm_widget_data_get(data);
1728    Elm_Entry_Anchor_Info ei;
1729    const char *p;
1730    char *p2;
1731    if (!wd) return;
1732    p = emission + sizeof("nchor,mouse,down,");
1733    ei.button = strtol(p, &p2, 10);
1734    ei.name = p2 + 1;
1735    ei.x = ei.y = ei.w = ei.h = 0;
1736
1737    _signal_anchor_geoms_do_things_with(wd, &ei);
1738
1739    if (!wd->disabled)
1740      evas_object_smart_callback_call(data, SIG_ANCHOR_DOWN, &ei);
1741 }
1742
1743 static void
1744 _signal_anchor_up(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1745 {
1746    Widget_Data *wd = elm_widget_data_get(data);
1747    Elm_Entry_Anchor_Info ei;
1748    const char *p;
1749    char *p2;
1750    if (!wd) return;
1751    p = emission + sizeof("nchor,mouse,up,");
1752    ei.button = strtol(p, &p2, 10);
1753    ei.name = p2 + 1;
1754    ei.x = ei.y = ei.w = ei.h = 0;
1755
1756    _signal_anchor_geoms_do_things_with(wd, &ei);
1757
1758    if (!wd->disabled)
1759      evas_object_smart_callback_call(data, SIG_ANCHOR_UP, &ei);
1760 }
1761
1762 static void
1763 _signal_anchor_clicked(void *data, Evas_Object *obj __UNUSED__, const char *emission, const char *source __UNUSED__)
1764 {
1765    Widget_Data *wd = elm_widget_data_get(data);
1766    Elm_Entry_Anchor_Info ei;
1767    const char *p;
1768    char *p2;
1769    if (!wd) return;
1770    p = emission + sizeof("nchor,mouse,clicked,");
1771    ei.button = strtol(p, &p2, 10);
1772    ei.name = p2 + 1;
1773    ei.x = ei.y = ei.w = ei.h = 0;
1774
1775    _signal_anchor_geoms_do_things_with(wd, &ei);
1776
1777    if (!wd->disabled)
1778      evas_object_smart_callback_call(data, SIG_ANCHOR_CLICKED, &ei);
1779 }
1780
1781 static void
1782 _signal_anchor_move(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1783 {
1784    Widget_Data *wd = elm_widget_data_get(data);
1785    if (!wd) return;
1786 }
1787
1788 static void
1789 _signal_anchor_in(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1790 {
1791    Widget_Data *wd = elm_widget_data_get(data);
1792    Elm_Entry_Anchor_Info ei;
1793    if (!wd) return;
1794    ei.name = emission + sizeof("nchor,mouse,in,");
1795    ei.button = 0;
1796    ei.x = ei.y = ei.w = ei.h = 0;
1797
1798    _signal_anchor_geoms_do_things_with(wd, &ei);
1799
1800    if (!wd->disabled)
1801      evas_object_smart_callback_call(data, SIG_ANCHOR_IN, &ei);
1802 }
1803
1804 static void
1805 _signal_anchor_out(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1806 {
1807    Widget_Data *wd = elm_widget_data_get(data);
1808    Elm_Entry_Anchor_Info ei;
1809    if (!wd) return;
1810    ei.name = emission + sizeof("nchor,mouse,out,");
1811    ei.button = 0;
1812    ei.x = ei.y = ei.w = ei.h = 0;
1813
1814    _signal_anchor_geoms_do_things_with(wd, &ei);
1815
1816    if (!wd->disabled)
1817      evas_object_smart_callback_call(data, SIG_ANCHOR_OUT, &ei);
1818 }
1819
1820 static void
1821 _signal_key_enter(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1822 {
1823    Widget_Data *wd = elm_widget_data_get(data);
1824    if (!wd) return;
1825    evas_object_smart_callback_call(data, SIG_ACTIVATED, NULL);
1826 }
1827
1828 static void
1829 _signal_mouse_down(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1830 {
1831    Widget_Data *wd = elm_widget_data_get(data);
1832    if (!wd) return;
1833    evas_object_smart_callback_call(data, SIG_PRESS, NULL);
1834 }
1835
1836 static void
1837 _signal_mouse_clicked(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1838 {
1839    Widget_Data *wd = elm_widget_data_get(data);
1840    if (!wd) return;
1841    evas_object_smart_callback_call(data, SIG_CLICKED, NULL);
1842 }
1843
1844 static void
1845 _signal_mouse_double(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1846 {
1847    Widget_Data *wd = elm_widget_data_get(data);
1848    if (!wd) return;
1849    evas_object_smart_callback_call(data, SIG_CLICKED_DOUBLE, NULL);
1850 }
1851
1852 static void
1853 _signal_mouse_triple(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1854 {
1855    Widget_Data *wd = elm_widget_data_get(data);
1856    if (!wd) return;
1857    evas_object_smart_callback_call(data, SIG_CLICKED_TRIPLE, NULL);
1858 }
1859
1860 #ifdef HAVE_ELEMENTARY_X
1861 static Eina_Bool
1862 _event_selection_notify(void *data, int type __UNUSED__, void *event)
1863 {
1864    Widget_Data *wd = elm_widget_data_get(data);
1865    Ecore_X_Event_Selection_Notify *ev = event;
1866    if (!wd) return ECORE_CALLBACK_PASS_ON;
1867    if ((!wd->selection_asked) && (!wd->drag_selection_asked))
1868      return ECORE_CALLBACK_PASS_ON;
1869
1870    if ((ev->selection == ECORE_X_SELECTION_CLIPBOARD) ||
1871        (ev->selection == ECORE_X_SELECTION_PRIMARY))
1872      {
1873         Ecore_X_Selection_Data_Text *text_data;
1874
1875         text_data = ev->data;
1876         if (text_data->data.content == ECORE_X_SELECTION_CONTENT_TEXT)
1877           {
1878              if (text_data->text)
1879                {
1880                   char *txt = _elm_util_text_to_mkup(text_data->text);
1881
1882                   if (txt)
1883                     {
1884                        elm_entry_entry_insert(data, txt);
1885                        free(txt);
1886                     }
1887                }
1888           }
1889         wd->selection_asked = EINA_FALSE;
1890      }
1891    else if (ev->selection == ECORE_X_SELECTION_XDND)
1892      {
1893         Ecore_X_Selection_Data_Text *text_data;
1894
1895         text_data = ev->data;
1896         if (text_data->data.content == ECORE_X_SELECTION_CONTENT_TEXT)
1897           {
1898              if (text_data->text)
1899                {
1900                   char *txt = _elm_util_text_to_mkup(text_data->text);
1901
1902                   if (txt)
1903                     {
1904                        /* Massive FIXME: this should be at the drag point */
1905                        elm_entry_entry_insert(data, txt);
1906                        free(txt);
1907                     }
1908                }
1909           }
1910         wd->drag_selection_asked = EINA_FALSE;
1911
1912         ecore_x_dnd_send_finished();
1913
1914      }
1915    return ECORE_CALLBACK_PASS_ON;
1916 }
1917
1918 static Eina_Bool
1919 _event_selection_clear(void *data __UNUSED__, int type __UNUSED__, void *event __UNUSED__)
1920 {
1921    Widget_Data *wd = elm_widget_data_get(data);
1922    Ecore_X_Event_Selection_Clear *ev = event;
1923    if (!wd) return ECORE_CALLBACK_PASS_ON;
1924    if (!wd->have_selection) return ECORE_CALLBACK_PASS_ON;
1925    if ((ev->selection == ECORE_X_SELECTION_CLIPBOARD) ||
1926        (ev->selection == ECORE_X_SELECTION_PRIMARY))
1927      {
1928         elm_entry_select_none(data);
1929      }
1930    return ECORE_CALLBACK_PASS_ON;
1931 }
1932
1933 static Eina_Bool
1934 _drag_drop_cb(void *data __UNUSED__, Evas_Object *obj, Elm_Selection_Data *drop)
1935 {
1936    Widget_Data *wd;
1937    Eina_Bool rv;
1938
1939    wd = elm_widget_data_get(obj);
1940    if (!wd) return EINA_FALSE;
1941    printf("Inserting at (%d,%d) %s\n",drop->x,drop->y,(char*)drop->data);
1942
1943    edje_object_part_text_cursor_copy(wd->ent, "elm.text",
1944                                      EDJE_CURSOR_MAIN,/*->*/EDJE_CURSOR_USER);
1945    rv = edje_object_part_text_cursor_coord_set(wd->ent,"elm.text",
1946                                                EDJE_CURSOR_MAIN,drop->x,drop->y);
1947    if (!rv) printf("Warning: Failed to position cursor: paste anyway\n");
1948    elm_entry_entry_insert(obj, drop->data);
1949    edje_object_part_text_cursor_copy(wd->ent, "elm.text",
1950                                      EDJE_CURSOR_USER,/*->*/EDJE_CURSOR_MAIN);
1951
1952    return EINA_TRUE;
1953 }
1954 #endif
1955
1956 static Evas_Object *
1957 _get_item(void *data, Evas_Object *edje __UNUSED__, const char *part __UNUSED__, const char *item)
1958 {
1959    Widget_Data *wd = elm_widget_data_get(data);
1960    Evas_Object *o;
1961    Eina_List *l;
1962    Elm_Entry_Item_Provider *ip;
1963
1964    EINA_LIST_FOREACH(wd->item_providers, l, ip)
1965      {
1966         o = ip->func(ip->data, data, item);
1967         if (o) return o;
1968      }
1969    if (!strncmp(item, "file://", 7))
1970      {
1971         const char *fname = item + 7;
1972
1973         o = evas_object_image_filled_add(evas_object_evas_get(data));
1974         evas_object_image_file_set(o, fname, NULL);
1975         if (evas_object_image_load_error_get(o) == EVAS_LOAD_ERROR_NONE)
1976           {
1977              evas_object_show(o);
1978           }
1979         else
1980           {
1981              evas_object_del(o);
1982              o = edje_object_add(evas_object_evas_get(data));
1983              _elm_theme_object_set(data, o, "entry/emoticon", "wtf", elm_widget_style_get(data));
1984           }
1985         return o;
1986      }
1987    o = edje_object_add(evas_object_evas_get(data));
1988    if (!_elm_theme_object_set(data, o, "entry", item, elm_widget_style_get(data)))
1989      _elm_theme_object_set(data, o, "entry/emoticon", "wtf", elm_widget_style_get(data));
1990    return o;
1991 }
1992
1993 static void
1994 _text_filter(void *data, Evas_Object *edje __UNUSED__, const char *part __UNUSED__, Edje_Text_Filter_Type type, char **text)
1995 {
1996    Widget_Data *wd = elm_widget_data_get(data);
1997    Eina_List *l;
1998    Elm_Entry_Markup_Filter *tf;
1999
2000    if (type == EDJE_TEXT_FILTER_FORMAT)
2001      return;
2002
2003    EINA_LIST_FOREACH(wd->text_filters, l, tf)
2004      {
2005         tf->func(tf->data, data, text);
2006         if (!*text)
2007           break;
2008      }
2009 }
2010
2011 static void
2012 _markup_filter(void *data, Evas_Object *edje __UNUSED__, const char *part __UNUSED__, char **text)
2013 {
2014    Widget_Data *wd = elm_widget_data_get(data);
2015    Eina_List *l;
2016    Elm_Entry_Markup_Filter *tf;
2017
2018    EINA_LIST_FOREACH(wd->markup_filters, l, tf)
2019      {
2020         tf->func(tf->data, data, text);
2021         if (!*text)
2022           break;
2023      }
2024 }
2025
2026 /* This function is used to insert text by chunks in jobs */
2027 static Eina_Bool
2028 _text_append_idler(void *data)
2029 {
2030    int start;
2031    char backup;
2032    Evas_Object *obj = (Evas_Object *) data;
2033    Widget_Data *wd = elm_widget_data_get(obj);
2034    evas_event_freeze(evas_object_evas_get(obj));
2035    if (wd->text) eina_stringshare_del(wd->text);
2036    wd->text = NULL;
2037    wd->changed = EINA_TRUE;
2038
2039    start = wd->append_text_position;
2040    if (start + _CHUNK_SIZE < wd->append_text_len)
2041      {
2042         int pos = start;
2043         int tag_start, esc_start;
2044
2045         tag_start = esc_start = -1;
2046         /* Find proper markup cut place */
2047         while (pos - start < _CHUNK_SIZE)
2048           {
2049              int prev_pos = pos;
2050              Eina_Unicode tmp =
2051                 eina_unicode_utf8_get_next(wd->append_text_left, &pos);
2052              if (esc_start == -1)
2053                {
2054                   if (tmp == '<')
2055                      tag_start = prev_pos;
2056                   else if (tmp == '>')
2057                      tag_start = -1;
2058                }
2059              if (tag_start == -1)
2060                {
2061                   if (tmp == '&')
2062                      esc_start = prev_pos;
2063                   else if (tmp == ';')
2064                      esc_start = -1;
2065                }
2066           }
2067
2068         if (tag_start >= 0)
2069           {
2070              wd->append_text_position = tag_start;
2071           }
2072         else if (esc_start >= 0)
2073           {
2074              wd->append_text_position = esc_start;
2075           }
2076         else
2077           {
2078              wd->append_text_position = pos;
2079           }
2080      }
2081    else
2082      {
2083         wd->append_text_position = wd->append_text_len;
2084      }
2085
2086    backup = wd->append_text_left[wd->append_text_position];
2087    wd->append_text_left[wd->append_text_position] = '\0';
2088
2089    edje_object_part_text_append(wd->ent, "elm.text",
2090                                 wd->append_text_left + start);
2091
2092    wd->append_text_left[wd->append_text_position] = backup;
2093
2094    evas_event_thaw(evas_object_evas_get(obj));
2095    evas_event_thaw_eval(evas_object_evas_get(obj));
2096
2097    /* If there's still more to go, renew the idler, else, cleanup */
2098    if (wd->append_text_position < wd->append_text_len)
2099      {
2100         return ECORE_CALLBACK_RENEW;
2101      }
2102    else
2103      {
2104         free(wd->append_text_left);
2105         wd->append_text_left = NULL;
2106         wd->append_text_idler = NULL;
2107         return ECORE_CALLBACK_CANCEL;
2108      }
2109 }
2110
2111 static void
2112 _add_chars_till_limit(Evas_Object *obj, char **text, int can_add, Length_Unit unit)
2113 {
2114    int i = 0, current_len = 0;
2115    char *new_text;
2116
2117    if (!*text) return;
2118    if (unit >= LENGTH_UNIT_LAST) return;
2119    new_text = *text;
2120    current_len = strlen(*text);
2121    while (*new_text)
2122      {
2123         int idx = 0, unit_size = 0;
2124         char *markup, *utfstr;
2125         if (*new_text == '<')
2126           {
2127              while (*(new_text + idx) != '>')
2128                {
2129                   idx++;
2130                   if (!*(new_text + idx)) break;
2131                }
2132           }
2133         else if (*new_text == '&')
2134           {
2135              while (*(new_text + idx) != ';')
2136                {
2137                   idx++;
2138                   if (!*(new_text + idx)) break;
2139                }
2140           }
2141         idx = evas_string_char_next_get(new_text, idx, NULL);
2142         markup = malloc(idx + 1);
2143         if (markup)
2144           {
2145              strncpy(markup, new_text, idx);
2146              markup[idx] = 0;
2147              utfstr = elm_entry_markup_to_utf8(markup);
2148              if (utfstr)
2149                {
2150                   if (unit == LENGTH_UNIT_BYTE)
2151                     unit_size = strlen(utfstr);
2152                   else if (unit == LENGTH_UNIT_CHAR)
2153                     unit_size = evas_string_char_len_get(utfstr);
2154                   free(utfstr);
2155                   utfstr = NULL;
2156                }
2157              free(markup);
2158              markup = NULL;
2159           }
2160         if (can_add < unit_size)
2161           {
2162              if (!i)
2163                {
2164                   evas_object_smart_callback_call(obj, "maxlength,reached", NULL);
2165                   free(*text);
2166                   *text = NULL;
2167                   return;
2168                }
2169              can_add = 0;
2170              strncpy(new_text, new_text + idx, current_len - ((new_text + idx) - *text));
2171              current_len -= idx;
2172              (*text)[current_len] = 0;
2173           }
2174         else
2175           {
2176              new_text += idx;
2177              can_add -= unit_size;
2178           }
2179         i++;
2180      }
2181    evas_object_smart_callback_call(obj, "maxlength,reached", NULL);
2182 }
2183
2184 static void
2185 _elm_entry_text_set(Evas_Object *obj, const char *item, const char *entry)
2186 {
2187    int len = 0;
2188    ELM_CHECK_WIDTYPE(obj, widtype);
2189    Widget_Data *wd = elm_widget_data_get(obj);
2190    if (!wd) return;
2191    evas_event_freeze(evas_object_evas_get(obj));
2192    if (!entry) entry = "";
2193    if (item && strcmp(item, "default"))
2194      {
2195         edje_object_part_text_set(wd->ent, item, entry);
2196         return;
2197      }
2198
2199    if (wd->text) eina_stringshare_del(wd->text);
2200    wd->text = NULL;
2201    wd->changed = EINA_TRUE;
2202
2203    /* Clear currently pending job if there is one */
2204    if (wd->append_text_idler)
2205      {
2206         ecore_idler_del(wd->append_text_idler);
2207         free(wd->append_text_left);
2208         wd->append_text_left = NULL;
2209         wd->append_text_idler = NULL;
2210      }
2211
2212    len = strlen(entry);
2213    /* Split to ~_CHUNK_SIZE chunks */
2214    if (len > _CHUNK_SIZE)
2215      {
2216         wd->append_text_left = (char *) malloc(len + 1);
2217      }
2218
2219    /* If we decided to use the idler */
2220    if (wd->append_text_left)
2221      {
2222         /* Need to clear the entry first */
2223         edje_object_part_text_set(wd->ent, "elm.text", "");
2224         memcpy(wd->append_text_left, entry, len + 1);
2225         wd->append_text_position = 0;
2226         wd->append_text_len = len;
2227         wd->append_text_idler = ecore_idler_add(_text_append_idler, obj);
2228      }
2229    else
2230      {
2231         edje_object_part_text_set(wd->ent, "elm.text", entry);
2232      }
2233    evas_event_thaw(evas_object_evas_get(obj));
2234    evas_event_thaw_eval(evas_object_evas_get(obj));
2235 }
2236
2237 static const char *
2238 _elm_entry_text_get(const Evas_Object *obj, const char *item)
2239 {
2240    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
2241    Widget_Data *wd = elm_widget_data_get(obj);
2242    if (item && strcmp(item, "default")) return NULL;
2243    const char *text;
2244    if (!wd) return NULL;
2245    if (wd->text) return wd->text;
2246    text = edje_object_part_text_get(wd->ent, "elm.text");
2247    if (!text)
2248      {
2249         ERR("text=NULL for edje %p, part 'elm.text'", wd->ent);
2250         return NULL;
2251      }
2252
2253    if (wd->append_text_len > 0)
2254      {
2255         char *tmpbuf;
2256         size_t tlen;
2257         tlen = strlen(text);
2258         tmpbuf = malloc(tlen + wd->append_text_len + 1);
2259         if (!tmpbuf)
2260           {
2261              ERR("Failed to allocate memory for entry's text %p", obj);
2262              return NULL;
2263           }
2264         memcpy(tmpbuf, text, tlen);
2265         memcpy(tmpbuf + tlen, wd->append_text_left, wd->append_text_len);
2266         tmpbuf[tlen + wd->append_text_len] = '\0';
2267         eina_stringshare_replace(&wd->text, tmpbuf);
2268         free(tmpbuf);
2269      }
2270    else
2271      {
2272         eina_stringshare_replace(&wd->text, text);
2273      }
2274    return wd->text;
2275 }
2276
2277 EAPI Evas_Object *
2278 elm_entry_add(Evas_Object *parent)
2279 {
2280    Evas_Object *obj, *top;
2281    Evas *e;
2282    Widget_Data *wd;
2283
2284    ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
2285
2286    ELM_SET_WIDTYPE(widtype, "entry");
2287    elm_widget_type_set(obj, "entry");
2288    elm_widget_sub_object_add(parent, obj);
2289    elm_widget_on_focus_hook_set(obj, _on_focus_hook, NULL);
2290    elm_widget_data_set(obj, wd);
2291    elm_widget_del_hook_set(obj, _del_hook);
2292    elm_widget_del_pre_hook_set(obj, _del_pre_hook);
2293    elm_widget_theme_hook_set(obj, _theme_hook);
2294    elm_widget_disable_hook_set(obj, _disable_hook);
2295    elm_widget_signal_emit_hook_set(obj, _signal_emit_hook);
2296    elm_widget_focus_region_hook_set(obj, _focus_region_hook);
2297    elm_widget_on_focus_region_hook_set(obj, _on_focus_region_hook);
2298    elm_widget_signal_callback_add_hook_set(obj, _signal_callback_add_hook);
2299    elm_widget_signal_callback_del_hook_set(obj, _signal_callback_del_hook);
2300    elm_object_cursor_set(obj, ELM_CURSOR_XTERM);
2301    elm_widget_can_focus_set(obj, EINA_TRUE);
2302    elm_widget_highlight_ignore_set(obj, EINA_TRUE);
2303    elm_widget_text_set_hook_set(obj, _elm_entry_text_set);
2304    elm_widget_text_get_hook_set(obj, _elm_entry_text_get);
2305    elm_widget_content_set_hook_set(obj, _content_set_hook);
2306    elm_widget_content_unset_hook_set(obj, _content_unset_hook);
2307    elm_widget_content_get_hook_set(obj, _content_get_hook);
2308    elm_widget_translate_hook_set(obj, _translate_hook);
2309
2310    evas_object_smart_callback_add(obj, "sub-object-del", _sub_del, wd);
2311
2312    wd->linewrap     = ELM_WRAP_WORD;
2313    wd->editable     = EINA_TRUE;
2314    wd->disabled     = EINA_FALSE;
2315    wd->context_menu = EINA_TRUE;
2316    wd->autosave     = EINA_TRUE;
2317    wd->textonly     = EINA_FALSE;
2318    wd->scroll       = EINA_FALSE;
2319    wd->input_panel_imdata = NULL;
2320
2321    wd->ent = edje_object_add(e);
2322    edje_object_item_provider_set(wd->ent, _get_item, obj);
2323    edje_object_text_insert_filter_callback_add(wd->ent,"elm.text", _text_filter, obj);
2324    edje_object_markup_filter_callback_add(wd->ent,"elm.text", _markup_filter, obj);
2325    evas_object_event_callback_add(wd->ent, EVAS_CALLBACK_MOVE, _move, obj);
2326    evas_object_event_callback_add(wd->ent, EVAS_CALLBACK_MOUSE_DOWN,
2327                                   _mouse_down, obj);
2328    evas_object_event_callback_add(wd->ent, EVAS_CALLBACK_MOUSE_UP,
2329                                   _mouse_up, obj);
2330    evas_object_event_callback_add(wd->ent, EVAS_CALLBACK_MOUSE_MOVE,
2331                                   _mouse_move, obj);
2332    evas_object_event_callback_add(obj, EVAS_CALLBACK_RESIZE, _resize, obj);
2333
2334    _elm_theme_object_set(obj, wd->ent, "entry", "base", "default");
2335    edje_object_signal_callback_add(wd->ent, "entry,changed", "elm.text",
2336                                    _signal_entry_changed, obj);
2337    edje_object_signal_callback_add(wd->ent, "entry,changed,user", "elm.text",
2338                                    _signal_entry_changed_user, obj);
2339    edje_object_signal_callback_add(wd->ent, "preedit,changed", "elm.text",
2340                                    _signal_preedit_changed, obj);
2341    edje_object_signal_callback_add(wd->ent, "selection,start", "elm.text",
2342                                    _signal_selection_start, obj);
2343    edje_object_signal_callback_add(wd->ent, "selection,changed", "elm.text",
2344                                    _signal_selection_changed, obj);
2345    edje_object_signal_callback_add(wd->ent, "entry,selection,all,request", "elm.text",
2346                                    _signal_selection_all, obj);
2347    edje_object_signal_callback_add(wd->ent, "entry,selection,none,request", "elm.text",
2348                                    _signal_selection_none, obj);
2349    edje_object_signal_callback_add(wd->ent, "selection,cleared", "elm.text",
2350                                    _signal_selection_cleared, obj);
2351    edje_object_signal_callback_add(wd->ent, "entry,paste,request,*", "elm.text",
2352                                    _signal_entry_paste_request, obj);
2353    edje_object_signal_callback_add(wd->ent, "entry,copy,notify", "elm.text",
2354                                    _signal_entry_copy_notify, obj);
2355    edje_object_signal_callback_add(wd->ent, "entry,cut,notify", "elm.text",
2356                                    _signal_entry_cut_notify, obj);
2357    edje_object_signal_callback_add(wd->ent, "cursor,changed", "elm.text",
2358                                    _signal_cursor_changed, obj);
2359    edje_object_signal_callback_add(wd->ent, "cursor,changed,manual", "elm.text",
2360                                    _signal_cursor_changed_manual, obj);
2361    edje_object_signal_callback_add(wd->ent, "anchor,mouse,down,*", "elm.text",
2362                                    _signal_anchor_down, obj);
2363    edje_object_signal_callback_add(wd->ent, "anchor,mouse,up,*", "elm.text",
2364                                    _signal_anchor_up, obj);
2365    edje_object_signal_callback_add(wd->ent, "anchor,mouse,clicked,*", "elm.text",
2366                                    _signal_anchor_clicked, obj);
2367    edje_object_signal_callback_add(wd->ent, "anchor,mouse,move,*", "elm.text",
2368                                    _signal_anchor_move, obj);
2369    edje_object_signal_callback_add(wd->ent, "anchor,mouse,in,*", "elm.text",
2370                                    _signal_anchor_in, obj);
2371    edje_object_signal_callback_add(wd->ent, "anchor,mouse,out,*", "elm.text",
2372                                    _signal_anchor_out, obj);
2373    edje_object_signal_callback_add(wd->ent, "entry,key,enter", "elm.text",
2374                                    _signal_key_enter, obj);
2375    edje_object_signal_callback_add(wd->ent, "mouse,down,1", "elm.text",
2376                                    _signal_mouse_down, obj);
2377    edje_object_signal_callback_add(wd->ent, "mouse,clicked,1", "elm.text",
2378                                    _signal_mouse_clicked, obj);
2379    edje_object_signal_callback_add(wd->ent, "mouse,down,1,double", "elm.text",
2380                                    _signal_mouse_double, obj);
2381    edje_object_signal_callback_add(wd->ent, "mouse,down,1,triple", "elm.text",
2382                                    _signal_mouse_triple, obj);
2383    edje_object_signal_callback_add(wd->ent, "entry,undo,request", "elm.text",
2384                                    _signal_undo_request, obj);
2385    edje_object_signal_callback_add(wd->ent, "entry,redo,request", "elm.text",
2386                                    _signal_redo_request, obj);
2387    edje_object_part_text_set(wd->ent, "elm.text", "");
2388    if (_elm_config->desktop_entry)
2389      edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_TRUE);
2390    elm_widget_resize_object_set(obj, wd->ent);
2391    _sizing_eval(obj);
2392
2393    elm_entry_input_panel_layout_set(obj, ELM_INPUT_PANEL_LAYOUT_NORMAL);
2394    elm_entry_input_panel_enabled_set(obj, EINA_TRUE);
2395    elm_entry_prediction_allow_set(obj, EINA_TRUE);
2396
2397    wd->autocapital_type = edje_object_part_text_autocapital_type_get(wd->ent, "elm.text");
2398
2399 #ifdef HAVE_ELEMENTARY_X
2400    top = elm_widget_top_get(obj);
2401    if ((top) && (elm_win_xwindow_get(top)))
2402      {
2403         wd->sel_notify_handler =
2404            ecore_event_handler_add(ECORE_X_EVENT_SELECTION_NOTIFY,
2405                                    _event_selection_notify, obj);
2406         wd->sel_clear_handler =
2407            ecore_event_handler_add(ECORE_X_EVENT_SELECTION_CLEAR,
2408                                    _event_selection_clear, obj);
2409      }
2410
2411    elm_drop_target_add(obj, ELM_SEL_FORMAT_MARKUP | ELM_SEL_FORMAT_IMAGE,
2412                        _drag_drop_cb, NULL);
2413 #endif
2414
2415    entries = eina_list_prepend(entries, obj);
2416
2417    // module - find module for entry
2418    wd->api = _module(obj);
2419    // if found - hook in
2420    if ((wd->api) && (wd->api->obj_hook)) wd->api->obj_hook(obj);
2421
2422    _mirrored_set(obj, elm_widget_mirrored_get(obj));
2423    // TODO: convert Elementary to subclassing of Evas_Smart_Class
2424    // TODO: and save some bytes, making descriptions per-class and not instance!
2425    evas_object_smart_callbacks_descriptions_set(obj, _signals);
2426    return obj;
2427 }
2428
2429 EAPI void
2430 elm_entry_single_line_set(Evas_Object *obj, Eina_Bool single_line)
2431 {
2432    ELM_CHECK_WIDTYPE(obj, widtype);
2433    Widget_Data *wd = elm_widget_data_get(obj);
2434    if (!wd) return;
2435    if (wd->single_line == single_line) return;
2436    wd->single_line = single_line;
2437    wd->linewrap = ELM_WRAP_NONE;
2438    elm_entry_cnp_textonly_set(obj, EINA_TRUE);
2439    _theme_hook(obj);
2440    if (wd->scroller)
2441      {
2442         if (wd->single_line)
2443           elm_smart_scroller_policy_set(wd->scroller,
2444                                         ELM_SMART_SCROLLER_POLICY_OFF,
2445                                         ELM_SMART_SCROLLER_POLICY_OFF);
2446         else
2447           {
2448              const Elm_Scroller_Policy map[3] =
2449                {
2450                   ELM_SMART_SCROLLER_POLICY_AUTO,
2451                   ELM_SMART_SCROLLER_POLICY_ON,
2452                   ELM_SMART_SCROLLER_POLICY_OFF
2453                };
2454              elm_smart_scroller_policy_set(wd->scroller,
2455                                            map[wd->policy_h],
2456                                            map[wd->policy_v]);
2457           }
2458         _sizing_eval(obj);
2459      }
2460 }
2461
2462 EAPI Eina_Bool
2463 elm_entry_single_line_get(const Evas_Object *obj)
2464 {
2465    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
2466    Widget_Data *wd = elm_widget_data_get(obj);
2467    if (!wd) return EINA_FALSE;
2468    return wd->single_line;
2469 }
2470
2471 EAPI void
2472 elm_entry_password_set(Evas_Object *obj, Eina_Bool password)
2473 {
2474    ELM_CHECK_WIDTYPE(obj, widtype);
2475    Widget_Data *wd = elm_widget_data_get(obj);
2476    if (!wd) return;
2477    if (wd->password == password) return;
2478    wd->password = password;
2479    if (password)
2480      {
2481         wd->single_line = EINA_TRUE;
2482         wd->linewrap = ELM_WRAP_NONE;
2483 #ifdef HAVE_ELEMENTARY_X
2484         elm_drop_target_del(obj);
2485 #endif
2486         edje_object_signal_callback_del_full(wd->ent, "selection,start", "elm.text",
2487                                         _signal_selection_start, obj);
2488         edje_object_signal_callback_del_full(wd->ent, "selection,changed", "elm.text",
2489                                         _signal_selection_changed, obj);
2490         edje_object_signal_callback_del_full(wd->ent, "entry,selection,all,request", "elm.text",
2491                                         _signal_selection_all, obj);
2492         edje_object_signal_callback_del_full(wd->ent, "entry,selection,none,request", "elm.text",
2493                                         _signal_selection_none, obj);
2494         edje_object_signal_callback_del_full(wd->ent, "selection,cleared", "elm.text",
2495                                         _signal_selection_cleared, obj);
2496         edje_object_signal_callback_del_full(wd->ent, "entry,paste,request,*", "elm.text",
2497                                         _signal_entry_paste_request, obj);
2498         edje_object_signal_callback_del_full(wd->ent, "entry,copy,notify", "elm.text",
2499                                         _signal_entry_copy_notify, obj);
2500         edje_object_signal_callback_del_full(wd->ent, "entry,cut,notify", "elm.text",
2501                                         _signal_entry_cut_notify, obj);
2502      }
2503    else
2504      {
2505 #ifdef HAVE_ELEMENTARY_X
2506         elm_drop_target_add(obj, ELM_SEL_FORMAT_MARKUP, _drag_drop_cb, NULL);
2507 #endif
2508         edje_object_signal_callback_add(wd->ent, "selection,start", "elm.text",
2509                                         _signal_selection_start, obj);
2510         edje_object_signal_callback_add(wd->ent, "selection,changed", "elm.text",
2511                                         _signal_selection_changed, obj);
2512         edje_object_signal_callback_add(wd->ent, "entry,selection,all,request", "elm.text",
2513                                         _signal_selection_all, obj);
2514         edje_object_signal_callback_add(wd->ent, "entry,selection,none,request", "elm.text",
2515                                         _signal_selection_none, obj);
2516         edje_object_signal_callback_add(wd->ent, "selection,cleared", "elm.text",
2517                                         _signal_selection_cleared, obj);
2518         edje_object_signal_callback_add(wd->ent, "entry,paste,request,*", "elm.text",
2519                                         _signal_entry_paste_request, obj);
2520         edje_object_signal_callback_add(wd->ent, "entry,copy,notify", "elm.text",
2521                                         _signal_entry_copy_notify, obj);
2522         edje_object_signal_callback_add(wd->ent, "entry,cut,notify", "elm.text",
2523                                         _signal_entry_cut_notify, obj);
2524      }
2525    _theme_hook(obj);
2526 }
2527
2528 EAPI Eina_Bool
2529 elm_entry_password_get(const Evas_Object *obj)
2530 {
2531    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
2532    Widget_Data *wd = elm_widget_data_get(obj);
2533    if (!wd) return EINA_FALSE;
2534    return wd->password;
2535 }
2536
2537 EAPI void
2538 elm_entry_entry_set(Evas_Object *obj, const char *entry)
2539 {
2540    _elm_entry_text_set(obj, NULL, entry);
2541 }
2542
2543 EAPI const char *
2544 elm_entry_entry_get(const Evas_Object *obj)
2545 {
2546    return _elm_entry_text_get(obj, NULL);
2547 }
2548
2549 EAPI void
2550 elm_entry_entry_append(Evas_Object *obj, const char *entry)
2551 {
2552    int len = 0;
2553    ELM_CHECK_WIDTYPE(obj, widtype);
2554    Widget_Data *wd = elm_widget_data_get(obj);
2555    if (!wd) return;
2556    if (!entry) entry = "";
2557    wd->changed = EINA_TRUE;
2558
2559    len = strlen(entry);
2560    if (wd->append_text_left)
2561      {
2562         char *tmpbuf;
2563         tmpbuf = realloc(wd->append_text_left, wd->append_text_len + len + 1);
2564         if (!tmpbuf)
2565           {
2566              /* Do something */
2567              return;
2568           }
2569         wd->append_text_left = tmpbuf;
2570         memcpy(wd->append_text_left + wd->append_text_len, entry, len + 1);
2571         wd->append_text_len += len;
2572      }
2573    else
2574      {
2575         /* FIXME: Add chunked appending here (like in entry_set) */
2576         edje_object_part_text_append(wd->ent, "elm.text", entry);
2577      }
2578 }
2579
2580 EAPI Eina_Bool
2581 elm_entry_is_empty(const Evas_Object *obj)
2582 {
2583    /* FIXME: until there's support for that in textblock, we just check
2584     * to see if the there is text or not. */
2585    ELM_CHECK_WIDTYPE(obj, widtype) EINA_TRUE;
2586    Widget_Data *wd = elm_widget_data_get(obj);
2587    const Evas_Object *tb;
2588    Evas_Textblock_Cursor *cur;
2589    Eina_Bool ret;
2590    if (!wd) return EINA_TRUE;
2591    /* It's a hack until we get the support suggested above.
2592     * We just create a cursor, point it to the begining, and then
2593     * try to advance it, if it can advance, the tb is not empty,
2594     * otherwise it is. */
2595    tb = edje_object_part_object_get(wd->ent, "elm.text");
2596    cur = evas_object_textblock_cursor_new((Evas_Object *) tb); /* This is
2597                                                                   actually, ok for the time being, thsese hackish stuff will be removed
2598                                                                   once evas 1.0 is out*/
2599    evas_textblock_cursor_pos_set(cur, 0);
2600    ret = evas_textblock_cursor_char_next(cur);
2601    evas_textblock_cursor_free(cur);
2602
2603    return !ret;
2604 }
2605
2606 EAPI Evas_Object *
2607 elm_entry_textblock_get(Evas_Object *obj)
2608 {
2609    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
2610    Widget_Data *wd = elm_widget_data_get(obj);
2611    if (!wd) return NULL;
2612
2613    return (Evas_Object *) edje_object_part_object_get(wd->ent, "elm.text");
2614 }
2615
2616 EAPI void
2617 elm_entry_calc_force(Evas_Object *obj)
2618 {
2619    ELM_CHECK_WIDTYPE(obj, widtype);
2620    Widget_Data *wd = elm_widget_data_get(obj);
2621    if (!wd) return;
2622
2623    edje_object_calc_force(wd->ent);
2624    wd->changed = EINA_TRUE;
2625    _sizing_eval(obj);
2626 }
2627
2628
2629 EAPI const char *
2630 elm_entry_selection_get(const Evas_Object *obj)
2631 {
2632    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
2633    Widget_Data *wd = elm_widget_data_get(obj);
2634    if ((!wd) || (wd->password)) return NULL;
2635    return edje_object_part_text_selection_get(wd->ent, "elm.text");
2636 }
2637
2638 EAPI void
2639 elm_entry_entry_insert(Evas_Object *obj, const char *entry)
2640 {
2641    ELM_CHECK_WIDTYPE(obj, widtype);
2642    Widget_Data *wd = elm_widget_data_get(obj);
2643    if (!wd) return;
2644    edje_object_part_text_insert(wd->ent, "elm.text", entry);
2645    wd->changed = EINA_TRUE;
2646    _sizing_eval(obj);
2647 }
2648
2649 EAPI void
2650 elm_entry_line_wrap_set(Evas_Object *obj, Elm_Wrap_Type wrap)
2651 {
2652    ELM_CHECK_WIDTYPE(obj, widtype);
2653    Widget_Data *wd = elm_widget_data_get(obj);
2654    if (!wd) return;
2655    if (wd->linewrap == wrap) return;
2656    wd->lastw = -1;
2657    wd->linewrap = wrap;
2658    _theme_hook(obj);
2659 }
2660
2661 EAPI Elm_Wrap_Type
2662 elm_entry_line_wrap_get(const Evas_Object *obj)
2663 {
2664    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
2665    Widget_Data *wd = elm_widget_data_get(obj);
2666    if (!wd) return EINA_FALSE;
2667    return wd->linewrap;
2668 }
2669
2670 EAPI void
2671 elm_entry_editable_set(Evas_Object *obj, Eina_Bool editable)
2672 {
2673    ELM_CHECK_WIDTYPE(obj, widtype);
2674    Widget_Data *wd = elm_widget_data_get(obj);
2675    if (!wd) return;
2676    if (wd->editable == editable) return;
2677    wd->editable = editable;
2678    _theme_hook(obj);
2679
2680 #ifdef HAVE_ELEMENTARY_X
2681    if (editable)
2682      elm_drop_target_add(obj, ELM_SEL_FORMAT_MARKUP, _drag_drop_cb, NULL);
2683    else
2684      elm_drop_target_del(obj);
2685 #endif
2686 }
2687
2688 EAPI Eina_Bool
2689 elm_entry_editable_get(const Evas_Object *obj)
2690 {
2691    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
2692    Widget_Data *wd = elm_widget_data_get(obj);
2693    if (!wd) return EINA_FALSE;
2694    return wd->editable;
2695 }
2696
2697 EAPI void
2698 elm_entry_select_none(Evas_Object *obj)
2699 {
2700    ELM_CHECK_WIDTYPE(obj, widtype);
2701    Widget_Data *wd = elm_widget_data_get(obj);
2702    if ((!wd) || (wd->password)) return;
2703    if (wd->selmode)
2704      {
2705         wd->selmode = EINA_FALSE;
2706         if (!_elm_config->desktop_entry)
2707           edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_FALSE);
2708         edje_object_signal_emit(wd->ent, "elm,state,select,off", "elm");
2709      }
2710    wd->have_selection = EINA_FALSE;
2711    edje_object_part_text_select_none(wd->ent, "elm.text");
2712 }
2713
2714 EAPI void
2715 elm_entry_select_all(Evas_Object *obj)
2716 {
2717    ELM_CHECK_WIDTYPE(obj, widtype);
2718    Widget_Data *wd = elm_widget_data_get(obj);
2719    if ((!wd) || (wd->password)) return;
2720    if (wd->selmode)
2721      {
2722         wd->selmode = EINA_FALSE;
2723         if (!_elm_config->desktop_entry)
2724           edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_FALSE);
2725         edje_object_signal_emit(wd->ent, "elm,state,select,off", "elm");
2726      }
2727    wd->have_selection = EINA_TRUE;
2728    edje_object_part_text_select_all(wd->ent, "elm.text");
2729 }
2730
2731 EAPI Eina_Bool
2732 elm_entry_cursor_geometry_get(const Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h)
2733 {
2734    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
2735    Widget_Data *wd = elm_widget_data_get(obj);
2736    if (!wd) return EINA_FALSE;
2737    edje_object_part_text_cursor_geometry_get(wd->ent, "elm.text", x, y, w, h);
2738    return EINA_TRUE;
2739 }
2740
2741 EAPI Eina_Bool
2742 elm_entry_cursor_next(Evas_Object *obj)
2743 {
2744    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
2745    Widget_Data *wd = elm_widget_data_get(obj);
2746    if (!wd) return EINA_FALSE;
2747    return edje_object_part_text_cursor_next(wd->ent, "elm.text", EDJE_CURSOR_MAIN);
2748 }
2749
2750 EAPI Eina_Bool
2751 elm_entry_cursor_prev(Evas_Object *obj)
2752 {
2753    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
2754    Widget_Data *wd = elm_widget_data_get(obj);
2755    if (!wd) return EINA_FALSE;
2756    return edje_object_part_text_cursor_prev(wd->ent, "elm.text", EDJE_CURSOR_MAIN);
2757 }
2758
2759 EAPI Eina_Bool
2760 elm_entry_cursor_up(Evas_Object *obj)
2761 {
2762    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
2763    Widget_Data *wd = elm_widget_data_get(obj);
2764    if (!wd) return EINA_FALSE;
2765    return edje_object_part_text_cursor_up(wd->ent, "elm.text", EDJE_CURSOR_MAIN);
2766 }
2767
2768 EAPI Eina_Bool
2769 elm_entry_cursor_down(Evas_Object *obj)
2770 {
2771    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
2772    Widget_Data *wd = elm_widget_data_get(obj);
2773    if (!wd) return EINA_FALSE;
2774    return edje_object_part_text_cursor_down(wd->ent, "elm.text", EDJE_CURSOR_MAIN);
2775 }
2776
2777 EAPI void
2778 elm_entry_cursor_begin_set(Evas_Object *obj)
2779 {
2780    ELM_CHECK_WIDTYPE(obj, widtype);
2781    Widget_Data *wd = elm_widget_data_get(obj);
2782    if (!wd) return;
2783    edje_object_part_text_cursor_begin_set(wd->ent, "elm.text", EDJE_CURSOR_MAIN);
2784 }
2785
2786 EAPI void
2787 elm_entry_cursor_end_set(Evas_Object *obj)
2788 {
2789    ELM_CHECK_WIDTYPE(obj, widtype);
2790    Widget_Data *wd = elm_widget_data_get(obj);
2791    if (!wd) return;
2792    edje_object_part_text_cursor_end_set(wd->ent, "elm.text", EDJE_CURSOR_MAIN);
2793 }
2794
2795 EAPI void
2796 elm_entry_cursor_line_begin_set(Evas_Object *obj)
2797 {
2798    ELM_CHECK_WIDTYPE(obj, widtype);
2799    Widget_Data *wd = elm_widget_data_get(obj);
2800    if (!wd) return;
2801    edje_object_part_text_cursor_line_begin_set(wd->ent, "elm.text", EDJE_CURSOR_MAIN);
2802 }
2803
2804 EAPI void
2805 elm_entry_cursor_line_end_set(Evas_Object *obj)
2806 {
2807    ELM_CHECK_WIDTYPE(obj, widtype);
2808    Widget_Data *wd = elm_widget_data_get(obj);
2809    if (!wd) return;
2810    edje_object_part_text_cursor_line_end_set(wd->ent, "elm.text", EDJE_CURSOR_MAIN);
2811 }
2812
2813 EAPI void
2814 elm_entry_cursor_selection_begin(Evas_Object *obj)
2815 {
2816    ELM_CHECK_WIDTYPE(obj, widtype);
2817    Widget_Data *wd = elm_widget_data_get(obj);
2818    if (!wd) return;
2819    edje_object_part_text_select_begin(wd->ent, "elm.text");
2820 }
2821
2822 EAPI void
2823 elm_entry_cursor_selection_end(Evas_Object *obj)
2824 {
2825    ELM_CHECK_WIDTYPE(obj, widtype);
2826    Widget_Data *wd = elm_widget_data_get(obj);
2827    if (!wd) return;
2828    edje_object_part_text_select_extend(wd->ent, "elm.text");
2829 }
2830
2831 EAPI Eina_Bool
2832 elm_entry_cursor_is_format_get(const Evas_Object *obj)
2833 {
2834    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
2835    Widget_Data *wd = elm_widget_data_get(obj);
2836    if (!wd) return EINA_FALSE;
2837    return edje_object_part_text_cursor_is_format_get(wd->ent, "elm.text", EDJE_CURSOR_MAIN);
2838 }
2839
2840 EAPI Eina_Bool
2841 elm_entry_cursor_is_visible_format_get(const Evas_Object *obj)
2842 {
2843    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
2844    Widget_Data *wd = elm_widget_data_get(obj);
2845    if (!wd) return EINA_FALSE;
2846    return edje_object_part_text_cursor_is_visible_format_get(wd->ent, "elm.text", EDJE_CURSOR_MAIN);
2847 }
2848
2849 EAPI char *
2850 elm_entry_cursor_content_get(const Evas_Object *obj)
2851 {
2852    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
2853    Widget_Data *wd = elm_widget_data_get(obj);
2854    if (!wd) return NULL;
2855    return edje_object_part_text_cursor_content_get(wd->ent, "elm.text", EDJE_CURSOR_MAIN);
2856 }
2857
2858 EAPI void
2859 elm_entry_cursor_pos_set(Evas_Object *obj, int pos)
2860 {
2861    ELM_CHECK_WIDTYPE(obj, widtype);
2862    Widget_Data *wd = elm_widget_data_get(obj);
2863    if (!wd) return;
2864    edje_object_part_text_cursor_pos_set(wd->ent, "elm.text", EDJE_CURSOR_MAIN, pos);
2865    edje_object_message_signal_process(wd->ent);
2866 }
2867
2868 EAPI int
2869 elm_entry_cursor_pos_get(const Evas_Object *obj)
2870 {
2871    ELM_CHECK_WIDTYPE(obj, widtype) 0;
2872    Widget_Data *wd = elm_widget_data_get(obj);
2873    if (!wd) return 0;
2874    return edje_object_part_text_cursor_pos_get(wd->ent, "elm.text", EDJE_CURSOR_MAIN);
2875 }
2876
2877 EAPI void
2878 elm_entry_selection_cut(Evas_Object *obj)
2879 {
2880    ELM_CHECK_WIDTYPE(obj, widtype);
2881    Widget_Data *wd = elm_widget_data_get(obj);
2882    if ((!wd) || (wd->password)) return;
2883    _cut(obj, NULL, NULL);
2884 }
2885
2886 EAPI void
2887 elm_entry_selection_copy(Evas_Object *obj)
2888 {
2889    ELM_CHECK_WIDTYPE(obj, widtype);
2890    Widget_Data *wd = elm_widget_data_get(obj);
2891    if ((!wd) || (wd->password)) return;
2892    _copy(obj, NULL, NULL);
2893 }
2894
2895 EAPI void
2896 elm_entry_selection_paste(Evas_Object *obj)
2897 {
2898    ELM_CHECK_WIDTYPE(obj, widtype);
2899    Widget_Data *wd = elm_widget_data_get(obj);
2900    if ((!wd) || (wd->password)) return;
2901    _paste(obj, NULL, NULL);
2902 }
2903
2904 EAPI void
2905 elm_entry_context_menu_clear(Evas_Object *obj)
2906 {
2907    ELM_CHECK_WIDTYPE(obj, widtype);
2908    Widget_Data *wd = elm_widget_data_get(obj);
2909    Elm_Entry_Context_Menu_Item *it;
2910    if (!wd) return;
2911    EINA_LIST_FREE(wd->items, it)
2912      {
2913         eina_stringshare_del(it->label);
2914         eina_stringshare_del(it->icon_file);
2915         eina_stringshare_del(it->icon_group);
2916         free(it);
2917      }
2918 }
2919
2920 EAPI void
2921 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)
2922 {
2923    ELM_CHECK_WIDTYPE(obj, widtype);
2924    Widget_Data *wd = elm_widget_data_get(obj);
2925    Elm_Entry_Context_Menu_Item *it;
2926    if (!wd) return;
2927    it = calloc(1, sizeof(Elm_Entry_Context_Menu_Item));
2928    if (!it) return;
2929    wd->items = eina_list_append(wd->items, it);
2930    it->obj = obj;
2931    it->label = eina_stringshare_add(label);
2932    it->icon_file = eina_stringshare_add(icon_file);
2933    it->icon_type = icon_type;
2934    it->func = func;
2935    it->data = (void *)data;
2936 }
2937
2938 EAPI void
2939 elm_entry_context_menu_disabled_set(Evas_Object *obj, Eina_Bool disabled)
2940 {
2941    ELM_CHECK_WIDTYPE(obj, widtype);
2942    Widget_Data *wd = elm_widget_data_get(obj);
2943    if (!wd) return;
2944    if (wd->context_menu == !disabled) return;
2945    wd->context_menu = !disabled;
2946 }
2947
2948 EAPI Eina_Bool
2949 elm_entry_context_menu_disabled_get(const Evas_Object *obj)
2950 {
2951    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
2952    Widget_Data *wd = elm_widget_data_get(obj);
2953    if (!wd) return EINA_FALSE;
2954    return !wd->context_menu;
2955 }
2956
2957 EAPI void
2958 elm_entry_item_provider_append(Evas_Object *obj, Evas_Object *(*func) (void *data, Evas_Object *entry, const char *item), void *data)
2959 {
2960    ELM_CHECK_WIDTYPE(obj, widtype);
2961    Widget_Data *wd = elm_widget_data_get(obj);
2962    if (!wd) return;
2963    EINA_SAFETY_ON_NULL_RETURN(func);
2964    Elm_Entry_Item_Provider *ip = calloc(1, sizeof(Elm_Entry_Item_Provider));
2965    if (!ip) return;
2966    ip->func = func;
2967    ip->data = data;
2968    wd->item_providers = eina_list_append(wd->item_providers, ip);
2969 }
2970
2971 EAPI void
2972 elm_entry_item_provider_prepend(Evas_Object *obj, Evas_Object *(*func) (void *data, Evas_Object *entry, const char *item), void *data)
2973 {
2974    ELM_CHECK_WIDTYPE(obj, widtype);
2975    Widget_Data *wd = elm_widget_data_get(obj);
2976    if (!wd) return;
2977    EINA_SAFETY_ON_NULL_RETURN(func);
2978    Elm_Entry_Item_Provider *ip = calloc(1, sizeof(Elm_Entry_Item_Provider));
2979    if (!ip) return;
2980    ip->func = func;
2981    ip->data = data;
2982    wd->item_providers = eina_list_prepend(wd->item_providers, ip);
2983 }
2984
2985 EAPI void
2986 elm_entry_item_provider_remove(Evas_Object *obj, Evas_Object *(*func) (void *data, Evas_Object *entry, const char *item), void *data)
2987 {
2988    ELM_CHECK_WIDTYPE(obj, widtype);
2989    Widget_Data *wd = elm_widget_data_get(obj);
2990    Eina_List *l;
2991    Elm_Entry_Item_Provider *ip;
2992    if (!wd) return;
2993    EINA_SAFETY_ON_NULL_RETURN(func);
2994    EINA_LIST_FOREACH(wd->item_providers, l, ip)
2995      {
2996         if ((ip->func == func) && ((!data) || (ip->data == data)))
2997           {
2998              wd->item_providers = eina_list_remove_list(wd->item_providers, l);
2999              free(ip);
3000              return;
3001           }
3002      }
3003 }
3004
3005 EAPI void
3006 elm_entry_text_filter_append(Evas_Object *obj, Elm_Entry_Filter_Cb func, void *data)
3007 {
3008    Widget_Data *wd;
3009    Elm_Entry_Markup_Filter *tf;
3010    ELM_CHECK_WIDTYPE(obj, widtype);
3011
3012    wd = elm_widget_data_get(obj);
3013
3014    EINA_SAFETY_ON_NULL_RETURN(func);
3015
3016    tf = _filter_new(func, data);
3017    if (!tf) return;
3018
3019    wd->text_filters = eina_list_append(wd->text_filters, tf);
3020 }
3021
3022 EAPI void
3023 elm_entry_text_filter_prepend(Evas_Object *obj, Elm_Entry_Filter_Cb func, void *data)
3024 {
3025    Widget_Data *wd;
3026    Elm_Entry_Markup_Filter *tf;
3027    ELM_CHECK_WIDTYPE(obj, widtype);
3028
3029    wd = elm_widget_data_get(obj);
3030
3031    EINA_SAFETY_ON_NULL_RETURN(func);
3032
3033    tf = _filter_new(func, data);
3034    if (!tf) return;
3035
3036    wd->text_filters = eina_list_prepend(wd->text_filters, tf);
3037 }
3038
3039 EAPI void
3040 elm_entry_text_filter_remove(Evas_Object *obj, Elm_Entry_Filter_Cb func, void *data)
3041 {
3042    Widget_Data *wd;
3043    Eina_List *l;
3044    Elm_Entry_Markup_Filter *tf;
3045    ELM_CHECK_WIDTYPE(obj, widtype);
3046
3047    wd = elm_widget_data_get(obj);
3048
3049    EINA_SAFETY_ON_NULL_RETURN(func);
3050
3051    EINA_LIST_FOREACH(wd->text_filters, l, tf)
3052      {
3053         if ((tf->func == func) && ((!data) || (tf->data == data)))
3054           {
3055              wd->text_filters = eina_list_remove_list(wd->text_filters, l);
3056              _filter_free(tf);
3057              return;
3058           }
3059      }
3060 }
3061
3062 EAPI void
3063 elm_entry_markup_filter_append(Evas_Object *obj, Elm_Entry_Filter_Cb func, void *data)
3064 {
3065    Widget_Data *wd;
3066    Elm_Entry_Markup_Filter *tf;
3067    ELM_CHECK_WIDTYPE(obj, widtype);
3068
3069    wd = elm_widget_data_get(obj);
3070
3071    EINA_SAFETY_ON_NULL_RETURN(func);
3072
3073    tf = _filter_new(func, data);
3074    if (!tf) return;
3075
3076    wd->markup_filters = eina_list_append(wd->markup_filters, tf);
3077 }
3078
3079 EAPI void
3080 elm_entry_markup_filter_prepend(Evas_Object *obj, Elm_Entry_Filter_Cb func, void *data)
3081 {
3082    Widget_Data *wd;
3083    Elm_Entry_Markup_Filter *tf;
3084    ELM_CHECK_WIDTYPE(obj, widtype);
3085
3086    wd = elm_widget_data_get(obj);
3087
3088    EINA_SAFETY_ON_NULL_RETURN(func);
3089
3090    tf = _filter_new(func, data);
3091    if (!tf) return;
3092
3093    wd->markup_filters = eina_list_prepend(wd->markup_filters, tf);
3094 }
3095
3096 EAPI void
3097 elm_entry_markup_filter_remove(Evas_Object *obj, Elm_Entry_Filter_Cb func, void *data)
3098 {
3099    Widget_Data *wd;
3100    Eina_List *l;
3101    Elm_Entry_Markup_Filter *tf;
3102    ELM_CHECK_WIDTYPE(obj, widtype);
3103
3104    wd = elm_widget_data_get(obj);
3105
3106    EINA_SAFETY_ON_NULL_RETURN(func);
3107
3108    EINA_LIST_FOREACH(wd->markup_filters, l, tf)
3109      {
3110         if ((tf->func == func) && ((!data) || (tf->data == data)))
3111           {
3112              wd->markup_filters = eina_list_remove_list(wd->markup_filters, l);
3113              _filter_free(tf);
3114              return;
3115           }
3116      }
3117 }
3118
3119 EAPI char *
3120 elm_entry_markup_to_utf8(const char *s)
3121 {
3122    char *ss = _elm_util_mkup_to_text(s);
3123    if (!ss) ss = strdup("");
3124    return ss;
3125 }
3126
3127 EAPI char *
3128 elm_entry_utf8_to_markup(const char *s)
3129 {
3130    char *ss = _elm_util_text_to_mkup(s);
3131    if (!ss) ss = strdup("");
3132    return ss;
3133 }
3134
3135 static const char *
3136 _text_get(const Evas_Object *obj)
3137 {
3138    return elm_object_text_get(obj);
3139 }
3140
3141 EAPI void
3142 elm_entry_filter_limit_size(void *data, Evas_Object *entry, char **text)
3143 {
3144    Elm_Entry_Filter_Limit_Size *lim = data;
3145    char *current, *utfstr;
3146    int len, newlen;
3147    const char *(*text_get)(const Evas_Object *);
3148
3149    EINA_SAFETY_ON_NULL_RETURN(data);
3150    EINA_SAFETY_ON_NULL_RETURN(entry);
3151    EINA_SAFETY_ON_NULL_RETURN(text);
3152
3153    /* hack. I don't want to copy the entire function to work with
3154     * scrolled_entry */
3155    text_get = _text_get;
3156
3157    current = elm_entry_markup_to_utf8(text_get(entry));
3158    utfstr = elm_entry_markup_to_utf8(*text);
3159
3160    if (lim->max_char_count > 0)
3161      {
3162         len = evas_string_char_len_get(current);
3163         if (len >= lim->max_char_count)
3164           {
3165              evas_object_smart_callback_call(entry, "maxlength,reached", NULL);
3166              free(*text);
3167              *text = NULL;
3168              free(current);
3169              free(utfstr);
3170              return;
3171           }
3172         newlen = evas_string_char_len_get(utfstr);
3173         if ((len + newlen) > lim->max_char_count)
3174           _add_chars_till_limit(entry, text, (lim->max_char_count - len), LENGTH_UNIT_CHAR);
3175      }
3176    else if (lim->max_byte_count > 0)
3177      {
3178         len = strlen(current);
3179         if (len >= lim->max_byte_count)
3180           {
3181              evas_object_smart_callback_call(entry, "maxlength,reached", NULL);
3182              free(*text);
3183              *text = NULL;
3184              free(current);
3185              free(utfstr);
3186              return;
3187           }
3188         newlen = strlen(utfstr);
3189         if ((len + newlen) > lim->max_byte_count)
3190           _add_chars_till_limit(entry, text, (lim->max_byte_count - len), LENGTH_UNIT_BYTE);
3191      }
3192    free(current);
3193    free(utfstr);
3194 }
3195
3196 EAPI void
3197 elm_entry_filter_accept_set(void *data, Evas_Object *entry __UNUSED__, char **text)
3198 {
3199    Elm_Entry_Filter_Accept_Set *as = data;
3200    const char *set;
3201    char *insert;
3202    Eina_Bool goes_in;
3203    int read_idx, last_read_idx = 0, read_char;
3204
3205    EINA_SAFETY_ON_NULL_RETURN(data);
3206    EINA_SAFETY_ON_NULL_RETURN(text);
3207
3208    if ((!as->accepted) && (!as->rejected))
3209      return;
3210
3211    if (as->accepted)
3212      {
3213         set = as->accepted;
3214         goes_in = EINA_TRUE;
3215      }
3216    else
3217      {
3218         set = as->rejected;
3219         goes_in = EINA_FALSE;
3220      }
3221
3222    insert = *text;
3223    read_idx = evas_string_char_next_get(*text, 0, &read_char);
3224    while (read_char)
3225      {
3226         int cmp_idx, cmp_char;
3227         Eina_Bool in_set = EINA_FALSE;
3228
3229         cmp_idx = evas_string_char_next_get(set, 0, &cmp_char);
3230         while (cmp_char)
3231           {
3232              if (read_char == cmp_char)
3233                {
3234                   in_set = EINA_TRUE;
3235                   break;
3236                }
3237              cmp_idx = evas_string_char_next_get(set, cmp_idx, &cmp_char);
3238           }
3239         if (in_set == goes_in)
3240           {
3241              int size = read_idx - last_read_idx;
3242              const char *src = (*text) + last_read_idx;
3243              if (src != insert)
3244                memcpy(insert, *text + last_read_idx, size);
3245              insert += size;
3246           }
3247         last_read_idx = read_idx;
3248         read_idx = evas_string_char_next_get(*text, read_idx, &read_char);
3249      }
3250    *insert = 0;
3251 }
3252
3253 EAPI void
3254 elm_entry_file_set(Evas_Object *obj, const char *file, Elm_Text_Format format)
3255 {
3256    ELM_CHECK_WIDTYPE(obj, widtype);
3257    Widget_Data *wd = elm_widget_data_get(obj);
3258    if (!wd) return;
3259    if (wd->delay_write)
3260      {
3261         ecore_timer_del(wd->delay_write);
3262         wd->delay_write = NULL;
3263      }
3264    if (wd->autosave) _save(obj);
3265    eina_stringshare_replace(&wd->file, file);
3266    wd->format = format;
3267    _load(obj);
3268 }
3269
3270 EAPI void
3271 elm_entry_file_get(const Evas_Object *obj, const char **file, Elm_Text_Format *format)
3272 {
3273    ELM_CHECK_WIDTYPE(obj, widtype);
3274    Widget_Data *wd = elm_widget_data_get(obj);
3275    if (!wd) return;
3276    if (file) *file = wd->file;
3277    if (format) *format = wd->format;
3278 }
3279
3280 EAPI void
3281 elm_entry_file_save(Evas_Object *obj)
3282 {
3283    ELM_CHECK_WIDTYPE(obj, widtype);
3284    Widget_Data *wd = elm_widget_data_get(obj);
3285    if (!wd) return;
3286    if (wd->delay_write)
3287      {
3288         ecore_timer_del(wd->delay_write);
3289         wd->delay_write = NULL;
3290      }
3291    _save(obj);
3292    wd->delay_write = ecore_timer_add(2.0, _delay_write, obj);
3293 }
3294
3295 EAPI void
3296 elm_entry_autosave_set(Evas_Object *obj, Eina_Bool autosave)
3297 {
3298    ELM_CHECK_WIDTYPE(obj, widtype);
3299    Widget_Data *wd = elm_widget_data_get(obj);
3300    if (!wd) return;
3301    wd->autosave = !!autosave;
3302 }
3303
3304 EAPI Eina_Bool
3305 elm_entry_autosave_get(const Evas_Object *obj)
3306 {
3307    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
3308    Widget_Data *wd = elm_widget_data_get(obj);
3309    if (!wd) return EINA_FALSE;
3310    return wd->autosave;
3311 }
3312
3313 EAPI void
3314 elm_entry_cnp_textonly_set(Evas_Object *obj, Eina_Bool textonly)
3315 {
3316    Elm_Sel_Format format = ELM_SEL_FORMAT_MARKUP;
3317    ELM_CHECK_WIDTYPE(obj, widtype);
3318    Widget_Data *wd = elm_widget_data_get(obj);
3319    if (!wd) return;
3320    textonly = !!textonly;
3321    if (wd->textonly == textonly) return;
3322    wd->textonly = !!textonly;
3323    if (!textonly) format |= ELM_SEL_FORMAT_IMAGE;
3324 #ifdef HAVE_ELEMENTARY_X
3325    elm_drop_target_add(obj, format, _drag_drop_cb, NULL);
3326 #endif
3327 }
3328
3329 EAPI Eina_Bool
3330 elm_entry_cnp_textonly_get(const Evas_Object *obj)
3331 {
3332    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
3333    Widget_Data *wd = elm_widget_data_get(obj);
3334    if (!wd) return EINA_FALSE;
3335    return wd->textonly;
3336 }
3337
3338 EAPI void
3339 elm_entry_scrollable_set(Evas_Object *obj, Eina_Bool scroll)
3340 {
3341    ELM_CHECK_WIDTYPE(obj, widtype);
3342    Widget_Data *wd = elm_widget_data_get(obj);
3343    const Elm_Scroller_Policy map[3] =
3344      {
3345         ELM_SMART_SCROLLER_POLICY_AUTO,
3346         ELM_SMART_SCROLLER_POLICY_ON,
3347         ELM_SMART_SCROLLER_POLICY_OFF
3348      };
3349    if (!wd) return;
3350    scroll = !!scroll;
3351    if (wd->scroll == scroll) return;
3352    wd->scroll = scroll;
3353    if (wd->scroll)
3354      {
3355         if (!wd->scroller)
3356           {
3357              wd->scroller = elm_smart_scroller_add(evas_object_evas_get(obj));
3358              elm_widget_resize_object_set(obj, wd->scroller);
3359              elm_smart_scroller_widget_set(wd->scroller, obj);
3360              elm_smart_scroller_object_theme_set(obj, wd->scroller, "scroller", "entry",
3361                                                  elm_widget_style_get(obj));
3362              evas_object_size_hint_weight_set(wd->scroller, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
3363              evas_object_size_hint_align_set(wd->scroller, EVAS_HINT_FILL, EVAS_HINT_FILL);
3364              evas_object_propagate_events_set(wd->scroller, EINA_TRUE);
3365              evas_object_propagate_events_set(elm_smart_scroller_edje_object_get(wd->scroller),
3366                                               EINA_TRUE);
3367           }
3368         elm_smart_scroller_bounce_allow_set(wd->scroller, wd->h_bounce, wd->v_bounce);
3369         if (wd->single_line)
3370           elm_smart_scroller_policy_set(wd->scroller, ELM_SMART_SCROLLER_POLICY_OFF,
3371                                         ELM_SMART_SCROLLER_POLICY_OFF);
3372         else
3373           elm_smart_scroller_policy_set(wd->scroller, map[wd->policy_h], map[wd->policy_v]);
3374         elm_widget_sub_object_add(obj, wd->ent);
3375         elm_smart_scroller_child_set(wd->scroller, wd->ent);
3376         evas_object_show(wd->scroller);
3377         elm_widget_on_show_region_hook_set(obj, _show_region_hook, obj);
3378      }
3379    else
3380      {
3381         if (wd->scroller)
3382           {
3383              elm_smart_scroller_child_set(wd->scroller, NULL);
3384              evas_object_smart_member_add(wd->scroller, obj);
3385              elm_widget_sub_object_add(obj, wd->scroller);
3386              evas_object_hide(wd->scroller);
3387           }
3388         elm_widget_sub_object_del(obj, wd->ent);
3389         elm_widget_resize_object_set(obj, wd->ent);
3390         elm_widget_on_show_region_hook_set(obj, NULL, NULL);
3391      }
3392    wd->lastw = -1;
3393    _theme_hook(obj);
3394 }
3395
3396 EAPI Eina_Bool
3397 elm_entry_scrollable_get(const Evas_Object *obj)
3398 {
3399    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
3400    Widget_Data *wd = elm_widget_data_get(obj);
3401    if (!wd) return EINA_FALSE;
3402    return wd->scroll;
3403 }
3404
3405 EAPI void
3406 elm_entry_icon_set(Evas_Object *obj, Evas_Object *icon)
3407 {
3408    ELM_CHECK_WIDTYPE(obj, widtype);
3409    EINA_SAFETY_ON_NULL_RETURN(icon);
3410    _content_set_hook(obj, NULL, icon);
3411 }
3412
3413 EAPI Evas_Object *
3414 elm_entry_icon_get(const Evas_Object *obj)
3415 {
3416    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3417    return _content_get_hook(obj, NULL);
3418 }
3419
3420 EAPI Evas_Object *
3421 elm_entry_icon_unset(Evas_Object *obj)
3422 {
3423    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3424    return _content_unset_hook(obj, NULL);
3425 }
3426
3427 EAPI void
3428 elm_entry_icon_visible_set(Evas_Object *obj, Eina_Bool setting)
3429 {
3430    ELM_CHECK_WIDTYPE(obj, widtype);
3431    Widget_Data *wd = elm_widget_data_get(obj);
3432    Evas_Object *edje;
3433    if (!wd) return;
3434    if (wd->scroll)
3435       edje = elm_smart_scroller_edje_object_get(wd->scroller);
3436    else
3437       edje = wd->ent;
3438
3439    if ((!edje) || (!edje_object_part_swallow_get(edje, "elm.swallow.icon"))) return;
3440    if (setting)
3441      edje_object_signal_emit(edje, "elm,action,show,icon", "elm");
3442    else
3443      edje_object_signal_emit(edje, "elm,action,hide,icon", "elm");
3444    _sizing_eval(obj);
3445 }
3446
3447 EAPI void
3448 elm_entry_end_set(Evas_Object *obj, Evas_Object *end)
3449 {
3450    ELM_CHECK_WIDTYPE(obj, widtype);
3451    EINA_SAFETY_ON_NULL_RETURN(end);
3452    _content_set_hook(obj, "end", end);
3453 }
3454
3455 EAPI Evas_Object *
3456 elm_entry_end_get(const Evas_Object *obj)
3457 {
3458    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3459    return _content_get_hook(obj, "end");
3460 }
3461
3462 EAPI Evas_Object *
3463 elm_entry_end_unset(Evas_Object *obj)
3464 {
3465    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3466    return _content_unset_hook(obj, "end");
3467 }
3468
3469 EAPI void
3470 elm_entry_end_visible_set(Evas_Object *obj, Eina_Bool setting)
3471 {
3472    ELM_CHECK_WIDTYPE(obj, widtype);
3473    Widget_Data *wd = elm_widget_data_get(obj);
3474    Evas_Object *edje;
3475    if (!wd) return;
3476    if (wd->scroll)
3477       edje = elm_smart_scroller_edje_object_get(wd->scroller);
3478    else
3479       edje = wd->ent;
3480
3481    if ((!edje) || (!edje_object_part_swallow_get(edje, "elm.swallow.icon"))) return;
3482    if (setting)
3483      edje_object_signal_emit(edje, "elm,action,show,end", "elm");
3484    else
3485      edje_object_signal_emit(edje, "elm,action,hide,end", "elm");
3486    _sizing_eval(obj);
3487 }
3488
3489 EAPI void
3490 elm_entry_scrollbar_policy_set(Evas_Object *obj, Elm_Scroller_Policy h, Elm_Scroller_Policy v)
3491 {
3492    ELM_CHECK_WIDTYPE(obj, widtype);
3493    Widget_Data *wd = elm_widget_data_get(obj);
3494    const Elm_Scroller_Policy map[3] =
3495      {
3496         ELM_SMART_SCROLLER_POLICY_AUTO,
3497         ELM_SMART_SCROLLER_POLICY_ON,
3498         ELM_SMART_SCROLLER_POLICY_OFF
3499      };
3500    if (!wd) return;
3501    wd->policy_h = h;
3502    wd->policy_v = v;
3503    elm_smart_scroller_policy_set(wd->scroller,
3504                                  map[wd->policy_h],
3505                                  map[wd->policy_v]);
3506 }
3507
3508 EAPI void
3509 elm_entry_bounce_set(Evas_Object *obj, Eina_Bool h_bounce, Eina_Bool v_bounce)
3510 {
3511    ELM_CHECK_WIDTYPE(obj, widtype);
3512    Widget_Data *wd = elm_widget_data_get(obj);
3513    if (!wd) return;
3514    wd->h_bounce = h_bounce;
3515    wd->v_bounce = v_bounce;
3516    elm_smart_scroller_bounce_allow_set(wd->scroller, h_bounce, v_bounce);
3517 }
3518
3519 EAPI void
3520 elm_entry_bounce_get(const Evas_Object *obj, Eina_Bool *h_bounce, Eina_Bool *v_bounce)
3521 {
3522    ELM_CHECK_WIDTYPE(obj, widtype);
3523    Widget_Data *wd = elm_widget_data_get(obj);
3524    if (!wd) return;
3525    elm_smart_scroller_bounce_allow_get(wd->scroller, h_bounce, v_bounce);
3526 }
3527
3528 EAPI void
3529 elm_entry_input_panel_layout_set(Evas_Object *obj, Elm_Input_Panel_Layout layout)
3530 {
3531    ELM_CHECK_WIDTYPE(obj, widtype);
3532    Widget_Data *wd = elm_widget_data_get(obj);
3533    if (!wd) return;
3534
3535    wd->input_panel_layout = layout;
3536
3537    edje_object_part_text_input_panel_layout_set(wd->ent, "elm.text", layout);
3538 }
3539
3540 EAPI Elm_Input_Panel_Layout
3541 elm_entry_input_panel_layout_get(const Evas_Object *obj)
3542 {
3543    ELM_CHECK_WIDTYPE(obj, widtype) ELM_INPUT_PANEL_LAYOUT_INVALID;
3544    Widget_Data *wd = elm_widget_data_get(obj);
3545    if (!wd) return ELM_INPUT_PANEL_LAYOUT_INVALID;
3546
3547    return wd->input_panel_layout;
3548 }
3549
3550 EAPI void
3551 elm_entry_autocapital_type_set(Evas_Object *obj, Elm_Autocapital_Type autocapital_type)
3552 {
3553    ELM_CHECK_WIDTYPE(obj, widtype);
3554    Widget_Data *wd = elm_widget_data_get(obj);
3555    if (!wd) return;
3556
3557    wd->autocapital_type = autocapital_type;
3558    edje_object_part_text_autocapital_type_set(wd->ent, "elm.text", autocapital_type);
3559 }
3560
3561 EAPI Elm_Autocapital_Type
3562 elm_entry_autocapital_type_get(const Evas_Object *obj)
3563 {
3564    ELM_CHECK_WIDTYPE(obj, widtype) ELM_AUTOCAPITAL_TYPE_NONE;
3565    Widget_Data *wd = elm_widget_data_get(obj);
3566    if (!wd) return ELM_AUTOCAPITAL_TYPE_NONE;
3567
3568    return wd->autocapital_type;
3569 }
3570
3571 EAPI void
3572 elm_entry_prediction_allow_set(Evas_Object *obj, Eina_Bool prediction)
3573 {
3574    ELM_CHECK_WIDTYPE(obj, widtype);
3575    Widget_Data *wd = elm_widget_data_get(obj);
3576    if (!wd) return;
3577
3578    wd->prediction_allow = prediction;
3579    edje_object_part_text_prediction_allow_set(wd->ent, "elm.text", prediction);
3580 }
3581
3582 EAPI Eina_Bool
3583 elm_entry_prediction_allow_get(const Evas_Object *obj)
3584 {
3585    ELM_CHECK_WIDTYPE(obj, widtype) EINA_TRUE;
3586    Widget_Data *wd = elm_widget_data_get(obj);
3587    if (!wd) return EINA_TRUE;
3588
3589    return wd->prediction_allow;
3590 }
3591
3592 EAPI void
3593 elm_entry_imf_context_reset(Evas_Object *obj)
3594 {
3595    ELM_CHECK_WIDTYPE(obj, widtype);
3596    Widget_Data *wd = elm_widget_data_get(obj);
3597    if (!wd) return;
3598
3599    edje_object_part_text_imf_context_reset(wd->ent, "elm.text");
3600 }
3601
3602 EAPI void
3603 elm_entry_input_panel_enabled_set(Evas_Object *obj, Eina_Bool enabled)
3604 {
3605    ELM_CHECK_WIDTYPE(obj, widtype);
3606    Widget_Data *wd = elm_widget_data_get(obj);
3607    if (!wd) return;
3608
3609    wd->input_panel_enable = enabled;
3610    edje_object_part_text_input_panel_enabled_set(wd->ent, "elm.text", enabled);
3611 }
3612
3613 EAPI Eina_Bool
3614 elm_entry_input_panel_enabled_get(const Evas_Object *obj)
3615 {
3616    ELM_CHECK_WIDTYPE(obj, widtype) EINA_TRUE;
3617    Widget_Data *wd = elm_widget_data_get(obj);
3618    if (!wd) return EINA_TRUE;
3619
3620    return wd->input_panel_enable;
3621 }
3622
3623 EAPI void
3624 elm_entry_input_panel_show(Evas_Object *obj)
3625 {
3626    ELM_CHECK_WIDTYPE(obj, widtype);
3627    Widget_Data *wd = elm_widget_data_get(obj);
3628    if (!wd) return;
3629
3630    edje_object_part_text_input_panel_show(wd->ent, "elm.text");
3631 }
3632
3633 EAPI void
3634 elm_entry_input_panel_hide(Evas_Object *obj)
3635 {
3636    ELM_CHECK_WIDTYPE(obj, widtype);
3637    Widget_Data *wd = elm_widget_data_get(obj);
3638    if (!wd) return;
3639
3640    edje_object_part_text_input_panel_hide(wd->ent, "elm.text");
3641 }
3642
3643 EAPI void
3644 elm_entry_input_panel_language_set(Evas_Object *obj, Elm_Input_Panel_Lang lang)
3645 {
3646    ELM_CHECK_WIDTYPE(obj, widtype);
3647    Widget_Data *wd = elm_widget_data_get(obj);
3648    if (!wd) return;
3649
3650    wd->input_panel_lang = lang;
3651    edje_object_part_text_input_panel_language_set(wd->ent, "elm.text", lang);
3652 }
3653
3654 EAPI Elm_Input_Panel_Lang
3655 elm_entry_input_panel_language_get(const Evas_Object *obj)
3656 {
3657    ELM_CHECK_WIDTYPE(obj, widtype) ELM_INPUT_PANEL_LANG_AUTOMATIC;
3658    Widget_Data *wd = elm_widget_data_get(obj);
3659    if (!wd) return ELM_INPUT_PANEL_LANG_AUTOMATIC;
3660
3661    return wd->input_panel_lang;
3662 }
3663
3664 EAPI void
3665 elm_entry_input_panel_imdata_set(Evas_Object *obj, const void *data, int len)
3666 {
3667    ELM_CHECK_WIDTYPE(obj, widtype);
3668    Widget_Data *wd = elm_widget_data_get(obj);
3669    if (!wd) return;
3670
3671    if (wd->input_panel_imdata)
3672      free(wd->input_panel_imdata);
3673
3674    wd->input_panel_imdata = calloc(1, len);
3675    wd->input_panel_imdata_len = len;
3676    memcpy(wd->input_panel_imdata, data, len);
3677
3678    edje_object_part_text_input_panel_imdata_set(wd->ent, "elm.text", wd->input_panel_imdata, wd->input_panel_imdata_len);
3679 }
3680
3681 EAPI void
3682 elm_entry_input_panel_imdata_get(const Evas_Object *obj, void *data, int *len)
3683 {
3684    ELM_CHECK_WIDTYPE(obj, widtype);
3685    Widget_Data *wd = elm_widget_data_get(obj);
3686    if (!wd) return;
3687
3688    edje_object_part_text_input_panel_imdata_get(wd->ent, "elm.text", data, len);
3689 }
3690
3691 EAPI void
3692 elm_text_input_panel_return_key_type_set(Evas_Object *obj, Elm_Input_Panel_Return_Key_Type return_key_type)
3693 {
3694    ELM_CHECK_WIDTYPE(obj, widtype);
3695    Widget_Data *wd = elm_widget_data_get(obj);
3696    if (!wd) return;
3697
3698    wd->input_panel_return_key_type = return_key_type;
3699
3700    edje_object_part_text_input_panel_return_key_type_set(wd->ent, "elm.text", return_key_type);
3701 }
3702
3703 EAPI Elm_Input_Panel_Return_Key_Type
3704 elm_entry_input_panel_return_key_type_get(const Evas_Object *obj)
3705 {
3706    ELM_CHECK_WIDTYPE(obj, widtype) ELM_INPUT_PANEL_RETURN_KEY_TYPE_DEFAULT;
3707    Widget_Data *wd = elm_widget_data_get(obj);
3708    if (!wd) return ELM_INPUT_PANEL_RETURN_KEY_TYPE_DEFAULT;
3709
3710    return wd->input_panel_return_key_type;
3711 }
3712
3713 EAPI void
3714 elm_entry_input_panel_return_key_disabled_set(Evas_Object *obj, Eina_Bool disabled)
3715 {
3716    ELM_CHECK_WIDTYPE(obj, widtype);
3717    Widget_Data *wd = elm_widget_data_get(obj);
3718    if (!wd) return;
3719
3720    wd->input_panel_return_key_disabled = disabled;
3721
3722    edje_object_part_text_input_panel_return_key_disabled_set(wd->ent, "elm.text", disabled);
3723 }
3724
3725 EAPI Eina_Bool
3726 elm_entry_input_panel_return_key_disabled_get(const Evas_Object *obj)
3727 {
3728    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
3729    Widget_Data *wd = elm_widget_data_get(obj);
3730    if (!wd) return EINA_FALSE;
3731
3732    return wd->input_panel_return_key_disabled;
3733 }
3734