src/lib/elm_list.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3 #include "els_scroller.h"
   4
   5 #define SWIPE_MOVES 12
   6
   7 typedef struct _Widget_Data Widget_Data;
   8
   9 struct _Widget_Data
  10 {
  11    Evas_Object *scr, *box, *self;
  12    Eina_List *items, *selected, *to_delete;
  13    Elm_List_Item *last_selected_item;
  14    Elm_List_Mode mode;
  15    Elm_List_Mode h_mode;
  16    Evas_Coord minw[2], minh[2];
  17    Eina_Bool scr_minw : 1;
  18    Eina_Bool scr_minh : 1;
  19    int walking;
  20    int movements;
  21    struct {
  22         Evas_Coord x, y;
  23    } history[SWIPE_MOVES];
  24    Eina_Bool swipe : 1;
  25    Eina_Bool fix_pending : 1;
  26    Eina_Bool on_hold : 1;
  27    Eina_Bool multi : 1;
  28    Eina_Bool always_select : 1;
  29    Eina_Bool longpressed : 1;
  30    Eina_Bool wasselected : 1;
  31 };
  32
  33 struct _Elm_List_Item
  34 {
  35    Elm_Widget_Item base;
  36    Widget_Data *wd;
  37    Eina_List *node;
  38    const char *label;
  39    Evas_Object *icon, *end;
  40    Evas_Smart_Cb func;
  41    Ecore_Timer *long_timer;
  42    Ecore_Timer *swipe_timer;
  43    Eina_Bool deleted : 1;
  44    Eina_Bool disabled : 1;
  45    Eina_Bool even : 1;
  46    Eina_Bool is_even : 1;
  47    Eina_Bool is_separator : 1;
  48    Eina_Bool fixed : 1;
  49    Eina_Bool selected : 1;
  50    Eina_Bool hilighted : 1;
  51    Eina_Bool dummy_icon : 1;
  52    Eina_Bool dummy_end : 1;
  53 };
  54
  55 static const char *widtype = NULL;
  56 static void _del_hook(Evas_Object *obj);
  57 static void _mirrored_set(Evas_Object *obj, Eina_Bool rtl);
  58 static void _theme_hook(Evas_Object *obj);
  59 static void _sizing_eval(Evas_Object *obj);
  60 static void _disable_hook(Evas_Object *obj);
  61 static void _on_focus_hook(void *data, Evas_Object *obj);
  62 static void _signal_emit_hook(Evas_Object *obj, const char *emission, const char *source);
  63 static void _changed_size_hints(void *data, Evas *e, Evas_Object *obj, void *event_info);
  64 static void _sub_del(void *data, Evas_Object *obj, void *event_info);
  65 static void _fix_items(Evas_Object *obj);
  66 static void _mouse_down(void *data, Evas *evas, Evas_Object *obj, void *event_info);
  67 static void _mouse_up(void *data, Evas *evas, Evas_Object *obj, void *event_info);
  68 static void _mouse_move(void *data, Evas *evas, Evas_Object *obj, void *event_info);
  69 static void _scroll_edge_left(void *data, Evas_Object *scr, void *event_info);
  70 static void _scroll_edge_right(void *data, Evas_Object *scr, void *event_info);
  71 static void _scroll_edge_top(void *data, Evas_Object *scr, void *event_info);
  72 static void _scroll_edge_bottom(void *data, Evas_Object *scr, void *event_info);
  73 static Eina_Bool _item_multi_select_up(Widget_Data *wd);
  74 static Eina_Bool _item_multi_select_down(Widget_Data *wd);
  75 static Eina_Bool _item_single_select_up(Widget_Data *wd);
  76 static Eina_Bool _item_single_select_down(Widget_Data *wd);
  77 static Eina_Bool _event_hook(Evas_Object *obj, Evas_Object *src,
  78                              Evas_Callback_Type type, void *event_info);
  79 static Eina_Bool _deselect_all_items(Widget_Data *wd);
  80
  81 static const char SIG_CLICKED_DOUBLE[] = "clicked,double";
  82 static const char SIG_SELECTED[] = "selected";
  83 static const char SIG_UNSELECTED[] = "unselected";
  84 static const char SIG_LONGPRESSED[] = "longpressed";
  85 static const char SIG_SCROLL_EDGE_TOP[] = "scroll,edge,top";
  86 static const char SIG_SCROLL_EDGE_BOTTOM[] = "scroll,edge,bottom";
  87 static const char SIG_SCROLL_EDGE_LEFT[] = "scroll,edge,left";
  88 static const char SIG_SCROLL_EDGE_RIGHT[] = "scroll,edge,right";
  89
  90 static const Evas_Smart_Cb_Description _signals[] = {
  91    {SIG_CLICKED_DOUBLE, ""},
  92    {SIG_SELECTED, ""},
  93    {SIG_UNSELECTED, ""},
  94    {SIG_LONGPRESSED, ""},
  95    {SIG_SCROLL_EDGE_TOP, ""},
  96    {SIG_SCROLL_EDGE_BOTTOM, ""},
  97    {SIG_SCROLL_EDGE_LEFT, ""},
  98    {SIG_SCROLL_EDGE_RIGHT, ""},
  99    {NULL, NULL}
 100 };
 101
 102 #define ELM_LIST_ITEM_CHECK_DELETED_RETURN(it, ...)                      \
 103    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, __VA_ARGS__);             \
 104 if (it->deleted)                                                         \
 105 {                                                                        \
 106    ERR("ERROR: "#it" has been DELETED.\n");                              \
 107    return __VA_ARGS__;                                                   \
 108 }
 109
 110 static inline void
 111 _elm_list_item_free(Elm_List_Item *it)
 112 {
 113    evas_object_event_callback_del_full
 114       (it->base.view, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down, it);
 115    evas_object_event_callback_del_full
 116       (it->base.view, EVAS_CALLBACK_MOUSE_UP, _mouse_up, it);
 117    evas_object_event_callback_del_full
 118       (it->base.view, EVAS_CALLBACK_MOUSE_MOVE, _mouse_move, it);
 119
 120    if (it->icon)
 121      evas_object_event_callback_del_full
 122         (it->icon, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
 123          _changed_size_hints, it->base.widget);
 124
 125    if (it->end)
 126      evas_object_event_callback_del_full
 127         (it->end, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
 128          _changed_size_hints, it->base.widget);
 129
 130    eina_stringshare_del(it->label);
 131
 132    if (it->swipe_timer) ecore_timer_del(it->swipe_timer);
 133    if (it->long_timer) ecore_timer_del(it->long_timer);
 134    if (it->icon) evas_object_del(it->icon);
 135    if (it->end) evas_object_del(it->end);
 136
 137    elm_widget_item_del(it);
 138 }
 139
 140 static Eina_Bool
 141 _event_hook(Evas_Object *obj, Evas_Object *src __UNUSED__, Evas_Callback_Type type, void *event_info)
 142 {
 143    if (type != EVAS_CALLBACK_KEY_DOWN) return EINA_FALSE;
 144    Evas_Event_Key_Down *ev = event_info;
 145    Widget_Data *wd = elm_widget_data_get(obj);
 146    if (!wd) return EINA_FALSE;
 147    if (!wd->items) return EINA_FALSE;
 148    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return EINA_FALSE;
 149    if (elm_widget_disabled_get(obj)) return EINA_FALSE;
 150
 151    Elm_List_Item *it = NULL;
 152    Evas_Coord x = 0;
 153    Evas_Coord y = 0;
 154    Evas_Coord step_x = 0;
 155    Evas_Coord step_y = 0;
 156    Evas_Coord v_w = 0;
 157    Evas_Coord v_h = 0;
 158    Evas_Coord page_x = 0;
 159    Evas_Coord page_y = 0;
 160
 161    elm_smart_scroller_child_pos_get(wd->scr, &x, &y);
 162    elm_smart_scroller_step_size_get(wd->scr, &step_x, &step_y);
 163    elm_smart_scroller_page_size_get(wd->scr, &page_x, &page_y);
 164    elm_smart_scroller_child_viewport_size_get(wd->scr, &v_w, &v_h);
 165
 166    /* TODO: fix logic for horizontal mode */
 167    if ((!strcmp(ev->keyname, "Left")) ||
 168        (!strcmp(ev->keyname, "KP_Left")))
 169      {
 170         if ((wd->h_mode) &&
 171             (((evas_key_modifier_is_set(ev->modifiers, "Shift")) &&
 172               (_item_multi_select_up(wd)))
 173              || (_item_single_select_up(wd))))
 174           {
 175              ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 176              return EINA_TRUE;
 177           }
 178         else
 179           x -= step_x;
 180      }
 181    else if ((!strcmp(ev->keyname, "Right")) ||
 182             (!strcmp(ev->keyname, "KP_Right")))
 183      {
 184         if ((wd->h_mode) &&
 185             (((evas_key_modifier_is_set(ev->modifiers, "Shift")) &&
 186               (_item_multi_select_down(wd)))
 187              || (_item_single_select_down(wd))))
 188           {
 189              ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 190              return EINA_TRUE;
 191           }
 192         else
 193           x += step_x;
 194      }
 195    else if ((!strcmp(ev->keyname, "Up"))  ||
 196             (!strcmp(ev->keyname, "KP_Up")))
 197      {
 198         if ((!wd->h_mode) &&
 199             (((evas_key_modifier_is_set(ev->modifiers, "Shift")) &&
 200               (_item_multi_select_up(wd)))
 201              || (_item_single_select_up(wd))))
 202           {
 203              ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 204              return EINA_TRUE;
 205           }
 206         else
 207           y -= step_y;
 208      }
 209    else if ((!strcmp(ev->keyname, "Down")) ||
 210             (!strcmp(ev->keyname, "KP_Down")))
 211      {
 212         if ((!wd->h_mode) &&
 213             (((evas_key_modifier_is_set(ev->modifiers, "Shift")) &&
 214               (_item_multi_select_down(wd)))
 215              || (_item_single_select_down(wd))))
 216           {
 217              ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 218              return EINA_TRUE;
 219           }
 220         else
 221           y += step_y;
 222      }
 223    else if ((!strcmp(ev->keyname, "Home")) ||
 224             (!strcmp(ev->keyname, "KP_Home")))
 225      {
 226         it = eina_list_data_get(wd->items);
 227         elm_list_item_bring_in(it);
 228         ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 229         return EINA_TRUE;
 230      }
 231    else if ((!strcmp(ev->keyname, "End")) ||
 232             (!strcmp(ev->keyname, "KP_End")))
 233      {
 234         it = eina_list_data_get(eina_list_last(wd->items));
 235         elm_list_item_bring_in(it);
 236         ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 237         return EINA_TRUE;
 238      }
 239    else if ((!strcmp(ev->keyname, "Prior")) ||
 240             (!strcmp(ev->keyname, "KP_Prior")))
 241      {
 242         if (wd->h_mode)
 243           {
 244              if (page_x < 0)
 245                x -= -(page_x * v_w) / 100;
 246              else
 247                x -= page_x;
 248           }
 249         else
 250           {
 251              if (page_y < 0)
 252                y -= -(page_y * v_h) / 100;
 253              else
 254                y -= page_y;
 255           }
 256      }
 257    else if ((!strcmp(ev->keyname, "Next")) ||
 258             (!strcmp(ev->keyname, "KP_Next")))
 259      {
 260         if (wd->h_mode)
 261           {
 262              if (page_x < 0)
 263                x += -(page_x * v_w) / 100;
 264              else
 265                x += page_x;
 266           }
 267         else
 268           {
 269              if (page_y < 0)
 270                y += -(page_y * v_h) / 100;
 271              else
 272                y += page_y;
 273           }
 274      }
 275    else if (!strcmp(ev->keyname, "Escape"))
 276      {
 277         if (!_deselect_all_items(wd)) return EINA_FALSE;
 278         ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 279         return EINA_TRUE;
 280      }
 281    else return EINA_FALSE;
 282
 283    ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 284    elm_smart_scroller_child_pos_set(wd->scr, x, y);
 285    return EINA_TRUE;
 286 }
 287
 288 static Eina_Bool
 289 _deselect_all_items(Widget_Data *wd)
 290 {
 291    if (!wd->selected) return EINA_FALSE;
 292    while (wd->selected)
 293      elm_list_item_selected_set(wd->selected->data, EINA_FALSE);
 294
 295    return EINA_TRUE;
 296 }
 297
 298 static Eina_Bool
 299 _item_multi_select_up(Widget_Data *wd)
 300 {
 301    if (!wd->selected) return EINA_FALSE;
 302    if (!wd->multi) return EINA_FALSE;
 303
 304    Elm_List_Item *prev = elm_list_item_prev(wd->last_selected_item);
 305    if (!prev) return EINA_TRUE;
 306
 307    if (elm_list_item_selected_get(prev))
 308      {
 309         elm_list_item_selected_set(wd->last_selected_item, EINA_FALSE);
 310         wd->last_selected_item = prev;
 311         elm_list_item_show(wd->last_selected_item);
 312      }
 313    else
 314      {
 315         elm_list_item_selected_set(prev, EINA_TRUE);
 316         elm_list_item_show(prev);
 317      }
 318    return EINA_TRUE;
 319 }
 320
 321 static Eina_Bool
 322 _item_multi_select_down(Widget_Data *wd)
 323 {
 324    if (!wd->selected) return EINA_FALSE;
 325    if (!wd->multi) return EINA_FALSE;
 326
 327    Elm_List_Item *next = elm_list_item_next(wd->last_selected_item);
 328    if (!next) return EINA_TRUE;
 329
 330    if (elm_list_item_selected_get(next))
 331      {
 332         elm_list_item_selected_set(wd->last_selected_item, EINA_FALSE);
 333         wd->last_selected_item = next;
 334         elm_list_item_show(wd->last_selected_item);
 335      }
 336    else
 337      {
 338         elm_list_item_selected_set(next, EINA_TRUE);
 339         elm_list_item_show(next);
 340      }
 341    return EINA_TRUE;
 342 }
 343
 344 static Eina_Bool
 345 _item_single_select_up(Widget_Data *wd)
 346 {
 347    Elm_List_Item *prev;
 348
 349    if (!wd->selected) prev = eina_list_data_get(eina_list_last(wd->items));
 350    else prev = elm_list_item_prev(wd->last_selected_item);
 351
 352    if (!prev) return EINA_FALSE;
 353
 354    _deselect_all_items(wd);
 355
 356    elm_list_item_selected_set(prev, EINA_TRUE);
 357    elm_list_item_show(prev);
 358    return EINA_TRUE;
 359 }
 360
 361 static Eina_Bool
 362 _item_single_select_down(Widget_Data *wd)
 363 {
 364    Elm_List_Item *next;
 365
 366    if (!wd->selected) next = eina_list_data_get(wd->items);
 367    else next = elm_list_item_next(wd->last_selected_item);
 368
 369    if (!next) return EINA_FALSE;
 370
 371    _deselect_all_items(wd);
 372
 373    elm_list_item_selected_set(next, EINA_TRUE);
 374    elm_list_item_show(next);
 375    return EINA_TRUE;
 376 }
 377
 378 static void
 379 _elm_list_process_deletions(Widget_Data *wd)
 380 {
 381    Elm_List_Item *it;
 382
 383    wd->walking++; // avoid nested deletion and also _sub_del() fix_items
 384
 385    EINA_LIST_FREE(wd->to_delete, it)
 386      {
 387         elm_widget_item_pre_notify_del(it);
 388
 389         wd->items = eina_list_remove_list(wd->items, it->node);
 390         _elm_list_item_free(it);
 391      }
 392
 393    wd->walking--;
 394 }
 395
 396 static inline void
 397 _elm_list_walk(Widget_Data *wd)
 398 {
 399    if (wd->walking < 0)
 400      {
 401         ERR("ERROR: walking was negative. fixed!\n");
 402         wd->walking = 0;
 403      }
 404    wd->walking++;
 405 }
 406
 407 static inline void
 408 _elm_list_unwalk(Widget_Data *wd)
 409 {
 410    wd->walking--;
 411    if (wd->walking < 0)
 412      {
 413         ERR("ERROR: walking became negative. fixed!\n");
 414         wd->walking = 0;
 415      }
 416
 417    if (wd->walking)
 418      return;
 419
 420    if (wd->to_delete)
 421      _elm_list_process_deletions(wd);
 422
 423    if (wd->fix_pending)
 424      {
 425         wd->fix_pending = EINA_FALSE;
 426         _fix_items(wd->self);
 427         _sizing_eval(wd->self);
 428      }
 429 }
 430
 431 static void
 432 _del_pre_hook(Evas_Object *obj)
 433 {
 434    Widget_Data *wd = elm_widget_data_get(obj);
 435    if (!wd) return;
 436
 437    evas_object_event_callback_del(wd->scr,
 438                                   EVAS_CALLBACK_CHANGED_SIZE_HINTS,
 439                                   _changed_size_hints);
 440    evas_object_event_callback_del(wd->box,
 441                                   EVAS_CALLBACK_CHANGED_SIZE_HINTS,
 442                                   _changed_size_hints);
 443 }
 444
 445 static void
 446 _del_hook(Evas_Object *obj)
 447 {
 448    Widget_Data *wd = elm_widget_data_get(obj);
 449    Elm_List_Item *it;
 450    Eina_List *n;
 451
 452    if (!wd) return;
 453    if (wd->walking)
 454      ERR("ERROR: list deleted while walking.\n");
 455
 456    _elm_list_walk(wd);
 457    EINA_LIST_FOREACH(wd->items, n, it) elm_widget_item_pre_notify_del(it);
 458    _elm_list_unwalk(wd);
 459    if (wd->to_delete)
 460      ERR("ERROR: leaking nodes!\n");
 461
 462    EINA_LIST_FREE(wd->items, it) _elm_list_item_free(it);
 463    eina_list_free(wd->selected);
 464    free(wd);
 465 }
 466
 467 static void
 468 _show_region_hook(void *data, Evas_Object *obj)
 469 {
 470    Widget_Data *wd = elm_widget_data_get(data);
 471    Evas_Coord x, y, w, h;
 472    if (!wd) return;
 473    elm_widget_show_region_get(obj, &x, &y, &w, &h);
 474    elm_smart_scroller_child_region_set(wd->scr, x, y, w, h);
 475 }
 476
 477 static void
 478 _disable_hook(Evas_Object *obj)
 479 {
 480    Widget_Data *wd = elm_widget_data_get(obj);
 481    if (!wd) return;
 482    if (elm_widget_disabled_get(obj))
 483      {
 484         _signal_emit_hook(obj, "elm,state,disabled", "elm");
 485         elm_widget_scroll_freeze_push(obj);
 486         elm_widget_scroll_hold_push(obj);
 487         /* FIXME: if we get to have a way to only un-hilight items
 488          * in the future, keeping them selected... */
 489         _deselect_all_items(wd);
 490      }
 491    else
 492      {
 493         _signal_emit_hook(obj, "elm,state,enabled", "elm");
 494         elm_widget_scroll_freeze_pop(obj);
 495         elm_widget_scroll_hold_pop(obj);
 496      }
 497 }
 498
 499 static void
 500 _sizing_eval(Evas_Object *obj)
 501 {
 502
 503    Widget_Data *wd = elm_widget_data_get(obj);
 504    if (!wd) return;
 505    Evas_Coord  vw, vh, minw, minh, maxw, maxh, w, h, vmw, vmh;
 506    double xw, yw;
 507
 508    evas_object_size_hint_min_get(wd->box, &minw, &minh);
 509    evas_object_size_hint_max_get(wd->box, &maxw, &maxh);
 510    evas_object_size_hint_weight_get(wd->box, &xw, &yw);
 511    if (!wd->scr) return;
 512    elm_smart_scroller_child_viewport_size_get(wd->scr, &vw, &vh);
 513    if (xw > 0.0)
 514      {
 515         if ((minw > 0) && (vw < minw)) vw = minw;
 516         else if ((maxw > 0) && (vw > maxw)) vw = maxw;
 517      }
 518    else if (minw > 0) vw = minw;
 519    if (yw > 0.0)
 520      {
 521         if ((minh > 0) && (vh < minh)) vh = minh;
 522         else if ((maxh > 0) && (vh > maxh)) vh = maxh;
 523      }
 524    else if (minh > 0) vh = minh;
 525    evas_object_resize(wd->box, vw, vh);
 526    w = -1;
 527    h = -1;
 528    edje_object_size_min_calc(elm_smart_scroller_edje_object_get(wd->scr),
 529                              &vmw, &vmh);
 530    if (wd->scr_minw) w = vmw + minw;
 531    if (wd->scr_minh) h = vmh + minh;
 532
 533    evas_object_size_hint_max_get(obj, &maxw, &maxh);
 534    if ((maxw > 0) && (w > maxw))
 535      w = maxw;
 536    if ((maxh > 0) && (h > maxh))
 537      h = maxh;
 538
 539    evas_object_size_hint_min_set(obj, w, h);
 540 }
 541
 542 static void
 543 _signal_emit_hook(Evas_Object *obj, const char *emission, const char *source)
 544 {
 545    Widget_Data *wd = elm_widget_data_get(obj);
 546    edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr),
 547                            emission, source);
 548 }
 549
 550 static void
 551 _signal_callback_add_hook(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func_cb, void *data)
 552 {
 553    Widget_Data *wd = elm_widget_data_get(obj);
 554    edje_object_signal_callback_add(elm_smart_scroller_edje_object_get(wd->scr),
 555                                    emission, source, func_cb, data);
 556 }
 557
 558 static void
 559 _signal_callback_del_hook(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func_cb, void *data)
 560 {
 561    Widget_Data *wd = elm_widget_data_get(obj);
 562    edje_object_signal_callback_del_full(
 563       elm_smart_scroller_edje_object_get(wd->scr),
 564       emission, source, func_cb, data);
 565 }
 566
 567 static void
 568 _mirrored_set(Evas_Object *obj, Eina_Bool rtl)
 569 {
 570    Widget_Data *wd = elm_widget_data_get(obj);
 571    Elm_List_Item *it;
 572    Eina_List *n;
 573
 574    if (!wd) return;
 575    if (wd->scr)
 576      elm_smart_scroller_mirrored_set(wd->scr, rtl);
 577
 578    EINA_LIST_FOREACH(wd->items, n, it)
 579       edje_object_mirrored_set(it->base.view, rtl);
 580 }
 581
 582 static void
 583 _theme_hook(Evas_Object *obj)
 584 {
 585    Widget_Data *wd = elm_widget_data_get(obj);
 586    Elm_List_Item *it;
 587    Eina_List *n;
 588
 589    if (!wd) return;
 590    _elm_widget_mirrored_reload(obj);
 591    _mirrored_set(obj, elm_widget_mirrored_get(obj));
 592
 593    if (wd->scr)
 594      {
 595         Evas_Object *edj;
 596         const char *str;
 597
 598         elm_smart_scroller_object_theme_set(obj, wd->scr, "list", "base",
 599                                             elm_widget_style_get(obj));
 600         //        edje_object_scale_set(wd->scr, elm_widget_scale_get(obj) * _elm_config->scale);
 601         edj = elm_smart_scroller_edje_object_get(wd->scr);
 602         str = edje_object_data_get(edj, "focus_highlight");
 603         if ((str) && (!strcmp(str, "on")))
 604           elm_widget_highlight_in_theme_set(obj, EINA_TRUE);
 605         else
 606           elm_widget_highlight_in_theme_set(obj, EINA_FALSE);
 607         elm_object_style_set(wd->scr, elm_widget_style_get(obj));
 608      }
 609    EINA_LIST_FOREACH(wd->items, n, it)
 610      {
 611         edje_object_scale_set(it->base.view, elm_widget_scale_get(obj) * _elm_config->scale);
 612         it->fixed = 0;
 613      }
 614    _fix_items(obj);
 615    _sizing_eval(obj);
 616 }
 617
 618 static void
 619 _on_focus_hook(void *data __UNUSED__, Evas_Object *obj)
 620 {
 621    Widget_Data *wd = elm_widget_data_get(obj);
 622    if (!wd) return;
 623    if (elm_widget_focus_get(obj))
 624      {
 625         edje_object_signal_emit(wd->self, "elm,action,focus", "elm");
 626         evas_object_focus_set(wd->self, EINA_TRUE);
 627
 628         if ((wd->selected) && (!wd->last_selected_item))
 629           wd->last_selected_item = eina_list_data_get(wd->selected);
 630      }
 631    else
 632      {
 633         edje_object_signal_emit(wd->self, "elm,action,unfocus", "elm");
 634         evas_object_focus_set(wd->self, EINA_FALSE);
 635      }
 636 }
 637
 638 static void
 639 _changed_size_hints(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 640 {
 641    Widget_Data *wd = elm_widget_data_get(data);
 642    if (!wd) return;
 643    _fix_items(data);
 644    _sizing_eval(data);
 645 }
 646
 647 static void
 648 _sub_del(void *data __UNUSED__, Evas_Object *obj, void *event_info)
 649 {
 650    Widget_Data *wd = elm_widget_data_get(obj);
 651    Evas_Object *sub = event_info;
 652    const Eina_List *l;
 653    Elm_List_Item *it;
 654
 655    if (!wd) return;
 656    if (!sub) abort();
 657    if ((sub == wd->box) || (sub == wd->scr)) return;
 658
 659    EINA_LIST_FOREACH(wd->items, l, it)
 660      {
 661         if ((sub == it->icon) || (sub == it->end))
 662           {
 663              if (it->icon == sub) it->icon = NULL;
 664              if (it->end == sub) it->end = NULL;
 665              evas_object_event_callback_del_full
 666              (sub, EVAS_CALLBACK_CHANGED_SIZE_HINTS, _changed_size_hints,
 667               obj);
 668              if (!wd->walking)
 669                {
 670                   _fix_items(obj);
 671                   _sizing_eval(obj);
 672                }
 673              else
 674                wd->fix_pending = EINA_TRUE;
 675              break;
 676           }
 677      }
 678 }
 679
 680 static void
 681 _item_hilight(Elm_List_Item *it)
 682 {
 683    Evas_Object *obj = it->base.widget;
 684    Widget_Data *wd = elm_widget_data_get(obj);
 685    const char *selectraise;
 686
 687    if (!wd) return;
 688    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it);
 689    if (it->hilighted) return;
 690
 691    evas_object_ref(obj);
 692    _elm_list_walk(wd);
 693
 694    edje_object_signal_emit(it->base.view, "elm,state,selected", "elm");
 695    selectraise = edje_object_data_get(it->base.view, "selectraise");
 696    if ((selectraise) && (!strcmp(selectraise, "on")))
 697      evas_object_raise(it->base.view);
 698    it->hilighted = EINA_TRUE;
 699
 700    _elm_list_unwalk(wd);
 701    evas_object_unref(obj);
 702 }
 703
 704 static void
 705 _item_select(Elm_List_Item *it)
 706 {
 707    Evas_Object *obj = it->base.widget;
 708    Widget_Data *wd = elm_widget_data_get(obj);
 709
 710    if (!wd) return;
 711    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it);
 712    if (it->selected)
 713      {
 714         if (wd->always_select) goto call;
 715         return;
 716      }
 717    it->selected = EINA_TRUE;
 718    wd->selected = eina_list_append(wd->selected, it);
 719
 720 call:
 721    evas_object_ref(obj);
 722    _elm_list_walk(wd);
 723
 724    if (it->func) it->func((void *)it->base.data, it->base.widget, it);
 725    evas_object_smart_callback_call(obj, SIG_SELECTED, it);
 726    it->wd->last_selected_item = it;
 727
 728    _elm_list_unwalk(wd);
 729    evas_object_unref(obj);
 730 }
 731
 732 static void
 733 _item_unselect(Elm_List_Item *it)
 734 {
 735    Evas_Object *obj = it->base.widget;
 736    Widget_Data *wd = elm_widget_data_get(obj);
 737    const char *stacking, *selectraise;
 738
 739    if (!wd) return;
 740    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it);
 741    if (!it->hilighted) return;
 742
 743    evas_object_ref(obj);
 744    _elm_list_walk(wd);
 745
 746    edje_object_signal_emit(it->base.view, "elm,state,unselected", "elm");
 747    stacking = edje_object_data_get(it->base.view, "stacking");
 748    selectraise = edje_object_data_get(it->base.view, "selectraise");
 749    if ((selectraise) && (!strcmp(selectraise, "on")))
 750      {
 751         if ((stacking) && (!strcmp(stacking, "below")))
 752           evas_object_lower(it->base.view);
 753      }
 754    it->hilighted = EINA_FALSE;
 755    if (it->selected)
 756      {
 757         it->selected = EINA_FALSE;
 758         wd->selected = eina_list_remove(wd->selected, it);
 759         evas_object_smart_callback_call(it->base.widget, SIG_UNSELECTED, it);
 760      }
 761
 762    _elm_list_unwalk(wd);
 763    evas_object_unref(obj);
 764 }
 765
 766 static Eina_Bool
 767 _swipe_cancel(void *data)
 768 {
 769    Elm_List_Item *it = data;
 770    Widget_Data *wd = elm_widget_data_get(it->base.widget);
 771
 772    if (!wd) return ECORE_CALLBACK_CANCEL;
 773    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it, ECORE_CALLBACK_CANCEL);
 774    wd->swipe = EINA_FALSE;
 775    wd->movements = 0;
 776    return ECORE_CALLBACK_RENEW;
 777 }
 778
 779 static void
 780 _mouse_move(void *data, Evas *evas __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
 781 {
 782    Elm_List_Item *it = data;
 783    Evas_Object *obj2 = it->base.widget;
 784    Widget_Data *wd = elm_widget_data_get(obj2);
 785    Evas_Event_Mouse_Move *ev = event_info;
 786
 787    if (!wd) return;
 788    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it);
 789
 790    evas_object_ref(obj2);
 791    _elm_list_walk(wd);
 792
 793    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
 794      {
 795         if (!wd->on_hold)
 796           {
 797              wd->on_hold = EINA_TRUE;
 798              if (it->long_timer)
 799                {
 800                   ecore_timer_del(it->long_timer);
 801                   it->long_timer = NULL;
 802                }
 803              if (!wd->wasselected)
 804                _item_unselect(it);
 805           }
 806         if (wd->movements == SWIPE_MOVES) wd->swipe = EINA_TRUE;
 807         else
 808           {
 809              wd->history[wd->movements].x = ev->cur.canvas.x;
 810              wd->history[wd->movements].y = ev->cur.canvas.y;
 811              if (abs((wd->history[wd->movements].x - wd->history[0].x)) > 40)
 812                wd->swipe = EINA_TRUE;
 813              else
 814                wd->movements++;
 815           }
 816      }
 817
 818    _elm_list_unwalk(wd);
 819    evas_object_unref(obj2);
 820 }
 821
 822 static void
 823 _scroll_edge_left(void *data, Evas_Object *scr __UNUSED__, void *event_info __UNUSED__)
 824 {
 825    Evas_Object *obj = data;
 826    evas_object_smart_callback_call(obj, SIG_SCROLL_EDGE_LEFT, NULL);
 827 }
 828
 829 static void
 830 _scroll_edge_right(void *data, Evas_Object *scr __UNUSED__, void *event_info __UNUSED__)
 831 {
 832    Evas_Object *obj = data;
 833    evas_object_smart_callback_call(obj, SIG_SCROLL_EDGE_RIGHT, NULL);
 834 }
 835
 836 static void
 837 _scroll_edge_top(void *data, Evas_Object *scr __UNUSED__, void *event_info __UNUSED__)
 838 {
 839    Evas_Object *obj = data;
 840    evas_object_smart_callback_call(obj, SIG_SCROLL_EDGE_TOP, NULL);
 841 }
 842
 843 static void
 844 _scroll_edge_bottom(void *data, Evas_Object *scr __UNUSED__, void *event_info __UNUSED__)
 845 {
 846    Evas_Object *obj = data;
 847    evas_object_smart_callback_call(obj, SIG_SCROLL_EDGE_BOTTOM, NULL);
 848 }
 849
 850 static Eina_Bool
 851 _long_press(void *data)
 852 {
 853    Elm_List_Item *it = data;
 854    Evas_Object *obj = it->base.widget;
 855    Widget_Data *wd = elm_widget_data_get(obj);
 856
 857    if (!wd) goto end;
 858
 859    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it, ECORE_CALLBACK_CANCEL);
 860    it->long_timer = NULL;
 861    if (it->disabled) goto end;
 862
 863    wd->longpressed = EINA_TRUE;
 864    evas_object_smart_callback_call(it->base.widget, SIG_LONGPRESSED, it);
 865
 866 end:
 867    return ECORE_CALLBACK_CANCEL;
 868 }
 869
 870 static void
 871 _swipe(Elm_List_Item *it)
 872 {
 873    int i, sum = 0;
 874    Widget_Data *wd = elm_widget_data_get(it->base.widget);
 875
 876    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it);
 877    if (!wd) return;
 878    wd->swipe = EINA_FALSE;
 879    for (i = 0; i < wd->movements; i++)
 880      {
 881         sum += wd->history[i].x;
 882         if (abs(wd->history[0].y - wd->history[i].y) > 10) return;
 883      }
 884
 885    sum /= wd->movements;
 886    if (abs(sum - wd->history[0].x) <= 10) return;
 887    evas_object_smart_callback_call(it->base.widget, "swipe", it);
 888 }
 889
 890 static void
 891 _mouse_down(void *data, Evas *evas __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
 892 {
 893    Elm_List_Item *it = data;
 894    Evas_Object *obj2 = it->base.widget;
 895    Widget_Data *wd = elm_widget_data_get(obj2);
 896    Evas_Event_Mouse_Down *ev = event_info;
 897
 898    if (!wd) return;
 899    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it);
 900    if (ev->button != 1) return;
 901    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) wd->on_hold = EINA_TRUE;
 902    else wd->on_hold = EINA_FALSE;
 903    if (wd->on_hold) return;
 904    wd->wasselected = it->selected;
 905
 906    evas_object_ref(obj2);
 907    _elm_list_walk(wd);
 908
 909    _item_hilight(it);
 910    wd->longpressed = EINA_FALSE;
 911    if (it->long_timer) ecore_timer_del(it->long_timer);
 912    it->long_timer = ecore_timer_add(_elm_config->longpress_timeout, _long_press, it);
 913    if (it->swipe_timer) ecore_timer_del(it->swipe_timer);
 914    it->swipe_timer = ecore_timer_add(0.4, _swipe_cancel, it);
 915    /* Always call the callbacks last - the user may delete our context! */
 916    if (ev->flags & EVAS_BUTTON_DOUBLE_CLICK)
 917      evas_object_smart_callback_call(it->base.widget, SIG_CLICKED_DOUBLE, it);
 918    wd->swipe = EINA_FALSE;
 919    wd->movements = 0;
 920
 921    _elm_list_unwalk(wd);
 922    evas_object_unref(obj2);
 923 }
 924
 925 static void
 926 _mouse_up(void *data, Evas *evas __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
 927 {
 928    Elm_List_Item *it = data;
 929    Evas_Object *obj2 = it->base.widget;
 930    Widget_Data *wd = elm_widget_data_get(obj2);
 931    Evas_Event_Mouse_Up *ev = event_info;
 932
 933    if (!wd) return;
 934    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it);
 935    if (ev->button != 1) return;
 936    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) wd->on_hold = EINA_TRUE;
 937    else wd->on_hold = EINA_FALSE;
 938    wd->longpressed = EINA_FALSE;
 939    if (it->long_timer)
 940      {
 941         ecore_timer_del(it->long_timer);
 942         it->long_timer = NULL;
 943      }
 944    if (it->swipe_timer)
 945      {
 946         ecore_timer_del(it->swipe_timer);
 947         it->swipe_timer = NULL;
 948      }
 949    if (wd->on_hold)
 950      {
 951         if (wd->swipe) _swipe(data);
 952         wd->on_hold = EINA_FALSE;
 953         return;
 954      }
 955    if (wd->longpressed)
 956      {
 957         if (!wd->wasselected) _item_unselect(it);
 958         wd->wasselected = 0;
 959         return;
 960      }
 961
 962    if (it->disabled)
 963      return;
 964    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
 965
 966    evas_object_ref(obj2);
 967    _elm_list_walk(wd);
 968
 969    if (wd->multi)
 970      {
 971         if (!it->selected)
 972           {
 973              _item_hilight(it);
 974              _item_select(it);
 975           }
 976         else _item_unselect(it);
 977      }
 978    else
 979      {
 980         if (!it->selected)
 981           {
 982              while (wd->selected)
 983                _item_unselect(wd->selected->data);
 984              _item_hilight(it);
 985              _item_select(it);
 986           }
 987         else
 988           {
 989              const Eina_List *l, *l_next;
 990              Elm_List_Item *it2;
 991
 992              EINA_LIST_FOREACH_SAFE(wd->selected, l, l_next, it2)
 993                 if (it2 != it) _item_unselect(it2);
 994              _item_hilight(it);
 995              _item_select(it);
 996           }
 997      }
 998
 999    _elm_list_unwalk(wd);
