src/lib/elm_entry.c

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