src/lib/elm_diskselector.c

   1 /**
   2  * @defgroup Diskselector
   3  *
   4  * A diskselector is a kind of list widget. It scrolls horizontally,
   5  * and can contain label and icon objects. Three items are displayed
   6  * with the selected on the middle.
   7  *
   8  * It can act like a circular list with round mode and labels can be
   9  * reduced for a defined length for side items.
  10  *
  11  * Signals that you can add callbacks for are:
  12  *
  13  * "selected" - when item is selected (scroller stops)
  14  */
  15
  16 #include <Elementary.h>
  17 #include "elm_priv.h"
  18
  19 #ifndef MAX
  20 # define MAX(a, b) (((a) > (b)) ? (a) : (b))
  21 #endif
  22
  23 #ifndef CEIL
  24 #define CEIL(a) (((a) % 2 != 0) ? ((a) / 2 + 1) : ((a) / 2))
  25 #endif
  26
  27 #define DISPLAY_ITEM_NUM_MIN 3
  28
  29 typedef struct _Widget_Data Widget_Data;
  30
  31 struct _Widget_Data
  32 {
  33    Evas_Object *self;
  34    Evas_Object *scroller;
  35    Evas_Object *main_box;
  36    Evas_Object *left_blank;
  37    Evas_Object *right_blank;
  38    Elm_Diskselector_Item *selected_item;
  39    Elm_Diskselector_Item *first;
  40    Elm_Diskselector_Item *second;
  41    Elm_Diskselector_Item *s_last;
  42    Elm_Diskselector_Item *last;
  43    Eina_List *items;
  44    Eina_List *r_items;
  45    Eina_List *over_items;
  46    Eina_List *under_items;
  47    int item_count, len_threshold, len_side, display_item_num;
  48    Ecore_Idler *idler;
  49    Ecore_Idler *check_idler;
  50    Evas_Coord minw, minh;
  51    Eina_Bool init:1;
  52    Eina_Bool round:1;
  53    Eina_Bool display_item_num_by_api:1;
  54 };
  55
  56 struct _Elm_Diskselector_Item
  57 {
  58    Elm_Widget_Item base;
  59    Eina_List *node;
  60    Evas_Object *icon;
  61    const char *label;
  62    Evas_Smart_Cb func;
  63 };
  64
  65 static const char *widtype = NULL;
  66
  67 #define ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, ...)                  \
  68    ELM_WIDGET_ITEM_CHECK_OR_RETURN((Elm_Widget_Item *)it, __VA_ARGS__); \
  69    ELM_CHECK_WIDTYPE(it->base.widget, widtype) __VA_ARGS__;
  70
  71 static Eina_Bool _move_scroller(void *data);
  72 static void _del_hook(Evas_Object * obj);
  73 static void _del_pre_hook(Evas_Object * obj);
  74 static void _sizing_eval(Evas_Object * obj);
  75 static void _theme_hook(Evas_Object * obj);
  76 static void _on_focus_hook(void *data, Evas_Object *obj);
  77 static Eina_Bool _event_hook(Evas_Object *obj, Evas_Object *src, Evas_Callback_Type type, void *event_info);
  78 static void _sub_del(void *data, Evas_Object * obj, void *event_info);
  79 static void _round_items_del(Widget_Data *wd);
  80 static void _scroller_move_cb(void *data, Evas_Object *obj, void *event_info);
  81 static void _item_click_cb(void *data, Evas_Object *obj __UNUSED__,
  82                            const char *emission __UNUSED__,
  83                            const char *source __UNUSED__);
  84 static void _selected_item_indicate(Elm_Diskselector_Item *it);
  85
  86 static const char SIG_SELECTED[] = "selected";
  87 static const Evas_Smart_Cb_Description _signals[] = {
  88        {SIG_SELECTED, ""},
  89        {NULL, NULL}
  90 };
  91
  92 static void
  93 _diskselector_object_resize(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
  94 {
  95    Widget_Data *wd;
  96    Evas_Coord w, h;
  97
  98    wd = elm_widget_data_get(data);
  99    if (!wd) return;
 100
 101    if (wd->minw == -1 && wd->minh == -1) elm_coords_finger_size_adjust(6, &wd->minw, 1, &wd->minh);
 102    edje_object_size_min_restricted_calc(elm_smart_scroller_edje_object_get(
 103          wd->scroller), &wd->minw, &wd->minh, wd->minw, wd->minh);
 104    evas_object_size_hint_min_set(obj, wd->minw, wd->minh);
 105    evas_object_size_hint_max_set(obj, -1, -1);
 106
 107    evas_object_geometry_get(wd->scroller, NULL, NULL, &w, &h);
 108    if (wd->round)
 109      evas_object_resize(wd->main_box, (w / wd->display_item_num) * (wd->item_count + (CEIL(wd->display_item_num) * 2)), h);
 110    else
 111      evas_object_resize(wd->main_box, (w / wd->display_item_num) * (wd->item_count + CEIL(wd->display_item_num)), h);
 112
 113    elm_smart_scroller_paging_set(wd->scroller, 0, 0,
 114                                  (int)(w / wd->display_item_num), 0);
 115
 116    if (!wd->idler)
 117      wd->idler = ecore_idler_add(_move_scroller, data);
 118 }
 119
 120 static Elm_Diskselector_Item *
 121 _item_new(Evas_Object *obj, Evas_Object *icon, const char *label, Evas_Smart_Cb func, const void *data)
 122 {
 123    Elm_Diskselector_Item *it;
 124    const char *style = elm_widget_style_get(obj);
 125
 126    it = elm_widget_item_new(obj, Elm_Diskselector_Item);
 127    if (!it) return NULL;
 128
 129    it->label = eina_stringshare_add(label);
 130    it->icon = icon;
 131    it->func = func;
 132    it->base.data = data;
 133    it->base.view = edje_object_add(evas_object_evas_get(obj));
 134    _elm_theme_object_set(obj, it->base.view, "diskselector", "item", style);
 135    evas_object_size_hint_weight_set(it->base.view, EVAS_HINT_EXPAND,
 136                                     EVAS_HINT_EXPAND);
 137    evas_object_size_hint_align_set(it->base.view, EVAS_HINT_FILL,
 138                                    EVAS_HINT_FILL);
 139    evas_object_show(it->base.view);
 140
 141    if (it->label)
 142      {
 143         edje_object_part_text_set(it->base.view, "elm.text", it->label);
 144         edje_object_signal_callback_add(it->base.view, "elm,action,click", "", _item_click_cb, it);
 145      }
 146    if (it->icon)
 147      {
 148         evas_object_size_hint_min_set(it->icon, 24, 24);
 149         evas_object_size_hint_max_set(it->icon, 40, 40);
 150         edje_object_part_swallow(it->base.view, "elm.swallow.icon", it->icon);
 151         evas_object_show(it->icon);
 152         elm_widget_sub_object_add(obj, it->icon);
 153      }
 154    return it;
 155 }
 156
 157 static void
 158 _item_del(Elm_Diskselector_Item *item)
 159 {
 160    if (!item) return;
 161    eina_stringshare_del(item->label);
 162    if (item->icon)
 163      evas_object_del(item->icon);
 164    elm_widget_item_del(item);
 165 }
 166
 167 static void
 168 _theme_data_get(Widget_Data *wd)
 169 {
 170    const char* str;
 171    Evas_Object *parent;
 172    str = edje_object_data_get(wd->right_blank, "len_threshold");
 173    if (str) wd->len_threshold = MAX(0, atoi(str));
 174    else wd->len_threshold = 0;
 175
 176    if (!wd->display_item_num_by_api)
 177      {
 178         str = edje_object_data_get(wd->right_blank, "display_item_num");
 179         if (str) wd->display_item_num = MAX(DISPLAY_ITEM_NUM_MIN, atoi(str));
 180         else wd->display_item_num = DISPLAY_ITEM_NUM_MIN;
 181      }
 182
 183    str = edje_object_data_get(wd->right_blank, "min_width");
 184    if (str) wd->minw = MAX(-1, atoi(str));
 185    else
 186      {
 187         parent = elm_widget_parent_widget_get(wd->self);
 188         if (!parent) wd->minw = -1;
 189         else evas_object_geometry_get(parent, NULL, NULL, &wd->minw, NULL);
 190      }
 191
 192    str = edje_object_data_get(wd->right_blank, "min_height");
 193    if (str) wd->minh = MAX(-1, atoi(str));
 194    else wd->minh = -1;
 195 }
 196
 197 static void
 198 _default_display_item_num_set(Widget_Data *wd)
 199 {
 200    const char* str;
 201    str = edje_object_data_get(wd->right_blank, "display_item_num");
 202    if (str) wd->display_item_num = MAX(DISPLAY_ITEM_NUM_MIN, atoi(str));
 203    else wd->display_item_num = DISPLAY_ITEM_NUM_MIN;
 204 }
 205
 206 static void
 207 _del_hook(Evas_Object * obj)
 208 {
 209    Widget_Data *wd = elm_widget_data_get(obj);
 210    if (!wd) return;
 211    free(wd);
 212 }
 213
 214 static void
 215 _del_pre_hook(Evas_Object * obj)
 216 {
 217    Elm_Diskselector_Item *it;
 218    Eina_List *l;
 219
 220    Widget_Data *wd = elm_widget_data_get(obj);
 221    if (!wd) return;
 222
 223    if (wd->left_blank)
 224      evas_object_del(wd->left_blank);
 225    if (wd->right_blank)
 226      evas_object_del(wd->right_blank);
 227    if (wd->last)
 228      {
 229         eina_stringshare_del(wd->last->label);
 230         evas_object_del(wd->last->base.view);
 231         free(wd->last);
 232      }
 233    if (wd->s_last)
 234      {
 235         eina_stringshare_del(wd->s_last->label);
 236         evas_object_del(wd->s_last->base.view);
 237         free(wd->s_last);
 238      }
 239    if (wd->second)
 240      {
 241         eina_stringshare_del(wd->second->label);
 242         evas_object_del(wd->second->base.view);
 243         free(wd->second);
 244      }
 245    if (wd->first)
 246      {
 247         eina_stringshare_del(wd->first->label);
 248         evas_object_del(wd->first->base.view);
 249         free(wd->first);
 250      }
 251
 252    EINA_LIST_FOREACH(wd->under_items, l, it)
 253      {
 254         if (it)
 255           {
 256              eina_stringshare_del(it->label);
 257              evas_object_del(wd->first->base.view);
 258              free(it);
 259           }
 260      }
 261
 262    EINA_LIST_FOREACH(wd->over_items, l, it)
 263    {
 264      if (it)
 265         {
 266            eina_stringshare_del(it->label);
 267            evas_object_del(wd->first->base.view);
 268            free(it);
 269         }
 270    }
 271
 272    EINA_LIST_FREE(wd->items, it) _item_del(it);
 273    eina_list_free(wd->r_items);
 274 }
 275
 276 static void
 277 _sizing_eval(Evas_Object * obj)
 278 {
 279    Widget_Data *wd = elm_widget_data_get(obj);
 280    if (!wd) return;
 281    _diskselector_object_resize(obj, NULL, obj, NULL);
 282 }
 283
 284 static void
 285 _theme_hook(Evas_Object * obj)
 286 {
 287    Eina_List *l;
 288    Elm_Diskselector_Item *it;
 289    Widget_Data *wd = elm_widget_data_get(obj);
 290    if (!wd) return;
 291
 292    if (wd->scroller)
 293      elm_smart_scroller_object_theme_set(obj, wd->scroller, "diskselector",
 294                                          "base", elm_widget_style_get(obj));
 295    if (wd->round)
 296      {
 297         EINA_LIST_FOREACH(wd->r_items, l, it)
 298           {
 299              _elm_theme_object_set(obj, it->base.view, "diskselector", "item",
 300                                    elm_widget_style_get(obj));
 301              edje_object_part_text_set(it->base.view, "elm.text", it->label);
 302           }
 303      }
 304    else
 305      {
 306         EINA_LIST_FOREACH(wd->items, l, it)
 307           {
 308              _elm_theme_object_set(obj, it->base.view, "diskselector", "item",
 309                                    elm_widget_style_get(obj));
 310              edje_object_part_text_set(it->base.view, "elm.text", it->label);
 311           }
 312      }
 313    _elm_theme_object_set(obj, wd->right_blank, "diskselector", "item",
 314                                    elm_widget_style_get(obj));
 315    _theme_data_get(wd);
 316    _sizing_eval(obj);
 317 }
 318
 319 static void
 320 _sub_del(void *data __UNUSED__, Evas_Object * obj, void *event_info)
 321 {
 322    Widget_Data *wd = elm_widget_data_get(obj);
 323    Evas_Object *sub = event_info;
 324    Elm_Diskselector_Item *it;
 325    const Eina_List *l;
 326
 327    if (!wd) return;
 328    if (!sub) abort();
 329    if (sub == wd->scroller)
 330      wd->scroller = NULL;
 331    else
 332      {
 333         EINA_LIST_FOREACH(wd->items, l, it)
 334           {
 335              if (sub == it->icon)
 336                {
 337                   it->icon = NULL;
 338                   _sizing_eval(obj);
 339                   break;
 340                }
 341           }
 342      }
 343 }
 344
 345 static void
 346 _select_item(Elm_Diskselector_Item *it)
 347 {
 348    if (!it) return;
 349    Widget_Data *wd = elm_widget_data_get(it->base.widget);
 350    wd->selected_item = it;
 351    _selected_item_indicate(wd->selected_item);
 352    if (it->func) it->func((void *)it->base.data, it->base.widget, it);
 353    evas_object_smart_callback_call(it->base.widget, SIG_SELECTED, it);
 354 }
 355
 356 static void
 357 _on_focus_hook(void *data __UNUSED__, Evas_Object *obj)
 358 {
 359    Widget_Data *wd = elm_widget_data_get(obj);
 360    if (!wd)
 361      return;
 362
 363    if (elm_widget_focus_get(obj))
 364      {
 365         edje_object_signal_emit(wd->self, "elm,action,focus", "elm");
 366         evas_object_focus_set(wd->self, EINA_TRUE);
 367      }
 368    else
 369      {
 370         edje_object_signal_emit(wd->self, "elm,action,unfocus", "elm");
 371         evas_object_focus_set(wd->self, EINA_FALSE);
 372      }
 373 }
 374
 375 static Eina_Bool
 376 _event_hook(Evas_Object *obj, Evas_Object *src __UNUSED__, Evas_Callback_Type type, void *event_info)
 377 {
 378    if (type != EVAS_CALLBACK_KEY_DOWN) return EINA_FALSE;
 379    Evas_Event_Key_Down *ev = event_info;
 380    Widget_Data *wd = elm_widget_data_get(obj);
 381    if (!wd) return EINA_FALSE;
 382    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return EINA_FALSE;
 383    if (elm_widget_disabled_get(obj)) return EINA_FALSE;
 384
 385    Elm_Diskselector_Item *it = NULL;
 386    Eina_List *l;
 387
 388    if (!wd->selected_item) {
 389         ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 390         return EINA_TRUE;
 391    }
 392
 393    if ((!strcmp(ev->keyname, "Left")) || (!strcmp(ev->keyname, "KP_Left")) ||
 394        (!strcmp(ev->keyname, "Up"))  || (!strcmp(ev->keyname, "KP_Up")))
 395      {
 396         l = wd->selected_item->node->prev;
 397         if ((!l) && (wd->round))
 398           l = eina_list_last(wd->items);
 399      }
 400    else if ((!strcmp(ev->keyname, "Right")) || (!strcmp(ev->keyname, "KP_Right")) ||
 401             (!strcmp(ev->keyname, "Down")) || (!strcmp(ev->keyname, "KP_Down")))
 402      {
 403         l = wd->selected_item->node->next;
 404         if ((!l) && (wd->round))
 405           l = wd->items;
 406      }
 407    else if ((!strcmp(ev->keyname, "Home")) || (!strcmp(ev->keyname, "KP_Home")))
 408      l = wd->items;
 409    else if ((!strcmp(ev->keyname, "End")) || (!strcmp(ev->keyname, "KP_End")))
 410      l = eina_list_last(wd->items);
 411    else return EINA_FALSE;
 412
 413    if (l)
 414      it = eina_list_data_get(l);
 415
 416    if (it)
 417      {
 418         wd->selected_item = it;
 419         if (!wd->idler)
 420           wd->idler = ecore_idler_add(_move_scroller, obj);
 421      }
 422
 423    ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 424    return EINA_TRUE;
 425 }
 426
 427 static int
 428 _count_letter(const char *str)
 429 {
 430    int pos = 0;
 431    int code = 0, chnum;
 432
 433    for (chnum = 0; ; chnum++)
 434      {
 435         pos = evas_string_char_next_get(str, pos, &code);
 436         if (code == 0) break;
 437      }
 438    return chnum;
 439 }
 440
 441 static int
 442 _check_letter(const char *str, int length)
 443 {
 444    int pos = 0;
 445    int code = 0, chnum;
 446
 447    for (chnum = 0; ; chnum++)
 448      {
 449         if (chnum == length) break;
 450         pos = evas_string_char_next_get(str, pos, &code);
 451         if (code == 0) break;
 452      }
 453    return pos;
 454 }
 455
 456 static Eina_Bool
 457 _check_string(void *data)
 458 {
 459    int mid, steps, length, diff;
 460    Elm_Diskselector_Item *it;
 461    Eina_List *list, *l;
 462    Evas_Coord ox, ow;
 463    char buf[1024];
 464    Widget_Data *wd = data;
 465
 466    evas_object_geometry_get(wd->scroller, &ox, NULL, &ow, NULL);
 467    if (ow <= 0)
 468      return EINA_FALSE;
 469    if (!wd->init)
 470      return EINA_FALSE;
 471    if (!wd->round)
 472      list = wd->items;
 473    else
 474      list = wd->r_items;
 475
 476    EINA_LIST_FOREACH(list, l, it)
 477      {
 478         Evas_Coord x, w;
 479         int len;
 480         evas_object_geometry_get(it->base.view, &x, NULL, &w, NULL);
 481         /* item not visible */
 482         if ((x + w <= ox) || (x >= ox + ow))
 483           continue;
 484
 485         len = _count_letter(it->label);
 486 //        // FIXME: len should be # of ut8f letters. ie count using utf8 string walk, not stringshare len
 487 //        len = eina_stringshare_strlen(it->label);
 488
 489         if (x <= ox + 5)
 490           edje_object_signal_emit(it->base.view, "elm,state,left_side",
 491                                   "elm");
 492         else if (x + w >= ox + ow - 5)
 493           edje_object_signal_emit(it->base.view, "elm,state,right_side",
 494                                   "elm");
 495         else
 496           {
 497              if ((wd->len_threshold) && (len > wd->len_threshold))
 498                edje_object_signal_emit(it->base.view, "elm,state,center_small",
 499                                        "elm");
 500              else
 501                edje_object_signal_emit(it->base.view, "elm,state,center",
 502                                        "elm");
 503           }
 504
 505         // if len is les that the limit len, skip anyway
 506         if (len <= wd->len_side)
 507           continue;
 508
 509         steps = len - wd->len_side + 1;
 510         mid = x + w / 2;
 511         if (mid <= ox + ow / 2)
 512           diff = (ox + ow / 2) - mid;
 513         else
 514           diff = mid - (ox + ow / 2);
 515
 516         length = len - (int)(diff * steps / (ow / 3));
 517         length = MAX(length, wd->len_side);
 518         // limit string len to "length" ut8f chars
 519         length = _check_letter(it->label, length);
 520         // cut it off at byte mark returned form _check_letter
 521         strncpy(buf, it->label, length);
 522         buf[length] = '\0';
 523         edje_object_part_text_set(it->base.view, "elm.text", buf);
 524      }
 525
 526    if (wd->check_idler)
 527      ecore_idler_del(wd->check_idler);
 528    wd->check_idler = NULL;
 529    return EINA_FALSE;
 530 }
 531
 532 static void
 533 _selected_item_indicate(Elm_Diskselector_Item *it)
 534 {
 535    Elm_Diskselector_Item *item;
 536    Eina_List *l;
 537    Widget_Data *wd;
 538    wd = elm_widget_data_get(it->base.widget);
 539
 540    if (!wd) return;
 541
 542    EINA_LIST_FOREACH(wd->r_items, l, item)
 543      {
 544         if (!strcmp(item->label, it->label)) edje_object_signal_emit(item->base.view, "elm,state,selected", "elm");
 545         else
 546            edje_object_signal_emit(item->base.view, "elm,state,default", "elm");
 547      }
 548 }
 549
 550 static void
 551 _item_click_cb(void *data, Evas_Object *obj __UNUSED__,
 552                const char *emission __UNUSED__, const char *source __UNUSED__)
 553 {
 554    Elm_Diskselector_Item *it = data;
 555
 556    if (!it) return;
 557
 558    Widget_Data *wd;
 559    wd = elm_widget_data_get(it->base.widget);
 560
 561    if (!wd) return;
 562
 563    if (wd->selected_item != it)
 564      {
 565         wd->selected_item = it;
 566         _selected_item_indicate(wd->selected_item);
 567      }
 568
 569    if (it->func) it->func((void *)it->base.data, it->base.widget, it);
 570 }
 571
 572 static void
 573 _scroller_move_cb(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 574 {
 575    Evas_Coord x, y, w, h, bw;
 576    Widget_Data *wd = data;
 577
 578    _check_string(wd);
 579    elm_smart_scroller_child_pos_get(obj, &x, &y);
 580    elm_smart_scroller_child_viewport_size_get(obj, &w, &h);
 581    if (wd->round)
 582      {
 583         evas_object_geometry_get(wd->main_box, NULL, NULL, &bw, NULL);
 584         if (x > ((w / wd->display_item_num) * (wd->item_count + (wd->display_item_num % 2))))
 585            elm_smart_scroller_child_region_show(wd->scroller,
 586                                                x - ((w / wd->display_item_num) * wd->item_count),
 587                                                y, w, h);
 588         else if (x < 0)
 589            elm_smart_scroller_child_region_show(wd->scroller,
 590                                                x + ((w / wd->display_item_num) * wd->item_count),
 591                                                y, w, h);
 592      }
 593 }
 594
 595 static void
 596 _scroller_stop_cb(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
 597 {
 598    Elm_Diskselector_Item *it;
 599    Widget_Data *wd = data;
 600    Evas_Coord x, w, ow;
 601    Eina_List *l, *list;
 602
 603    if (wd->idler)
 604      return;
 605
 606    if (!wd->round)
 607      list = wd->items;
 608    else
 609      list = wd->r_items;
 610
 611    evas_object_geometry_get(wd->scroller, NULL, NULL, &ow, NULL);
 612    EINA_LIST_FOREACH(list, l, it)
 613      {
 614         evas_object_geometry_get(it->base.view, &x, NULL, &w, NULL);
 615         if (abs((int)(ow / 2 - (int)(x + w / 2))) < 10)
 616           break;
 617      }
 618
 619    if (!it)
 620      return;
 621
 622    _select_item(it);
 623 }
 624
 625 static Eina_Bool
 626 _move_scroller(void *data)
 627 {
 628    Evas_Object *obj = data;
 629    Widget_Data *wd;
 630    Eina_List *l;
 631    Elm_Diskselector_Item *dit;
 632    Evas_Coord y, w, h;
 633    int i;
 634
 635    wd = elm_widget_data_get(obj);
 636    if (!wd) return EINA_FALSE;
 637
 638    if (wd->round)
 639      i = 1;
 640    else
 641      i = 0;
 642
 643    EINA_LIST_FOREACH(wd->items, l, dit)
 644      {
 645         if (wd->selected_item == dit)
 646           break;
 647         i++;
 648      }
 649    if (!dit)
 650      {
 651         wd->selected_item =
 652            (Elm_Diskselector_Item *) eina_list_nth(wd->items, 0);
 653         return EINA_FALSE;
 654      }
 655
 656    evas_object_geometry_get(wd->scroller, NULL, &y, &w, &h);
 657    //move scroller in two steps for getting smooth launching effect.
 658    if (i > 2)
 659      elm_smart_scroller_child_region_show(wd->scroller, w / wd->display_item_num * (i-2), y, w, h);
 660    elm_smart_scroller_region_bring_in(wd->scroller, w / wd->display_item_num * i, y, w, h);
 661
 662    _select_item(dit);
 663    if (wd->idler)
 664      {
 665         ecore_idler_del(wd->idler);
 666         wd->idler = NULL;
 667      }
 668    wd->init = EINA_TRUE;
 669    _check_string(wd);
 670
 671    return EINA_TRUE;
 672 }
 673
 674 static void
 675 _round_item_del(Widget_Data *wd, Elm_Diskselector_Item *it)
 676 {
 677    if (!it) return;
 678    elm_box_unpack(wd->main_box, it->base.view);
 679    wd->r_items = eina_list_remove(wd->r_items, it);
 680    eina_stringshare_del(it->label);
 681    evas_object_del(it->base.view);
 682    free(it);
 683 }
 684
 685 static void
 686 _round_items_del(Widget_Data *wd)
 687 {
 688    Eina_List *l;
 689    Elm_Diskselector_Item * it;
 690
 691    _round_item_del(wd, wd->last);
 692    wd->last = NULL;
 693    _round_item_del(wd, wd->s_last);
 694    wd->s_last = NULL;
 695    _round_item_del(wd, wd->second);
 696    wd->second = NULL;
 697    _round_item_del(wd, wd->first);
 698    wd->first = NULL;
 699
 700    EINA_LIST_FOREACH(wd->under_items, l, it)
 701      {
 702         _round_item_del(wd, it);
 703         it = NULL;
 704      }
 705
 706    EINA_LIST_FOREACH(wd->over_items, l, it)
 707      {
 708         _round_item_del(wd, it);
 709         it = NULL;
 710      }
 711 }
 712
 713 static void
 714 _round_items_add(Widget_Data *wd)
 715 {
 716    Elm_Diskselector_Item *dit;
 717    Elm_Diskselector_Item *it;
 718    Elm_Diskselector_Item *temp_it;
 719    int i = 0;
 720    dit = it = eina_list_nth(wd->items, 0);
 721    if (!dit) return;
 722
 723    if (!wd->first)
 724      {
 725         wd->first = _item_new(it->base.widget, it->icon, it->label, it->func,
 726                               it->base.data);
 727         wd->first->node = it->node;
 728         wd->r_items = eina_list_append(wd->r_items, wd->first);
 729      }
 730
 731    it = eina_list_nth(wd->items, 1);
 732    if (!it)
 733      it = dit;
 734    if (!wd->second)
 735      {
 736         wd->second = _item_new(it->base.widget, it->icon, it->label, it->func,
 737                                it->base.data);
 738         wd->second->node = it->node;
 739         wd->r_items = eina_list_append(wd->r_items, wd->second);
 740      }
 741
 742    // if more than 3 itmes should be displayed
 743    for (i = 2; i < CEIL(wd->display_item_num); i++)
 744      {
 745         it = eina_list_nth(wd->items, i);
 746         if (!it) it = dit;
 747         temp_it = _item_new(it->base.widget, it->icon, it->label, it->func, it->base.data);
 748         wd->over_items = eina_list_append(wd->over_items, temp_it);
 749         wd->r_items = eina_list_append(wd->r_items, temp_it);
 750      }
 751
 752    it = eina_list_nth(wd->items, wd->item_count - 1);
 753    if (!it)
 754      it = dit;
 755    if (!wd->last)
 756      {
 757         wd->last = _item_new(it->base.widget, it->icon, it->label, it->func,
 758                              it->base.data);
 759         wd->last->node = it->node;
 760         wd->r_items = eina_list_prepend(wd->r_items, wd->last);
 761      }
 762
 763    it = eina_list_nth(wd->items, wd->item_count - 2);
 764    if (!it)
 765      it = dit;
 766    if (!wd->s_last)
 767      {
 768         wd->s_last = _item_new(it->base.widget, it->icon, it->label, it->func,
 769                                it->base.data);
 770         wd->s_last->node = it->node;
 771         wd->r_items = eina_list_prepend(wd->r_items, wd->s_last);
 772      }
 773
 774    // if more than 3 itmes should be displayed
 775    for (i = 3; i <= CEIL(wd->display_item_num); i++)
 776      {
 777         it = eina_list_nth(wd->items, wd->item_count - i);
 778         if (!it) it = dit;
 779         temp_it = _item_new(it->base.widget, it->icon, it->label, it->func, it->base.data);
 780         wd->under_items = eina_list_append(wd->under_items, temp_it);
 781         wd->r_items = eina_list_prepend(wd->r_items, temp_it);
 782      }
 783 }
 784
 785 /**
 786  * Add a new diskselector object
 787  *
 788  * @param parent The parent object
 789  * @return The new object or NULL if it cannot be created
 790  *
 791  * @ingroup Diskselector
 792  */
 793 EAPI Evas_Object *
 794 elm_diskselector_add(Evas_Object *parent)
 795 {
 796    Evas *e;
 797    Evas_Object *obj;
 798    Widget_Data *wd;
 799
 800    ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
 801
 802    ELM_SET_WIDTYPE(widtype, "diskselector");
 803    elm_widget_type_set(obj, "diskselector");
 804    elm_widget_sub_object_add(parent, obj);
 805    elm_widget_data_set(obj, wd);
 806    elm_widget_del_hook_set(obj, _del_hook);
 807    elm_widget_del_pre_hook_set(obj, _del_pre_hook);
 808    elm_widget_theme_hook_set(obj, _theme_hook);
 809    elm_widget_can_focus_set(obj, EINA_TRUE);
 810    elm_widget_on_focus_hook_set(obj, _on_focus_hook, NULL);
 811    elm_widget_event_hook_set(obj, _event_hook);
 812
 813    wd->self = obj;
 814    wd->item_count = 0;
 815    wd->round = EINA_FALSE;
 816    wd->init = EINA_FALSE;
 817    wd->len_side = 3;
 818    wd->display_item_num_by_api = EINA_FALSE;
 819
 820    wd->scroller = elm_smart_scroller_add(e);
 821    elm_smart_scroller_widget_set(wd->scroller, obj);
 822    _theme_hook(obj);
 823    elm_widget_resize_object_set(obj, wd->scroller);
 824    elm_smart_scroller_policy_set(wd->scroller, ELM_SMART_SCROLLER_POLICY_OFF,
 825                                  ELM_SMART_SCROLLER_POLICY_OFF);
 826    elm_smart_scroller_bounce_allow_set(wd->scroller, EINA_TRUE, EINA_FALSE);
 827    evas_object_smart_callback_add(wd->scroller, "scroll", _scroller_move_cb,
 828                                   wd);
 829    evas_object_smart_callback_add(wd->scroller, "animate,stop",
 830                                   _scroller_stop_cb, wd);
 831    _elm_theme_object_set(obj, wd->scroller, "diskselector", "base",
 832                          "default");
 833    evas_object_event_callback_add(wd->scroller, EVAS_CALLBACK_RESIZE,
 834                                   _diskselector_object_resize, obj);
 835
 836    wd->main_box = elm_box_add(parent);
 837    elm_box_horizontal_set(wd->main_box, EINA_TRUE);
 838    elm_box_homogeneous_set(wd->main_box, EINA_TRUE);
 839    evas_object_size_hint_weight_set(wd->main_box, EVAS_HINT_EXPAND,
 840                                     EVAS_HINT_EXPAND);
 841    evas_object_size_hint_align_set(wd->main_box, EVAS_HINT_FILL,
 842                                    EVAS_HINT_FILL);
 843    _elm_theme_object_set(obj, wd->main_box, "diskselector", "base",
 844                          "default");
 845    elm_widget_sub_object_add(obj, wd->main_box);
 846
 847    elm_smart_scroller_child_set(wd->scroller, wd->main_box);
 848
 849    wd->left_blank = edje_object_add(evas_object_evas_get(obj));
 850    _elm_theme_object_set(obj, wd->left_blank, "diskselector", "item",
 851                          "default");
 852    evas_object_size_hint_weight_set(wd->left_blank, EVAS_HINT_EXPAND,
 853                                     EVAS_HINT_EXPAND);
 854    evas_object_size_hint_align_set(wd->left_blank, EVAS_HINT_FILL,
 855                                    EVAS_HINT_FILL);
 856    elm_box_pack_end(wd->main_box, wd->left_blank);
 857    evas_object_show(wd->left_blank);
 858
 859    wd->right_blank = edje_object_add(evas_object_evas_get(obj));
 860    _elm_theme_object_set(obj, wd->right_blank, "diskselector", "item",
 861                          "default");
 862    evas_object_size_hint_weight_set(wd->right_blank, EVAS_HINT_EXPAND,
 863                                     EVAS_HINT_EXPAND);
 864    evas_object_size_hint_align_set(wd->right_blank, EVAS_HINT_FILL,
 865                                    EVAS_HINT_FILL);
 866    elm_box_pack_end(wd->main_box, wd->right_blank);
 867    evas_object_show(wd->right_blank);
 868
 869    _theme_data_get(wd);
 870
 871    evas_object_smart_callback_add(obj, "sub-object-del", _sub_del, obj);
 872    evas_object_smart_callbacks_descriptions_set(obj, _signals);
 873    _sizing_eval(obj);
 874    return obj;
 875 }
 876
 877 /**
 878  * Get round mode
 879  *
 880  * If round mode is activated the items list will work like a circle list,
 881  * so when the user reaches the last item, the first one will popup.
 882  *
 883  * @param obj The diskselector object
 884  * @return if or not set round mode or false if not a valid diskselector
 885  *
 886  * @ingroup Diskselector
 887  */
 888 EAPI Eina_Bool
 889 elm_diskselector_round_get(const Evas_Object *obj)
 890 {
 891    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 892    Widget_Data *wd = elm_widget_data_get(obj);
 893    if (!wd) return EINA_FALSE;
 894    return wd->round;
 895 }
 896
 897 /**
 898  * Set round mode
 899  *
 900  * If round mode is activated the items list will work like a circle list,
 901  * so when the user reaches the last item, the first one will popup.
 902  *
 903  * @param it The item of diskselector
 904  * @param if or not set round mode
 905  *
 906  * @ingroup Diskselector
 907  */
 908 EAPI void
 909 elm_diskselector_round_set(Evas_Object * obj, Eina_Bool round)
 910 {
 911    Eina_List *elist;
 912    Elm_Diskselector_Item *it;
 913
 914    ELM_CHECK_WIDTYPE(obj, widtype);
 915    Widget_Data *wd = elm_widget_data_get(obj);
 916    if (!wd) return;
 917
 918    if (wd->round == round)
 919      return;
 920
 921    wd->round = round;
 922    if (round)
 923      {
 924         wd->r_items = eina_list_clone(wd->items);
 925         elm_box_unpack(wd->main_box, wd->left_blank);
 926         evas_object_hide(wd->left_blank);
 927         elm_box_unpack(wd->main_box, wd->right_blank);
 928         evas_object_hide(wd->right_blank);
 929         if (!wd->items)
 930           return;
 931
 932         _round_items_add(wd);
 933
 934         if (wd->last)
 935           elm_box_pack_start(wd->main_box, wd->last->base.view);
 936         if (wd->s_last)
 937           elm_box_pack_start(wd->main_box, wd->s_last->base.view);
 938
 939         // if more than 3 items should be displayed
 940         EINA_LIST_FOREACH(wd->under_items, elist, it)
 941            elm_box_pack_start(wd->main_box, it->base.view);
 942
 943         if (wd->first)
 944           elm_box_pack_end(wd->main_box, wd->first->base.view);
 945         if (wd->second)
 946           elm_box_pack_end(wd->main_box, wd->second->base.view);
 947
 948         // if more than 3 items should be displayed
 949         EINA_LIST_FOREACH(wd->over_items, elist, it)
 950            elm_box_pack_end(wd->main_box, it->base.view);
 951      }
 952    else
 953      {
 954         _round_items_del(wd);
 955         elm_box_pack_start(wd->main_box, wd->left_blank);
 956         elm_box_pack_end(wd->main_box, wd->right_blank);
 957         eina_list_free(wd->r_items);
 958         wd->r_items = NULL;
 959      }
 960
 961    _sizing_eval(obj);
 962 }
 963
 964 /**
 965  * Get the side labels max length
 966  *
 967  * @param obj The diskselector object
 968  * @return The max length defined for side labels, or 0 if not a valid
 969  * diskselector
 970  *
 971  * @ingroup Diskselector
 972  */
 973 EAPI int
 974 elm_diskselector_side_label_length_get(const Evas_Object *obj)
 975 {
 976    ELM_CHECK_WIDTYPE(obj, widtype) 0;
 977    Widget_Data *wd = elm_widget_data_get(obj);
 978    if (!wd) return 0;
 979    return wd->len_side;
 980 }
 981
 982 /**
 983  * Set the side labels max length
 984  *
 985  * @param obj The diskselector object
 986  * @param len The max length defined for side labels
 987  *
 988  * @ingroup Diskselector
 989  */
 990 EAPI void
 991 elm_diskselector_side_label_length_set(Evas_Object *obj, int len)
 992 {
 993    ELM_CHECK_WIDTYPE(obj, widtype);
 994    Widget_Data *wd = elm_widget_data_get(obj);
 995    if (!wd) return;
 996    wd->len_side = len;
 997 }
 998
 999 EAPI void
1000 elm_diskselector_side_label_lenght_set(Evas_Object *obj, int len)
1001 {
1002    return elm_diskselector_side_label_length_set(obj, len);
1003 }
1004
1005 EAPI int
1006 elm_diskselector_side_label_lenght_get(const Evas_Object *obj)
1007 {
1008    return elm_diskselector_side_label_length_get(obj);
1009 }
1010
1011 /**
1012  * Set bounce mode
1013  *
1014  * This will enable or disable the scroller bounce mode for the diskselector.
1015  * See elm_scroller_bounce_set() for details. Horizontal bounce is enabled by
1016  * default.
1017  *
1018  * @param obj The diskselector object
1019  * @param h_bounce Allow bounce horizontally
1020  * @param v_bounce Allow bounce vertically
1021  *
1022  * @ingroup Diskselector
1023  */
1024 EAPI void
1025 elm_diskselector_bounce_set(Evas_Object *obj, Eina_Bool h_bounce, Eina_Bool v_bounce)
1026 {
1027    ELM_CHECK_WIDTYPE(obj, widtype);
1028    Widget_Data *wd = elm_widget_data_get(obj);
1029    if (!wd) return;
1030    if (wd->scroller)
1031      elm_smart_scroller_bounce_allow_set(wd->scroller, h_bounce, v_bounce);
1032 }
1033
1034 /**
1035  * Get the bounce mode
1036  *
1037  * @param obj The Diskselector object
1038  * @param h_bounce Allow bounce horizontally
1039  * @param v_bounce Allow bounce vertically
1040  *
1041  * @ingroup Diskselector
1042  */
1043 EAPI void
1044 elm_diskselector_bounce_get(const Evas_Object *obj, Eina_Bool *h_bounce, Eina_Bool *v_bounce)
1045 {
1046    ELM_CHECK_WIDTYPE(obj, widtype);
1047    Widget_Data *wd = elm_widget_data_get(obj);
1048    if (!wd) return;
1049    elm_smart_scroller_bounce_allow_get(wd->scroller, h_bounce, v_bounce);
1050 }
1051
1052 /**
1053  * Get the scrollbar policy
1054  *
1055  * This sets the scrollbar visibility policy for the given scroller.
1056  * ELM_SMART_SCROLLER_POLICY_AUTO means the scrollber is made visible if it
1057  * is needed, and otherwise kept hidden. ELM_SMART_SCROLLER_POLICY_ON turns
1058  * it on all the time, and ELM_SMART_SCROLLER_POLICY_OFF always keeps it off.
1059  * This applies respectively for the horizontal and vertical scrollbars.
1060  * The both are disabled by default.
1061  *
1062  * @param obj The diskselector object
1063  * @param policy_h Horizontal scrollbar policy
1064  * @param policy_v Vertical scrollbar policy
1065  *
1066  * @ingroup Diskselector
1067  */
1068
1069 EAPI void
1070 elm_diskselector_scroller_policy_get(const Evas_Object *obj, Elm_Scroller_Policy *policy_h, Elm_Scroller_Policy *policy_v)
1071 {
1072    ELM_CHECK_WIDTYPE(obj, widtype);
1073    Elm_Smart_Scroller_Policy s_policy_h, s_policy_v;
1074    Widget_Data *wd = elm_widget_data_get(obj);
1075    if ((!wd) || (!wd->scroller)) return;
1076    elm_smart_scroller_policy_get(wd->scroller, &s_policy_h, &s_policy_v);
1077    *policy_h = (Elm_Scroller_Policy) s_policy_h;
1078    *policy_v = (Elm_Scroller_Policy) s_policy_v;
1079 }
1080
1081
1082 /**
1083  * Set the scrollbar policy
1084  *
1085  * This sets the scrollbar visibility policy for the given scroller.
1086  * ELM_SMART_SCROLLER_POLICY_AUTO means the scrollber is made visible if it
1087  * is needed, and otherwise kept hidden. ELM_SMART_SCROLLER_POLICY_ON turns
1088  * it on all the time, and ELM_SMART_SCROLLER_POLICY_OFF always keeps it off.
1089  * This applies respectively for the horizontal and vertical scrollbars.
1090  * The both are disabled by default.
1091  *
1092  * @param obj The diskselector object
1093  * @param policy_h Horizontal scrollbar policy
1094  * @param policy_v Vertical scrollbar policy
1095  *
1096  * @ingroup Diskselector
1097  */
1098 EAPI void
1099 elm_diskselector_scroller_policy_set(Evas_Object *obj, Elm_Scroller_Policy policy_h, Elm_Scroller_Policy policy_v)
1100 {
1101    ELM_CHECK_WIDTYPE(obj, widtype);
1102    Widget_Data *wd = elm_widget_data_get(obj);
1103    if (!wd) return;
1104    if ((policy_h >= 3) || (policy_v >= 3)) return;
1105    if (wd->scroller)
1106      elm_smart_scroller_policy_set(wd->scroller, policy_h, policy_v);
1107 }
1108
1109 /**
1110  * Clears a diskselector of all items.
1111  *
1112  * @param obj The diskselector object
1113  *
1114  * @ingroup Diskselector
1115  */
1116 EAPI void
1117 elm_diskselector_clear(Evas_Object *obj)
1118 {
1119    ELM_CHECK_WIDTYPE(obj, widtype);
1120    Widget_Data *wd = elm_widget_data_get(obj);
1121    Elm_Diskselector_Item *it;
1122
1123    if (!wd) return;
1124    if (!wd->items) return;
1125
1126    wd->selected_item = NULL;
1127    EINA_LIST_FREE(wd->items, it) _item_del(it);
1128    _round_items_del(wd);
1129    _sizing_eval(obj);
1130 }
1131
1132 /**
1133  * Returns a list of all the diskselector items.
1134  *
1135  * @param obj The diskselector object
1136  * @return An Eina_List* of the diskselector items, or NULL on failure
1137  *
1138  * @ingroup Diskselector
1139  */
1140 EAPI const Eina_List *
1141 elm_diskselector_items_get(const Evas_Object *obj)
1142 {
1143    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1144    Widget_Data *wd = elm_widget_data_get(obj);
1145    if (!wd) return NULL;
1146    return wd->items;
1147 }
1148
1149 /**
1150  * Appends an item to the diskselector object.
1151  *
1152  * @param obj The diskselector object
1153  * @param label The label of the diskselector item
1154  * @param icon The icon object to use for the left side of the item
1155  * @param func The function to call when the item is selected
1156  * @param data The data to associate with the item for related callbacks
1157  *
1158  * @return The created item or NULL upon failure
1159  *
1160  * @ingroup Diskselector
1161  */
1162 EAPI Elm_Diskselector_Item *
1163 elm_diskselector_item_append(Evas_Object *obj, const char *label, Evas_Object *icon, Evas_Smart_Cb func, const void *data)
1164 {
1165    Elm_Diskselector_Item *it;
1166    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1167    Widget_Data *wd = elm_widget_data_get(obj);
1168    if (!wd) return NULL;
1169
1170    it = _item_new(obj, icon, label, func, data);
1171    wd->items = eina_list_append(wd->items, it);
1172    it->node = eina_list_last(wd->items);
1173    wd->item_count++;
1174    if (wd->round)
1175      {
1176         _round_items_del(wd);
1177         wd->r_items = eina_list_append(wd->r_items, it);
1178         _round_items_add(wd);
1179         if (wd->last)
1180           elm_box_pack_start(wd->main_box, wd->last->base.view);
1181         if (wd->s_last)
1182           elm_box_pack_start(wd->main_box, wd->s_last->base.view);
1183         elm_box_pack_end(wd->main_box, it->base.view);
1184         if (wd->first)
1185           elm_box_pack_end(wd->main_box, wd->first->base.view);
1186         if (wd->second)
1187           elm_box_pack_end(wd->main_box, wd->second->base.view);
1188      }
1189    else
1190      {
1191         elm_box_unpack(wd->main_box, wd->right_blank);
1192         elm_box_pack_end(wd->main_box, it->base.view);
1193         elm_box_pack_end(wd->main_box, wd->right_blank);
1194      }
1195    if (!wd->selected_item)
1196      wd->selected_item = it;
1197    if (!wd->idler)
1198      wd->idler = ecore_idler_add(_move_scroller, obj);
1199    _sizing_eval(obj);
1200    return it;
1201 }
1202
1203 /**
1204  * Delete the item
1205  *
1206  * @param it The item of diskselector
1207  *
1208  * @ingroup Diskselector
1209  */
1210 EAPI void
1211 elm_diskselector_item_del(Elm_Diskselector_Item * it)
1212 {
1213    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it);
1214    Elm_Diskselector_Item *dit;
1215    Elm_Diskselector_Item *item;
1216    Eina_List *l;
1217    int i = 0;
1218    Widget_Data *wd = elm_widget_data_get(it->base.widget);
1219    if (!wd) return;
1220
1221    elm_box_unpack(wd->main_box, it->base.view);
1222
1223    if (wd->round)
1224      wd->r_items = eina_list_remove(wd->r_items, it);
1225
1226    wd->items = eina_list_remove(wd->items, it);
1227
1228    if (wd->selected_item == it)
1229      {
1230         dit = (Elm_Diskselector_Item *) eina_list_nth(wd->items, 0);
1231         if (dit != it)
1232           wd->selected_item = dit;
1233         else
1234           wd->selected_item = eina_list_nth(wd->items, 1);
1235
1236         _selected_item_indicate(wd->selected_item);
1237      }
1238
1239    _item_del(it);
1240    wd->item_count -= 1;
1241
1242    if (wd->round)
1243      {
1244         if (!wd->item_count)
1245           {
1246              evas_object_hide(wd->first->base.view);
1247              evas_object_hide(wd->second->base.view);
1248              evas_object_hide(wd->last->base.view);
1249              evas_object_hide(wd->s_last->base.view);
1250
1251              EINA_LIST_FOREACH(wd->under_items, l, item)
1252                 evas_object_hide(item->base.view);
1253
1254              EINA_LIST_FOREACH(wd->over_items, l, item)
1255                 evas_object_hide(item->base.view);
1256           }
1257         else
1258           {
1259              dit = eina_list_nth(wd->items, 0);
1260              if (dit)
1261                {
1262                   eina_stringshare_replace(&wd->first->label, dit->label);
1263                   edje_object_part_text_set(wd->first->base.view, "elm.text",
1264                                             wd->first->label);
1265                }
1266              dit = eina_list_nth(wd->items, 1);
1267              if (dit)
1268                {
1269                   eina_stringshare_replace(&wd->second->label, dit->label);
1270                   edje_object_part_text_set(wd->second->base.view, "elm.text",
1271                                             wd->second->label);
1272                }
1273              // if more than 3 itmes should be displayed
1274              for (i = 2; i < CEIL(wd->display_item_num); i++)
1275                {
1276                   dit = eina_list_nth(wd->items, i);
1277                   item = eina_list_nth(wd->over_items, i - 2);
1278                   eina_stringshare_replace(&item->label, dit->label);
1279                   edje_object_part_text_set(item->base.view, "elm.text", item->label);
1280                }
1281
1282              dit = eina_list_nth(wd->items, eina_list_count(wd->items) - 1);
1283              if (dit)
1284                {
1285                   eina_stringshare_replace(&wd->last->label, dit->label);
1286                   edje_object_part_text_set(wd->last->base.view, "elm.text",
1287                                             wd->last->label);
1288                }
1289              dit = eina_list_nth(wd->items, eina_list_count(wd->items) - 2);
1290              if (dit)
1291                {
1292                   eina_stringshare_replace(&wd->s_last->label, dit->label);
1293                   edje_object_part_text_set(wd->s_last->base.view, "elm.text",
1294                                             wd->s_last->label);
1295                }
1296              // if more than 3 itmes should be displayed
1297              for (i = 3; i <= CEIL(wd->display_item_num); i++)
1298                {
1299                   dit = eina_list_nth(wd->items, wd->item_count - i);
1300                   item = eina_list_nth(wd->under_items, i - 3);
1301                   eina_stringshare_replace(&item->label, dit->label);
1302                   edje_object_part_text_set(item->base.view, "elm.text", item->label);
1303                }
1304           }
1305      }
1306    wd->check_idler = ecore_idler_add(_check_string, wd);
1307    _sizing_eval(wd->self);
1308 }
1309
1310 /**
1311  * Get the label of item
1312  *
1313  * @param it The item of diskselector
1314  * @return The label of item
1315  *
1316  * @ingroup Diskselector
1317  */
1318 EAPI const char *
1319 elm_diskselector_item_label_get(const Elm_Diskselector_Item * it)
1320 {
1321    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, NULL);
1322    return it->label;
1323 }
1324
1325 /**
1326  * Set the label of item
1327  *
1328  * @param it The item of diskselector
1329  * @param label The label of item
1330  *
1331  * @ingroup Diskselector
1332  */
1333 EAPI void
1334 elm_diskselector_item_label_set(Elm_Diskselector_Item * it, const char *label)
1335 {
1336    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it);
1337    eina_stringshare_replace(&it->label, label);
1338    edje_object_part_text_set(it->base.view, "elm.text", it->label);
1339 }
1340
1341 /**
1342  * Get the selected item
1343  *
1344  * @param obj The diskselector object
1345  * @return The selected diskselector item
1346  *
1347  * @ingroup Diskselector
1348  */
1349 EAPI Elm_Diskselector_Item *
1350 elm_diskselector_selected_item_get(const Evas_Object *obj)
1351 {
1352    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1353    Widget_Data *wd = elm_widget_data_get(obj);
1354    if (!wd) return NULL;
1355    return wd->selected_item;
1356 }
1357
1358 /**
1359  * Set the selected state of an item
1360  *
1361  * This sets the selected state (EINA_TRUE selected, EINA_FALSE not selected)
1362  * of the given item @p it.
1363  * If a new item is selected the previosly selected will be unselected.
1364  * If the item @p it is unselected, the first item will be selected.
1365  *
1366  * @param it The diskselector item
1367  * @param selected The selected state
1368  *
1369  * @ingroup Diskselector
1370  */
1371 EAPI void
1372 elm_diskselector_item_selected_set(Elm_Diskselector_Item *it, Eina_Bool selected)
1373 {
1374    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it);
1375    Widget_Data *wd;
1376    wd = elm_widget_data_get(it->base.widget);
1377    if (!wd) return;
1378
1379    if ((wd->selected_item == it) && (selected))
1380      return;
1381
1382    if ((wd->selected_item == it) && (!selected))
1383      wd->selected_item = eina_list_data_get(wd->items);
1384    else
1385      {
1386         wd->selected_item = it;
1387         _selected_item_indicate(wd->selected_item);
1388      }
1389
1390    if (!wd->idler)
1391      ecore_idler_add(_move_scroller, it->base.widget);
1392 }
1393
1394 /*
1395  * Get the selected state of @p item.
1396  *
1397  * @param it The diskselector item
1398  * @return If true, the item is selected
1399  *
1400  * @ingroup Diskselector
1401  */
1402 EAPI Eina_Bool
1403 elm_diskselector_item_selected_get(const Elm_Diskselector_Item *it)
1404 {
1405    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, EINA_FALSE);
1406    Widget_Data *wd;
1407
1408    wd = elm_widget_data_get(it->base.widget);
1409    if (!wd) return EINA_FALSE;
1410    return (wd->selected_item == it);
1411 }
1412
1413 /**
1414  * Set the function called when a diskselector item is freed.
1415  *
1416  * @param it The item to set the callback on
1417  * @param func The function called
1418  *
1419  * @ingroup Diskselector
1420  */
1421 EAPI void
1422 elm_diskselector_item_del_cb_set(Elm_Diskselector_Item *it, Evas_Smart_Cb func)
1423 {
1424    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it);
1425    elm_widget_item_del_cb_set(it, func);
1426 }
1427
1428 /**
1429  * Returns the data associated with the item.
1430  *
1431  * @param it The diskselector item
1432  * @return The data associated with @p it
1433  *
1434  * @ingroup Diskselector
1435  */
1436 EAPI void *
1437 elm_diskselector_item_data_get(const Elm_Diskselector_Item *it)
1438 {
1439    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, NULL);
1440    return elm_widget_item_data_get(it);
1441 }
1442
1443 /**
1444  * Returns the icon associated with the item.
1445  *
1446  * @param it The diskselector item
1447  * @return The icon associated with @p it
1448  *
1449  * @ingroup Diskselector
1450  */
1451 EAPI Evas_Object *
1452 elm_diskselector_item_icon_get(const Elm_Diskselector_Item *it)
1453 {
1454    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, NULL);
1455    return it->icon;
1456 }
1457
1458 /**
1459  * Sets the icon associated with the item.
1460  *
1461  * Once the icon object is set, a previously set one will be deleted.
1462  * You probably don't want, then, to have the <b>same</b> icon object set
1463  * for more than one item of the diskselector.
1464  *
1465  * @param it The diskselector item
1466  * @param icon The icon object to associate with @p it
1467  *
1468  * @ingroup Diskselector
1469  */
1470 EAPI void
1471 elm_diskselector_item_icon_set(Elm_Diskselector_Item *it, Evas_Object *icon)
1472 {
1473    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it);
1474    if (it->icon == icon) return;
1475    if (it->icon)
1476      evas_object_del(it->icon);
1477    it->icon = icon;
1478    if (it->base.view)
1479      edje_object_part_swallow(it->base.view, "elm.swallow.icon", icon);
1480 }
1481
1482 /**
1483  * Gets the item before @p it in the list.
1484  *
1485  * @param it The diskselector item
1486  * @return The item before @p it, or NULL on failure
1487  *
1488  * @ingroup Diskselector
1489  */
1490 EAPI Elm_Diskselector_Item *
1491 elm_diskselector_item_prev_get(const Elm_Diskselector_Item *it)
1492 {
1493    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, NULL);
1494    if (it->node->prev) return it->node->prev->data;
1495    else return NULL;
1496 }
1497
1498 /**
1499  * Gets the item after @p it in the list.
1500  *
1501  * @param it The diskselector item
1502  * @return The item after @p it, or NULL on failure
1503  *
1504  * @ingroup Diskselector
1505  */
1506 EAPI Elm_Diskselector_Item *
1507 elm_diskselector_item_next_get(const Elm_Diskselector_Item *it)
1508 {
1509    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, NULL);
1510    if (it->node->next) return it->node->next->data;
1511    else return NULL;
1512 }
1513
1514 /**
1515  * Get the first item in the diskselector
1516  *
1517  * @param obj The diskselector object
1518  * @return The first item, or NULL if none
1519  *
1520  * @ingroup Diskselector
1521  */
1522 EAPI Elm_Diskselector_Item *
1523 elm_diskselector_first_item_get(const Evas_Object *obj)
1524 {
1525    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1526    Widget_Data *wd;
1527
1528    wd = elm_widget_data_get(obj);
1529    if (!wd || !wd->items)
1530      return NULL;
1531
1532    return eina_list_data_get(wd->items);
1533 }
1534
1535 /**
1536  * Get the last item in the diskselector
1537  *
1538  * @param obj The diskselector object
1539  * @return The last item, or NULL if none
1540  *
1541  * @ingroup Diskselector
1542  */
1543 EAPI Elm_Diskselector_Item *
1544 elm_diskselector_last_item_get(const Evas_Object *obj)
1545 {
1546    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1547
1548    Widget_Data *wd;
1549    wd = elm_widget_data_get(obj);
1550    if (!wd || !wd->items)
1551      return NULL;
1552
1553    return eina_list_data_get(eina_list_last(wd->items));
1554 }
1555
1556 /**
1557  * Set the text to be shown in the diskselector item.
1558  *
1559  * @param item Target item
1560  * @param text The text to set in the content
1561  *
1562  * Setup the text as tooltip to object. The item can have only one tooltip,
1563  * so any previous tooltip data is removed.
1564  *
1565  * @ingroup Diskselector
1566  */
1567 EAPI void
1568 elm_diskselector_item_tooltip_text_set(Elm_Diskselector_Item *item, const char *text)
1569 {
1570    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1571    elm_widget_item_tooltip_text_set(item, text);
1572 }
1573
1574 /**
1575  * Set the content to be shown in the tooltip item
1576  *
1577  * Setup the tooltip to item. The item can have only one tooltip,
1578  * so any previous tooltip data is removed. @p func(with @p data) will
1579  * be called every time that need show the tooltip and it should
1580  * return a valid Evas_Object. This object is then managed fully by
1581  * tooltip system and is deleted when the tooltip is gone.
1582  *
1583  * @param item the diskselector item being attached a tooltip.
1584  * @param func the function used to create the tooltip contents.
1585  * @param data what to provide to @a func as callback data/context.
1586  * @param del_cb called when data is not needed anymore, either when
1587  *        another callback replaces @func, the tooltip is unset with
1588  *        elm_diskselector_item_tooltip_unset() or the owner @a item
1589  *        dies. This callback receives as the first parameter the
1590  *        given @a data, and @c event_info is the item.
1591  *
1592  * @ingroup Diskselector
1593  */
1594 EAPI void
1595 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)
1596 {
1597    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1598    elm_widget_item_tooltip_content_cb_set(item, func, data, del_cb);
1599 }
1600
1601 /**
1602  * Unset tooltip from item
1603  *
1604  * @param item diskselector item to remove previously set tooltip.
1605  *
1606  * Remove tooltip from item. The callback provided as del_cb to
1607  * elm_diskselector_item_tooltip_content_cb_set() will be called to notify
1608  * it is not used anymore.
1609  *
1610  * @see elm_diskselector_item_tooltip_content_cb_set()
1611  *
1612  * @ingroup Diskselector
1613  */
1614 EAPI void
1615 elm_diskselector_item_tooltip_unset(Elm_Diskselector_Item *item)
1616 {
1617    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1618    elm_widget_item_tooltip_unset(item);
1619 }
1620
1621 /**
1622  * Sets a different style for this item tooltip.
1623  *
1624  * @note before you set a style you should define a tooltip with
1625  *       elm_diskselector_item_tooltip_content_cb_set() or
1626  *       elm_diskselector_item_tooltip_text_set()
1627  *
1628  * @param item diskselector item with tooltip already set.
1629  * @param style the theme style to use (default, transparent, ...)
1630  *
1631  * @ingroup Diskselector
1632  */
1633 EAPI void
1634 elm_diskselector_item_tooltip_style_set(Elm_Diskselector_Item *item, const char *style)
1635 {
1636    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1637    elm_widget_item_tooltip_style_set(item, style);
1638 }
1639
1640 /**
1641  * Get the style for this item tooltip.
1642  *
1643  * @param item diskselector item with tooltip already set.
1644  * @return style the theme style in use, defaults to "default". If the
1645  *         object does not have a tooltip set, then NULL is returned.
1646  *
1647  * @ingroup Diskselector
1648  */
1649 EAPI const char *
1650 elm_diskselector_item_tooltip_style_get(const Elm_Diskselector_Item *item)
1651 {
1652    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item, NULL);
1653    return elm_widget_item_tooltip_style_get(item);
1654 }
1655
1656 /**
1657  * Set the cursor to be shown when mouse is over the diskselector item
1658  *
1659  * @param item Target item
1660  * @param cursor the cursor name to be used.
1661  *
1662  * @see elm_object_cursor_set()
1663  * @ingroup Diskselector
1664  */
1665 EAPI void
1666 elm_diskselector_item_cursor_set(Elm_Diskselector_Item *item, const char *cursor)
1667 {
1668    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1669    elm_widget_item_cursor_set(item, cursor);
1670 }
1671
1672 /**
1673  * Get the cursor to be shown when mouse is over the diskselector item
1674  *
1675  * @param item diskselector item with cursor already set.
1676  * @return the cursor name.
1677  *
1678  * @ingroup Diskselector
1679  */
1680 EAPI const char *
1681 elm_diskselector_item_cursor_get(const Elm_Diskselector_Item *item)
1682 {
1683    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item, NULL);
1684    return elm_widget_item_cursor_get(item);
1685 }
1686
1687 /**
1688  * Unset the cursor to be shown when mouse is over the diskselector item
1689  *
1690  * @param item Target item
1691  *
1692  * @see elm_object_cursor_unset()
1693  * @ingroup Diskselector
1694  */
1695 EAPI void
1696 elm_diskselector_item_cursor_unset(Elm_Diskselector_Item *item)
1697 {
1698    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1699    elm_widget_item_cursor_unset(item);
1700 }
1701
1702 /**
1703  * Sets a different style for this item cursor.
1704  *
1705  * @note before you set a style you should define a cursor with
1706  *       elm_diskselector_item_cursor_set()
1707  *
1708  * @param item diskselector item with cursor already set.
1709  * @param style the theme style to use (default, transparent, ...)
1710  *
1711  * @ingroup Diskselector
1712  */
1713 EAPI void
1714 elm_diskselector_item_cursor_style_set(Elm_Diskselector_Item *item, const char *style)
1715 {
1716    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1717    elm_widget_item_cursor_style_set(item, style);
1718 }
1719
1720 /**
1721  * Get the style for this item cursor.
1722  *
1723  * @param item diskselector item with cursor already set.
1724  * @return style the theme style in use, defaults to "default". If the
1725  *         object does not have a cursor set, then NULL is returned.
1726  *
1727  * @ingroup Diskselector
1728  */
1729 EAPI const char *
1730 elm_diskselector_item_cursor_style_get(const Elm_Diskselector_Item *item)
1731 {
1732    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item, NULL);
1733    return elm_widget_item_cursor_style_get(item);
1734 }
1735
1736 /**
1737  * Set if the cursor set should be searched on the theme or should use
1738  * the provided by the engine, only.
1739  *
1740  * @note before you set if should look on theme you should define a cursor
1741  * with elm_object_cursor_set(). By default it will only look for cursors
1742  * provided by the engine.
1743  *
1744  * @param item widget item with cursor already set.
1745  * @param engine_only boolean to define it cursors should be looked only
1746  * between the provided by the engine or searched on widget's theme as well.
1747  *
1748  * @ingroup Diskselector
1749  */
1750 EAPI void
1751 elm_diskselector_item_cursor_engine_only_set(Elm_Diskselector_Item *item, Eina_Bool engine_only)
1752 {
1753    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1754    elm_widget_item_cursor_engine_only_set(item, engine_only);
1755 }
1756
1757 /**
1758  * Get the cursor engine only usage for this item cursor.
1759  *
1760  * @param item widget item with cursor already set.
1761  * @return engine_only boolean to define it cursors should be looked only
1762  * between the provided by the engine or searched on widget's theme as well. If
1763  *         the object does not have a cursor set, then EINA_FALSE is returned.
1764  *
1765  * @ingroup Diskselector
1766  */
1767 EAPI Eina_Bool
1768 elm_diskselector_item_cursor_engine_only_get(const Elm_Diskselector_Item *item)
1769 {
1770    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item, EINA_FALSE);
1771    return elm_widget_item_cursor_engine_only_get(item);
1772 }
1773 /**
1774  * Set the number of items to be displayed
1775  *
1776  * @param obj The diskselector object
1777  * @param num The number of itmes that diskselector will display
1778  *
1779  * @ingroup Diskselector
1780  */
1781 EAPI void
1782 elm_diskselector_display_item_num_set(Evas_Object *obj, int num)
1783 {
1784    ELM_CHECK_WIDTYPE(obj, widtype);
1785    Widget_Data *wd = elm_widget_data_get(obj);
1786    if (!wd) return;
1787    if (num < DISPLAY_ITEM_NUM_MIN) num = DISPLAY_ITEM_NUM_MIN;
1788    wd->display_item_num = num;
1789    wd->display_item_num_by_api = EINA_TRUE;
1790 }