1000    evas_object_unref(obj2);
1001 }
1002
1003 static Elm_List_Item *
1004 _item_new(Evas_Object *obj, const char *label, Evas_Object *icon, Evas_Object *end, Evas_Smart_Cb func, const void *data)
1005 {
1006    Widget_Data *wd = elm_widget_data_get(obj);
1007    Elm_List_Item *it;
1008
1009    if (!wd) return NULL;
1010    it = elm_widget_item_new(obj, Elm_List_Item);
1011    it->wd = wd;
1012    it->label = eina_stringshare_add(label);
1013    it->icon = icon;
1014    it->end = end;
1015    it->func = func;
1016    it->base.data = data;
1017    it->base.view = edje_object_add(evas_object_evas_get(obj));
1018    edje_object_mirrored_set(it->base.view, elm_widget_mirrored_get(obj));
1019    evas_object_event_callback_add(it->base.view, EVAS_CALLBACK_MOUSE_DOWN,
1020                                   _mouse_down, it);
1021    evas_object_event_callback_add(it->base.view, EVAS_CALLBACK_MOUSE_UP,
1022                                   _mouse_up, it);
1023    evas_object_event_callback_add(it->base.view, EVAS_CALLBACK_MOUSE_MOVE,
1024                                   _mouse_move, it);
1025    evas_object_size_hint_weight_set(it->base.view, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1026    evas_object_size_hint_align_set(it->base.view, EVAS_HINT_FILL, EVAS_HINT_FILL);
1027    if (it->icon)
1028      {
1029         elm_widget_sub_object_add(obj, it->icon);
1030         evas_object_event_callback_add(it->icon, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
1031                                        _changed_size_hints, obj);
1032      }
1033    if (it->end)
1034      {
1035         elm_widget_sub_object_add(obj, it->end);
1036         evas_object_event_callback_add(it->end, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
1037                                        _changed_size_hints, obj);
1038      }
1039    return it;
1040 }
1041
1042 static void
1043 _elm_list_mode_set_internal(Widget_Data *wd)
1044 {
1045    if (!wd->scr)
1046      return;
1047
1048    if (wd->mode == ELM_LIST_LIMIT)
1049      {
1050         if (!wd->h_mode)
1051           {
1052              wd->scr_minw = EINA_TRUE;
1053              wd->scr_minh = EINA_FALSE;
1054           }
1055         else
1056           {
1057              wd->scr_minw = EINA_FALSE;
1058              wd->scr_minh = EINA_TRUE;
1059           }
1060      }
1061    else if (wd->mode == ELM_LIST_EXPAND)
1062      {
1063         wd->scr_minw = EINA_TRUE;
1064         wd->scr_minh = EINA_TRUE;
1065      }
1066    else
1067      {
1068         wd->scr_minw = EINA_FALSE;
1069         wd->scr_minh = EINA_FALSE;
1070      }
1071
1072    _sizing_eval(wd->self);
1073 }
1074
1075 static void
1076 _fix_items(Evas_Object *obj)
1077 {
1078    Widget_Data *wd = elm_widget_data_get(obj);
1079    if (!wd) return;
1080    const Eina_List *l;
1081    Elm_List_Item *it;
1082    Evas_Coord minw[2] = { 0, 0 }, minh[2] = { 0, 0 };
1083    Evas_Coord mw, mh;
1084    int i, redo = 0;
1085    const char *style = elm_widget_style_get(obj);
1086    const char *it_plain = wd->h_mode ? "h_item" : "item";
1087    const char *it_odd = wd->h_mode ? "h_item_odd" : "item_odd";
1088    const char *it_compress = wd->h_mode ? "h_item_compress" : "item_compress";
1089    const char *it_compress_odd = wd->h_mode ? "h_item_compress_odd" : "item_compress_odd";
1090
1091    if (wd->walking)
1092      {
1093         wd->fix_pending = EINA_TRUE;
1094         return;
1095      }
1096
1097    evas_object_ref(obj);
1098    _elm_list_walk(wd); // watch out "return" before unwalk!
1099
1100    EINA_LIST_FOREACH(wd->items, l, it)
1101      {
1102         if (it->deleted) continue;
1103         if (it->icon)
1104           {
1105              evas_object_size_hint_min_get(it->icon, &mw, &mh);
1106              if (mw > minw[0]) minw[0] = mw;
1107              if (mh > minh[0]) minh[0] = mh;
1108           }
1109         if (it->end)
1110           {
1111              evas_object_size_hint_min_get(it->end, &mw, &mh);
1112              if (mw > minw[1]) minw[1] = mw;
1113              if (mh > minh[1]) minh[1] = mh;
1114           }
1115      }
1116
1117    if ((minw[0] != wd->minw[0]) || (minw[1] != wd->minw[1]) ||
1118        (minw[0] != wd->minh[0]) || (minh[1] != wd->minh[1]))
1119      {
1120         wd->minw[0] = minw[0];
1121         wd->minw[1] = minw[1];
1122         wd->minh[0] = minh[0];
1123         wd->minh[1] = minh[1];
1124         redo = 1;
1125      }
1126    i = 0;
1127    EINA_LIST_FOREACH(wd->items, l, it)
1128      {
1129         if (it->deleted)
1130           continue;
1131
1132         it->even = i & 0x1;
1133         if ((it->even != it->is_even) || (!it->fixed) || (redo))
1134           {
1135              const char *stacking;
1136
1137              /* FIXME: separators' themes seem to be b0rked */
1138              if (it->is_separator)
1139                _elm_theme_object_set(obj, it->base.view, "separator",
1140                                      wd->h_mode ? "horizontal" : "vertical",
1141                                      style);
1142              else if (wd->mode == ELM_LIST_COMPRESS)
1143                {
1144                   if (it->even)
1145                     _elm_theme_object_set(obj, it->base.view, "list",
1146                                           it_compress, style);
1147                   else
1148                     _elm_theme_object_set(obj, it->base.view, "list",
1149                                           it_compress_odd, style);
1150                }
1151              else
1152                {
1153                   if (it->even)
1154                     _elm_theme_object_set(obj, it->base.view, "list", it_plain,
1155                                           style);
1156                   else
1157                     _elm_theme_object_set(obj, it->base.view, "list", it_odd,
1158                                           style);
1159                }
1160              stacking = edje_object_data_get(it->base.view, "stacking");
1161              if (stacking)
1162                {
1163                   if (!strcmp(stacking, "below"))
1164                     evas_object_lower(it->base.view);
1165                   else if (!strcmp(stacking, "above"))
1166                     evas_object_raise(it->base.view);
1167                }
1168              edje_object_part_text_set(it->base.view, "elm.text", it->label);
1169
1170              if ((!it->icon) && (minh[0] > 0))
1171                {
1172                   it->icon = evas_object_rectangle_add(evas_object_evas_get(it->base.view));
1173                   evas_object_color_set(it->icon, 0, 0, 0, 0);
1174                   it->dummy_icon = EINA_TRUE;
1175                }
1176              if ((!it->end) && (minh[1] > 0))
1177                {
1178                   it->end = evas_object_rectangle_add(evas_object_evas_get(it->base.view));
1179                   evas_object_color_set(it->end, 0, 0, 0, 0);
1180                   it->dummy_end = EINA_TRUE;
1181                }
1182              if (it->icon)
1183                {
1184                   evas_object_size_hint_min_set(it->icon, minw[0], minh[0]);
1185                   evas_object_size_hint_max_set(it->icon, 99999, 99999);
1186                   edje_object_part_swallow(it->base.view, "elm.swallow.icon", it->icon);
1187                }
1188              if (it->end)
1189                {
1190                   evas_object_size_hint_min_set(it->end, minw[1], minh[1]);
1191                   evas_object_size_hint_max_set(it->end, 99999, 99999);
1192                   edje_object_part_swallow(it->base.view, "elm.swallow.end", it->end);
1193                }
1194              if (!it->fixed)
1195                {
1196                   // this may call up user and it may modify the list item
1197                   // but we're safe as we're flagged as walking.
1198                   // just don't process further
1199                   edje_object_message_signal_process(it->base.view);
1200                   if (it->deleted)
1201                     continue;
1202                   mw = mh = -1;
1203                   elm_coords_finger_size_adjust(1, &mw, 1, &mh);
1204                   edje_object_size_min_restricted_calc(it->base.view, &mw, &mh, mw, mh);
1205                   elm_coords_finger_size_adjust(1, &mw, 1, &mh);
1206                   evas_object_size_hint_min_set(it->base.view, mw, mh);
1207                   evas_object_show(it->base.view);
1208                }
1209              if ((it->selected) || (it->hilighted))
1210                {
1211                   const char *selectraise;
1212
1213                   // this may call up user and it may modify the list item
1214                   // but we're safe as we're flagged as walking.
1215                   // just don't process further
1216                   edje_object_signal_emit(it->base.view, "elm,state,selected", "elm");
1217                   if (it->deleted)
1218                     continue;
1219
1220                   selectraise = edje_object_data_get(it->base.view, "selectraise");
1221                   if ((selectraise) && (!strcmp(selectraise, "on")))
1222                     evas_object_raise(it->base.view);
1223                }
1224              if (it->disabled)
1225                edje_object_signal_emit(it->base.view, "elm,state,disabled",
1226                                        "elm");
1227
1228              it->fixed = EINA_TRUE;
1229              it->is_even = it->even;
1230           }
1231         i++;
1232      }
1233
1234    mw = 0; mh = 0;
1235    evas_object_size_hint_min_get(wd->box, &mw, &mh);
1236
1237    _elm_list_mode_set_internal(wd);
1238
1239    _elm_list_unwalk(wd);
1240    evas_object_unref(obj);
1241 }
1242
1243 static void
1244 _hold_on(void *data __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
1245 {
1246    Widget_Data *wd = elm_widget_data_get(obj);
1247    if (!wd) return;
1248    if (wd->scr)
1249      elm_smart_scroller_hold_set(wd->scr, EINA_TRUE);
1250 }
1251
1252 static void
1253 _hold_off(void *data __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
1254 {
1255    Widget_Data *wd = elm_widget_data_get(obj);
1256    if (!wd) return;
1257    if (wd->scr)
1258      elm_smart_scroller_hold_set(wd->scr, EINA_FALSE);
1259 }
1260
1261 static void
1262 _freeze_on(void *data __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
1263 {
1264    Widget_Data *wd = elm_widget_data_get(obj);
1265    if (!wd) return;
1266    if (wd->scr)
1267      elm_smart_scroller_freeze_set(wd->scr, EINA_TRUE);
1268 }
1269
1270 static void
1271 _freeze_off(void *data __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
1272 {
1273    Widget_Data *wd = elm_widget_data_get(obj);
1274    if (!wd) return;
1275    if (wd->scr)
1276      elm_smart_scroller_freeze_set(wd->scr, EINA_FALSE);
1277 }
1278
1279 static void
1280 _resize(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1281 {
1282    _sizing_eval(data);
1283 }
1284
1285 EAPI Evas_Object *
1286 elm_list_add(Evas_Object *parent)
1287 {
1288    Evas_Object *obj;
1289    Evas *e;
1290    Widget_Data *wd;
1291    Evas_Coord minw, minh;
1292
1293    ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
1294
1295    ELM_SET_WIDTYPE(widtype, "list");
1296    elm_widget_type_set(obj, "list");
1297    elm_widget_sub_object_add(parent, obj);
1298    elm_widget_on_focus_hook_set(obj, _on_focus_hook, NULL);
1299    elm_widget_data_set(obj, wd);
1300    elm_widget_del_pre_hook_set(obj, _del_pre_hook);
1301    elm_widget_del_hook_set(obj, _del_hook);
1302    elm_widget_theme_hook_set(obj, _theme_hook);
1303    elm_widget_disable_hook_set(obj, _disable_hook);
1304    elm_widget_can_focus_set(obj, EINA_TRUE);
1305    elm_widget_signal_emit_hook_set(obj, _signal_emit_hook);
1306    elm_widget_signal_callback_add_hook_set(obj, _signal_callback_add_hook);
1307    elm_widget_signal_callback_del_hook_set(obj, _signal_callback_del_hook);
1308    elm_widget_event_hook_set(obj, _event_hook);
1309
1310    wd->self = obj;
1311    wd->scr = elm_smart_scroller_add(e);
1312    elm_smart_scroller_widget_set(wd->scr, obj);
1313    elm_widget_resize_object_set(obj, wd->scr);
1314    evas_object_event_callback_add(wd->scr, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
1315                                   _changed_size_hints, obj);
1316    edje_object_size_min_calc(elm_smart_scroller_edje_object_get(wd->scr), &minw, &minh);
1317    evas_object_size_hint_min_set(obj, minw, minh);
1318    evas_object_event_callback_add(obj, EVAS_CALLBACK_RESIZE, _resize, obj);
1319
1320    elm_smart_scroller_bounce_allow_set(wd->scr, EINA_FALSE,
1321                                        _elm_config->thumbscroll_bounce_enable);
1322
1323    wd->box = elm_box_add(parent);
1324    elm_box_homogeneous_set(wd->box, 1);
1325    evas_object_size_hint_weight_set(wd->box, EVAS_HINT_EXPAND, 0.0);
1326    evas_object_size_hint_align_set(wd->box, EVAS_HINT_FILL, 0.0);
1327    elm_widget_on_show_region_hook_set(wd->box, _show_region_hook, obj);
1328    elm_widget_sub_object_add(obj, wd->box);
1329    elm_smart_scroller_child_set(wd->scr, wd->box);
1330    evas_object_event_callback_add(wd->box, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
1331                                   _changed_size_hints, obj);
1332
1333    evas_object_show(wd->box);
1334
1335    _theme_hook(obj);
1336
1337    wd->mode = ELM_LIST_SCROLL;
1338
1339    evas_object_smart_callback_add(wd->scr, "edge,left", _scroll_edge_left, obj);
1340    evas_object_smart_callback_add(wd->scr, "edge,right", _scroll_edge_right, obj);
1341    evas_object_smart_callback_add(wd->scr, "edge,top", _scroll_edge_top, obj);
1342    evas_object_smart_callback_add(wd->scr, "edge,bottom", _scroll_edge_bottom, obj);
1343
1344    evas_object_smart_callback_add(obj, "sub-object-del", _sub_del, obj);
1345    evas_object_smart_callback_add(obj, "scroll-hold-on", _hold_on, obj);
1346    evas_object_smart_callback_add(obj, "scroll-hold-off", _hold_off, obj);
1347    evas_object_smart_callback_add(obj, "scroll-freeze-on", _freeze_on, obj);
1348    evas_object_smart_callback_add(obj, "scroll-freeze-off", _freeze_off, obj);
1349
1350    evas_object_smart_callbacks_descriptions_set(obj, _signals);
1351
1352    _mirrored_set(obj, elm_widget_mirrored_get(obj));
1353    _sizing_eval(obj);
1354    return obj;
1355 }
1356
1357 EAPI Elm_List_Item *
1358 elm_list_item_append(Evas_Object *obj, const char *label, Evas_Object *icon, Evas_Object *end, Evas_Smart_Cb func, const void *data)
1359 {
1360    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1361    Widget_Data *wd = elm_widget_data_get(obj);
1362    Elm_List_Item *it = _item_new(obj, label, icon, end, func, data);
1363
1364    wd->items = eina_list_append(wd->items, it);
1365    it->node = eina_list_last(wd->items);
1366    elm_box_pack_end(wd->box, it->base.view);
1367    return it;
1368 }
1369
1370 EAPI Elm_List_Item *
1371 elm_list_item_prepend(Evas_Object *obj, const char *label, Evas_Object *icon, Evas_Object *end, Evas_Smart_Cb func, const void *data)
1372 {
1373    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1374    Widget_Data *wd = elm_widget_data_get(obj);
1375    Elm_List_Item *it = _item_new(obj, label, icon, end, func, data);
1376
1377    wd->items = eina_list_prepend(wd->items, it);
1378    it->node = wd->items;
1379    elm_box_pack_start(wd->box, it->base.view);
1380    return it;
1381 }
1382
1383 EAPI Elm_List_Item *
1384 elm_list_item_insert_before(Evas_Object *obj, Elm_List_Item *before, const char *label, Evas_Object *icon, Evas_Object *end, Evas_Smart_Cb func, const void *data)
1385 {
1386    Widget_Data *wd;
1387    Elm_List_Item *it;
1388
1389    EINA_SAFETY_ON_NULL_RETURN_VAL(before, NULL);
1390    if (!before->node) return NULL;
1391    ELM_LIST_ITEM_CHECK_DELETED_RETURN(before, NULL);
1392
1393    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1394    wd = elm_widget_data_get(obj);
1395    if (!wd) return NULL;
1396    it = _item_new(obj, label, icon, end, func, data);
1397    wd->items = eina_list_prepend_relative_list(wd->items, it, before->node);
1398    it->node = before->node->prev;
1399    elm_box_pack_before(wd->box, it->base.view, before->base.view);
1400    return it;
1401 }
1402
1403 EAPI Elm_List_Item *
1404 elm_list_item_insert_after(Evas_Object *obj, Elm_List_Item *after, const char *label, Evas_Object *icon, Evas_Object *end, Evas_Smart_Cb func, const void *data)
1405 {
1406    Widget_Data *wd;
1407    Elm_List_Item *it;
1408
1409    EINA_SAFETY_ON_NULL_RETURN_VAL(after, NULL);
1410    if (!after->node) return NULL;
1411    ELM_LIST_ITEM_CHECK_DELETED_RETURN(after, NULL);
1412
1413    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1414    wd = elm_widget_data_get(obj);
1415    if (!wd) return NULL;
1416    it = _item_new(obj, label, icon, end, func, data);
1417    wd->items = eina_list_append_relative_list(wd->items, it, after->node);
1418    it->node = after->node->next;
1419    elm_box_pack_after(wd->box, it->base.view, after->base.view);
1420    return it;
1421 }
1422
1423 EAPI Elm_List_Item *
1424 elm_list_item_sorted_insert(Evas_Object *obj, const char *label, Evas_Object *icon, Evas_Object *end, Evas_Smart_Cb func, const void *data, Eina_Compare_Cb cmp_func)
1425 {
1426    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1427    Widget_Data *wd = elm_widget_data_get(obj);
1428    Elm_List_Item *it = _item_new(obj, label, icon, end, func, data);
1429    Eina_List *l;
1430
1431    wd->items = eina_list_sorted_insert(wd->items, cmp_func, it);
1432    l = eina_list_data_find_list(wd->items, it);
1433    l = eina_list_next(l);
1434    if (!l)
1435      {
1436         it->node = eina_list_last(wd->items);
1437         elm_box_pack_end(wd->box, it->base.view);
1438      }
1439    else
1440      {
1441         Elm_List_Item *before = eina_list_data_get(l);
1442         it->node = before->node->prev;
1443         elm_box_pack_before(wd->box, it->base.view, before->base.view);
1444      }
1445    return it;
1446 }
1447
1448 EAPI void
1449 elm_list_clear(Evas_Object *obj)
1450 {
1451    ELM_CHECK_WIDTYPE(obj, widtype);
1452    Widget_Data *wd = elm_widget_data_get(obj);
1453    Elm_List_Item *it;
1454
1455    if (!wd) return;
1456    if (!wd->items) return;
1457
1458    eina_list_free(wd->selected);
1459    wd->selected = NULL;
1460
1461    if (wd->walking > 0)
1462      {
1463         Eina_List *n;
1464
1465         EINA_LIST_FOREACH(wd->items, n, it)
1466           {
1467              if (it->deleted) continue;
1468              it->deleted = EINA_TRUE;
1469              wd->to_delete = eina_list_append(wd->to_delete, it);
1470           }
1471         return;
1472      }
1473
1474    evas_object_ref(obj);
1475    _elm_list_walk(wd);
1476
1477    EINA_LIST_FREE(wd->items, it)
1478      {
1479         elm_widget_item_pre_notify_del(it);
1480         _elm_list_item_free(it);
1481      }
1482
1483    _elm_list_unwalk(wd);
1484
1485    _fix_items(obj);
1486    _sizing_eval(obj);
1487    evas_object_unref(obj);
1488 }
1489
1490 EAPI void
1491 elm_list_go(Evas_Object *obj)
1492 {
1493    ELM_CHECK_WIDTYPE(obj, widtype);
1494    Widget_Data *wd = elm_widget_data_get(obj);
1495    if (!wd) return;
1496    _fix_items(obj);
1497 }
1498
1499 EAPI void
1500 elm_list_multi_select_set(Evas_Object *obj, Eina_Bool multi)
1501 {
1502    ELM_CHECK_WIDTYPE(obj, widtype);
1503    Widget_Data *wd = elm_widget_data_get(obj);
1504    if (!wd) return;
1505    wd->multi = multi;
1506 }
1507
1508 EAPI Eina_Bool
1509 elm_list_multi_select_get(const Evas_Object *obj)
1510 {
1511    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1512    Widget_Data *wd = elm_widget_data_get(obj);
1513    if (!wd) return EINA_FALSE;
1514    return wd->multi;
1515 }
1516
1517 EAPI void
1518 elm_list_mode_set(Evas_Object *obj, Elm_List_Mode mode)
1519 {
1520    ELM_CHECK_WIDTYPE(obj, widtype);
1521
1522    Widget_Data *wd;
1523
1524    wd = elm_widget_data_get(obj);
1525    if (!wd)
1526      return;
1527    if (wd->mode == mode)
1528      return;
1529    wd->mode = mode;
1530
1531    _elm_list_mode_set_internal(wd);
1532 }
1533
1534 EAPI Elm_List_Mode
1535 elm_list_mode_get(const Evas_Object *obj)
1536 {
1537    ELM_CHECK_WIDTYPE(obj, widtype) ELM_LIST_LAST;
1538    Widget_Data *wd = elm_widget_data_get(obj);
1539    if (!wd) return ELM_LIST_LAST;
1540    return wd->mode;
1541 }
1542
1543 EAPI void
1544 elm_list_horizontal_set(Evas_Object *obj, Eina_Bool horizontal)
1545 {
1546    ELM_CHECK_WIDTYPE(obj, widtype);
1547
1548    Widget_Data *wd;
1549    Eina_Bool bounce = _elm_config->thumbscroll_bounce_enable;
1550
1551    wd = elm_widget_data_get(obj);
1552    if (!wd)
1553      return;
1554
1555    if (wd->h_mode == horizontal)
1556      return;
1557
1558    wd->h_mode = horizontal;
1559    elm_box_horizontal_set(wd->box, horizontal);
1560
1561    if (horizontal)
1562      {
1563         evas_object_size_hint_weight_set(wd->box, 0.0, EVAS_HINT_EXPAND);
1564         evas_object_size_hint_align_set(wd->box, 0.0, EVAS_HINT_FILL);
1565         elm_smart_scroller_bounce_allow_set(wd->scr, bounce, EINA_FALSE);
1566      }
1567    else
1568      {
1569         evas_object_size_hint_weight_set(wd->box, EVAS_HINT_EXPAND, 0.0);
1570         evas_object_size_hint_align_set(wd->box, EVAS_HINT_FILL, 0.0);
1571         elm_smart_scroller_bounce_allow_set(wd->scr, EINA_FALSE, bounce);
1572      }
1573
1574    _elm_list_mode_set_internal(wd);
1575 }
1576
1577 EAPI Eina_Bool
1578 elm_list_horizontal_get(const Evas_Object *obj)
1579 {
1580    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1581
1582    Widget_Data *wd;
1583
1584    wd = elm_widget_data_get(obj);
1585    if (!wd)
1586      return EINA_FALSE;
1587
1588    return wd->h_mode;
1589 }
1590
1591 EAPI void
1592 elm_list_always_select_mode_set(Evas_Object *obj, Eina_Bool always_select)
1593 {
1594    ELM_CHECK_WIDTYPE(obj, widtype);
1595    Widget_Data *wd = elm_widget_data_get(obj);
1596    if (!wd) return;
1597    wd->always_select = always_select;
1598 }
1599
1600 EAPI Eina_Bool
1601 elm_list_always_select_mode_get(const Evas_Object *obj)
1602 {
1603    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
1604    Widget_Data *wd = elm_widget_data_get(obj);
1605    if (!wd) return EINA_FALSE;
1606    return wd->always_select;
1607 }
1608
1609 EAPI const Eina_List *
1610 elm_list_items_get(const Evas_Object *obj)
1611 {
1612    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1613    Widget_Data *wd = elm_widget_data_get(obj);
1614    if (!wd) return NULL;
1615    return wd->items;
1616 }
1617
1618 EAPI Elm_List_Item *
1619 elm_list_selected_item_get(const Evas_Object *obj)
1620 {
1621    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1622    Widget_Data *wd = elm_widget_data_get(obj);
1623    if (!wd) return NULL;
1624    if (wd->selected) return wd->selected->data;
1625    return NULL;
1626 }
1627
1628 EAPI const Eina_List *
1629 elm_list_selected_items_get(const Evas_Object *obj)
1630 {
1631    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1632    Widget_Data *wd = elm_widget_data_get(obj);
1633    if (!wd) return NULL;
1634    return wd->selected;
1635 }
1636
1637 EAPI void
1638 elm_list_item_separator_set(Elm_List_Item *it, Eina_Bool setting)
1639 {
1640    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it);
1641    it->is_separator = !!setting;
1642 }
1643
1644 EAPI Eina_Bool
1645 elm_list_item_separator_get(const Elm_List_Item *it)
1646 {
1647    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it, EINA_FALSE);
1648    return it->is_separator;
1649 }
1650
1651 EAPI void
1652 elm_list_item_selected_set(Elm_List_Item *it, Eina_Bool selected)
1653 {
1654    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it);
1655    Evas_Object *obj = it->base.widget;
1656    Widget_Data *wd = elm_widget_data_get(obj);
1657    if (!wd) return;
1658
1659    selected = !!selected;
1660    if (it->selected == selected) return;
1661
1662    evas_object_ref(obj);
1663    _elm_list_walk(wd);
1664
1665    if (selected)
1666      {
1667         if (!wd->multi)
1668           {
1669              while (wd->selected)
1670                _item_unselect(wd->selected->data);
1671           }
1672         _item_hilight(it);
1673         _item_select(it);
1674      }
1675    else
1676      _item_unselect(it);
1677
1678    _elm_list_unwalk(wd);
1679    evas_object_unref(obj);
1680 }
1681
1682 EAPI Eina_Bool
1683 elm_list_item_selected_get(const Elm_List_Item *it)
1684 {
1685    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it, EINA_FALSE);
1686    return it->selected;
1687 }
1688
1689 EAPI void
1690 elm_list_item_show(Elm_List_Item *it)
1691 {
1692    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it);
1693    Widget_Data *wd = elm_widget_data_get(it->base.widget);
1694    Evas_Coord bx, by, bw, bh;
1695    Evas_Coord x, y, w, h;
1696
1697    evas_object_geometry_get(wd->box, &bx, &by, &bw, &bh);
1698    evas_object_geometry_get(it->base.view, &x, &y, &w, &h);
1699    x -= bx;
1700    y -= by;
1701    if (wd->scr)
1702      elm_smart_scroller_child_region_show(wd->scr, x, y, w, h);
1703 }
1704
1705 EAPI void
1706 elm_list_item_bring_in(Elm_List_Item *it)
1707 {
1708    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it);
1709    Widget_Data *wd = elm_widget_data_get(it->base.widget);
1710    Evas_Coord bx, by, bw, bh;
1711    Evas_Coord x, y, w, h;
1712
1713    evas_object_geometry_get(wd->box, &bx, &by, &bw, &bh);
1714    evas_object_geometry_get(it->base.view, &x, &y, &w, &h);
1715    x -= bx;
1716    y -= by;
1717    if (wd->scr)
1718      elm_smart_scroller_region_bring_in(wd->scr, x, y, w, h);
1719 }
1720
1721 EAPI void
1722 elm_list_item_del(Elm_List_Item *it)
1723 {
1724    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it);
1725    Evas_Object *obj = it->base.widget;
1726    Widget_Data *wd = elm_widget_data_get(obj);
1727    if (!wd) return;
1728
1729    if (it->selected) _item_unselect(it);
1730
1731    if (wd->walking > 0)
1732      {
1733         if (it->deleted) return;
1734         it->deleted = EINA_TRUE;
1735         wd->to_delete = eina_list_append(wd->to_delete, it);
1736         return;
1737      }
1738
1739    wd->items = eina_list_remove_list(wd->items, it->node);
1740
1741    evas_object_ref(obj);
1742    _elm_list_walk(wd);
1743
1744    elm_widget_item_pre_notify_del(it);
1745    _elm_list_item_free(it);
1746
1747    _elm_list_unwalk(wd);
1748    evas_object_unref(obj);
1749 }
1750
1751 EAPI void
1752 elm_list_item_del_cb_set(Elm_List_Item *it, Evas_Smart_Cb func)
1753 {
1754    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it);
1755    elm_widget_item_del_cb_set(it, func);
1756 }
1757
1758 EAPI void *
1759 elm_list_item_data_get(const Elm_List_Item *it)
1760 {
1761    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it, NULL);
1762    return elm_widget_item_data_get(it);
1763 }
1764
1765 EAPI Evas_Object *
1766 elm_list_item_icon_get(const Elm_List_Item *it)
1767 {
1768    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it, NULL);
1769    if (it->dummy_icon) return NULL;
1770    return it->icon;
1771 }
1772
1773 EAPI void
1774 elm_list_item_icon_set(Elm_List_Item *it, Evas_Object *icon)
1775 {
1776    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it);
1777    if (it->icon == icon) return;
1778    if ((it->dummy_icon) && (!icon)) return;
1779    if (it->dummy_icon)
1780      {
1781         evas_object_del(it->icon);
1782         it->dummy_icon = EINA_FALSE;
1783      }
1784    if (!icon)
1785      {
1786         icon = evas_object_rectangle_add(evas_object_evas_get(it->base.widget));
1787         evas_object_color_set(icon, 0, 0, 0, 0);
1788         it->dummy_icon = EINA_TRUE;
1789      }
1790    if (it->icon)
1791      {
1792         evas_object_del(it->icon);
1793         it->icon = NULL;
1794      }
1795    it->icon = icon;
1796    if (it->base.view)
1797      edje_object_part_swallow(it->base.view, "elm.swallow.icon", icon);
1798 }
1799
1800 EAPI Evas_Object *
1801 elm_list_item_end_get(const Elm_List_Item *it)
1802 {
1803    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it, NULL);
1804    if (it->dummy_end) return NULL;
1805    return it->end;
1806 }
1807
1808 EAPI void
1809 elm_list_item_end_set(Elm_List_Item *it, Evas_Object *end)
1810 {
1811    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it);
1812    if (it->end == end) return;
1813    if ((it->dummy_end) && (!end)) return;
1814    if (it->dummy_end)
1815      {
1816         evas_object_del(it->end);
1817         it->dummy_icon = EINA_FALSE;
1818      }
1819    if (!end)
1820      {
1821         end = evas_object_rectangle_add(evas_object_evas_get(it->base.widget));
1822         evas_object_color_set(end, 0, 0, 0, 0);
1823         it->dummy_end = EINA_TRUE;
1824      }
1825    if (it->end)
1826      {
1827         evas_object_del(it->end);
1828         it->end = NULL;
1829      }
1830    it->end = end;
1831    if (it->base.view)
1832      edje_object_part_swallow(it->base.view, "elm.swallow.end", end);
1833 }
1834
1835 EAPI Evas_Object *
1836 elm_list_item_base_get(const Elm_List_Item *it)
1837 {
1838    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it, NULL);
1839    return it->base.view;
1840 }
1841
1842 EAPI const char *
1843 elm_list_item_label_get(const Elm_List_Item *it)
1844 {
1845    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it, NULL);
1846    return it->label;
1847 }
1848
1849 EAPI void
1850 elm_list_item_label_set(Elm_List_Item *it, const char *text)
1851 {
1852    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it);
1853    if (!eina_stringshare_replace(&it->label, text)) return;
1854    if (it->base.view)
1855      edje_object_part_text_set(it->base.view, "elm.text", it->label);
1856 }
1857
1858 EAPI Elm_List_Item *
1859 elm_list_item_prev(const Elm_List_Item *it)
1860 {
1861    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it, NULL);
1862    if (it->node->prev) return it->node->prev->data;
1863    else return NULL;
1864 }
1865
1866 EAPI Elm_List_Item *
1867 elm_list_item_next(const Elm_List_Item *it)
1868 {
1869    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it, NULL);
1870    if (it->node->next) return it->node->next->data;
1871    else return NULL;
1872 }
1873
1874 EAPI void
1875 elm_list_item_tooltip_text_set(Elm_List_Item *item, const char *text)
1876 {
1877    ELM_LIST_ITEM_CHECK_DELETED_RETURN(item);
1878    elm_widget_item_tooltip_text_set(item, text);
1879 }
1880
1881 EAPI void
1882 elm_list_item_tooltip_content_cb_set(Elm_List_Item *item, Elm_Tooltip_Item_Content_Cb func, const void *data, Evas_Smart_Cb del_cb)
1883 {
1884    ELM_LIST_ITEM_CHECK_DELETED_RETURN(item);
1885    elm_widget_item_tooltip_content_cb_set(item, func, data, del_cb);
1886 }
1887
1888 EAPI void
1889 elm_list_item_tooltip_unset(Elm_List_Item *item)
1890 {
1891    ELM_LIST_ITEM_CHECK_DELETED_RETURN(item);
1892    elm_widget_item_tooltip_unset(item);
1893 }
1894
1895 EAPI void
1896 elm_list_item_tooltip_style_set(Elm_List_Item *item, const char *style)
1897 {
1898    ELM_LIST_ITEM_CHECK_DELETED_RETURN(item);
1899    elm_widget_item_tooltip_style_set(item, style);
1900 }
1901
1902 EAPI const char *
1903 elm_list_item_tooltip_style_get(const Elm_List_Item *item)
1904 {
1905    ELM_LIST_ITEM_CHECK_DELETED_RETURN(item, NULL);
1906    return elm_widget_item_tooltip_style_get(item);
1907 }
1908
1909 EAPI void
1910 elm_list_item_cursor_set(Elm_List_Item *item, const char *cursor)
1911 {
1912    ELM_LIST_ITEM_CHECK_DELETED_RETURN(item);
1913    elm_widget_item_cursor_set(item, cursor);
1914 }
1915
1916 EAPI const char *
1917 elm_list_item_cursor_get(const Elm_List_Item *item)
1918 {
1919    ELM_LIST_ITEM_CHECK_DELETED_RETURN(item, NULL);
1920    return elm_widget_item_cursor_get(item);
1921 }
1922
1923 EAPI void
1924 elm_list_item_cursor_unset(Elm_List_Item *item)
1925 {
1926    ELM_LIST_ITEM_CHECK_DELETED_RETURN(item);
1927    elm_widget_item_cursor_unset(item);
1928 }
1929
1930 EAPI void
1931 elm_list_item_cursor_style_set(Elm_List_Item *item, const char *style)
1932 {
1933    ELM_LIST_ITEM_CHECK_DELETED_RETURN(item);
1934    elm_widget_item_cursor_style_set(item, style);
1935 }
1936
1937 EAPI const char *
1938 elm_list_item_cursor_style_get(const Elm_List_Item *item)
1939 {
1940    ELM_LIST_ITEM_CHECK_DELETED_RETURN(item, NULL);
1941    return elm_widget_item_cursor_style_get(item);
1942 }
1943
1944 EAPI void
1945 elm_list_item_cursor_engine_only_set(Elm_List_Item *item, Eina_Bool engine_only)
1946 {
1947    ELM_LIST_ITEM_CHECK_DELETED_RETURN(item);
1948    elm_widget_item_cursor_engine_only_set(item, engine_only);
1949 }
1950
1951 EAPI Eina_Bool
1952 elm_list_item_cursor_engine_only_get(const Elm_List_Item *item)
1953 {
1954    ELM_LIST_ITEM_CHECK_DELETED_RETURN(item, EINA_FALSE);
1955    return elm_widget_item_cursor_engine_only_get(item);
1956 }
1957
1958 EAPI void
1959 elm_list_bounce_set(Evas_Object *obj, Eina_Bool h_bounce, Eina_Bool v_bounce)
1960 {
1961    ELM_CHECK_WIDTYPE(obj, widtype);
1962    Widget_Data *wd = elm_widget_data_get(obj);
1963    if (!wd) return;
1964    if (wd->scr)
1965      elm_smart_scroller_bounce_allow_set(wd->scr, h_bounce, v_bounce);
1966 }
1967
1968 EAPI void
1969 elm_list_bounce_get(const Evas_Object *obj, Eina_Bool *h_bounce, Eina_Bool *v_bounce)
1970 {
1971    ELM_CHECK_WIDTYPE(obj, widtype);
1972    Widget_Data *wd = elm_widget_data_get(obj);
1973    if (!wd) return;
1974    elm_smart_scroller_bounce_allow_get(wd->scr, h_bounce, v_bounce);
1975 }
1976
1977 EAPI void
1978 elm_list_scroller_policy_set(Evas_Object *obj, Elm_Scroller_Policy policy_h, Elm_Scroller_Policy policy_v)
1979 {
1980    ELM_CHECK_WIDTYPE(obj, widtype);
1981    Widget_Data *wd = elm_widget_data_get(obj);
1982    if (!wd) return;
1983    if ((policy_h >= ELM_SCROLLER_POLICY_LAST) ||
1984        (policy_v >= ELM_SCROLLER_POLICY_LAST))
1985      if (wd->scr)
1986        elm_smart_scroller_policy_set(wd->scr, policy_h, policy_v);
1987 }
1988
1989 EAPI void
1990 elm_list_scroller_policy_get(const Evas_Object *obj, Elm_Scroller_Policy *policy_h, Elm_Scroller_Policy *policy_v)
1991 {
1992    ELM_CHECK_WIDTYPE(obj, widtype);
1993    Widget_Data *wd = elm_widget_data_get(obj);
1994    Elm_Smart_Scroller_Policy s_policy_h, s_policy_v;
1995    if ((!wd) || (!wd->scr)) return;
1996    elm_smart_scroller_policy_get(wd->scr, &s_policy_h, &s_policy_v);
1997    if (policy_h) *policy_h = (Elm_Scroller_Policy) s_policy_h;
1998    if (policy_v) *policy_v = (Elm_Scroller_Policy) s_policy_v;
1999 }
2000
2001 EAPI void
2002 elm_list_item_disabled_set(Elm_List_Item *it, Eina_Bool disabled)
2003 {
2004    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it);
2005
2006    if (it->disabled == disabled)
2007      return;
2008
2009    it->disabled = !!disabled;
2010
2011    if (it->disabled)
2012      edje_object_signal_emit(it->base.view, "elm,state,disabled", "elm");
2013    else
2014      edje_object_signal_emit(it->base.view, "elm,state,enabled", "elm");
2015 }
2016
2017 EAPI Eina_Bool
2018 elm_list_item_disabled_get(const Elm_List_Item *it)
2019 {
2020    ELM_LIST_ITEM_CHECK_DELETED_RETURN(it, EINA_FALSE);
2021
2022    return it->disabled;
2023 }