src/lib/elm_list.c

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