src/lib/elm_diskselector.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3
   4 #ifndef MAX
   5 # define MAX(a, b) (((a) > (b)) ? (a) : (b))
   6 #endif
   7
   8 #ifndef CEIL
   9 #define CEIL(a) (((a) % 2 != 0) ? ((a) / 2 + 1) : ((a) / 2))
  10 #endif
  11
  12 #define DISPLAY_ITEM_NUM_MIN 3
  13
  14 typedef struct _Widget_Data Widget_Data;
  15
  16 struct _Widget_Data
  17 {
  18    Evas_Object *self;
  19    Evas_Object *scroller;
  20    Evas_Object *main_box;
  21    Evas_Object *left_blank;
  22    Evas_Object *right_blank;
  23    Elm_Diskselector_Item *selected_item;
  24    Elm_Diskselector_Item *first;
  25    Elm_Diskselector_Item *second;
  26    Elm_Diskselector_Item *s_last;
  27    Elm_Diskselector_Item *last;
  28    Eina_List *items;
  29    Eina_List *r_items;
  30    Eina_List *over_items;
  31    Eina_List *under_items;
  32    int item_count, len_threshold, len_side, display_item_num;
  33    Ecore_Idle_Enterer *idler;
  34    Ecore_Idle_Enterer *check_idler;
  35    Evas_Coord minw, minh;
  36    Eina_Bool init:1;
  37    Eina_Bool round:1;
  38    Eina_Bool display_item_num_by_api:1;
  39 };
  40
  41 struct _Elm_Diskselector_Item
  42 {
  43    Elm_Widget_Item base;
  44    Eina_List *node;
  45    Evas_Object *icon;
  46    const char *label;
  47    Evas_Smart_Cb func;
  48 };
  49
  50 static const char *widtype = NULL;
  51
  52 #define ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, ...)                  \
  53    ELM_WIDGET_ITEM_CHECK_OR_RETURN((Elm_Widget_Item *)it, __VA_ARGS__); \
  54    ELM_CHECK_WIDTYPE(it->base.widget, widtype) __VA_ARGS__;
  55
  56 static Eina_Bool _move_scroller(void *data);
  57 static void _del_hook(Evas_Object * obj);
  58 static void _del_pre_hook(Evas_Object * obj);
  59 static void _sizing_eval(Evas_Object * obj);
  60 static void _theme_hook(Evas_Object * obj);
  61 static void _on_focus_hook(void *data, Evas_Object *obj);
  62 static Eina_Bool _event_hook(Evas_Object *obj, Evas_Object *src, Evas_Callback_Type type, void *event_info);
  63 static void _sub_del(void *data, Evas_Object * obj, void *event_info);
  64 static void _round_items_del(Widget_Data *wd);
  65 static void _scroller_move_cb(void *data, Evas_Object *obj, void *event_info);
  66 static void _item_click_cb(void *data, Evas_Object *obj __UNUSED__,
  67                            const char *emission __UNUSED__,
  68                            const char *source __UNUSED__);
  69 static void _selected_item_indicate(Elm_Diskselector_Item *it);
  70
  71 static const char SIG_SELECTED[] = "selected";
  72 static const Evas_Smart_Cb_Description _signals[] = {
  73        {SIG_SELECTED, ""},
  74        {NULL, NULL}
  75 };
  76
  77 static void
  78 _diskselector_object_resize(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
  79 {
  80    Widget_Data *wd;
  81    Evas_Coord w, h;
  82
  83    wd = elm_widget_data_get(data);
  84    if (!wd) return;
  85
  86    if ((wd->minw == -1) && (wd->minh == -1))
  87       elm_coords_finger_size_adjust(6, &wd->minw, 1, &wd->minh);
  88    edje_object_size_min_restricted_calc
  89       (elm_smart_scroller_edje_object_get
  90           (wd->scroller), &wd->minw, &wd->minh, wd->minw, wd->minh);
  91    evas_object_size_hint_min_set(obj, wd->minw, wd->minh);
  92    evas_object_size_hint_max_set(obj, -1, -1);
  93
  94    evas_object_geometry_get(wd->scroller, NULL, NULL, &w, &h);
  95    if (wd->round)
  96      evas_object_resize(wd->main_box, (w / wd->display_item_num) * (wd->item_count + (CEIL(wd->display_item_num) * 2)), h);
  97    else
  98      evas_object_resize(wd->main_box, (w / wd->display_item_num) * (wd->item_count + CEIL(wd->display_item_num)), h);
  99
 100    elm_smart_scroller_paging_set(wd->scroller, 0, 0,
 101                                  (int)(w / wd->display_item_num), 0);
 102
 103    if (!wd->idler)
 104      wd->idler = ecore_idle_enterer_before_add(_move_scroller, data);
 105 }
 106
 107 static Elm_Diskselector_Item *
 108 _item_new(Evas_Object *obj, Evas_Object *icon, const char *label, Evas_Smart_Cb func, const void *data)
 109 {
 110    Elm_Diskselector_Item *it;
 111    const char *style = elm_widget_style_get(obj);
 112
 113    it = elm_widget_item_new(obj, Elm_Diskselector_Item);
 114    if (!it) return NULL;
 115
 116    it->label = eina_stringshare_add(label);
 117    it->icon = icon;
 118    it->func = func;
 119    it->base.data = data;
 120    it->base.view = edje_object_add(evas_object_evas_get(obj));
 121    _elm_theme_object_set(obj, it->base.view, "diskselector", "item", style);
 122    evas_object_size_hint_weight_set(it->base.view, EVAS_HINT_EXPAND,
 123                                     EVAS_HINT_EXPAND);
 124    evas_object_size_hint_align_set(it->base.view, EVAS_HINT_FILL,
 125                                    EVAS_HINT_FILL);
 126    evas_object_show(it->base.view);
 127
 128    if (it->label)
 129      {
 130         edje_object_part_text_set(it->base.view, "elm.text", it->label);
 131         edje_object_signal_callback_add(it->base.view, "elm,action,click", "", _item_click_cb, it);
 132      }
 133    if (it->icon)
 134      {
 135         evas_object_size_hint_min_set(it->icon, 24, 24);
 136         evas_object_size_hint_max_set(it->icon, 40, 40);
 137         edje_object_part_swallow(it->base.view, "elm.swallow.icon", it->icon);
 138         evas_object_show(it->icon);
 139         elm_widget_sub_object_add(obj, it->icon);
 140      }
 141    return it;
 142 }
 143
 144 static void
 145 _item_del(Elm_Diskselector_Item *item)
 146 {
 147    if (!item) return;
 148    eina_stringshare_del(item->label);
 149    if (item->icon)
 150      evas_object_del(item->icon);
 151    elm_widget_item_del(item);
 152 }
 153
 154 static void
 155 _theme_data_get(Widget_Data *wd)
 156 {
 157    const char* str;
 158    str = edje_object_data_get(wd->right_blank, "len_threshold");
 159    if (str) wd->len_threshold = MAX(0, atoi(str));
 160    else wd->len_threshold = 0;
 161
 162    if (!wd->display_item_num_by_api)
 163      {
 164         str = edje_object_data_get(wd->right_blank, "display_item_num");
 165         if (str) wd->display_item_num = MAX(DISPLAY_ITEM_NUM_MIN, atoi(str));
 166         else wd->display_item_num = DISPLAY_ITEM_NUM_MIN;
 167      }
 168
 169    str = edje_object_data_get(wd->right_blank, "min_width");
 170    if (str) wd->minw = MAX(-1, atoi(str));
 171    else wd->minw = -1;
 172
 173    str = edje_object_data_get(wd->right_blank, "min_height");
 174    if (str) wd->minh = MAX(-1, atoi(str));
 175    else wd->minh = -1;
 176 }
 177
 178 static void
 179 _del_hook(Evas_Object * obj)
 180 {
 181    Widget_Data *wd = elm_widget_data_get(obj);
 182    if (!wd) return;
 183    free(wd);
 184 }
 185
 186 static void
 187 _del_pre_hook(Evas_Object * obj)
 188 {
 189    Elm_Diskselector_Item *it;
 190    Eina_List *l;
 191
 192    Widget_Data *wd = elm_widget_data_get(obj);
 193    if (!wd) return;
 194
 195    if (wd->left_blank)
 196      evas_object_del(wd->left_blank);
 197    if (wd->right_blank)
 198      evas_object_del(wd->right_blank);
 199    if (wd->last)
 200      {
 201         eina_stringshare_del(wd->last->label);
 202         evas_object_del(wd->last->base.view);
 203         free(wd->last);
 204      }
 205    if (wd->s_last)
 206      {
 207         eina_stringshare_del(wd->s_last->label);
 208         evas_object_del(wd->s_last->base.view);
 209         free(wd->s_last);
 210      }
 211    if (wd->second)
 212      {
 213         eina_stringshare_del(wd->second->label);
 214         evas_object_del(wd->second->base.view);
 215         free(wd->second);
 216      }
 217    if (wd->first)
 218      {
 219         eina_stringshare_del(wd->first->label);
 220         evas_object_del(wd->first->base.view);
 221         free(wd->first);
 222      }
 223
 224    EINA_LIST_FOREACH(wd->under_items, l, it)
 225      {
 226         if (it)
 227           {
 228              eina_stringshare_del(it->label);
 229              evas_object_del(it->base.view);
 230              free(it);
 231           }
 232      }
 233
 234    EINA_LIST_FOREACH(wd->over_items, l, it)
 235    {
 236      if (it)
 237         {
 238            eina_stringshare_del(it->label);
 239            evas_object_del(it->base.view);
 240            free(it);
 241         }
 242    }
 243
 244    EINA_LIST_FREE(wd->items, it) _item_del(it);
 245    eina_list_free(wd->r_items);
 246 }
 247
 248 static void
 249 _sizing_eval(Evas_Object * obj)
 250 {
 251    Widget_Data *wd = elm_widget_data_get(obj);
 252    if (!wd) return;
 253    _diskselector_object_resize(obj, NULL, obj, NULL);
 254 }
 255
 256 static void
 257 _theme_hook(Evas_Object * obj)
 258 {
 259    Eina_List *l;
 260    Elm_Diskselector_Item *it;
 261    Widget_Data *wd = elm_widget_data_get(obj);
 262    if (!wd) return;
 263
 264    if (wd->scroller)
 265      elm_smart_scroller_object_theme_set(obj, wd->scroller, "diskselector",
 266                                          "base", elm_widget_style_get(obj));
 267    if (wd->round)
 268      {
 269         EINA_LIST_FOREACH(wd->r_items, l, it)
 270           {
 271              _elm_theme_object_set(obj, it->base.view, "diskselector", "item",
 272                                    elm_widget_style_get(obj));
 273              edje_object_part_text_set(it->base.view, "elm.text", it->label);
 274           }
 275      }
 276    else
 277      {
 278         EINA_LIST_FOREACH(wd->items, l, it)
 279           {
 280              _elm_theme_object_set(obj, it->base.view, "diskselector", "item",
 281                                    elm_widget_style_get(obj));
 282              edje_object_part_text_set(it->base.view, "elm.text", it->label);
 283           }
 284      }
 285    _elm_theme_object_set(obj, wd->right_blank, "diskselector", "item",
 286                                    elm_widget_style_get(obj));
 287    _theme_data_get(wd);
 288    _sizing_eval(obj);
 289 }
 290
 291 static void
 292 _sub_del(void *data __UNUSED__, Evas_Object * obj, void *event_info)
 293 {
 294    Widget_Data *wd = elm_widget_data_get(obj);
 295    Evas_Object *sub = event_info;
 296    Elm_Diskselector_Item *it;
 297    const Eina_List *l;
 298
 299    if (!wd) return;
 300    if (!sub) abort();
 301    if (sub == wd->scroller)
 302      wd->scroller = NULL;
 303    else
 304      {
 305         EINA_LIST_FOREACH(wd->items, l, it)
 306           {
 307              if (sub == it->icon)
 308                {
 309                   it->icon = NULL;
 310                   _sizing_eval(obj);
 311                   break;
 312                }
 313           }
 314      }
 315 }
 316
 317 static void
 318 _select_item(Elm_Diskselector_Item *it)
 319 {
 320    if (!it) return;
 321    Widget_Data *wd = elm_widget_data_get(it->base.widget);
 322    wd->selected_item = it;
 323    _selected_item_indicate(wd->selected_item);
 324    if (it->func) it->func((void *)it->base.data, it->base.widget, it);
 325    evas_object_smart_callback_call(it->base.widget, SIG_SELECTED, it);
 326 }
 327
 328 static void
 329 _on_focus_hook(void *data __UNUSED__, Evas_Object *obj)
 330 {
 331    Widget_Data *wd = elm_widget_data_get(obj);
 332    if (!wd)
 333      return;
 334
 335    if (elm_widget_focus_get(obj))
 336      {
 337         edje_object_signal_emit(wd->self, "elm,action,focus", "elm");
 338         evas_object_focus_set(wd->self, EINA_TRUE);
 339      }
 340    else
 341      {
 342         edje_object_signal_emit(wd->self, "elm,action,unfocus", "elm");
 343         evas_object_focus_set(wd->self, EINA_FALSE);
 344      }
 345 }
 346
 347 static Eina_Bool
 348 _event_hook(Evas_Object *obj, Evas_Object *src __UNUSED__, Evas_Callback_Type type, void *event_info)
 349 {
 350    if (type != EVAS_CALLBACK_KEY_DOWN) return EINA_FALSE;
 351    Evas_Event_Key_Down *ev = event_info;
 352    Widget_Data *wd = elm_widget_data_get(obj);
 353    if (!wd) return EINA_FALSE;
 354    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return EINA_FALSE;
 355    if (elm_widget_disabled_get(obj)) return EINA_FALSE;
 356
 357    Elm_Diskselector_Item *it = NULL;
 358    Eina_List *l;
 359
 360    if (!wd->selected_item) {
 361         ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 362         return EINA_TRUE;
 363    }
 364
 365    if ((!strcmp(ev->keyname, "Left")) || (!strcmp(ev->keyname, "KP_Left")) ||
 366        (!strcmp(ev->keyname, "Up"))  || (!strcmp(ev->keyname, "KP_Up")))
 367      {
 368         l = wd->selected_item->node->prev;
 369         if ((!l) && (wd->round))
 370           l = eina_list_last(wd->items);
 371      }
 372    else if ((!strcmp(ev->keyname, "Right")) || (!strcmp(ev->keyname, "KP_Right")) ||
 373             (!strcmp(ev->keyname, "Down")) || (!strcmp(ev->keyname, "KP_Down")))
 374      {
 375         l = wd->selected_item->node->next;
 376         if ((!l) && (wd->round))
 377           l = wd->items;
 378      }
 379    else if ((!strcmp(ev->keyname, "Home")) || (!strcmp(ev->keyname, "KP_Home")))
 380      l = wd->items;
 381    else if ((!strcmp(ev->keyname, "End")) || (!strcmp(ev->keyname, "KP_End")))
 382      l = eina_list_last(wd->items);
 383    else return EINA_FALSE;
 384
 385    if (l)
 386      it = eina_list_data_get(l);
 387
 388    if (it)
 389      {
 390         wd->selected_item = it;
 391         if (!wd->idler)
 392           wd->idler = ecore_idle_enterer_before_add(_move_scroller, obj);
 393      }
 394
 395    ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 396    return EINA_TRUE;
 397 }
 398
 399 static int
 400 _count_letter(const char *str)
 401 {
 402    int pos = 0;
 403    int code = 0, chnum;
 404
 405    for (chnum = 0; ; chnum++)
 406      {
 407         pos = evas_string_char_next_get(str, pos, &code);
 408         if (code == 0) break;
 409      }
 410    return chnum;
 411 }
 412
 413 static int
 414 _check_letter(const char *str, int length)
 415 {
 416    int pos = 0;
 417    int code = 0, chnum;
 418
 419    for (chnum = 0; ; chnum++)
 420      {
 421         if (chnum == length) break;
 422         pos = evas_string_char_next_get(str, pos, &code);
 423         if (code == 0) break;
 424      }
 425    return pos;
 426 }
 427
 428 static Eina_Bool
 429 _check_string(void *data)
 430 {
 431    int mid, steps, length, diff;
 432    Elm_Diskselector_Item *it;
 433    Eina_List *list, *l;
 434    Evas_Coord ox, ow;
 435    char buf[1024];
 436    Widget_Data *wd = data;
 437
 438    evas_object_geometry_get(wd->scroller, &ox, NULL, &ow, NULL);
 439    if (ow <= 0)
 440      return EINA_FALSE;
 441    if (!wd->init)
 442      return EINA_FALSE;
 443    if (!wd->round)
 444      list = wd->items;
 445    else
 446      list = wd->r_items;
 447
 448    EINA_LIST_FOREACH(list, l, it)
 449      {
 450         Evas_Coord x, w;
 451         int len;
 452         evas_object_geometry_get(it->base.view, &x, NULL, &w, NULL);
 453         /* item not visible */
 454         if ((x + w <= ox) || (x >= ox + ow))
 455           continue;
 456
 457         len = _count_letter(it->label);
 458 //        // FIXME: len should be # of ut8f letters. ie count using utf8 string walk, not stringshare len
 459 //        len = eina_stringshare_strlen(it->label);
 460
 461         if (x <= ox + 5)
 462           edje_object_signal_emit(it->base.view, "elm,state,left_side",
 463                                   "elm");
 464         else if (x + w >= ox + ow - 5)
 465           edje_object_signal_emit(it->base.view, "elm,state,right_side",
 466                                   "elm");
 467         else
 468           {
 469              if ((wd->len_threshold) && (len > wd->len_threshold))
 470                edje_object_signal_emit(it->base.view, "elm,state,center_small",
 471                                        "elm");
 472              else
 473                edje_object_signal_emit(it->base.view, "elm,state,center",
 474                                        "elm");
 475           }
 476
 477         // if len is les that the limit len, skip anyway
 478         if (len <= wd->len_side)
 479           continue;
 480
 481         steps = len - wd->len_side + 1;
 482         mid = x + w / 2;
 483         if (mid <= ox + ow / 2)
 484           diff = (ox + ow / 2) - mid;
 485         else
 486           diff = mid - (ox + ow / 2);
 487
 488         length = len - (int)(diff * steps / (ow / 3));
 489         length = MAX(length, wd->len_side);
 490         // limit string len to "length" ut8f chars
 491         length = _check_letter(it->label, length);
 492         // cut it off at byte mark returned form _check_letter
 493         strncpy(buf, it->label, length);
 494         buf[length] = '\0';
 495         edje_object_part_text_set(it->base.view, "elm.text", buf);
 496      }
 497
 498    if (wd->check_idler)
 499      ecore_idle_enterer_del(wd->check_idler);
 500    wd->check_idler = NULL;
 501    return EINA_FALSE;
 502 }
 503
 504 static void
 505 _selected_item_indicate(Elm_Diskselector_Item *it)
 506 {
 507    Elm_Diskselector_Item *item;
 508    Eina_List *l;
 509    Widget_Data *wd;
 510    wd = elm_widget_data_get(it->base.widget);
 511
 512    if (!wd) return;
 513
 514    EINA_LIST_FOREACH(wd->r_items, l, item)
 515      {
 516         if (!strcmp(item->label, it->label)) edje_object_signal_emit(item->base.view, "elm,state,selected", "elm");
 517         else
 518            edje_object_signal_emit(item->base.view, "elm,state,default", "elm");
 519      }
 520 }
 521
 522 static void
 523 _item_click_cb(void *data, Evas_Object *obj __UNUSED__,
 524                const char *emission __UNUSED__, const char *source __UNUSED__)
 525 {
 526    Elm_Diskselector_Item *it = data;
 527
 528    if (!it) return;
 529
 530    Widget_Data *wd;
 531    wd = elm_widget_data_get(it->base.widget);
 532
 533    if (!wd) return;
 534
 535    if (wd->selected_item != it)
 536      {
 537         wd->selected_item = it;
 538         _selected_item_indicate(wd->selected_item);
 539      }
 540
 541    if (it->func) it->func((void *)it->base.data, it->base.widget, it);
 542 }
 543
 544 static void
 545 _scroller_move_cb(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 546 {
 547    Evas_Coord x, y, w, h, bw;
 548    Widget_Data *wd = data;
 549
 550    _check_string(wd);
 551    elm_smart_scroller_child_pos_get(obj, &x, &y);
 552    elm_smart_scroller_child_viewport_size_get(obj, &w, &h);
 553    if (wd->round)
 554      {
 555         evas_object_geometry_get(wd->main_box, NULL, NULL, &bw, NULL);
 556         if (x > ((w / wd->display_item_num) * (wd->item_count + (wd->display_item_num % 2))))
 557            elm_smart_scroller_child_region_show(wd->scroller,
 558                                                x - ((w / wd->display_item_num) * wd->item_count),
 559                                                y, w, h);
 560         else if (x < 0)
 561            elm_smart_scroller_child_region_show(wd->scroller,
 562                                                x + ((w / wd->display_item_num) * wd->item_count),
 563                                                y, w, h);
 564      }
 565 }
 566
 567 static void
 568 _scroller_stop_cb(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 569 {
 570    Elm_Diskselector_Item *it;
 571    Widget_Data *wd = data;
 572    Evas_Coord x, w, ow;
 573    Eina_List *l, *list;
 574
 575    if (wd->idler)
 576      return;
 577
 578    if (!wd->round)
 579      list = wd->items;
 580    else
 581      list = wd->r_items;
 582
 583    evas_object_geometry_get(wd->scroller, NULL, NULL, &ow, NULL);
 584    EINA_LIST_FOREACH(list, l, it)
 585      {
 586         evas_object_geometry_get(it->base.view, &x, NULL, &w, NULL);
 587         if (abs((int)(ow / 2 - (int)(x + w / 2))) < 10)
 588           break;
 589      }
 590
 591    if (!it)
 592      return;
 593
 594    _select_item(it);
 595 }
 596
 597 static Eina_Bool
 598 _move_scroller(void *data)
 599 {
 600    Evas_Object *obj = data;
 601    Widget_Data *wd;
 602    Eina_List *l;
 603    Elm_Diskselector_Item *dit;
 604    Evas_Coord y, w, h;
 605    int i;
 606
 607    wd = elm_widget_data_get(obj);
 608    if (!wd) return EINA_FALSE;
 609
 610    if (wd->round)
 611      i = 1;
 612    else
 613      i = 0;
 614
 615    EINA_LIST_FOREACH(wd->items, l, dit)
 616      {
 617         if (wd->selected_item == dit)
 618           break;
 619         i++;
 620      }
 621    if (!dit)
 622      {
 623         wd->selected_item =
 624            (Elm_Diskselector_Item *) eina_list_nth(wd->items, 0);
 625         return EINA_FALSE;
 626      }
 627
 628    evas_object_geometry_get(wd->scroller, NULL, &y, &w, &h);
 629    elm_smart_scroller_child_region_show(wd->scroller, w / wd->display_item_num * i, y, w, h);
 630    _select_item(dit);
 631    if (wd->idler)
 632      {
 633         ecore_idle_enterer_del(wd->idler);
 634         wd->idler = NULL;
 635      }
 636    wd->init = EINA_TRUE;
 637    _check_string(wd);
 638
 639    return EINA_TRUE;
 640 }
 641
 642 static void
 643 _round_item_del(Widget_Data *wd, Elm_Diskselector_Item *it)
 644 {
 645    if (!it) return;
 646    elm_box_unpack(wd->main_box, it->base.view);
 647    wd->r_items = eina_list_remove(wd->r_items, it);
 648    eina_stringshare_del(it->label);
 649    evas_object_del(it->base.view);
 650    free(it);
 651 }
 652
 653 static void
 654 _round_items_del(Widget_Data *wd)
 655 {
 656    Eina_List *l;
 657    Elm_Diskselector_Item * it;
 658
 659    _round_item_del(wd, wd->last);
 660    wd->last = NULL;
 661    _round_item_del(wd, wd->s_last);
 662    wd->s_last = NULL;
 663    _round_item_del(wd, wd->second);
 664    wd->second = NULL;
 665    _round_item_del(wd, wd->first);
 666    wd->first = NULL;
 667
 668    EINA_LIST_FOREACH(wd->under_items, l, it)
 669      {
 670         _round_item_del(wd, it);
 671         it = NULL;
 672      }
 673
 674    EINA_LIST_FOREACH(wd->over_items, l, it)
 675      {
 676         _round_item_del(wd, it);
 677         it = NULL;
 678      }
 679 }
 680
 681 static void
 682 _round_items_add(Widget_Data *wd)
 683 {
 684    Elm_Diskselector_Item *dit;
 685    Elm_Diskselector_Item *it;
 686    Elm_Diskselector_Item *temp_it;
 687    int i = 0;
 688    dit = it = eina_list_nth(wd->items, 0);
 689    if (!dit) return;
 690
 691    if (!wd->first)
 692      {
 693         wd->first = _item_new(it->base.widget, it->icon, it->label, it->func,
 694                               it->base.data);
 695         wd->first->node = it->node;
 696         wd->r_items = eina_list_append(wd->r_items, wd->first);
 697      }
 698
 699    it = eina_list_nth(wd->items, 1);
 700    if (!it)
 701      it = dit;
 702    if (!wd->second)
 703      {
 704         wd->second = _item_new(it->base.widget, it->icon, it->label, it->func,
 705                                it->base.data);
 706         wd->second->node = it->node;
 707         wd->r_items = eina_list_append(wd->r_items, wd->second);
 708      }
 709
 710    // if more than 3 itmes should be displayed
 711    for (i = 2; i < CEIL(wd->display_item_num); i++)
 712      {
 713         it = eina_list_nth(wd->items, i);
 714         if (!it) it = dit;
 715         temp_it = _item_new(it->base.widget, it->icon, it->label, it->func, it->base.data);
 716         wd->over_items = eina_list_append(wd->over_items, temp_it);
 717         wd->r_items = eina_list_append(wd->r_items, temp_it);
 718      }
 719
 720    it = eina_list_nth(wd->items, wd->item_count - 1);
 721    if (!it)
 722      it = dit;
 723    if (!wd->last)
 724      {
 725         wd->last = _item_new(it->base.widget, it->icon, it->label, it->func,
 726                              it->base.data);
 727         wd->last->node = it->node;
 728         wd->r_items = eina_list_prepend(wd->r_items, wd->last);
 729      }
 730
 731    it = eina_list_nth(wd->items, wd->item_count - 2);
 732    if (!it)
 733      it = dit;
 734    if (!wd->s_last)
 735      {
 736         wd->s_last = _item_new(it->base.widget, it->icon, it->label, it->func,
 737                                it->base.data);
 738         wd->s_last->node = it->node;
 739         wd->r_items = eina_list_prepend(wd->r_items, wd->s_last);
 740      }
 741
 742    // if more than 3 itmes should be displayed
 743    for (i = 3; i <= CEIL(wd->display_item_num); i++)
 744      {
 745         it = eina_list_nth(wd->items, wd->item_count - i);
 746         if (!it) it = dit;
 747         temp_it = _item_new(it->base.widget, it->icon, it->label, it->func, it->base.data);
 748         wd->under_items = eina_list_append(wd->under_items, temp_it);
 749         wd->r_items = eina_list_prepend(wd->r_items, temp_it);
 750      }
 751 }
 752
 753 EAPI Evas_Object *
 754 elm_diskselector_add(Evas_Object *parent)
 755 {
 756    Evas *e;
 757    Evas_Object *obj;
 758    Widget_Data *wd;
 759
 760    ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
 761
 762    ELM_SET_WIDTYPE(widtype, "diskselector");
 763    elm_widget_type_set(obj, "diskselector");
 764    elm_widget_sub_object_add(parent, obj);
 765    elm_widget_data_set(obj, wd);
 766    elm_widget_del_hook_set(obj, _del_hook);
 767    elm_widget_del_pre_hook_set(obj, _del_pre_hook);
 768    elm_widget_theme_hook_set(obj, _theme_hook);
 769    elm_widget_can_focus_set(obj, EINA_TRUE);
 770    elm_widget_on_focus_hook_set(obj, _on_focus_hook, NULL);
 771    elm_widget_event_hook_set(obj, _event_hook);
 772
 773    wd->self = obj;
 774    wd->item_count = 0;
 775    wd->round = EINA_FALSE;
 776    wd->init = EINA_FALSE;
 777    wd->len_side = 3;
 778    wd->display_item_num_by_api = EINA_FALSE;
 779
 780    wd->scroller = elm_smart_scroller_add(e);
 781    elm_smart_scroller_widget_set(wd->scroller, obj);
 782    _theme_hook(obj);
 783    elm_widget_resize_object_set(obj, wd->scroller);
 784    elm_smart_scroller_policy_set(wd->scroller, ELM_SMART_SCROLLER_POLICY_OFF,
 785                                  ELM_SMART_SCROLLER_POLICY_OFF);
 786    elm_smart_scroller_bounce_allow_set(wd->scroller, EINA_TRUE, EINA_FALSE);
 787    evas_object_smart_callback_add(wd->scroller, "scroll", _scroller_move_cb,
 788                                   wd);
 789    evas_object_smart_callback_add(wd->scroller, "animate,stop",
 790                                   _scroller_stop_cb, wd);
 791    _elm_theme_object_set(obj, wd->scroller, "diskselector", "base",
 792                          "default");
 793    evas_object_event_callback_add(wd->scroller, EVAS_CALLBACK_RESIZE,
 794                                   _diskselector_object_resize, obj);
 795
 796    wd->main_box = elm_box_add(parent);
 797    elm_box_horizontal_set(wd->main_box, EINA_TRUE);
 798    elm_box_homogeneous_set(wd->main_box, EINA_TRUE);
 799    evas_object_size_hint_weight_set(wd->main_box, EVAS_HINT_EXPAND,
 800                                     EVAS_HINT_EXPAND);
 801    evas_object_size_hint_align_set(wd->main_box, EVAS_HINT_FILL,
 802                                    EVAS_HINT_FILL);
 803    _elm_theme_object_set(obj, wd->main_box, "diskselector", "base",
 804                          "default");
 805    elm_widget_sub_object_add(obj, wd->main_box);
 806
 807    elm_smart_scroller_child_set(wd->scroller, wd->main_box);
 808
 809    wd->left_blank = edje_object_add(evas_object_evas_get(obj));
 810    _elm_theme_object_set(obj, wd->left_blank, "diskselector", "item",
 811                          "default");
 812    evas_object_size_hint_weight_set(wd->left_blank, EVAS_HINT_EXPAND,
 813                                     EVAS_HINT_EXPAND);
 814    evas_object_size_hint_align_set(wd->left_blank, EVAS_HINT_FILL,
 815                                    EVAS_HINT_FILL);
 816    elm_box_pack_end(wd->main_box, wd->left_blank);
 817    evas_object_show(wd->left_blank);
 818
 819    wd->right_blank = edje_object_add(evas_object_evas_get(obj));
 820    _elm_theme_object_set(obj, wd->right_blank, "diskselector", "item",
 821                          "default");
 822    evas_object_size_hint_weight_set(wd->right_blank, EVAS_HINT_EXPAND,
 823                                     EVAS_HINT_EXPAND);
 824    evas_object_size_hint_align_set(wd->right_blank, EVAS_HINT_FILL,
 825                                    EVAS_HINT_FILL);
 826    elm_box_pack_end(wd->main_box, wd->right_blank);
 827    evas_object_show(wd->right_blank);
 828
 829    _theme_data_get(wd);
 830
 831    evas_object_smart_callback_add(obj, "sub-object-del", _sub_del, obj);
 832    evas_object_smart_callbacks_descriptions_set(obj, _signals);
 833    _sizing_eval(obj);
 834    return obj;
 835 }
 836
 837 EAPI Eina_Bool
 838 elm_diskselector_round_get(const Evas_Object *obj)
 839 {
 840    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 841    Widget_Data *wd = elm_widget_data_get(obj);
 842    if (!wd) return EINA_FALSE;
 843    return wd->round;
 844 }
 845
 846 EAPI void
 847 elm_diskselector_round_set(Evas_Object * obj, Eina_Bool round)
 848 {
 849    Eina_List *elist;
 850    Elm_Diskselector_Item *it;
 851
 852    ELM_CHECK_WIDTYPE(obj, widtype);
 853    Widget_Data *wd = elm_widget_data_get(obj);
 854    if (!wd) return;
 855
 856    if (wd->round == round)
 857      return;
 858
 859    wd->round = round;
 860    if (round)
 861      {
 862         wd->r_items = eina_list_clone(wd->items);
 863         elm_box_unpack(wd->main_box, wd->left_blank);
 864         evas_object_hide(wd->left_blank);
 865         elm_box_unpack(wd->main_box, wd->right_blank);
 866         evas_object_hide(wd->right_blank);
 867         if (!wd->items)
 868           return;
 869
 870         _round_items_add(wd);
 871
 872         if (wd->last)
 873           elm_box_pack_start(wd->main_box, wd->last->base.view);
 874         if (wd->s_last)
 875           elm_box_pack_start(wd->main_box, wd->s_last->base.view);
 876
 877         // if more than 3 items should be displayed
 878         EINA_LIST_FOREACH(wd->under_items, elist, it)
 879            elm_box_pack_start(wd->main_box, it->base.view);
 880
 881         if (wd->first)
 882           elm_box_pack_end(wd->main_box, wd->first->base.view);
 883         if (wd->second)
 884           elm_box_pack_end(wd->main_box, wd->second->base.view);
 885
 886         // if more than 3 items should be displayed
 887         EINA_LIST_FOREACH(wd->over_items, elist, it)
 888            elm_box_pack_end(wd->main_box, it->base.view);
 889      }
 890    else
 891      {
 892         _round_items_del(wd);
 893         elm_box_pack_start(wd->main_box, wd->left_blank);
 894         elm_box_pack_end(wd->main_box, wd->right_blank);
 895         eina_list_free(wd->r_items);
 896         wd->r_items = NULL;
 897      }
 898
 899    _selected_item_indicate(wd->selected_item);
 900    _sizing_eval(obj);
 901 }
 902
 903 EAPI int
 904 elm_diskselector_side_label_length_get(const Evas_Object *obj)
 905 {
 906    ELM_CHECK_WIDTYPE(obj, widtype) 0;
 907    Widget_Data *wd = elm_widget_data_get(obj);
 908    if (!wd) return 0;
 909    return wd->len_side;
 910 }
 911
 912 EAPI void
 913 elm_diskselector_side_label_length_set(Evas_Object *obj, int len)
 914 {
 915    ELM_CHECK_WIDTYPE(obj, widtype);
 916    Widget_Data *wd = elm_widget_data_get(obj);
 917    if (!wd) return;
 918    wd->len_side = len;
 919 }
 920
 921 EAPI void
 922 elm_diskselector_side_label_lenght_set(Evas_Object *obj, int len)
 923 {
 924    return elm_diskselector_side_label_length_set(obj, len);
 925 }
 926
 927 EAPI int
 928 elm_diskselector_side_label_lenght_get(const Evas_Object *obj)
 929 {
 930    return elm_diskselector_side_label_length_get(obj);
 931 }
 932
 933 EAPI void
 934 elm_diskselector_bounce_set(Evas_Object *obj, Eina_Bool h_bounce, Eina_Bool v_bounce)
 935 {
 936    ELM_CHECK_WIDTYPE(obj, widtype);
 937    Widget_Data *wd = elm_widget_data_get(obj);
 938    if (!wd) return;
 939    if (wd->scroller)
 940      elm_smart_scroller_bounce_allow_set(wd->scroller, h_bounce, v_bounce);
 941 }
 942
 943 EAPI void
 944 elm_diskselector_bounce_get(const Evas_Object *obj, Eina_Bool *h_bounce, Eina_Bool *v_bounce)
 945 {
 946    ELM_CHECK_WIDTYPE(obj, widtype);
 947    Widget_Data *wd = elm_widget_data_get(obj);
 948    if (!wd) return;
 949    elm_smart_scroller_bounce_allow_get(wd->scroller, h_bounce, v_bounce);
 950 }
 951
 952 EAPI void
 953 elm_diskselector_scroller_policy_get(const Evas_Object *obj, Elm_Scroller_Policy *policy_h, Elm_Scroller_Policy *policy_v)
 954 {
 955    ELM_CHECK_WIDTYPE(obj, widtype);
 956    Elm_Smart_Scroller_Policy s_policy_h, s_policy_v;
 957    Widget_Data *wd = elm_widget_data_get(obj);
 958    if ((!wd) || (!wd->scroller)) return;
 959    elm_smart_scroller_policy_get(wd->scroller, &s_policy_h, &s_policy_v);
 960    *policy_h = (Elm_Scroller_Policy) s_policy_h;
 961    *policy_v = (Elm_Scroller_Policy) s_policy_v;
 962 }
 963
 964 EAPI void
 965 elm_diskselector_scroller_policy_set(Evas_Object *obj, Elm_Scroller_Policy policy_h, Elm_Scroller_Policy policy_v)
 966 {
 967    ELM_CHECK_WIDTYPE(obj, widtype);
 968    Widget_Data *wd = elm_widget_data_get(obj);
 969    if ((!wd) || (!wd->scroller)) return;
 970    if ((policy_h >= ELM_SCROLLER_POLICY_LAST) ||
 971        (policy_v >= ELM_SCROLLER_POLICY_LAST))
 972      return;
 973    elm_smart_scroller_policy_set(wd->scroller, policy_h, policy_v);
 974 }
 975
 976 EAPI void
 977 elm_diskselector_clear(Evas_Object *obj)
 978 {
 979    ELM_CHECK_WIDTYPE(obj, widtype);
 980    Widget_Data *wd = elm_widget_data_get(obj);
 981    Elm_Diskselector_Item *it;
 982
 983    if (!wd) return;
 984    if (!wd->items) return;
 985
 986    wd->selected_item = NULL;
 987    EINA_LIST_FREE(wd->items, it) _item_del(it);
 988    _round_items_del(wd);
 989    _sizing_eval(obj);
 990 }
 991
 992 EAPI const Eina_List *
 993 elm_diskselector_items_get(const Evas_Object *obj)
 994 {
 995    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 996    Widget_Data *wd = elm_widget_data_get(obj);
 997    if (!wd) return NULL;
 998    return wd->items;
 999 }
1000
1001 EAPI Elm_Diskselector_Item *
1002 elm_diskselector_item_append(Evas_Object *obj, const char *label, Evas_Object *icon, Evas_Smart_Cb func, const void *data)
1003 {
1004    Elm_Diskselector_Item *it;
1005    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1006    Widget_Data *wd = elm_widget_data_get(obj);
1007    if (!wd) return NULL;
1008
1009    it = _item_new(obj, icon, label, func, data);
1010    wd->items = eina_list_append(wd->items, it);
1011    it->node = eina_list_last(wd->items);
1012    wd->item_count++;
1013    if (wd->round)
1014      {
1015         _round_items_del(wd);
1016         wd->r_items = eina_list_append(wd->r_items, it);
1017         _round_items_add(wd);
1018         if (wd->last)
1019           elm_box_pack_start(wd->main_box, wd->last->base.view);
1020         if (wd->s_last)
1021           elm_box_pack_start(wd->main_box, wd->s_last->base.view);
1022         elm_box_pack_end(wd->main_box, it->base.view);
1023         if (wd->first)
1024           elm_box_pack_end(wd->main_box, wd->first->base.view);
1025         if (wd->second)
1026           elm_box_pack_end(wd->main_box, wd->second->base.view);
1027      }
1028    else
1029      {
1030         elm_box_unpack(wd->main_box, wd->right_blank);
1031         elm_box_pack_end(wd->main_box, it->base.view);
1032         elm_box_pack_end(wd->main_box, wd->right_blank);
1033      }
1034    if (!wd->selected_item)
1035      wd->selected_item = it;
1036    if (!wd->idler)
1037      wd->idler = ecore_idle_enterer_before_add(_move_scroller, obj);
1038    _sizing_eval(obj);
1039    return it;
1040 }
1041
1042 EAPI void
1043 elm_diskselector_item_del(Elm_Diskselector_Item * it)
1044 {
1045    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it);
1046    Elm_Diskselector_Item *dit;
1047    Elm_Diskselector_Item *item;
1048    Eina_List *l;
1049    int i = 0;
1050    Widget_Data *wd = elm_widget_data_get(it->base.widget);
1051    if (!wd) return;
1052
1053    elm_box_unpack(wd->main_box, it->base.view);
1054
1055    if (wd->round)
1056      wd->r_items = eina_list_remove(wd->r_items, it);
1057
1058    wd->items = eina_list_remove(wd->items, it);
1059
1060    if (wd->selected_item == it)
1061      {
1062         dit = (Elm_Diskselector_Item *) eina_list_nth(wd->items, 0);
1063         if (dit != it)
1064           wd->selected_item = dit;
1065         else
1066           wd->selected_item = eina_list_nth(wd->items, 1);
1067
1068         _selected_item_indicate(wd->selected_item);
1069      }
1070
1071    _item_del(it);
1072    wd->item_count -= 1;
1073
1074    if (wd->round)
1075      {
1076         if (!wd->item_count)
1077           {
1078              evas_object_hide(wd->first->base.view);
1079              evas_object_hide(wd->second->base.view);
1080              evas_object_hide(wd->last->base.view);
1081              evas_object_hide(wd->s_last->base.view);
1082
1083              EINA_LIST_FOREACH(wd->under_items, l, item)
1084                 evas_object_hide(item->base.view);
1085
1086              EINA_LIST_FOREACH(wd->over_items, l, item)
1087                 evas_object_hide(item->base.view);
1088           }
1089         else
1090           {
1091              dit = eina_list_nth(wd->items, 0);
1092              if (dit)
1093                {
1094                   eina_stringshare_replace(&wd->first->label, dit->label);
1095                   edje_object_part_text_set(wd->first->base.view, "elm.text",
1096                                             wd->first->label);
1097                }
1098              dit = eina_list_nth(wd->items, 1);
1099              if (dit)
1100                {
1101                   eina_stringshare_replace(&wd->second->label, dit->label);
1102                   edje_object_part_text_set(wd->second->base.view, "elm.text",
1103                                             wd->second->label);
1104                }
1105              // if more than 3 itmes should be displayed
1106              for (i = 2; i < CEIL(wd->display_item_num); i++)
1107                {
1108                   dit = eina_list_nth(wd->items, i);
1109                   item = eina_list_nth(wd->over_items, i - 2);
1110                   eina_stringshare_replace(&item->label, dit->label);
1111                   edje_object_part_text_set(item->base.view, "elm.text", item->label);
1112                }
1113
1114              dit = eina_list_nth(wd->items, eina_list_count(wd->items) - 1);
1115              if (dit)
1116                {
1117                   eina_stringshare_replace(&wd->last->label, dit->label);
1118                   edje_object_part_text_set(wd->last->base.view, "elm.text",
1119                                             wd->last->label);
1120                }
1121              dit = eina_list_nth(wd->items, eina_list_count(wd->items) - 2);
1122              if (dit)
1123                {
1124                   eina_stringshare_replace(&wd->s_last->label, dit->label);
1125                   edje_object_part_text_set(wd->s_last->base.view, "elm.text",
1126                                             wd->s_last->label);
1127                }
1128              // if more than 3 itmes should be displayed
1129              for (i = 3; i <= CEIL(wd->display_item_num); i++)
1130                {
1131                   dit = eina_list_nth(wd->items, wd->item_count - i);
1132                   item = eina_list_nth(wd->under_items, i - 3);
1133                   eina_stringshare_replace(&item->label, dit->label);
1134                   edje_object_part_text_set(item->base.view, "elm.text", item->label);
1135                }
1136           }
1137      }
1138    wd->check_idler = ecore_idle_enterer_before_add(_check_string, wd);
1139    _sizing_eval(wd->self);
1140 }
1141
1142 EAPI const char *
1143 elm_diskselector_item_label_get(const Elm_Diskselector_Item * it)
1144 {
1145    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, NULL);
1146    return it->label;
1147 }
1148
1149 EAPI void
1150 elm_diskselector_item_label_set(Elm_Diskselector_Item * it, const char *label)
1151 {
1152    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it);
1153    eina_stringshare_replace(&it->label, label);
1154    edje_object_part_text_set(it->base.view, "elm.text", it->label);
1155 }
1156
1157 EAPI Elm_Diskselector_Item *
1158 elm_diskselector_selected_item_get(const Evas_Object *obj)
1159 {
1160    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1161    Widget_Data *wd = elm_widget_data_get(obj);
1162    if (!wd) return NULL;
1163    return wd->selected_item;
1164 }
1165
1166 EAPI void
1167 elm_diskselector_item_selected_set(Elm_Diskselector_Item *it, Eina_Bool selected)
1168 {
1169    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it);
1170    Widget_Data *wd;
1171    wd = elm_widget_data_get(it->base.widget);
1172    if (!wd) return;
1173
1174    if ((wd->selected_item == it) && (selected))
1175      return;
1176
1177    if ((wd->selected_item == it) && (!selected))
1178      wd->selected_item = eina_list_data_get(wd->items);
1179    else
1180      {
1181         wd->selected_item = it;
1182         _selected_item_indicate(wd->selected_item);
1183      }
1184
1185    if (!wd->idler)
1186      wd->idler = ecore_idle_enterer_before_add(_move_scroller, it->base.widget);
1187 }
1188
1189 EAPI Eina_Bool
1190 elm_diskselector_item_selected_get(const Elm_Diskselector_Item *it)
1191 {
1192    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, EINA_FALSE);
1193    Widget_Data *wd;
1194
1195    wd = elm_widget_data_get(it->base.widget);
1196    if (!wd) return EINA_FALSE;
1197    return (wd->selected_item == it);
1198 }
1199
1200 EAPI void
1201 elm_diskselector_item_del_cb_set(Elm_Diskselector_Item *it, Evas_Smart_Cb func)
1202 {
1203    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it);
1204    elm_widget_item_del_cb_set(it, func);
1205 }
1206
1207 EAPI void *
1208 elm_diskselector_item_data_get(const Elm_Diskselector_Item *it)
1209 {
1210    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, NULL);
1211    return elm_widget_item_data_get(it);
1212 }
1213
1214 EAPI Evas_Object *
1215 elm_diskselector_item_icon_get(const Elm_Diskselector_Item *it)
1216 {
1217    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, NULL);
1218    return it->icon;
1219 }
1220
1221 EAPI void
1222 elm_diskselector_item_icon_set(Elm_Diskselector_Item *it, Evas_Object *icon)
1223 {
1224    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it);
1225    if (it->icon == icon) return;
1226    if (it->icon)
1227      evas_object_del(it->icon);
1228    it->icon = icon;
1229    if (it->base.view)
1230      {
1231         evas_object_size_hint_min_set(it->icon, 24, 24);
1232         evas_object_size_hint_max_set(it->icon, 40, 40);
1233         edje_object_part_swallow(it->base.view, "elm.swallow.icon", it->icon);
1234         evas_object_show(it->icon);
1235         elm_widget_sub_object_add(it->base.widget, it->icon);
1236      }
1237 }
1238
1239 EAPI Elm_Diskselector_Item *
1240 elm_diskselector_item_prev_get(const Elm_Diskselector_Item *it)
1241 {
1242    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, NULL);
1243    if (it->node->prev) return it->node->prev->data;
1244    else return NULL;
1245 }
1246
1247 EAPI Elm_Diskselector_Item *
1248 elm_diskselector_item_next_get(const Elm_Diskselector_Item *it)
1249 {
1250    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, NULL);
1251    if (it->node->next) return it->node->next->data;
1252    else return NULL;
1253 }
1254
1255 EAPI Elm_Diskselector_Item *
1256 elm_diskselector_first_item_get(const Evas_Object *obj)
1257 {
1258    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1259    Widget_Data *wd;
1260
1261    wd = elm_widget_data_get(obj);
1262    if (!wd || !wd->items)
1263      return NULL;
1264
1265    return eina_list_data_get(wd->items);
1266 }
1267
1268 EAPI Elm_Diskselector_Item *
1269 elm_diskselector_last_item_get(const Evas_Object *obj)
1270 {
1271    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1272
1273    Widget_Data *wd;
1274    wd = elm_widget_data_get(obj);
1275    if (!wd || !wd->items)
1276      return NULL;
1277
1278    return eina_list_data_get(eina_list_last(wd->items));
1279 }
1280
1281 EAPI void
1282 elm_diskselector_item_tooltip_text_set(Elm_Diskselector_Item *item, const char *text)
1283 {
1284    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1285    elm_widget_item_tooltip_text_set(item, text);
1286 }
1287
1288 EAPI void
1289 elm_diskselector_item_tooltip_content_cb_set(Elm_Diskselector_Item *item, Elm_Tooltip_Item_Content_Cb func, const void *data, Evas_Smart_Cb del_cb)
1290 {
1291    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1292    elm_widget_item_tooltip_content_cb_set(item, func, data, del_cb);
1293 }
1294
1295 EAPI void
1296 elm_diskselector_item_tooltip_unset(Elm_Diskselector_Item *item)
1297 {
1298    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1299    elm_widget_item_tooltip_unset(item);
1300 }
1301
1302 EAPI void
1303 elm_diskselector_item_tooltip_style_set(Elm_Diskselector_Item *item, const char *style)
1304 {
1305    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1306    elm_widget_item_tooltip_style_set(item, style);
1307 }
1308
1309 EAPI const char *
1310 elm_diskselector_item_tooltip_style_get(const Elm_Diskselector_Item *item)
1311 {
1312    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item, NULL);
1313    return elm_widget_item_tooltip_style_get(item);
1314 }
1315
1316 EAPI void
1317 elm_diskselector_item_cursor_set(Elm_Diskselector_Item *item, const char *cursor)
1318 {
1319    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1320    elm_widget_item_cursor_set(item, cursor);
1321 }
1322
1323 EAPI const char *
1324 elm_diskselector_item_cursor_get(const Elm_Diskselector_Item *item)
1325 {
1326    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item, NULL);
1327    return elm_widget_item_cursor_get(item);
1328 }
1329
1330 EAPI void
1331 elm_diskselector_item_cursor_unset(Elm_Diskselector_Item *item)
1332 {
1333    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1334    elm_widget_item_cursor_unset(item);
1335 }
1336
1337 EAPI void
1338 elm_diskselector_item_cursor_style_set(Elm_Diskselector_Item *item, const char *style)
1339 {
1340    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1341    elm_widget_item_cursor_style_set(item, style);
1342 }
1343
1344 EAPI const char *
1345 elm_diskselector_item_cursor_style_get(const Elm_Diskselector_Item *item)
1346 {
1347    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item, NULL);
1348    return elm_widget_item_cursor_style_get(item);
1349 }
1350
1351 EAPI void
1352 elm_diskselector_item_cursor_engine_only_set(Elm_Diskselector_Item *item, Eina_Bool engine_only)
1353 {
1354    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1355    elm_widget_item_cursor_engine_only_set(item, engine_only);
1356 }
1357
1358 EAPI Eina_Bool
1359 elm_diskselector_item_cursor_engine_only_get(const Elm_Diskselector_Item *item)
1360 {
1361    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item, EINA_FALSE);
1362    return elm_widget_item_cursor_engine_only_get(item);
1363 }
1364
1365 EAPI void
1366 elm_diskselector_display_item_num_set(Evas_Object *obj, int num)
1367 {
1368    ELM_CHECK_WIDTYPE(obj, widtype);
1369    Widget_Data *wd = elm_widget_data_get(obj);
1370    if (!wd) return;
1371    if (num < DISPLAY_ITEM_NUM_MIN) num = DISPLAY_ITEM_NUM_MIN;
1372    wd->display_item_num = num;
1373    wd->display_item_num_by_api = EINA_TRUE;
1374 }
1375
1376 EAPI int
1377 elm_diskselector_display_item_num_get(const Evas_Object *item)
1378 {
1379    ELM_CHECK_WIDTYPE(item, widtype) (-1);
1380    Widget_Data *wd = elm_widget_data_get(item);
1381    if (!wd) return -1;
1382    return wd->display_item_num;
1383 }