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