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