src/lib/elm_entry.c

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