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