X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Flib%2Felm_entry.c;h=a83bd10d61f36c1c8ab8f95e9d08a96114fc32cd;hb=e837d6e35156ab4ef962d4984034c51312e0a624;hp=ebb50295c907202dd8d5e41b2b9a1fe1bdf19e1b;hpb=8598d9f918fef0c7520e09e3fd8963a01edba47d;p=framework%2Fuifw%2Felementary.git diff --git a/src/lib/elm_entry.c b/src/lib/elm_entry.c index ebb5029..a83bd10 100644 --- a/src/lib/elm_entry.c +++ b/src/lib/elm_entry.c @@ -2,94 +2,12 @@ #include #include "elm_priv.h" -/** - * @defgroup Entry Entry - * - * An entry is a convenience widget which shows - * a box that the user can enter text into. Unlike a - * @ref Scrolled_Entry widget, entries DO NOT scroll with user - * input. Entry widgets are capable of expanding past the - * boundaries of the window, thus resizing the window to its - * own length. - * - * You can also insert "items" in the entry with: - * - * \\ - * - * for example. sizing can be set bu size=WxH, relsize=WxH or absize=WxH with - * vsize=ascent or vsize=full. the href=NAME sets the item name. Entry - * supports a list of emoticon names by default. These are: - * - * - emoticon/angry - * - emoticon/angry-shout - * - emoticon/crazy-laugh - * - emoticon/evil-laugh - * - emoticon/evil - * - emoticon/goggle-smile - * - emoticon/grumpy - * - emoticon/grumpy-smile - * - emoticon/guilty - * - emoticon/guilty-smile - * - emoticon/haha - * - emoticon/half-smile - * - emoticon/happy-panting - * - emoticon/happy - * - emoticon/indifferent - * - emoticon/kiss - * - emoticon/knowing-grin - * - emoticon/laugh - * - emoticon/little-bit-sorry - * - emoticon/love-lots - * - emoticon/love - * - emoticon/minimal-smile - * - emoticon/not-happy - * - emoticon/not-impressed - * - emoticon/omg - * - emoticon/opensmile - * - emoticon/smile - * - emoticon/sorry - * - emoticon/squint-laugh - * - emoticon/surprised - * - emoticon/suspicious - * - emoticon/tongue-dangling - * - emoticon/tongue-poke - * - emoticon/uh - * - emoticon/unhappy - * - emoticon/very-sorry - * - emoticon/what - * - emoticon/wink - * - emoticon/worried - * - emoticon/wtf - * - * These are built-in currently, but you can add your own item provieer that - * can create inlined objects in the text and fill the space allocated to the - * item with a custom object of your own. - * - * See the entry test for some more examples of use of this. - * - * Entries have functions to load a text file, display it, - * allowing editing of it and saving of changes back to the file loaded. - * Changes are written back to the original file after a short delay. - * The file to load and save to is specified by elm_entry_file_set(). - * - * Signals that you can add callbacks for are: - * - "changed" - The text within the entry was changed - * - "activated" - The entry has had editing finished and changes are to be committed (generally when enter key is pressed) - * - "press" - The entry has been clicked - * - "longpressed" - The entry has been clicked for a couple seconds - * - "clicked" - The entry has been clicked - * - "clicked,double" - The entry has been double clicked - * - "focused" - The entry has received focus - * - "unfocused" - The entry has lost focus - * - "selection,paste" - A paste action has occurred - * - "selection,copy" - A copy action has occurred - * - "selection,cut" - A cut action has occurred - * - "selection,start" - A selection has begun - * - "selection,changed" - The selection has changed - * - "selection,cleared" - The selection has been cleared - * - "cursor,changed" - The cursor has changed - * - "anchor,clicked" - The anchor has been clicked - */ + +/* Maximum chunk size to be inserted to the entry at once + * FIXME: This size is arbitrary, should probably choose a better size. + * Possibly also find a way to set it to a low value for weak computers, + * and to a big value for better computers. */ +#define _CHUNK_SIZE 10000 typedef struct _Mod_Api Mod_Api; @@ -100,29 +18,34 @@ typedef struct _Elm_Entry_Text_Filter Elm_Entry_Text_Filter; struct _Widget_Data { - Evas_Object *ent; + Evas_Object *ent, *scroller, *end, *icon; Evas_Object *hoversel; Ecore_Job *deferred_recalc_job; Ecore_Event_Handler *sel_notify_handler; Ecore_Event_Handler *sel_clear_handler; Ecore_Timer *longpress_timer; Ecore_Timer *delay_write; + /* for deferred appending */ + Ecore_Idler *append_text_idler; + char *append_text_left; + int append_text_position; + int append_text_len; /* Only for clipboard */ const char *cut_sel; const char *text; const char *file; Elm_Text_Format format; - Evas_Coord lastw; + Evas_Coord lastw, entmw, entmh; Evas_Coord downx, downy; - Evas_Coord cx, cy, cw, ch; Eina_List *items; Eina_List *item_providers; Eina_List *text_filters; Ecore_Job *hovdeljob; Mod_Api *api; // module api if supplied + int cursor_pos; + Elm_Scroller_Policy policy_h, policy_v; + Elm_Wrap_Type linewrap; Eina_Bool changed : 1; - Eina_Bool linewrap : 1; - Eina_Bool char_linewrap : 1; Eina_Bool single_line : 1; Eina_Bool password : 1; Eina_Bool editable : 1; @@ -130,13 +53,15 @@ struct _Widget_Data Eina_Bool have_selection : 1; Eina_Bool selmode : 1; Eina_Bool deferred_cur : 1; + Eina_Bool cur_changed : 1; Eina_Bool disabled : 1; Eina_Bool context_menu : 1; Eina_Bool drag_selection_asked : 1; Eina_Bool can_write : 1; Eina_Bool autosave : 1; Eina_Bool textonly : 1; - int cursor_pos; + Eina_Bool usedown : 1; + Eina_Bool scroll : 1; }; struct _Elm_Entry_Context_Menu_Item @@ -158,10 +83,17 @@ struct _Elm_Entry_Item_Provider struct _Elm_Entry_Text_Filter { - void (*func) (void *data, Evas_Object *entry, char **text); + Elm_Entry_Filter_Cb func; void *data; }; +typedef enum _Length_Unit +{ + LENGTH_UNIT_CHAR, + LENGTH_UNIT_BYTE, + LENGTH_UNIT_LAST +} Length_Unit; + static const char *widtype = NULL; #ifdef HAVE_ELEMENTARY_X @@ -183,6 +115,7 @@ static void _signal_entry_paste_request(void *data, Evas_Object *obj, const char static void _signal_entry_copy_notify(void *data, Evas_Object *obj, const char *emission, const char *source); static void _signal_entry_cut_notify(void *data, Evas_Object *obj, const char *emission, const char *source); static void _signal_cursor_changed(void *data, Evas_Object *obj, const char *emission, const char *source); +static void _add_chars_till_limit(Evas_Object *obj, char **text, int can_add, Length_Unit unit); static const char SIG_CHANGED[] = "changed"; static const char SIG_ACTIVATED[] = "activated"; @@ -190,6 +123,7 @@ static const char SIG_PRESS[] = "press"; static const char SIG_LONGPRESSED[] = "longpressed"; static const char SIG_CLICKED[] = "clicked"; static const char SIG_CLICKED_DOUBLE[] = "clicked,double"; +static const char SIG_CLICKED_TRIPLE[] = "clicked,triple"; static const char SIG_FOCUSED[] = "focused"; static const char SIG_UNFOCUSED[] = "unfocused"; static const char SIG_SELECTION_PASTE[] = "selection,paste"; @@ -200,6 +134,11 @@ static const char SIG_SELECTION_CHANGED[] = "selection,changed"; static const char SIG_SELECTION_CLEARED[] = "selection,cleared"; static const char SIG_CURSOR_CHANGED[] = "cursor,changed"; static const char SIG_ANCHOR_CLICKED[] = "anchor,clicked"; +static const char SIG_ANCHOR_DOWN[] = "anchor,down"; +static const char SIG_ANCHOR_UP[] = "anchor,up"; +static const char SIG_ANCHOR_IN[] = "anchor,in"; +static const char SIG_ANCHOR_OUT[] = "anchor,out"; +static const char SIG_PREEDIT_CHANGED[] = "preedit,changed"; static const Evas_Smart_Cb_Description _signals[] = { {SIG_CHANGED, ""}, {SIG_ACTIVATED, ""}, @@ -207,6 +146,7 @@ static const Evas_Smart_Cb_Description _signals[] = { {SIG_LONGPRESSED, ""}, {SIG_CLICKED, ""}, {SIG_CLICKED_DOUBLE, ""}, + {SIG_CLICKED_TRIPLE, ""}, {SIG_FOCUSED, ""}, {SIG_UNFOCUSED, ""}, {SIG_SELECTION_PASTE, ""}, @@ -217,6 +157,11 @@ static const Evas_Smart_Cb_Description _signals[] = { {SIG_SELECTION_CLEARED, ""}, {SIG_CURSOR_CHANGED, ""}, {SIG_ANCHOR_CLICKED, ""}, + {SIG_ANCHOR_DOWN, ""}, + {SIG_ANCHOR_UP, ""}, + {SIG_ANCHOR_IN, ""}, + {SIG_ANCHOR_OUT, ""}, + {SIG_PREEDIT_CHANGED, ""}, {NULL, NULL} }; @@ -397,7 +342,7 @@ _delay_write(void *data) } static Elm_Entry_Text_Filter * -_filter_new(void (*func) (void *data, Evas_Object *entry, char **text), void *data) +_filter_new(Elm_Entry_Filter_Cb func, void *data) { Elm_Entry_Text_Filter *tf = ELM_NEW(Elm_Entry_Text_Filter); if (!tf) return NULL; @@ -500,12 +445,21 @@ _del_hook(Evas_Object *obj) entries = eina_list_remove(entries, obj); #ifdef HAVE_ELEMENTARY_X - ecore_event_handler_del(wd->sel_notify_handler); - ecore_event_handler_del(wd->sel_clear_handler); + if (wd->sel_notify_handler) + ecore_event_handler_del(wd->sel_notify_handler); + if (wd->sel_clear_handler) + ecore_event_handler_del(wd->sel_clear_handler); #endif if (wd->cut_sel) eina_stringshare_del(wd->cut_sel); if (wd->text) eina_stringshare_del(wd->text); if (wd->deferred_recalc_job) ecore_job_del(wd->deferred_recalc_job); + if (wd->append_text_idler) + { + ecore_idler_del(wd->append_text_idler); + free(wd->append_text_left); + wd->append_text_left = NULL; + wd->append_text_idler = NULL; + } if (wd->longpress_timer) ecore_timer_del(wd->longpress_timer); EINA_LIST_FREE(wd->items, it) { @@ -542,6 +496,8 @@ _theme_hook(Evas_Object *obj) t = eina_stringshare_add(elm_entry_entry_get(obj)); _elm_theme_object_set(obj, wd->ent, "entry", _getbase(obj), elm_widget_style_get(obj)); + if (_elm_config->desktop_entry) + edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_TRUE); elm_entry_entry_set(obj, t); eina_stringshare_del(t); if (elm_widget_disabled_get(obj)) @@ -551,6 +507,21 @@ _theme_hook(Evas_Object *obj) edje_object_signal_emit(wd->ent, "elm,action,focus", "elm"); edje_object_message_signal_process(wd->ent); edje_object_scale_set(wd->ent, elm_widget_scale_get(obj) * _elm_config->scale); + elm_smart_scroller_mirrored_set(wd->scroller, elm_widget_mirrored_get(obj)); + elm_smart_scroller_object_theme_set(obj, wd->scroller, "scroller", "entry", + elm_widget_style_get(obj)); + if (wd->scroll) + { + const char *str; + Evas_Object *edj; + + edj = elm_smart_scroller_edje_object_get(wd->scroller); + str = edje_object_data_get(edj, "focus_highlight"); + if ((str) && (!strcmp(str, "on"))) + elm_widget_highlight_in_theme_set(obj, EINA_TRUE); + else + elm_widget_highlight_in_theme_set(obj, EINA_FALSE); + } _sizing_eval(obj); } @@ -572,52 +543,188 @@ _disable_hook(Evas_Object *obj) } static void +_recalc_cursor_geometry(Evas_Object *obj) +{ + Widget_Data *wd = elm_widget_data_get(obj); + if (!wd) return; + evas_object_smart_callback_call(obj, SIG_CURSOR_CHANGED, NULL); + if (!elm_object_focus_get(obj)) return; + if (!wd->deferred_recalc_job) + { + Evas_Coord cx, cy, cw, ch; + edje_object_part_text_cursor_geometry_get(wd->ent, "elm.text", + &cx, &cy, &cw, &ch); + if (wd->cur_changed) + { + elm_widget_show_region_set(obj, cx, cy, cw, ch, EINA_FALSE); + wd->cur_changed = EINA_FALSE; + } + } + else + wd->deferred_cur = EINA_TRUE; +} + +static void _elm_win_recalc_job(void *data) { Widget_Data *wd = elm_widget_data_get(data); - Evas_Coord minw = -1, minh = -1, maxh = -1; - Evas_Coord resw, resh, minminw; + Evas_Coord minh = -1, resw = -1, minw = -1, fw = 0, fh = 0; if (!wd) return; wd->deferred_recalc_job = NULL; - evas_object_geometry_get(wd->ent, NULL, NULL, &resw, &resh); - resh = 0; - edje_object_size_min_restricted_calc(wd->ent, &minw, &minh, 0, 0); - elm_coords_finger_size_adjust(1, &minw, 1, &minh); - minminw = minw; + + evas_object_geometry_get(wd->ent, NULL, NULL, &resw, NULL); edje_object_size_min_restricted_calc(wd->ent, &minw, &minh, resw, 0); elm_coords_finger_size_adjust(1, &minw, 1, &minh); - evas_object_size_hint_min_set(data, minminw, minh); - if (wd->single_line) maxh = minh; - evas_object_size_hint_max_set(data, -1, maxh); - if (wd->deferred_cur) - elm_widget_show_region_set(data, wd->cx, wd->cy, wd->cw, wd->ch); + wd->entmw = minw; + wd->entmh = minh; + /* This is a hack to workaround the way min size hints are treated. + * If the minimum width is smaller than the restricted width, it means + * the mininmum doesn't matter. */ + if (minw <= resw) + { + Evas_Coord ominw = -1; + evas_object_size_hint_min_get(data, &ominw, NULL); + minw = ominw; + } + + elm_coords_finger_size_adjust(1, &fw, 1, &fh); + if (wd->scroll) + { + Evas_Coord vmw = 0, vmh = 0; + + edje_object_size_min_calc + (elm_smart_scroller_edje_object_get(wd->scroller), + &vmw, &vmh); + if (wd->single_line) + { + evas_object_size_hint_min_set(data, vmw, minh + vmh); + evas_object_size_hint_max_set(data, -1, minh + vmh); + } + else + { + evas_object_size_hint_min_set(data, vmw, vmh); + evas_object_size_hint_max_set(data, -1, -1); + } + } + else + { + if (wd->single_line) + { + evas_object_size_hint_min_set(data, minw, minh); + evas_object_size_hint_max_set(data, -1, minh); + } + else + { + evas_object_size_hint_min_set(data, fw, minh); + evas_object_size_hint_max_set(data, -1, -1); + } + } + + if ((wd->deferred_cur) && (elm_object_focus_get(data))) + { + Evas_Coord cx, cy, cw, ch; + edje_object_part_text_cursor_geometry_get(wd->ent, "elm.text", + &cx, &cy, &cw, &ch); + if (wd->cur_changed) + { + elm_widget_show_region_set(data, cx, cy, cw, ch, EINA_FALSE); + wd->cur_changed = EINA_FALSE; + } + } } static void _sizing_eval(Evas_Object *obj) { Widget_Data *wd = elm_widget_data_get(obj); - Evas_Coord minw = -1, minh = -1, maxw = -1, maxh = -1; + Evas_Coord minw = -1, minh = -1; Evas_Coord resw, resh; if (!wd) return; - if ((wd->linewrap) || (wd->char_linewrap)) + + evas_object_geometry_get(obj, NULL, NULL, &resw, &resh); + if (wd->linewrap) { - evas_object_geometry_get(wd->ent, NULL, NULL, &resw, &resh); if ((resw == wd->lastw) && (!wd->changed)) return; wd->changed = EINA_FALSE; wd->lastw = resw; - if (wd->deferred_recalc_job) ecore_job_del(wd->deferred_recalc_job); - wd->deferred_recalc_job = ecore_job_add(_elm_win_recalc_job, obj); + if (wd->scroll) + { + Evas_Coord vw = 0, vh = 0, vmw = 0, vmh = 0, w = -1, h = -1; + + evas_object_resize(wd->scroller, resw, resh); + edje_object_size_min_calc + (elm_smart_scroller_edje_object_get(wd->scroller), + &vmw, &vmh); + elm_smart_scroller_child_viewport_size_get(wd->scroller, &vw, &vh); + edje_object_size_min_restricted_calc(wd->ent, &minw, &minh, vw, 0); + wd->entmw = minw; + wd->entmh = minh; + elm_coords_finger_size_adjust(1, &minw, 1, &minh); + + if ((minw > 0) && (vw < minw)) vw = minw; + if (minh > vh) vh = minh; + + if (wd->single_line) h = vmh + minh; + else h = vmh; + evas_object_resize(wd->ent, vw, vh); + evas_object_size_hint_min_set(obj, w, h); + if (wd->single_line) + evas_object_size_hint_max_set(obj, -1, h); + else + evas_object_size_hint_max_set(obj, -1, -1); + } + else + { + if (wd->deferred_recalc_job) ecore_job_del(wd->deferred_recalc_job); + wd->deferred_recalc_job = ecore_job_add(_elm_win_recalc_job, obj); + } } else { - evas_object_geometry_get(wd->ent, NULL, NULL, &resw, &resh); - edje_object_size_min_calc(wd->ent, &minw, &minh); - elm_coords_finger_size_adjust(1, &minw, 1, &minh); - evas_object_size_hint_min_set(obj, minw, minh); - if (wd->single_line) maxh = minh; - evas_object_size_hint_max_set(obj, maxw, maxh); + if (!wd->changed) return; + wd->changed = EINA_FALSE; + wd->lastw = resw; + if (wd->scroll) + { + Evas_Coord vw = 0, vh = 0, vmw = 0, vmh = 0, w = -1, h = -1; + + edje_object_size_min_calc(wd->ent, &minw, &minh); + wd->entmw = minw; + wd->entmh = minh; + elm_coords_finger_size_adjust(1, &minw, 1, &minh); + + elm_smart_scroller_child_viewport_size_get(wd->scroller, &vw, &vh); + + if ((minw > 0) && (vw < minw)) vw = minw; + if (minh > 0) vh = minh; + + evas_object_resize(wd->ent, vw, vh); + edje_object_size_min_calc + (elm_smart_scroller_edje_object_get(wd->scroller), + &vmw, &vmh); + if (wd->single_line) h = vmh + minh; + else h = vmh; + evas_object_size_hint_min_set(obj, w, h); + if (wd->single_line) + evas_object_size_hint_max_set(obj, -1, h); + else + evas_object_size_hint_max_set(obj, -1, -1); + } + else + { + edje_object_size_min_calc(wd->ent, &minw, &minh); + wd->entmw = minw; + wd->entmh = minh; + elm_coords_finger_size_adjust(1, &minw, 1, &minh); + evas_object_size_hint_min_set(obj, minw, minh); + if (wd->single_line) + evas_object_size_hint_max_set(obj, -1, minh); + else + evas_object_size_hint_max_set(obj, -1, -1); + } } + + _recalc_cursor_geometry(obj); } static void @@ -649,22 +756,31 @@ _signal_emit_hook(Evas_Object *obj, const char *emission, const char *source) Widget_Data *wd = elm_widget_data_get(obj); if (!wd) return; edje_object_signal_emit(wd->ent, emission, source); + if (wd->scroller) + edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scroller), + emission, source); } static void -_signal_callback_add_hook(Evas_Object *obj, const char *emission, const char *source, void (*func_cb) (void *data, Evas_Object *o, const char *emission, const char *source), void *data) +_signal_callback_add_hook(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func_cb, void *data) { Widget_Data *wd = elm_widget_data_get(obj); if (!wd) return; edje_object_signal_callback_add(wd->ent, emission, source, func_cb, data); + if (wd->scroller) + edje_object_signal_callback_add(elm_smart_scroller_edje_object_get(wd->scroller), + emission, source, func_cb, data); } static void -_signal_callback_del_hook(Evas_Object *obj, const char *emission, const char *source, void (*func_cb) (void *data, Evas_Object *o, const char *emission, const char *source), void *data) +_signal_callback_del_hook(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func_cb, void *data) { Widget_Data *wd = elm_widget_data_get(obj); edje_object_signal_callback_del_full(wd->ent, emission, source, func_cb, data); + if (wd->scroller) + edje_object_signal_callback_del_full(elm_smart_scroller_edje_object_get(wd->scroller), + emission, source, func_cb, data); } static void @@ -675,14 +791,44 @@ _on_focus_region_hook(const Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Evas } static void +_focus_region_hook(Evas_Object *obj, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h) +{ + Widget_Data *wd = elm_widget_data_get(obj); + if (wd->scroll) + elm_smart_scroller_child_region_show(wd->scroller, x, y, w, h); +} + +static void +_show_region_hook(void *data, Evas_Object *obj) +{ + Widget_Data *wd = elm_widget_data_get(data); + Evas_Coord x, y, w, h; + if (!wd) return; + elm_widget_show_region_get(obj, &x, &y, &w, &h); + if (wd->scroll) + elm_smart_scroller_child_region_show(wd->scroller, x, y, w, h); +} + +static void _hoversel_position(Evas_Object *obj) { Widget_Data *wd = elm_widget_data_get(obj); Evas_Coord cx, cy, cw, ch, x, y, mw, mh; if (!wd) return; + + cx = cy = 0; + cw = ch = 1; evas_object_geometry_get(wd->ent, &x, &y, NULL, NULL); - edje_object_part_text_cursor_geometry_get(wd->ent, "elm.text", - &cx, &cy, &cw, &ch); + if (wd->usedown) + { + cx = wd->downx - x; + cy = wd->downy - y; + cw = 1; + ch = 1; + } + else + edje_object_part_text_cursor_geometry_get(wd->ent, "elm.text", + &cx, &cy, &cw, &ch); evas_object_size_hint_min_get(wd->hoversel, &mw, &mh); if (cw < mw) { @@ -711,13 +857,21 @@ _resize(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event { Widget_Data *wd = elm_widget_data_get(data); if (!wd) return; - if ((wd->linewrap) || (wd->char_linewrap)) + + if (wd->linewrap) { _sizing_eval(data); } + else if (wd->scroll) + { + Evas_Coord vw = 0, vh = 0; + + elm_smart_scroller_child_viewport_size_get(wd->scroller, &vw, &vh); + if (vw < wd->entmw) vw = wd->entmw; + if (vh < wd->entmh) vh = wd->entmh; + evas_object_resize(wd->ent, vw, vh); + } if (wd->hoversel) _hoversel_position(data); - // Evas_Coord ww, hh; - // evas_object_geometry_get(wd->ent, NULL, NULL, &ww, &hh); } static void @@ -739,11 +893,15 @@ _dismissed(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__) { Widget_Data *wd = elm_widget_data_get(data); if (!wd) return; + wd->usedown = 0; if (wd->hoversel) evas_object_hide(wd->hoversel); if (wd->selmode) { - if (!wd->password) - edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_TRUE); + if (!_elm_config->desktop_entry) + { + if (!wd->password) + edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_TRUE); + } } elm_widget_scroll_freeze_pop(data); if (wd->hovdeljob) ecore_job_del(wd->hovdeljob); @@ -757,10 +915,14 @@ _select(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__) if (!wd) return; wd->selmode = EINA_TRUE; edje_object_part_text_select_none(wd->ent, "elm.text"); - if (!wd->password) - edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_TRUE); + if (!_elm_config->desktop_entry) + { + if (!wd->password) + edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_TRUE); + } edje_object_signal_emit(wd->ent, "elm,state,select,on", "elm"); - elm_widget_scroll_hold_push(data); + if (!_elm_config->desktop_entry) + elm_widget_scroll_hold_push(data); } static void @@ -790,6 +952,7 @@ _store_selection(Elm_Sel_Type seltype, Evas_Object *obj) if (!wd) return; sel = edje_object_part_text_selection_get(wd->ent, "elm.text"); + if ((!sel) || (!sel[0])) return; /* avoid deleting our own selection */ elm_selection_set(seltype, obj, ELM_SEL_FORMAT_MARKUP, sel); if (seltype == ELM_SEL_CLIPBOARD) eina_stringshare_replace(&wd->cut_sel, sel); @@ -802,12 +965,15 @@ _cut(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__) /* Store it */ wd->selmode = EINA_FALSE; - edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_FALSE); + if (!_elm_config->desktop_entry) + edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_FALSE); edje_object_signal_emit(wd->ent, "elm,state,select,off", "elm"); - elm_widget_scroll_hold_pop(data); + if (!_elm_config->desktop_entry) + elm_widget_scroll_hold_pop(data); _store_selection(ELM_SEL_CLIPBOARD, data); edje_object_part_text_insert(wd->ent, "elm.text", ""); edje_object_part_text_select_none(wd->ent, "elm.text"); + _sizing_eval(data); } static void @@ -816,9 +982,12 @@ _copy(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__) Widget_Data *wd = elm_widget_data_get(data); if (!wd) return; wd->selmode = EINA_FALSE; - edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_FALSE); - edje_object_signal_emit(wd->ent, "elm,state,select,off", "elm"); - elm_widget_scroll_hold_pop(data); + if (!_elm_config->desktop_entry) + { + edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_FALSE); + edje_object_signal_emit(wd->ent, "elm,state,select,off", "elm"); + elm_widget_scroll_hold_pop(data); + } _store_selection(ELM_SEL_CLIPBOARD, data); // edje_object_part_text_select_none(wd->ent, "elm.text"); } @@ -829,9 +998,11 @@ _cancel(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__) Widget_Data *wd = elm_widget_data_get(data); if (!wd) return; wd->selmode = EINA_FALSE; - edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_FALSE); + if (!_elm_config->desktop_entry) + edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_FALSE); edje_object_signal_emit(wd->ent, "elm,state,select,off", "elm"); - elm_widget_scroll_hold_pop(data); + if (!_elm_config->desktop_entry) + elm_widget_scroll_hold_pop(data); edje_object_part_text_select_none(wd->ent, "elm.text"); } @@ -843,62 +1014,68 @@ _item_clicked(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED if (it->func) it->func(it->data, obj2, NULL); } -static Eina_Bool -_long_press(void *data) +static void +_menu_press(Evas_Object *obj) { - Widget_Data *wd = elm_widget_data_get(data); + Widget_Data *wd = elm_widget_data_get(obj); Evas_Object *top; const Eina_List *l; const Elm_Entry_Context_Menu_Item *it; - if (!wd) return ECORE_CALLBACK_CANCEL; + if (!wd) return; if ((wd->api) && (wd->api->obj_longpress)) { - wd->api->obj_longpress(data); + wd->api->obj_longpress(obj); } else if (wd->context_menu) { const char *context_menu_orientation; if (wd->hoversel) evas_object_del(wd->hoversel); - else elm_widget_scroll_freeze_push(data); - wd->hoversel = elm_hoversel_add(data); + else elm_widget_scroll_freeze_push(obj); + wd->hoversel = elm_hoversel_add(obj); context_menu_orientation = edje_object_data_get (wd->ent, "context_menu_orientation"); if ((context_menu_orientation) && (!strcmp(context_menu_orientation, "horizontal"))) elm_hoversel_horizontal_set(wd->hoversel, EINA_TRUE); elm_object_style_set(wd->hoversel, "entry"); - elm_widget_sub_object_add(data, wd->hoversel); - elm_hoversel_label_set(wd->hoversel, "Text"); - top = elm_widget_top_get(data); + elm_widget_sub_object_add(obj, wd->hoversel); + elm_object_text_set(wd->hoversel, "Text"); + top = elm_widget_top_get(obj); if (top) elm_hoversel_hover_parent_set(wd->hoversel, top); - evas_object_smart_callback_add(wd->hoversel, "dismissed", _dismissed, data); - if (!wd->selmode) + evas_object_smart_callback_add(wd->hoversel, "dismissed", _dismissed, obj); + if (wd->have_selection) { if (!wd->password) - elm_hoversel_item_add(wd->hoversel, E_("Select"), NULL, ELM_ICON_NONE, - _select, data); - if (1) // need way to detect if someone has a selection { - if (wd->editable) - elm_hoversel_item_add(wd->hoversel, E_("Paste"), NULL, ELM_ICON_NONE, - _paste, data); + if (wd->have_selection) + { + elm_hoversel_item_add(wd->hoversel, E_("Copy"), NULL, ELM_ICON_NONE, + _copy, obj); + if (wd->editable) + elm_hoversel_item_add(wd->hoversel, E_("Cut"), NULL, ELM_ICON_NONE, + _cut, obj); + } + elm_hoversel_item_add(wd->hoversel, E_("Cancel"), NULL, ELM_ICON_NONE, + _cancel, obj); } } else { - if (!wd->password) + if (!wd->selmode) { - if (wd->have_selection) + if (!_elm_config->desktop_entry) + { + if (!wd->password) + elm_hoversel_item_add(wd->hoversel, E_("Select"), NULL, ELM_ICON_NONE, + _select, obj); + } + if (1) // need way to detect if someone has a selection { - elm_hoversel_item_add(wd->hoversel, E_("Copy"), NULL, ELM_ICON_NONE, - _copy, data); if (wd->editable) - elm_hoversel_item_add(wd->hoversel, E_("Cut"), NULL, ELM_ICON_NONE, - _cut, data); + elm_hoversel_item_add(wd->hoversel, E_("Paste"), NULL, ELM_ICON_NONE, + _paste, obj); } - elm_hoversel_item_add(wd->hoversel, E_("Cancel"), NULL, ELM_ICON_NONE, - _cancel, data); } } EINA_LIST_FOREACH(wd->items, l, it) @@ -908,13 +1085,24 @@ _long_press(void *data) } if (wd->hoversel) { - _hoversel_position(data); + _hoversel_position(obj); evas_object_show(wd->hoversel); elm_hoversel_hover_begin(wd->hoversel); } - edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_FALSE); - edje_object_part_text_select_abort(wd->ent, "elm.text"); + if (!_elm_config->desktop_entry) + { + edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_FALSE); + edje_object_part_text_select_abort(wd->ent, "elm.text"); + } } +} + +static Eina_Bool +_long_press(void *data) +{ + Widget_Data *wd = elm_widget_data_get(data); + if (!wd) return ECORE_CALLBACK_CANCEL; + _menu_press(data); wd->longpress_timer = NULL; evas_object_smart_callback_call(data, SIG_LONGPRESSED, NULL); return ECORE_CALLBACK_CANCEL; @@ -928,12 +1116,13 @@ _mouse_down(void *data, Evas *evas __UNUSED__, Evas_Object *obj __UNUSED__, void if (!wd) return; if (wd->disabled) return; if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return; - if (ev->button != 1) return; - // if (ev->flags & EVAS_BUTTON_DOUBLE_CLICK) - if (wd->longpress_timer) ecore_timer_del(wd->longpress_timer); - wd->longpress_timer = ecore_timer_add(_elm_config->longpress_timeout, _long_press, data); wd->downx = ev->canvas.x; wd->downy = ev->canvas.y; + if (ev->button == 1) + { + if (wd->longpress_timer) ecore_timer_del(wd->longpress_timer); + wd->longpress_timer = ecore_timer_add(_elm_config->longpress_timeout, _long_press, data); + } } static void @@ -943,11 +1132,18 @@ _mouse_up(void *data, Evas *evas __UNUSED__, Evas_Object *obj __UNUSED__, void * Evas_Event_Mouse_Up *ev = event_info; if (!wd) return; if (wd->disabled) return; - if (ev->button != 1) return; - if (wd->longpress_timer) + if (ev->button == 1) { - ecore_timer_del(wd->longpress_timer); - wd->longpress_timer = NULL; + if (wd->longpress_timer) + { + ecore_timer_del(wd->longpress_timer); + wd->longpress_timer = NULL; + } + } + else if (ev->button == 3) + { + wd->usedown = 1; + _menu_press(data); } } @@ -1016,9 +1212,18 @@ _getbase(Evas_Object *obj) if (wd->single_line) return "base-single"; else { - if (wd->linewrap) return "base"; - else if (wd->char_linewrap) return "base-charwrap"; - else return "base-nowrap"; + switch (wd->linewrap) + { + case ELM_WRAP_CHAR: + return "base-charwrap"; + case ELM_WRAP_WORD: + return "base"; + case ELM_WRAP_MIXED: + return "base-mixedwrap"; + case ELM_WRAP_NONE: + default: + return "base-nowrap"; + } } } } @@ -1030,9 +1235,18 @@ _getbase(Evas_Object *obj) if (wd->single_line) return "base-single-noedit"; else { - if (wd->linewrap) return "base-noedit"; - else if (wd->char_linewrap) return "base-noedit-charwrap"; - else return "base-nowrap-noedit"; + switch (wd->linewrap) + { + case ELM_WRAP_CHAR: + return "base-noedit-charwrap"; + case ELM_WRAP_WORD: + return "base-noedit"; + case ELM_WRAP_MIXED: + return "base-noedit-mixedwrap"; + case ELM_WRAP_NONE: + default: + return "base-nowrap-noedit"; + } } } } @@ -1040,15 +1254,21 @@ _getbase(Evas_Object *obj) } static void -_signal_entry_changed(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__) +_entry_changed_common_handling(void *data, const char *event) { Widget_Data *wd = elm_widget_data_get(data); + Evas_Coord minh; if (!wd) return; wd->changed = EINA_TRUE; + /* Reset the size hints which are no more relevant. + * Keep the height, this is a hack, but doesn't really matter + * cause we'll re-eval in a moment. */ + evas_object_size_hint_min_get(data, NULL, &minh); + evas_object_size_hint_min_set(data, -1, minh); _sizing_eval(data); if (wd->text) eina_stringshare_del(wd->text); wd->text = NULL; - evas_object_smart_callback_call(data, SIG_CHANGED, NULL); + evas_object_smart_callback_call(data, event, NULL); if (wd->delay_write) { ecore_timer_del(wd->delay_write); @@ -1059,6 +1279,18 @@ _signal_entry_changed(void *data, Evas_Object *obj __UNUSED__, const char *emiss } static void +_signal_entry_changed(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__) +{ + _entry_changed_common_handling(data, SIG_CHANGED); +} + +static void +_signal_preedit_changed(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__) +{ + _entry_changed_common_handling(data, SIG_PREEDIT_CHANGED); +} + +static void _signal_selection_start(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__) { Widget_Data *wd = elm_widget_data_get(data); @@ -1085,14 +1317,29 @@ _signal_selection_start(void *data, Evas_Object *obj __UNUSED__, const char *emi } static void +_signal_selection_all(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__) +{ + Widget_Data *wd = elm_widget_data_get(data); + if (!wd) return; + elm_entry_select_all(data); +} + +static void +_signal_selection_none(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__) +{ + Widget_Data *wd = elm_widget_data_get(data); + if (!wd) return; + elm_entry_select_none(data); +} + +static void _signal_selection_changed(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__) { Widget_Data *wd = elm_widget_data_get(data); if (!wd) return; wd->have_selection = EINA_TRUE; evas_object_smart_callback_call(data, SIG_SELECTION_CHANGED, NULL); - elm_selection_set(ELM_SEL_PRIMARY, obj, ELM_SEL_FORMAT_MARKUP, - elm_entry_selection_get(data)); + _store_selection(ELM_SEL_PRIMARY, data); } static void @@ -1132,9 +1379,10 @@ _signal_selection_cleared(void *data, Evas_Object *obj __UNUSED__, const char *e } static void -_signal_entry_paste_request(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__) +_signal_entry_paste_request(void *data, Evas_Object *obj __UNUSED__, const char *emission, const char *source __UNUSED__) { Widget_Data *wd = elm_widget_data_get(data); + Elm_Sel_Type type = (emission[sizeof("ntry,paste,request,")] == '1') ? ELM_SEL_PRIMARY : ELM_SEL_CLIPBOARD; if (!wd) return; evas_object_smart_callback_call(data, SIG_SELECTION_PASTE, NULL); if (wd->sel_notify_handler) @@ -1146,7 +1394,7 @@ _signal_entry_paste_request(void *data, Evas_Object *obj __UNUSED__, const char if ((top) && (elm_win_xwindow_get(top))) { wd->selection_asked = EINA_TRUE; - elm_selection_get(ELM_SEL_CLIPBOARD, ELM_SEL_FORMAT_MARKUP, data, + elm_selection_get(type, ELM_SEL_FORMAT_MARKUP, data, NULL, NULL); } #endif @@ -1156,45 +1404,49 @@ _signal_entry_paste_request(void *data, Evas_Object *obj __UNUSED__, const char static void _signal_entry_copy_notify(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__) { - Widget_Data *wd = elm_widget_data_get(data); - if (!wd) return; - evas_object_smart_callback_call(data, SIG_SELECTION_COPY, NULL); - elm_selection_set(ELM_SEL_CLIPBOARD, obj, ELM_SEL_FORMAT_MARKUP, - elm_entry_selection_get(data)); + _copy(data, NULL, NULL); } static void _signal_entry_cut_notify(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__) { - Widget_Data *wd = elm_widget_data_get(data); - if (!wd) return; - evas_object_smart_callback_call(data, SIG_SELECTION_CUT, NULL); - elm_selection_set(ELM_SEL_CLIPBOARD, obj, ELM_SEL_FORMAT_MARKUP, - elm_entry_selection_get(data)); - edje_object_part_text_insert(wd->ent, "elm.text", ""); - wd->changed = EINA_TRUE; - _sizing_eval(data); + _cut(data, NULL, NULL); } static void _signal_cursor_changed(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__) { Widget_Data *wd = elm_widget_data_get(data); - Evas_Coord cx, cy, cw, ch; if (!wd) return; - evas_object_smart_callback_call(data, SIG_CURSOR_CHANGED, NULL); - edje_object_part_text_cursor_geometry_get(wd->ent, "elm.text", - &cx, &cy, &cw, &ch); wd->cursor_pos = edje_object_part_text_cursor_pos_get(wd->ent, "elm.text", EDJE_CURSOR_MAIN); - if (!wd->deferred_recalc_job) - elm_widget_show_region_set(data, cx, cy, cw, ch); - else + wd->cur_changed = EINA_TRUE; + _recalc_cursor_geometry(data); +} + +static void +_signal_anchor_geoms_do_things_with(Widget_Data *wd, Elm_Entry_Anchor_Info *ei) +{ + const Eina_List *geoms, *l; + Evas_Textblock_Rectangle *r; + Evas_Coord px, py, x, y; + + geoms = edje_object_part_text_anchor_geometry_get(wd->ent, "elm.text", ei->name); + if (!geoms) return; + + + evas_object_geometry_get(wd->ent, &x, &y, NULL, NULL); + evas_pointer_canvas_xy_get(evas_object_evas_get(wd->ent), &px, &py); + EINA_LIST_FOREACH(geoms, l, r) { - wd->deferred_cur = EINA_TRUE; - wd->cx = cx; - wd->cy = cy; - wd->cw = cw; - wd->ch = ch; + if (((r->x + x) <= px) && ((r->y + y) <= py) && + ((r->x + x + r->w) > px) && ((r->y + y + r->h) > py)) + { + ei->x = r->x + x; + ei->y = r->y + y; + ei->w = r->w; + ei->h = r->h; + break; + } } } @@ -1202,14 +1454,38 @@ static void _signal_anchor_down(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__) { Widget_Data *wd = elm_widget_data_get(data); + Elm_Entry_Anchor_Info ei; + const char *p; + char *p2; if (!wd) return; + p = emission + sizeof("nchor,mouse,down,"); + ei.button = strtol(p, &p2, 10); + ei.name = p2; + ei.x = ei.y = ei.w = ei.h = 0; + + _signal_anchor_geoms_do_things_with(wd, &ei); + + if (!wd->disabled) + evas_object_smart_callback_call(data, SIG_ANCHOR_DOWN, &ei); } static void _signal_anchor_up(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__) { Widget_Data *wd = elm_widget_data_get(data); + Elm_Entry_Anchor_Info ei; + const char *p; + char *p2; if (!wd) return; + p = emission + sizeof("nchor,mouse,up,"); + ei.button = strtol(p, &p2, 10); + ei.name = p2; + ei.x = ei.y = ei.w = ei.h = 0; + + _signal_anchor_geoms_do_things_with(wd, &ei); + + if (!wd->disabled) + evas_object_smart_callback_call(data, SIG_ANCHOR_UP, &ei); } static void @@ -1217,53 +1493,18 @@ _signal_anchor_clicked(void *data, Evas_Object *obj __UNUSED__, const char *emis { Widget_Data *wd = elm_widget_data_get(data); Elm_Entry_Anchor_Info ei; - char *buf2, *p, *p2, *n; + const char *p; + char *p2; if (!wd) return; - p = strrchr(emission, ','); - if (p) - { - const Eina_List *geoms; + p = emission + sizeof("nchor,mouse,clicked,"); + ei.button = strtol(p, &p2, 10); + ei.name = p2; + ei.x = ei.y = ei.w = ei.h = 0; - n = p + 1; - p2 = p -1; - while (p2 >= emission) - { - if (*p2 == ',') break; - p2--; - } - p2++; - buf2 = alloca(5 + p - p2); - strncpy(buf2, p2, p - p2); - buf2[p - p2] = 0; - ei.name = n; - ei.button = atoi(buf2); - ei.x = ei.y = ei.w = ei.h = 0; - geoms = - edje_object_part_text_anchor_geometry_get(wd->ent, "elm.text", ei.name); - if (geoms) - { - Evas_Textblock_Rectangle *r; - const Eina_List *l; - Evas_Coord px, py, x, y; + _signal_anchor_geoms_do_things_with(wd, &ei); - evas_object_geometry_get(wd->ent, &x, &y, NULL, NULL); - evas_pointer_output_xy_get(evas_object_evas_get(wd->ent), &px, &py); - EINA_LIST_FOREACH(geoms, l, r) - { - if (((r->x + x) <= px) && ((r->y + y) <= py) && - ((r->x + x + r->w) > px) && ((r->y + y + r->h) > py)) - { - ei.x = r->x + x; - ei.y = r->y + y; - ei.w = r->w; - ei.h = r->h; - break; - } - } - } - if (!wd->disabled) - evas_object_smart_callback_call(data, SIG_ANCHOR_CLICKED, &ei); - } + if (!wd->disabled) + evas_object_smart_callback_call(data, SIG_ANCHOR_CLICKED, &ei); } static void @@ -1277,14 +1518,32 @@ static void _signal_anchor_in(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__) { Widget_Data *wd = elm_widget_data_get(data); + Elm_Entry_Anchor_Info ei; if (!wd) return; + ei.name = emission + sizeof("nchor,mouse,in,"); + ei.button = 0; + ei.x = ei.y = ei.w = ei.h = 0; + + _signal_anchor_geoms_do_things_with(wd, &ei); + + if (!wd->disabled) + evas_object_smart_callback_call(data, SIG_ANCHOR_IN, &ei); } static void _signal_anchor_out(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__) { Widget_Data *wd = elm_widget_data_get(data); + Elm_Entry_Anchor_Info ei; if (!wd) return; + ei.name = emission + sizeof("nchor,mouse,out,"); + ei.button = 0; + ei.x = ei.y = ei.w = ei.h = 0; + + _signal_anchor_geoms_do_things_with(wd, &ei); + + if (!wd->disabled) + evas_object_smart_callback_call(data, SIG_ANCHOR_OUT, &ei); } static void @@ -1319,6 +1578,14 @@ _signal_mouse_double(void *data, Evas_Object *obj __UNUSED__, const char *emissi evas_object_smart_callback_call(data, SIG_CLICKED_DOUBLE, NULL); } +static void +_signal_mouse_triple(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__) +{ + Widget_Data *wd = elm_widget_data_get(data); + if (!wd) return; + evas_object_smart_callback_call(data, SIG_CLICKED_TRIPLE, NULL); +} + #ifdef HAVE_ELEMENTARY_X static Eina_Bool _event_selection_notify(void *data, int type __UNUSED__, void *event) @@ -1380,21 +1647,18 @@ _event_selection_notify(void *data, int type __UNUSED__, void *event) static Eina_Bool _event_selection_clear(void *data __UNUSED__, int type __UNUSED__, void *event __UNUSED__) { - /* - Widget_Data *wd = elm_widget_data_get(data); - Ecore_X_Event_Selection_Clear *ev = event; - if (!wd) return ECORE_CALLBACK_PASS_ON; - if (!wd->have_selection) return ECORE_CALLBACK_PASS_ON; - if ((ev->selection == ECORE_X_SELECTION_CLIPBOARD) || - (ev->selection == ECORE_X_SELECTION_PRIMARY)) - { - elm_entry_select_none(data); - } - return 1;*/ + Widget_Data *wd = elm_widget_data_get(data); + Ecore_X_Event_Selection_Clear *ev = event; + if (!wd) return ECORE_CALLBACK_PASS_ON; + if (!wd->have_selection) return ECORE_CALLBACK_PASS_ON; + if ((ev->selection == ECORE_X_SELECTION_CLIPBOARD) || + (ev->selection == ECORE_X_SELECTION_PRIMARY)) + { + elm_entry_select_none(data); + } return ECORE_CALLBACK_PASS_ON; } - static Eina_Bool _drag_drop_cb(void *data __UNUSED__, Evas_Object *obj, Elm_Selection_Data *drop) { @@ -1402,7 +1666,6 @@ _drag_drop_cb(void *data __UNUSED__, Evas_Object *obj, Elm_Selection_Data *drop) Eina_Bool rv; wd = elm_widget_data_get(obj); - if (!wd) return EINA_FALSE; printf("Inserting at (%d,%d) %s\n",drop->x,drop->y,(char*)drop->data); @@ -1474,14 +1737,207 @@ _text_filter(void *data, Evas_Object *edje __UNUSED__, const char *part __UNUSED } } -/** - * This adds an entry to @p parent object. - * - * @param parent The parent object - * @return The new object or NULL if it cannot be created - * - * @ingroup Entry - */ +/* This function is used to insert text by chunks in jobs */ +static Eina_Bool +_text_append_idler(void *data) +{ + int start; + char backup; + Evas_Object *obj = (Evas_Object *) data; + Widget_Data *wd = elm_widget_data_get(obj); + if (wd->text) eina_stringshare_del(wd->text); + wd->text = NULL; + wd->changed = EINA_TRUE; + + start = wd->append_text_position; + if(start + _CHUNK_SIZE < wd->append_text_len) + { + wd->append_text_position = (start + _CHUNK_SIZE); + /* Go to the start of the nearest codepoint, because we don't want + * to cut it in the middle */ + eina_unicode_utf8_get_prev(wd->append_text_left, + &wd->append_text_position); + } + else + { + wd->append_text_position = wd->append_text_len; + } + + backup = wd->append_text_left[wd->append_text_position]; + wd->append_text_left[wd->append_text_position] = '\0'; + + edje_object_part_text_append(wd->ent, "elm.text", + wd->append_text_left + start); + + wd->append_text_left[wd->append_text_position] = backup; + + /* If there's still more to go, renew the idler, else, cleanup */ + if (wd->append_text_position < wd->append_text_len) + { + return ECORE_CALLBACK_RENEW; + } + else + { + free(wd->append_text_left); + wd->append_text_left = NULL; + wd->append_text_idler = NULL; + return ECORE_CALLBACK_CANCEL; + } +} + +static void +_add_chars_till_limit(Evas_Object *obj, char **text, int can_add, Length_Unit unit) +{ + int i = 0, unit_size; + int current_len = strlen(*text); + char *new_text = *text; + if (unit >= LENGTH_UNIT_LAST) return; + while (*new_text) + { + if (*new_text == '<') + { + while (*new_text != '>') + { + new_text++; + if (!*new_text) break; + } + new_text++; + } + else + { + int index = 0; + if (*new_text == '&') + { + while (*(new_text + index) != ';') + { + index++; + if (!*(new_text + index)) break; + } + } + char *markup; + index = evas_string_char_next_get(new_text, index, NULL); + markup = malloc(index + 1); + strncpy(markup, new_text, index); + markup[index] = 0; + if (unit == LENGTH_UNIT_BYTE) + unit_size = strlen(elm_entry_markup_to_utf8(markup)); + else if (unit == LENGTH_UNIT_CHAR) + unit_size = evas_string_char_len_get(elm_entry_markup_to_utf8(markup)); + if (markup) + { + free(markup); + markup = NULL; + } + if (can_add < unit_size) + { + if (!i) + { + evas_object_smart_callback_call(obj, "maxlength,reached", NULL); + free(*text); + *text = NULL; + return; + } + can_add = 0; + strncpy(new_text, new_text + index, current_len - ((new_text + index) - *text)); + current_len -= index; + (*text)[current_len] = 0; + } + else + { + new_text += index; + can_add -= unit_size; + } + i++; + } + } + evas_object_smart_callback_call(obj, "maxlength,reached", NULL); +} + +static void +_elm_entry_text_set(Evas_Object *obj, const char *item, const char *entry) +{ + int len = 0; + ELM_CHECK_WIDTYPE(obj, widtype); + if (item && strcmp(item, "default")) return; + Widget_Data *wd = elm_widget_data_get(obj); + if (!wd) return; + if (!entry) entry = ""; + if (wd->text) eina_stringshare_del(wd->text); + wd->text = NULL; + wd->changed = EINA_TRUE; + + /* Clear currently pending job if there is one */ + if (wd->append_text_idler) + { + ecore_idler_del(wd->append_text_idler); + free(wd->append_text_left); + wd->append_text_left = NULL; + wd->append_text_idler = NULL; + } + + len = strlen(entry); + /* Split to ~_CHUNK_SIZE chunks */ + if (len > _CHUNK_SIZE) + { + wd->append_text_left = (char *) malloc(len + 1); + } + + /* If we decided to use the idler */ + if (wd->append_text_left) + { + /* Need to clear the entry first */ + edje_object_part_text_set(wd->ent, "elm.text", ""); + memcpy(wd->append_text_left, entry, len + 1); + wd->append_text_position = 0; + wd->append_text_len = len; + wd->append_text_idler = ecore_idler_add(_text_append_idler, obj); + } + else + { + edje_object_part_text_set(wd->ent, "elm.text", entry); + } +} + +static const char * +_elm_entry_text_get(const Evas_Object *obj, const char *item) +{ + ELM_CHECK_WIDTYPE(obj, widtype) NULL; + Widget_Data *wd = elm_widget_data_get(obj); + if (item && strcmp(item, "default")) return NULL; + const char *text; + if (!wd) return NULL; + if (wd->text) return wd->text; + text = edje_object_part_text_get(wd->ent, "elm.text"); + if (!text) + { + ERR("text=NULL for edje %p, part 'elm.text'", wd->ent); + return NULL; + } + + if (wd->append_text_len > 0) + { + char *tmpbuf; + size_t tlen; + tlen = strlen(text); + tmpbuf = malloc(tlen + wd->append_text_len + 1); + if (!tmpbuf) + { + ERR("Failed to allocate memory for entry's text %p", obj); + return NULL; + } + memcpy(tmpbuf, text, tlen); + memcpy(tmpbuf + tlen, wd->append_text_left, wd->append_text_len); + tmpbuf[tlen + wd->append_text_len] = '\0'; + eina_stringshare_replace(&wd->text, tmpbuf); + free(tmpbuf); + } + else + { + eina_stringshare_replace(&wd->text, text); + } + return wd->text; +} + EAPI Evas_Object * elm_entry_add(Evas_Object *parent) { @@ -1501,15 +1957,29 @@ elm_entry_add(Evas_Object *parent) elm_widget_theme_hook_set(obj, _theme_hook); elm_widget_disable_hook_set(obj, _disable_hook); elm_widget_signal_emit_hook_set(obj, _signal_emit_hook); + elm_widget_focus_region_hook_set(obj, _focus_region_hook); elm_widget_on_focus_region_hook_set(obj, _on_focus_region_hook); elm_widget_signal_callback_add_hook_set(obj, _signal_callback_add_hook); elm_widget_signal_callback_del_hook_set(obj, _signal_callback_del_hook); elm_object_cursor_set(obj, ELM_CURSOR_XTERM); elm_widget_can_focus_set(obj, EINA_TRUE); elm_widget_highlight_ignore_set(obj, EINA_TRUE); - - wd->linewrap = EINA_TRUE; - wd->char_linewrap= EINA_FALSE; + elm_widget_text_set_hook_set(obj, _elm_entry_text_set); + elm_widget_text_get_hook_set(obj, _elm_entry_text_get); + + wd->scroller = elm_smart_scroller_add(e); + elm_widget_sub_object_add(obj, wd->scroller); + elm_smart_scroller_widget_set(wd->scroller, obj); + elm_smart_scroller_object_theme_set(obj, wd->scroller, "scroller", "entry", + elm_widget_style_get(obj)); + evas_object_size_hint_weight_set(wd->scroller, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND); + evas_object_size_hint_align_set(wd->scroller, EVAS_HINT_FILL, EVAS_HINT_FILL); + elm_smart_scroller_bounce_allow_set(wd->scroller, EINA_FALSE, EINA_FALSE); + evas_object_propagate_events_set(wd->scroller, EINA_TRUE); + evas_object_propagate_events_set(elm_smart_scroller_edje_object_get( + wd->scroller), EINA_TRUE); + + wd->linewrap = ELM_WRAP_WORD; wd->editable = EINA_TRUE; wd->disabled = EINA_FALSE; wd->context_menu = EINA_TRUE; @@ -1517,27 +1987,34 @@ elm_entry_add(Evas_Object *parent) wd->textonly = EINA_FALSE; wd->ent = edje_object_add(e); + elm_widget_sub_object_add(obj, wd->ent); edje_object_item_provider_set(wd->ent, _get_item, obj); edje_object_text_insert_filter_callback_add(wd->ent,"elm.text", _text_filter, obj); evas_object_event_callback_add(wd->ent, EVAS_CALLBACK_MOVE, _move, obj); - evas_object_event_callback_add(wd->ent, EVAS_CALLBACK_RESIZE, _resize, obj); evas_object_event_callback_add(wd->ent, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down, obj); evas_object_event_callback_add(wd->ent, EVAS_CALLBACK_MOUSE_UP, _mouse_up, obj); evas_object_event_callback_add(wd->ent, EVAS_CALLBACK_MOUSE_MOVE, _mouse_move, obj); + evas_object_event_callback_add(obj, EVAS_CALLBACK_RESIZE, _resize, obj); _elm_theme_object_set(obj, wd->ent, "entry", "base", "default"); edje_object_signal_callback_add(wd->ent, "entry,changed", "elm.text", _signal_entry_changed, obj); + edje_object_signal_callback_add(wd->ent, "preedit,changed", "elm.text", + _signal_preedit_changed, obj); edje_object_signal_callback_add(wd->ent, "selection,start", "elm.text", _signal_selection_start, obj); edje_object_signal_callback_add(wd->ent, "selection,changed", "elm.text", _signal_selection_changed, obj); + edje_object_signal_callback_add(wd->ent, "entry,selection,all,request", "elm.text", + _signal_selection_all, obj); + edje_object_signal_callback_add(wd->ent, "entry,selection,none,request", "elm.text", + _signal_selection_none, obj); edje_object_signal_callback_add(wd->ent, "selection,cleared", "elm.text", _signal_selection_cleared, obj); - edje_object_signal_callback_add(wd->ent, "entry,paste,request", "elm.text", + edje_object_signal_callback_add(wd->ent, "entry,paste,request,*", "elm.text", _signal_entry_paste_request, obj); edje_object_signal_callback_add(wd->ent, "entry,copy,notify", "elm.text", _signal_entry_copy_notify, obj); @@ -1565,7 +2042,11 @@ elm_entry_add(Evas_Object *parent) _signal_mouse_clicked, obj); edje_object_signal_callback_add(wd->ent, "mouse,down,1,double", "elm.text", _signal_mouse_double, obj); + edje_object_signal_callback_add(wd->ent, "mouse,down,1,triple", "elm.text", + _signal_mouse_triple, obj); edje_object_part_text_set(wd->ent, "elm.text", ""); + if (_elm_config->desktop_entry) + edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_TRUE); elm_widget_resize_object_set(obj, wd->ent); _sizing_eval(obj); @@ -1599,17 +2080,6 @@ elm_entry_add(Evas_Object *parent) return obj; } - -/** - * This sets the entry object not to line wrap. All input will - * be on a single line, and the entry box will extend with user input. - * - * @param obj The entry object - * @param single_line If true, the text in the entry - * will be on a single line. - * - * @ingroup Entry - */ EAPI void elm_entry_single_line_set(Evas_Object *obj, Eina_Bool single_line) { @@ -1618,22 +2088,31 @@ elm_entry_single_line_set(Evas_Object *obj, Eina_Bool single_line) if (!wd) return; if (wd->single_line == single_line) return; wd->single_line = single_line; - wd->linewrap = EINA_FALSE; - wd->char_linewrap = EINA_FALSE; + wd->linewrap = ELM_WRAP_NONE; elm_entry_cnp_textonly_set(obj, EINA_TRUE); _theme_hook(obj); + if (wd->scroller) + { + if (wd->single_line) + elm_smart_scroller_policy_set(wd->scroller, + ELM_SMART_SCROLLER_POLICY_OFF, + ELM_SMART_SCROLLER_POLICY_OFF); + else + { + const Elm_Scroller_Policy map[3] = + { + ELM_SMART_SCROLLER_POLICY_AUTO, + ELM_SMART_SCROLLER_POLICY_ON, + ELM_SMART_SCROLLER_POLICY_OFF + }; + elm_smart_scroller_policy_set(wd->scroller, + map[wd->policy_h], + map[wd->policy_v]); + } + _sizing_eval(obj); + } } -/** - * This returns true if the entry has been set to single line mode. - * See also elm_entry_single_line_set(). - * - * @param obj The entry object - * @return single_line If true, the text in the entry is set to display - * on a single line. - * - * @ingroup Entry - */ EAPI Eina_Bool elm_entry_single_line_get(const Evas_Object *obj) { @@ -1643,15 +2122,6 @@ elm_entry_single_line_get(const Evas_Object *obj) return wd->single_line; } -/** - * This sets the entry object to password mode. All text entered - * and/or displayed within the widget will be replaced with asterisks (*). - * - * @param obj The entry object - * @param password If true, password mode is enabled. - * - * @ingroup Entry - */ EAPI void elm_entry_password_set(Evas_Object *obj, Eina_Bool password) { @@ -1661,22 +2131,10 @@ elm_entry_password_set(Evas_Object *obj, Eina_Bool password) if (wd->password == password) return; wd->password = password; wd->single_line = EINA_TRUE; - wd->linewrap = EINA_FALSE; - wd->char_linewrap = EINA_FALSE; + wd->linewrap = ELM_WRAP_NONE; _theme_hook(obj); } - -/** - * This returns whether password mode is enabled. - * See also elm_entry_password_set(). - * - * @param obj The entry object - * @return If true, the entry is set to display all characters - * as asterisks (*). - * - * @ingroup Entry - */ EAPI Eina_Bool elm_entry_password_get(const Evas_Object *obj) { @@ -1686,65 +2144,49 @@ elm_entry_password_get(const Evas_Object *obj) return wd->password; } -/** - * This sets the text displayed within the entry to @p entry. - * - * @param obj The entry object - * @param entry The text to be displayed - * - * @ingroup Entry - */ EAPI void elm_entry_entry_set(Evas_Object *obj, const char *entry) { + _elm_entry_text_set(obj, NULL, entry); +} + +EAPI void +elm_entry_entry_append(Evas_Object *obj, const char *entry) +{ + int len = 0; ELM_CHECK_WIDTYPE(obj, widtype); Widget_Data *wd = elm_widget_data_get(obj); if (!wd) return; if (!entry) entry = ""; - edje_object_part_text_set(wd->ent, "elm.text", entry); - if (wd->text) eina_stringshare_del(wd->text); - wd->text = NULL; wd->changed = EINA_TRUE; - _sizing_eval(obj); + + len = strlen(entry); + if (wd->append_text_left) + { + char *tmpbuf; + tmpbuf = realloc(wd->append_text_left, wd->append_text_len + len + 1); + if (!tmpbuf) + { + /* Do something */ + return; + } + wd->append_text_left = tmpbuf; + memcpy(wd->append_text_left + wd->append_text_len, entry, len + 1); + wd->append_text_len += len; + } + else + { + /* FIXME: Add chunked appending here (like in entry_set) */ + edje_object_part_text_append(wd->ent, "elm.text", entry); + } } -/** - * This returns the text currently shown in object @p entry. - * See also elm_entry_entry_set(). - * - * @param obj The entry object - * @return The currently displayed text or NULL on failure - * - * @ingroup Entry - */ EAPI const char * elm_entry_entry_get(const Evas_Object *obj) { - ELM_CHECK_WIDTYPE(obj, widtype) NULL; - Widget_Data *wd = elm_widget_data_get(obj); - const char *text; - if (!wd) return NULL; - if (wd->text) return wd->text; - text = edje_object_part_text_get(wd->ent, "elm.text"); - if (!text) - { - ERR("text=NULL for edje %p, part 'elm.text'", wd->ent); - return NULL; - } - eina_stringshare_replace(&wd->text, text); - return wd->text; + return _elm_entry_text_get(obj, NULL); } - -/** - * This returns EINA_TRUE if the entry is empty/there was an error - * and EINA_FALSE if it is not empty. - * - * @param obj The entry object - * @return If the entry is empty or not. - * - * @ingroup Entry - */ EAPI Eina_Bool elm_entry_is_empty(const Evas_Object *obj) { @@ -1771,14 +2213,6 @@ elm_entry_is_empty(const Evas_Object *obj) return !ret; } -/** - * This returns all selected text within the entry. - * - * @param obj The entry object - * @return The selected text within the entry or NULL on failure - * - * @ingroup Entry - */ EAPI const char * elm_entry_selection_get(const Evas_Object *obj) { @@ -1788,20 +2222,6 @@ elm_entry_selection_get(const Evas_Object *obj) return edje_object_part_text_selection_get(wd->ent, "elm.text"); } -/** - * This inserts text in @p entry where the current cursor position. - * - * This inserts text at the cursor position is as if it was typed - * by the user (note this also allows markup which a user - * can't just "type" as it would be converted to escaped text, so this - * call can be used to insert things like emoticon items or bold push/pop - * tags, other font and color change tags etc.) - * - * @param obj The entry object - * @param entry The text to insert - * - * @ingroup Entry - */ EAPI void elm_entry_entry_insert(Evas_Object *obj, const char *entry) { @@ -1813,66 +2233,27 @@ elm_entry_entry_insert(Evas_Object *obj, const char *entry) _sizing_eval(obj); } -/** - * This enables word line wrapping in the entry object. It is the opposite - * of elm_entry_single_line_set(). Additionally, setting this disables - * character line wrapping. - * See also elm_entry_line_char_wrap_set(). - * - * @param obj The entry object - * @param wrap If true, the entry will be wrapped once it reaches the end - * of the object. Wrapping will occur at the end of the word before the end of the - * object. - * - * @ingroup Entry - */ EAPI void -elm_entry_line_wrap_set(Evas_Object *obj, Eina_Bool wrap) +elm_entry_line_wrap_set(Evas_Object *obj, Elm_Wrap_Type wrap) { ELM_CHECK_WIDTYPE(obj, widtype); Widget_Data *wd = elm_widget_data_get(obj); if (!wd) return; if (wd->linewrap == wrap) return; + wd->lastw = -1; wd->linewrap = wrap; - if(wd->linewrap) - wd->char_linewrap = EINA_FALSE; _theme_hook(obj); } -/** - * This enables character line wrapping in the entry object. It is the opposite - * of elm_entry_single_line_set(). Additionally, setting this disables - * word line wrapping. - * See also elm_entry_line_wrap_set(). - * - * @param obj The entry object - * @param wrap If true, the entry will be wrapped once it reaches the end - * of the object. Wrapping will occur immediately upon reaching the end of the object. - * - * @ingroup Entry - */ -EAPI void -elm_entry_line_char_wrap_set(Evas_Object *obj, Eina_Bool wrap) +EAPI Elm_Wrap_Type +elm_entry_line_wrap_get(const Evas_Object *obj) { - ELM_CHECK_WIDTYPE(obj, widtype); + ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE; Widget_Data *wd = elm_widget_data_get(obj); - if (!wd) return; - if (wd->char_linewrap == wrap) return; - wd->char_linewrap = wrap; - if(wd->char_linewrap) - wd->linewrap = EINA_FALSE; - _theme_hook(obj); + if (!wd) return EINA_FALSE; + return wd->linewrap; } -/** - * This sets the editable attribute of the entry. - * - * @param obj The entry object - * @param editable If true, the entry will be editable by the user. - * If false, it will be set to the disabled state. - * - * @ingroup Entry - */ EAPI void elm_entry_editable_set(Evas_Object *obj, Eina_Bool editable) { @@ -1891,16 +2272,6 @@ elm_entry_editable_set(Evas_Object *obj, Eina_Bool editable) #endif } -/** - * This gets the editable attribute of the entry. - * See also elm_entry_editable_set(). - * - * @param obj The entry object - * @return If true, the entry is editable by the user. - * If false, it is not editable by the user - * - * @ingroup Entry - */ EAPI Eina_Bool elm_entry_editable_get(const Evas_Object *obj) { @@ -1910,13 +2281,6 @@ elm_entry_editable_get(const Evas_Object *obj) return wd->editable; } -/** - * This drops any existing text selection within the entry. - * - * @param obj The entry object - * - * @ingroup Entry - */ EAPI void elm_entry_select_none(Evas_Object *obj) { @@ -1926,20 +2290,14 @@ elm_entry_select_none(Evas_Object *obj) if (wd->selmode) { wd->selmode = EINA_FALSE; - edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_FALSE); + if (!_elm_config->desktop_entry) + edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_FALSE); edje_object_signal_emit(wd->ent, "elm,state,select,off", "elm"); } wd->have_selection = EINA_FALSE; edje_object_part_text_select_none(wd->ent, "elm.text"); } -/** - * This selects all text within the entry. - * - * @param obj The entry object - * - * @ingroup Entry - */ EAPI void elm_entry_select_all(Evas_Object *obj) { @@ -1949,29 +2307,14 @@ elm_entry_select_all(Evas_Object *obj) if (wd->selmode) { wd->selmode = EINA_FALSE; - edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_FALSE); + if (!_elm_config->desktop_entry) + edje_object_part_text_select_allow_set(wd->ent, "elm.text", EINA_FALSE); edje_object_signal_emit(wd->ent, "elm,state,select,off", "elm"); } wd->have_selection = EINA_TRUE; edje_object_part_text_select_all(wd->ent, "elm.text"); } -/** - * This function returns the geometry of the cursor. - * - * It's useful if you want to draw something on the cursor (or where it is), - * or for example in the case of scrolled entry where you want to show the - * cursor. - * - * @param obj The entry object - * @param x returned geometry - * @param y returned geometry - * @param w returned geometry - * @param h returned geometry - * @return EINA_TRUE upon success, EINA_FALSE upon failure - * - * @ingroup Entry - */ EAPI Eina_Bool elm_entry_cursor_geometry_get(const Evas_Object *obj, Evas_Coord *x, Evas_Coord *y, Evas_Coord *w, Evas_Coord *h) { @@ -1982,14 +2325,6 @@ elm_entry_cursor_geometry_get(const Evas_Object *obj, Evas_Coord *x, Evas_Coord return EINA_TRUE; } -/** - * This moves the cursor one place to the right within the entry. - * - * @param obj The entry object - * @return EINA_TRUE upon success, EINA_FALSE upon failure - * - * @ingroup Entry - */ EAPI Eina_Bool elm_entry_cursor_next(Evas_Object *obj) { @@ -1999,14 +2334,6 @@ elm_entry_cursor_next(Evas_Object *obj) return edje_object_part_text_cursor_next(wd->ent, "elm.text", EDJE_CURSOR_MAIN); } -/** - * This moves the cursor one place to the left within the entry. - * - * @param obj The entry object - * @return EINA_TRUE upon success, EINA_FALSE upon failure - * - * @ingroup Entry - */ EAPI Eina_Bool elm_entry_cursor_prev(Evas_Object *obj) { @@ -2016,14 +2343,6 @@ elm_entry_cursor_prev(Evas_Object *obj) return edje_object_part_text_cursor_prev(wd->ent, "elm.text", EDJE_CURSOR_MAIN); } -/** - * This moves the cursor one line up within the entry. - * - * @param obj The entry object - * @return EINA_TRUE upon success, EINA_FALSE upon failure - * - * @ingroup Entry - */ EAPI Eina_Bool elm_entry_cursor_up(Evas_Object *obj) { @@ -2033,14 +2352,6 @@ elm_entry_cursor_up(Evas_Object *obj) return edje_object_part_text_cursor_up(wd->ent, "elm.text", EDJE_CURSOR_MAIN); } -/** - * This moves the cursor one line down within the entry. - * - * @param obj The entry object - * @return EINA_TRUE upon success, EINA_FALSE upon failure - * - * @ingroup Entry - */ EAPI Eina_Bool elm_entry_cursor_down(Evas_Object *obj) { @@ -2050,13 +2361,6 @@ elm_entry_cursor_down(Evas_Object *obj) return edje_object_part_text_cursor_down(wd->ent, "elm.text", EDJE_CURSOR_MAIN); } -/** - * This moves the cursor to the beginning of the entry. - * - * @param obj The entry object - * - * @ingroup Entry - */ EAPI void elm_entry_cursor_begin_set(Evas_Object *obj) { @@ -2066,29 +2370,22 @@ elm_entry_cursor_begin_set(Evas_Object *obj) edje_object_part_text_cursor_begin_set(wd->ent, "elm.text", EDJE_CURSOR_MAIN); } -/** - * This moves the cursor to the end of the entry. - * - * @param obj The entry object - * - * @ingroup Entry - */ EAPI void elm_entry_cursor_end_set(Evas_Object *obj) { ELM_CHECK_WIDTYPE(obj, widtype); Widget_Data *wd = elm_widget_data_get(obj); if (!wd) return; + int x, y, w, h; + x = y = w = h = 1; edje_object_part_text_cursor_end_set(wd->ent, "elm.text", EDJE_CURSOR_MAIN); + if (wd->scroll) + { + elm_widget_show_region_get(wd->ent, &x, &y, &w, &h); + elm_smart_scroller_child_region_show(wd->scroller, x, y, w, h); + } } -/** - * This moves the cursor to the beginning of the current line. - * - * @param obj The entry object - * - * @ingroup Entry - */ EAPI void elm_entry_cursor_line_begin_set(Evas_Object *obj) { @@ -2098,13 +2395,6 @@ elm_entry_cursor_line_begin_set(Evas_Object *obj) edje_object_part_text_cursor_line_begin_set(wd->ent, "elm.text", EDJE_CURSOR_MAIN); } -/** - * This moves the cursor to the end of the current line. - * - * @param obj The entry object - * - * @ingroup Entry - */ EAPI void elm_entry_cursor_line_end_set(Evas_Object *obj) { @@ -2114,14 +2404,6 @@ elm_entry_cursor_line_end_set(Evas_Object *obj) edje_object_part_text_cursor_line_end_set(wd->ent, "elm.text", EDJE_CURSOR_MAIN); } -/** - * This begins a selection within the entry as though - * the user were holding down the mouse button to make a selection. - * - * @param obj The entry object - * - * @ingroup Entry - */ EAPI void elm_entry_cursor_selection_begin(Evas_Object *obj) { @@ -2131,14 +2413,6 @@ elm_entry_cursor_selection_begin(Evas_Object *obj) edje_object_part_text_select_begin(wd->ent, "elm.text"); } -/** - * This ends a selection within the entry as though - * the user had just released the mouse button while making a selection. - * - * @param obj The entry object - * - * @ingroup Entry - */ EAPI void elm_entry_cursor_selection_end(Evas_Object *obj) { @@ -2148,14 +2422,6 @@ elm_entry_cursor_selection_end(Evas_Object *obj) edje_object_part_text_select_extend(wd->ent, "elm.text"); } -/** - * TODO: fill this in - * - * @param obj The entry object - * @return TODO: fill this in - * - * @ingroup Entry - */ EAPI Eina_Bool elm_entry_cursor_is_format_get(const Evas_Object *obj) { @@ -2165,14 +2431,6 @@ elm_entry_cursor_is_format_get(const Evas_Object *obj) return edje_object_part_text_cursor_is_format_get(wd->ent, "elm.text", EDJE_CURSOR_MAIN); } -/** - * This returns whether the cursor is visible. - * - * @param obj The entry object - * @return If true, the cursor is visible. - * - * @ingroup Entry - */ EAPI Eina_Bool elm_entry_cursor_is_visible_format_get(const Evas_Object *obj) { @@ -2182,14 +2440,6 @@ elm_entry_cursor_is_visible_format_get(const Evas_Object *obj) return edje_object_part_text_cursor_is_visible_format_get(wd->ent, "elm.text", EDJE_CURSOR_MAIN); } -/** - * TODO: fill this in - * - * @param obj The entry object - * @return TODO: fill this in - * - * @ingroup Entry - */ EAPI const char * elm_entry_cursor_content_get(const Evas_Object *obj) { @@ -2199,14 +2449,6 @@ elm_entry_cursor_content_get(const Evas_Object *obj) return edje_object_part_text_cursor_content_get(wd->ent, "elm.text", EDJE_CURSOR_MAIN); } -/** - * Sets the cursor position in the entry to the given value - * - * @param obj The entry object - * @param pos The position of the cursor - * - * @ingroup Entry - */ EAPI void elm_entry_cursor_pos_set(Evas_Object *obj, int pos) { @@ -2217,14 +2459,6 @@ elm_entry_cursor_pos_set(Evas_Object *obj, int pos) edje_object_message_signal_process(wd->ent); } -/** - * Retrieves the current position of the cursor in the entry - * - * @param obj The entry object - * @return The cursor position - * - * @ingroup Entry - */ EAPI int elm_entry_cursor_pos_get(const Evas_Object *obj) { @@ -2234,13 +2468,6 @@ elm_entry_cursor_pos_get(const Evas_Object *obj) return edje_object_part_text_cursor_pos_get(wd->ent, "elm.text", EDJE_CURSOR_MAIN); } -/** - * This executes a "cut" action on the selected text in the entry. - * - * @param obj The entry object - * - * @ingroup Entry - */ EAPI void elm_entry_selection_cut(Evas_Object *obj) { @@ -2250,13 +2477,6 @@ elm_entry_selection_cut(Evas_Object *obj) _cut(obj, NULL, NULL); } -/** - * This executes a "copy" action on the selected text in the entry. - * - * @param obj The entry object - * - * @ingroup Entry - */ EAPI void elm_entry_selection_copy(Evas_Object *obj) { @@ -2266,13 +2486,6 @@ elm_entry_selection_copy(Evas_Object *obj) _copy(obj, NULL, NULL); } -/** - * This executes a "paste" action in the entry. - * - * @param obj The entry object - * - * @ingroup Entry - */ EAPI void elm_entry_selection_paste(Evas_Object *obj) { @@ -2282,13 +2495,6 @@ elm_entry_selection_paste(Evas_Object *obj) _paste(obj, NULL, NULL); } -/** - * This clears and frees the items in a entry's contextual (right click) menu. - * - * @param obj The entry object - * - * @ingroup Entry - */ EAPI void elm_entry_context_menu_clear(Evas_Object *obj) { @@ -2305,18 +2511,6 @@ elm_entry_context_menu_clear(Evas_Object *obj) } } -/** - * This adds an item to the entry's contextual menu. - * - * @param obj The entry object - * @param label The item's text label - * @param icon_file The item's icon file - * @param icon_type The item's icon type - * @param func The callback to execute when the item is clicked - * @param data The data to associate with the item for related functions - * - * @ingroup Entry - */ EAPI void 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) { @@ -2335,14 +2529,6 @@ elm_entry_context_menu_item_add(Evas_Object *obj, const char *label, const char it->data = (void *)data; } -/** - * This disables the entry's contextual (right click) menu. - * - * @param obj The entry object - * @param disabled If true, the menu is disabled - * - * @ingroup Entry - */ EAPI void elm_entry_context_menu_disabled_set(Evas_Object *obj, Eina_Bool disabled) { @@ -2353,14 +2539,6 @@ elm_entry_context_menu_disabled_set(Evas_Object *obj, Eina_Bool disabled) wd->context_menu = !disabled; } -/** - * This returns whether the entry's contextual (right click) menu is disabled. - * - * @param obj The entry object - * @return If true, the menu is disabled - * - * @ingroup Entry - */ EAPI Eina_Bool elm_entry_context_menu_disabled_get(const Evas_Object *obj) { @@ -2370,22 +2548,6 @@ elm_entry_context_menu_disabled_get(const Evas_Object *obj) return !wd->context_menu; } -/** - * This appends a custom item provider to the list for that entry - * - * This appends the given callback. The list is walked from beginning to end - * with each function called given the item href string in the text. If the - * function returns an object handle other than NULL (it should create an - * and object to do this), then this object is used to replace that item. If - * not the next provider is called until one provides an item object, or the - * default provider in entry does. - * - * @param obj The entry object - * @param func The function called to provide the item object - * @param data The data passed to @p func - * - * @ingroup Entry - */ EAPI void elm_entry_item_provider_append(Evas_Object *obj, Evas_Object *(*func) (void *data, Evas_Object *entry, const char *item), void *data) { @@ -2400,18 +2562,6 @@ elm_entry_item_provider_append(Evas_Object *obj, Evas_Object *(*func) (void *dat wd->item_providers = eina_list_append(wd->item_providers, ip); } -/** - * This prepends a custom item provider to the list for that entry - * - * This prepends the given callback. See elm_entry_item_provider_append() for - * more information - * - * @param obj The entry object - * @param func The function called to provide the item object - * @param data The data passed to @p func - * - * @ingroup Entry - */ EAPI void elm_entry_item_provider_prepend(Evas_Object *obj, Evas_Object *(*func) (void *data, Evas_Object *entry, const char *item), void *data) { @@ -2426,18 +2576,6 @@ elm_entry_item_provider_prepend(Evas_Object *obj, Evas_Object *(*func) (void *da wd->item_providers = eina_list_prepend(wd->item_providers, ip); } -/** - * This removes a custom item provider to the list for that entry - * - * This removes the given callback. See elm_entry_item_provider_append() for - * more information - * - * @param obj The entry object - * @param func The function called to provide the item object - * @param data The data passed to @p func - * - * @ingroup Entry - */ EAPI void elm_entry_item_provider_remove(Evas_Object *obj, Evas_Object *(*func) (void *data, Evas_Object *entry, const char *item), void *data) { @@ -2458,25 +2596,8 @@ elm_entry_item_provider_remove(Evas_Object *obj, Evas_Object *(*func) (void *dat } } -/** - * Append a filter function for text inserted in the entry - * - * Append the given callback to the list. This functions will be called - * whenever any text is inserted into the entry, with the text to be inserted - * as a parameter. The callback function is free to alter the text in any way - * it wants, but it must remember to free the given pointer and update it. - * If the new text is to be discarded, the function can free it and set it text - * parameter to NULL. This will also prevent any following filters from being - * called. - * - * @param obj The entry object - * @param func The function to use as text filter - * @param data User data to pass to @p func - * - * @ingroup Entry - */ EAPI void -elm_entry_text_filter_append(Evas_Object *obj, void (*func) (void *data, Evas_Object *entry, char **text), void *data) +elm_entry_text_filter_append(Evas_Object *obj, Elm_Entry_Filter_Cb func, void *data) { Widget_Data *wd; Elm_Entry_Text_Filter *tf; @@ -2492,20 +2613,8 @@ elm_entry_text_filter_append(Evas_Object *obj, void (*func) (void *data, Evas_Ob wd->text_filters = eina_list_append(wd->text_filters, tf); } -/** - * Prepend a filter function for text insdrted in the entry - * - * Prepend the given callback to the list. See elm_entry_text_filter_append() - * for more information - * - * @param obj The entry object - * @param func The function to use as text filter - * @param data User data to pass to @p func - * - * @ingroup Entry - */ EAPI void -elm_entry_text_filter_prepend(Evas_Object *obj, void (*func) (void *data, Evas_Object *entry, char **text), void *data) +elm_entry_text_filter_prepend(Evas_Object *obj, Elm_Entry_Filter_Cb func, void *data) { Widget_Data *wd; Elm_Entry_Text_Filter *tf; @@ -2521,20 +2630,8 @@ elm_entry_text_filter_prepend(Evas_Object *obj, void (*func) (void *data, Evas_O wd->text_filters = eina_list_prepend(wd->text_filters, tf); } -/** - * Remove a filter from the list - * - * Removes the given callback from the filter list. See elm_entry_text_filter_append() - * for more information. - * - * @param obj The entry object - * @param func The filter function to remove - * @param data The user data passed when adding the function - * - * @ingroup Entry - */ EAPI void -elm_entry_text_filter_remove(Evas_Object *obj, void (*func) (void *data, Evas_Object *entry, char **text), void *data) +elm_entry_text_filter_remove(Evas_Object *obj, Elm_Entry_Filter_Cb func, void *data) { Widget_Data *wd; Eina_List *l; @@ -2556,16 +2653,6 @@ elm_entry_text_filter_remove(Evas_Object *obj, void (*func) (void *data, Evas_Ob } } -/** - * This converts a markup (HTML-like) string into UTF-8. - * Returning string is obtained with malloc. - * After use the returned string, it should be freed. - * - * @param s The string (in markup) to be converted - * @return The converted string (in UTF-8). It should be freed. - * - * @ingroup Entry - */ EAPI char * elm_entry_markup_to_utf8(const char *s) { @@ -2574,16 +2661,6 @@ elm_entry_markup_to_utf8(const char *s) return ss; } -/** - * This converts a UTF-8 string into markup (HTML-like). - * Returning string is obtained with malloc. - * After use the returned string, it should be freed. - * - * @param s The string (in UTF-8) to be converted - * @return The converted string (in markup). It should be freed. - * - * @ingroup Entry - */ EAPI char * elm_entry_utf8_to_markup(const char *s) { @@ -2592,27 +2669,6 @@ elm_entry_utf8_to_markup(const char *s) return ss; } -/** - * Filter inserted text based on user defined character and byte limits - * - * Add this filter to an entry to limit the characters that it will accept - * based the the contents of the provided Elm_Entry_Filter_Limit_Size. - * The funtion works on the UTF-8 representation of the string, converting - * it from the set markup, thus not accounting for any format in it. - * - * The user must create an Elm_Entry_Filter_Limit_Size structure and pass - * it as data when setting the filter. In it it's possible to set limits - * by character count or bytes (any of them is disabled if 0), and both can - * be set at the same time. In that case, it first checks for characters, - * then bytes. - * - * The function will cut the inserted text in order to allow only the first - * number of characters that are still allowed. The cut is made in - * characters, even when limiting by bytes, in order to always contain - * valid ones and avoid half unicode characters making it in. - * - * @ingroup Entry - */ EAPI void elm_entry_filter_limit_size(void *data, Evas_Object *entry, char **text) { @@ -2631,8 +2687,6 @@ elm_entry_filter_limit_size(void *data, Evas_Object *entry, char **text) widget_type = elm_widget_type_get(entry); if (!strcmp(widget_type, "entry")) text_get = elm_entry_entry_get; - else if (!strcmp(widget_type, "scrolled_entry")) - text_get = elm_scrolled_entry_entry_get; else /* huh? */ return; @@ -2640,61 +2694,37 @@ elm_entry_filter_limit_size(void *data, Evas_Object *entry, char **text) if (lim->max_char_count > 0) { - int cut; len = evas_string_char_len_get(current); if (len >= lim->max_char_count) { + evas_object_smart_callback_call(entry, "maxlength,reached", NULL); free(*text); free(current); *text = NULL; return; } - newlen = evas_string_char_len_get(*text); - cut = strlen(*text); - while ((len + newlen) > lim->max_char_count) - { - cut = evas_string_char_prev_get(*text, cut, NULL); - newlen--; - } - (*text)[cut] = 0; + newlen = evas_string_char_len_get(elm_entry_markup_to_utf8(*text)); + if ((len + newlen) > lim->max_char_count) + _add_chars_till_limit(entry, text, (lim->max_char_count - len), LENGTH_UNIT_CHAR); } - - if (lim->max_byte_count > 0) + else if (lim->max_byte_count > 0) { len = strlen(current); if (len >= lim->max_byte_count) { + evas_object_smart_callback_call(entry, "maxlength,reached", NULL); free(*text); free(current); *text = NULL; return; } - newlen = strlen(*text); - while ((len + newlen) > lim->max_byte_count) - { - int p = evas_string_char_prev_get(*text, newlen, NULL); - newlen -= (newlen - p); - } - if (newlen) - (*text)[newlen] = 0; - else - { - free(*text); - *text = NULL; - } + newlen = strlen(elm_entry_markup_to_utf8(*text)); + if ((len + newlen) > lim->max_byte_count) + _add_chars_till_limit(entry, text, (lim->max_byte_count - len), LENGTH_UNIT_BYTE); } free(current); } -/** - * Filter inserted text based on accepted or rejected sets of characters - * - * Add this filter to an entry to restrict the set of accepted characters - * based on the sets in the provided Elm_Entry_Filter_Accept_Set. - * This structure contains both accepted and rejected sets, but they are - * mutually exclusive. If accepted is set, it will be used, otherwise it - * goes on to the rejected set. - */ EAPI void elm_entry_filter_accept_set(void *data, Evas_Object *entry __UNUSED__, char **text) { @@ -2752,17 +2782,6 @@ elm_entry_filter_accept_set(void *data, Evas_Object *entry __UNUSED__, char **te *insert = 0; } -/** - * This sets the file (and implicitly loads it) for the text to display and - * then edit. All changes are written back to the file after a short delay if - * the entry object is set to autosave. - * - * @param obj The entry object - * @param file The path to the file to load and save - * @param format The file format - * - * @ingroup Entry - */ EAPI void elm_entry_file_set(Evas_Object *obj, const char *file, Elm_Text_Format format) { @@ -2780,15 +2799,6 @@ elm_entry_file_set(Evas_Object *obj, const char *file, Elm_Text_Format format) _load(obj); } -/** - * Gets the file to load and save and the file format - * - * @param obj The entry object - * @param file The path to the file to load and save - * @param format The file format - * - * @ingroup Entry - */ EAPI void elm_entry_file_get(const Evas_Object *obj, const char **file, Elm_Text_Format *format) { @@ -2799,14 +2809,6 @@ elm_entry_file_get(const Evas_Object *obj, const char **file, Elm_Text_Format *f if (format) *format = wd->format; } -/** - * This function writes any changes made to the file set with - * elm_entry_file_set() - * - * @param obj The entry object - * - * @ingroup Entry - */ EAPI void elm_entry_file_save(Evas_Object *obj) { @@ -2822,14 +2824,6 @@ elm_entry_file_save(Evas_Object *obj) wd->delay_write = ecore_timer_add(2.0, _delay_write, obj); } -/** - * This sets the entry object to 'autosave' the loaded text file or not. - * - * @param obj The entry object - * @param autosave Autosave the loaded file or not - * - * @ingroup Entry - */ EAPI void elm_entry_autosave_set(Evas_Object *obj, Eina_Bool autosave) { @@ -2839,14 +2833,6 @@ elm_entry_autosave_set(Evas_Object *obj, Eina_Bool autosave) wd->autosave = !!autosave; } -/** - * This gets the entry object's 'autosave' status. - * - * @param obj The entry object - * @return Autosave the loaded file or not - * - * @ingroup Entry - */ EAPI Eina_Bool elm_entry_autosave_get(const Evas_Object *obj) { @@ -2856,20 +2842,6 @@ elm_entry_autosave_get(const Evas_Object *obj) return wd->autosave; } - -/** - * Control pasting of text and images for the widget. - * - * Normally the entry allows both text and images to be pasted. By setting - * textonly to be true, this prevents images from being pasted. - * - * Note this only changes the behaviour of text. - * - * @param obj The entry object - * @param textonly paste mode - EINA_TRUE is text only, EINA_FALSE is text+image+other. - * - * @ingroup Entry - */ EAPI void elm_entry_cnp_textonly_set(Evas_Object *obj, Eina_Bool textonly) { @@ -2886,18 +2858,8 @@ elm_entry_cnp_textonly_set(Evas_Object *obj, Eina_Bool textonly) #endif } -/** - * Getting elm_entry text paste/drop mode. - * - * In textonly mode, only text may be pasted or dropped into the widget. - * - * @param obj The entry object - * @return If the widget only accepts text from pastes. - * - * @ingroup Entry - */ EAPI Eina_Bool -elm_entry_cnp_textonly_get(Evas_Object *obj) +elm_entry_cnp_textonly_get(const Evas_Object *obj) { ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE; Widget_Data *wd = elm_widget_data_get(obj); @@ -2905,3 +2867,200 @@ elm_entry_cnp_textonly_get(Evas_Object *obj) return wd->textonly; } +EAPI void +elm_entry_scrollable_set(Evas_Object *obj, Eina_Bool scroll) +{ + ELM_CHECK_WIDTYPE(obj, widtype); + Widget_Data *wd = elm_widget_data_get(obj); + if (!wd) return; + scroll = !!scroll; + if (wd->scroll == scroll) return; + wd->scroll = scroll; + if (wd->scroll) + { + elm_widget_sub_object_del(obj, wd->scroller); + elm_widget_resize_object_set(obj, wd->scroller); + elm_widget_sub_object_add(obj, wd->ent); + elm_smart_scroller_child_set(wd->scroller, wd->ent); + evas_object_show(wd->scroller); + elm_widget_on_show_region_hook_set(obj, _show_region_hook, obj); + } + else + { + elm_smart_scroller_child_set(wd->scroller, NULL); + elm_widget_sub_object_del(obj, wd->ent); + elm_widget_resize_object_set(obj, wd->ent); + evas_object_smart_member_add(wd->scroller, obj); + elm_widget_sub_object_add(obj, wd->scroller); + evas_object_hide(wd->scroller); + elm_widget_on_show_region_hook_set(obj, NULL, NULL); + } + wd->lastw = -1; + _theme_hook(obj); +} + +EAPI Eina_Bool +elm_entry_scrollable_get(const Evas_Object *obj) +{ + ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE; + Widget_Data *wd = elm_widget_data_get(obj); + if (!wd) return EINA_FALSE; + return wd->scroll; +} + +EAPI void +elm_entry_icon_set(Evas_Object *obj, Evas_Object *icon) +{ + ELM_CHECK_WIDTYPE(obj, widtype); + Widget_Data *wd = elm_widget_data_get(obj); + Evas_Object *edje; + if (!wd) return; + EINA_SAFETY_ON_NULL_RETURN(icon); + if (wd->icon == icon) return; + if (wd->icon) evas_object_del(wd->icon); + wd->icon = icon; + edje = elm_smart_scroller_edje_object_get(wd->scroller); + if (!edje) return; + edje_object_part_swallow(edje, "elm.swallow.icon", wd->icon); + edje_object_signal_emit(edje, "elm,action,show,icon", "elm"); + _sizing_eval(obj); +} + +EAPI Evas_Object * +elm_entry_icon_get(const Evas_Object *obj) +{ + ELM_CHECK_WIDTYPE(obj, widtype) NULL; + Widget_Data *wd = elm_widget_data_get(obj); + if (!wd) return NULL; + return wd->icon; +} + +EAPI Evas_Object * +elm_entry_icon_unset(Evas_Object *obj) +{ + ELM_CHECK_WIDTYPE(obj, widtype) NULL; + Widget_Data *wd = elm_widget_data_get(obj); + Evas_Object *ret = NULL; + if (!wd) return NULL; + if (wd->icon) + { + Evas_Object *edje = elm_smart_scroller_edje_object_get(wd->scroller); + if (!edje) return NULL; + ret = wd->icon; + edje_object_part_unswallow(edje, wd->icon); + edje_object_signal_emit(edje, "elm,action,hide,icon", "elm"); + wd->icon = NULL; + _sizing_eval(obj); + } + return ret; +} + +EAPI void +elm_entry_icon_visible_set(Evas_Object *obj, Eina_Bool setting) +{ + ELM_CHECK_WIDTYPE(obj, widtype); + Widget_Data *wd = elm_widget_data_get(obj); + if ((!wd) || (!wd->icon)) return; + if (setting) + evas_object_hide(wd->icon); + else + evas_object_show(wd->icon); + _sizing_eval(obj); +} + +EAPI void +elm_entry_end_set(Evas_Object *obj, Evas_Object *end) +{ + ELM_CHECK_WIDTYPE(obj, widtype); + Widget_Data *wd = elm_widget_data_get(obj); + Evas_Object *edje; + if (!wd) return; + EINA_SAFETY_ON_NULL_RETURN(end); + if (wd->end == end) return; + if (wd->end) evas_object_del(wd->end); + wd->end = end; + edje = elm_smart_scroller_edje_object_get(wd->scroller); + if (!edje) return; + edje_object_part_swallow(edje, "elm.swallow.end", wd->end); + edje_object_signal_emit(edje, "elm,action,show,end", "elm"); + _sizing_eval(obj); +} + +EAPI Evas_Object * +elm_entry_end_get(const Evas_Object *obj) +{ + ELM_CHECK_WIDTYPE(obj, widtype) NULL; + Widget_Data *wd = elm_widget_data_get(obj); + if (!wd) return NULL; + return wd->end; +} + +EAPI Evas_Object * +elm_entry_end_unset(Evas_Object *obj) +{ + ELM_CHECK_WIDTYPE(obj, widtype) NULL; + Widget_Data *wd = elm_widget_data_get(obj); + Evas_Object *ret = NULL; + if (!wd) return NULL; + if (wd->end) + { + Evas_Object *edje = elm_smart_scroller_edje_object_get(wd->scroller); + if (!edje) return NULL; + ret = wd->end; + edje_object_part_unswallow(edje, wd->end); + edje_object_signal_emit(edje, "elm,action,hide,end", "elm"); + wd->end = NULL; + _sizing_eval(obj); + } + return ret; +} + +EAPI void +elm_entry_end_visible_set(Evas_Object *obj, Eina_Bool setting) +{ + ELM_CHECK_WIDTYPE(obj, widtype); + Widget_Data *wd = elm_widget_data_get(obj); + if ((!wd) || (!wd->end)) return; + if (setting) + evas_object_hide(wd->end); + else + evas_object_show(wd->end); + _sizing_eval(obj); +} + +EAPI void +elm_entry_scrollbar_policy_set(Evas_Object *obj, Elm_Scroller_Policy h, Elm_Scroller_Policy v) +{ + ELM_CHECK_WIDTYPE(obj, widtype); + Widget_Data *wd = elm_widget_data_get(obj); + const Elm_Scroller_Policy map[3] = + { + ELM_SMART_SCROLLER_POLICY_AUTO, + ELM_SMART_SCROLLER_POLICY_ON, + ELM_SMART_SCROLLER_POLICY_OFF + }; + if (!wd) return; + wd->policy_h = h; + wd->policy_v = v; + elm_smart_scroller_policy_set(wd->scroller, + map[wd->policy_h], + map[wd->policy_v]); +} + +EAPI void +elm_entry_bounce_set(Evas_Object *obj, Eina_Bool h_bounce, Eina_Bool v_bounce) +{ + ELM_CHECK_WIDTYPE(obj, widtype); + Widget_Data *wd = elm_widget_data_get(obj); + if (!wd) return; + elm_smart_scroller_bounce_allow_set(wd->scroller, h_bounce, v_bounce); +} + +EAPI void +elm_entry_bounce_get(const Evas_Object *obj, Eina_Bool *h_bounce, Eina_Bool *v_bounce) +{ + ELM_CHECK_WIDTYPE(obj, widtype); + Widget_Data *wd = elm_widget_data_get(obj); + if (!wd) return; + elm_smart_scroller_bounce_allow_get(wd->scroller, h_bounce, v_bounce); +}