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    elm_smart_scroller_child_region_show(wd->scroller, w / wd->display_item_num * i, y, w, h);
 658    _select_item(dit);
 659    if (wd->idler)
 660      {
 661         ecore_idler_del(wd->idler);
 662         wd->idler = NULL;
 663      }
 664    wd->init = EINA_TRUE;
 665    _check_string(wd);
 666
 667    return EINA_TRUE;
 668 }
 669
 670 static void
 671 _round_item_del(Widget_Data *wd, Elm_Diskselector_Item *it)
 672 {
 673    if (!it) return;
 674    elm_box_unpack(wd->main_box, it->base.view);
 675    wd->r_items = eina_list_remove(wd->r_items, it);
 676    eina_stringshare_del(it->label);
 677    evas_object_del(it->base.view);
 678    free(it);
 679 }
 680
 681 static void
 682 _round_items_del(Widget_Data *wd)
 683 {
 684    Eina_List *l;
 685    Elm_Diskselector_Item * it;
 686
 687    _round_item_del(wd, wd->last);
 688    wd->last = NULL;
 689    _round_item_del(wd, wd->s_last);
 690    wd->s_last = NULL;
 691    _round_item_del(wd, wd->second);
 692    wd->second = NULL;
 693    _round_item_del(wd, wd->first);
 694    wd->first = NULL;
 695
 696    EINA_LIST_FOREACH(wd->under_items, l, it)
 697      {
 698         _round_item_del(wd, it);
 699         it = NULL;
 700      }
 701
 702    EINA_LIST_FOREACH(wd->over_items, l, it)
 703      {
 704         _round_item_del(wd, it);
 705         it = NULL;
 706      }
 707 }
 708
 709 static void
 710 _round_items_add(Widget_Data *wd)
 711 {
 712    Elm_Diskselector_Item *dit;
 713    Elm_Diskselector_Item *it;
 714    Elm_Diskselector_Item *temp_it;
 715    int i = 0;
 716    dit = it = eina_list_nth(wd->items, 0);
 717    if (!dit) return;
 718
 719    if (!wd->first)
 720      {
 721         wd->first = _item_new(it->base.widget, it->icon, it->label, it->func,
 722                               it->base.data);
 723         wd->first->node = it->node;
 724         wd->r_items = eina_list_append(wd->r_items, wd->first);
 725      }
 726
 727    it = eina_list_nth(wd->items, 1);
 728    if (!it)
 729      it = dit;
 730    if (!wd->second)
 731      {
 732         wd->second = _item_new(it->base.widget, it->icon, it->label, it->func,
 733                                it->base.data);
 734         wd->second->node = it->node;
 735         wd->r_items = eina_list_append(wd->r_items, wd->second);
 736      }
 737
 738    // if more than 3 itmes should be displayed
 739    for (i = 2; i < CEIL(wd->display_item_num); i++)
 740      {
 741         it = eina_list_nth(wd->items, i);
 742         if (!it) it = dit;
 743         temp_it = _item_new(it->base.widget, it->icon, it->label, it->func, it->base.data);
 744         wd->over_items = eina_list_append(wd->over_items, temp_it);
 745         wd->r_items = eina_list_append(wd->r_items, temp_it);
 746      }
 747
 748    it = eina_list_nth(wd->items, wd->item_count - 1);
 749    if (!it)
 750      it = dit;
 751    if (!wd->last)
 752      {
 753         wd->last = _item_new(it->base.widget, it->icon, it->label, it->func,
 754                              it->base.data);
 755         wd->last->node = it->node;
 756         wd->r_items = eina_list_prepend(wd->r_items, wd->last);
 757      }
 758
 759    it = eina_list_nth(wd->items, wd->item_count - 2);
 760    if (!it)
 761      it = dit;
 762    if (!wd->s_last)
 763      {
 764         wd->s_last = _item_new(it->base.widget, it->icon, it->label, it->func,
 765                                it->base.data);
 766         wd->s_last->node = it->node;
 767         wd->r_items = eina_list_prepend(wd->r_items, wd->s_last);
 768      }
 769
 770    // if more than 3 itmes should be displayed
 771    for (i = 3; i <= CEIL(wd->display_item_num); i++)
 772      {
 773         it = eina_list_nth(wd->items, wd->item_count - i);
 774         if (!it) it = dit;
 775         temp_it = _item_new(it->base.widget, it->icon, it->label, it->func, it->base.data);
 776         wd->under_items = eina_list_append(wd->under_items, temp_it);
 777         wd->r_items = eina_list_prepend(wd->r_items, temp_it);
 778      }
 779 }
 780
 781 /**
 782  * Add a new diskselector object
 783  *
 784  * @param parent The parent object
 785  * @return The new object or NULL if it cannot be created
 786  *
 787  * @ingroup Diskselector
 788  */
 789 EAPI Evas_Object *
 790 elm_diskselector_add(Evas_Object *parent)
 791 {
 792    Evas *e;
 793    Evas_Object *obj;
 794    Widget_Data *wd;
 795
 796    ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
 797
 798    ELM_SET_WIDTYPE(widtype, "diskselector");
 799    elm_widget_type_set(obj, "diskselector");
 800    elm_widget_sub_object_add(parent, obj);
 801    elm_widget_data_set(obj, wd);
 802    elm_widget_del_hook_set(obj, _del_hook);
 803    elm_widget_del_pre_hook_set(obj, _del_pre_hook);
 804    elm_widget_theme_hook_set(obj, _theme_hook);
 805    elm_widget_can_focus_set(obj, EINA_TRUE);
 806    elm_widget_on_focus_hook_set(obj, _on_focus_hook, NULL);
 807    elm_widget_event_hook_set(obj, _event_hook);
 808
 809    wd->self = obj;
 810    wd->item_count = 0;
 811    wd->round = EINA_FALSE;
 812    wd->init = EINA_FALSE;
 813    wd->len_side = 3;
 814    wd->display_item_num_by_api = EINA_FALSE;
 815
 816    wd->scroller = elm_smart_scroller_add(e);
 817    elm_smart_scroller_widget_set(wd->scroller, obj);
 818    _theme_hook(obj);
 819    elm_widget_resize_object_set(obj, wd->scroller);
 820    elm_smart_scroller_policy_set(wd->scroller, ELM_SMART_SCROLLER_POLICY_OFF,
 821                                  ELM_SMART_SCROLLER_POLICY_OFF);
 822    elm_smart_scroller_bounce_allow_set(wd->scroller, EINA_TRUE, EINA_FALSE);
 823    evas_object_smart_callback_add(wd->scroller, "scroll", _scroller_move_cb,
 824                                   wd);
 825    evas_object_smart_callback_add(wd->scroller, "animate,stop",
 826                                   _scroller_stop_cb, wd);
 827    _elm_theme_object_set(obj, wd->scroller, "diskselector", "base",
 828                          "default");
 829    evas_object_event_callback_add(wd->scroller, EVAS_CALLBACK_RESIZE,
 830                                   _diskselector_object_resize, obj);
 831
 832    wd->main_box = elm_box_add(parent);
 833    elm_box_horizontal_set(wd->main_box, EINA_TRUE);
 834    elm_box_homogeneous_set(wd->main_box, EINA_TRUE);
 835    evas_object_size_hint_weight_set(wd->main_box, EVAS_HINT_EXPAND,
 836                                     EVAS_HINT_EXPAND);
 837    evas_object_size_hint_align_set(wd->main_box, EVAS_HINT_FILL,
 838                                    EVAS_HINT_FILL);
 839    _elm_theme_object_set(obj, wd->main_box, "diskselector", "base",
 840                          "default");
 841    elm_widget_sub_object_add(obj, wd->main_box);
 842
 843    elm_smart_scroller_child_set(wd->scroller, wd->main_box);
 844
 845    wd->left_blank = edje_object_add(evas_object_evas_get(obj));
 846    _elm_theme_object_set(obj, wd->left_blank, "diskselector", "item",
 847                          "default");
 848    evas_object_size_hint_weight_set(wd->left_blank, EVAS_HINT_EXPAND,
 849                                     EVAS_HINT_EXPAND);
 850    evas_object_size_hint_align_set(wd->left_blank, EVAS_HINT_FILL,
 851                                    EVAS_HINT_FILL);
 852    elm_box_pack_end(wd->main_box, wd->left_blank);
 853    evas_object_show(wd->left_blank);
 854
 855    wd->right_blank = edje_object_add(evas_object_evas_get(obj));
 856    _elm_theme_object_set(obj, wd->right_blank, "diskselector", "item",
 857                          "default");
 858    evas_object_size_hint_weight_set(wd->right_blank, EVAS_HINT_EXPAND,
 859                                     EVAS_HINT_EXPAND);
 860    evas_object_size_hint_align_set(wd->right_blank, EVAS_HINT_FILL,
 861                                    EVAS_HINT_FILL);
 862    elm_box_pack_end(wd->main_box, wd->right_blank);
 863    evas_object_show(wd->right_blank);
 864
 865    _theme_data_get(wd);
 866
 867    evas_object_smart_callback_add(obj, "sub-object-del", _sub_del, obj);
 868    evas_object_smart_callbacks_descriptions_set(obj, _signals);
 869    _sizing_eval(obj);
 870    return obj;
 871 }
 872
 873 /**
 874  * Get round mode
 875  *
 876  * If round mode is activated the items list will work like a circle list,
 877  * so when the user reaches the last item, the first one will popup.
 878  *
 879  * @param obj The diskselector object
 880  * @return if or not set round mode or false if not a valid diskselector
 881  *
 882  * @ingroup Diskselector
 883  */
 884 EAPI Eina_Bool
 885 elm_diskselector_round_get(const Evas_Object *obj)
 886 {
 887    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
 888    Widget_Data *wd = elm_widget_data_get(obj);
 889    if (!wd) return EINA_FALSE;
 890    return wd->round;
 891 }
 892
 893 /**
 894  * Set round mode
 895  *
 896  * If round mode is activated the items list will work like a circle list,
 897  * so when the user reaches the last item, the first one will popup.
 898  *
 899  * @param it The item of diskselector
 900  * @param if or not set round mode
 901  *
 902  * @ingroup Diskselector
 903  */
 904 EAPI void
 905 elm_diskselector_round_set(Evas_Object * obj, Eina_Bool round)
 906 {
 907    Eina_List *elist;
 908    Elm_Diskselector_Item *it;
 909
 910    ELM_CHECK_WIDTYPE(obj, widtype);
 911    Widget_Data *wd = elm_widget_data_get(obj);
 912    if (!wd) return;
 913
 914    if (wd->round == round)
 915      return;
 916
 917    wd->round = round;
 918    if (round)
 919      {
 920         wd->r_items = eina_list_clone(wd->items);
 921         elm_box_unpack(wd->main_box, wd->left_blank);
 922         evas_object_hide(wd->left_blank);
 923         elm_box_unpack(wd->main_box, wd->right_blank);
 924         evas_object_hide(wd->right_blank);
 925         if (!wd->items)
 926           return;
 927
 928         _round_items_add(wd);
 929
 930         if (wd->last)
 931           elm_box_pack_start(wd->main_box, wd->last->base.view);
 932         if (wd->s_last)
 933           elm_box_pack_start(wd->main_box, wd->s_last->base.view);
 934
 935         // if more than 3 items should be displayed
 936         EINA_LIST_FOREACH(wd->under_items, elist, it)
 937            elm_box_pack_start(wd->main_box, it->base.view);
 938
 939         if (wd->first)
 940           elm_box_pack_end(wd->main_box, wd->first->base.view);
 941         if (wd->second)
 942           elm_box_pack_end(wd->main_box, wd->second->base.view);
 943
 944         // if more than 3 items should be displayed
 945         EINA_LIST_FOREACH(wd->over_items, elist, it)
 946            elm_box_pack_end(wd->main_box, it->base.view);
 947      }
 948    else
 949      {
 950         _round_items_del(wd);
 951         elm_box_pack_start(wd->main_box, wd->left_blank);
 952         elm_box_pack_end(wd->main_box, wd->right_blank);
 953         eina_list_free(wd->r_items);
 954         wd->r_items = NULL;
 955      }
 956
 957    _sizing_eval(obj);
 958 }
 959
 960 /**
 961  * Get the side labels max length
 962  *
 963  * @param obj The diskselector object
 964  * @return The max length defined for side labels, or 0 if not a valid
 965  * diskselector
 966  *
 967  * @ingroup Diskselector
 968  */
 969 EAPI int
 970 elm_diskselector_side_label_length_get(const Evas_Object *obj)
 971 {
 972    ELM_CHECK_WIDTYPE(obj, widtype) 0;
 973    Widget_Data *wd = elm_widget_data_get(obj);
 974    if (!wd) return 0;
 975    return wd->len_side;
 976 }
 977
 978 /**
 979  * Set the side labels max length
 980  *
 981  * @param obj The diskselector object
 982  * @param len The max length defined for side labels
 983  *
 984  * @ingroup Diskselector
 985  */
 986 EAPI void
 987 elm_diskselector_side_label_length_set(Evas_Object *obj, int len)
 988 {
 989    ELM_CHECK_WIDTYPE(obj, widtype);
 990    Widget_Data *wd = elm_widget_data_get(obj);
 991    if (!wd) return;
 992    wd->len_side = len;
 993 }
 994
 995 EAPI void
 996 elm_diskselector_side_label_lenght_set(Evas_Object *obj, int len)
 997 {
 998    return elm_diskselector_side_label_length_set(obj, len);
 999 }
1000
1001 EAPI int
1002 elm_diskselector_side_label_lenght_get(const Evas_Object *obj)
1003 {
1004    return elm_diskselector_side_label_length_get(obj);
1005 }
1006
1007 /**
1008  * Set bounce mode
1009  *
1010  * This will enable or disable the scroller bounce mode for the diskselector.
1011  * See elm_scroller_bounce_set() for details. Horizontal bounce is enabled by
1012  * default.
1013  *
1014  * @param obj The diskselector object
1015  * @param h_bounce Allow bounce horizontally
1016  * @param v_bounce Allow bounce vertically
1017  *
1018  * @ingroup Diskselector
1019  */
1020 EAPI void
1021 elm_diskselector_bounce_set(Evas_Object *obj, Eina_Bool h_bounce, Eina_Bool v_bounce)
1022 {
1023    ELM_CHECK_WIDTYPE(obj, widtype);
1024    Widget_Data *wd = elm_widget_data_get(obj);
1025    if (!wd) return;
1026    if (wd->scroller)
1027      elm_smart_scroller_bounce_allow_set(wd->scroller, h_bounce, v_bounce);
1028 }
1029
1030 /**
1031  * Get the bounce mode
1032  *
1033  * @param obj The Diskselector object
1034  * @param h_bounce Allow bounce horizontally
1035  * @param v_bounce Allow bounce vertically
1036  *
1037  * @ingroup Diskselector
1038  */
1039 EAPI void
1040 elm_diskselector_bounce_get(const Evas_Object *obj, Eina_Bool *h_bounce, Eina_Bool *v_bounce)
1041 {
1042    ELM_CHECK_WIDTYPE(obj, widtype);
1043    Widget_Data *wd = elm_widget_data_get(obj);
1044    if (!wd) return;
1045    elm_smart_scroller_bounce_allow_get(wd->scroller, h_bounce, v_bounce);
1046 }
1047
1048 /**
1049  * Get the scrollbar policy
1050  *
1051  * This sets the scrollbar visibility policy for the given scroller.
1052  * ELM_SMART_SCROLLER_POLICY_AUTO means the scrollber is made visible if it
1053  * is needed, and otherwise kept hidden. ELM_SMART_SCROLLER_POLICY_ON turns
1054  * it on all the time, and ELM_SMART_SCROLLER_POLICY_OFF always keeps it off.
1055  * This applies respectively for the horizontal and vertical scrollbars.
1056  * The both are disabled by default.
1057  *
1058  * @param obj The diskselector object
1059  * @param policy_h Horizontal scrollbar policy
1060  * @param policy_v Vertical scrollbar policy
1061  *
1062  * @ingroup Diskselector
1063  */
1064
1065 EAPI void
1066 elm_diskselector_scroller_policy_get(const Evas_Object *obj, Elm_Scroller_Policy *policy_h, Elm_Scroller_Policy *policy_v)
1067 {
1068    ELM_CHECK_WIDTYPE(obj, widtype);
1069    Elm_Smart_Scroller_Policy s_policy_h, s_policy_v;
1070    Widget_Data *wd = elm_widget_data_get(obj);
1071    if ((!wd) || (!wd->scroller)) return;
1072    elm_smart_scroller_policy_get(wd->scroller, &s_policy_h, &s_policy_v);
1073    *policy_h = (Elm_Scroller_Policy) s_policy_h;
1074    *policy_v = (Elm_Scroller_Policy) s_policy_v;
1075 }
1076
1077
1078 /**
1079  * Set the scrollbar policy
1080  *
1081  * This sets the scrollbar visibility policy for the given scroller.
1082  * ELM_SMART_SCROLLER_POLICY_AUTO means the scrollber is made visible if it
1083  * is needed, and otherwise kept hidden. ELM_SMART_SCROLLER_POLICY_ON turns
1084  * it on all the time, and ELM_SMART_SCROLLER_POLICY_OFF always keeps it off.
1085  * This applies respectively for the horizontal and vertical scrollbars.
1086  * The both are disabled by default.
1087  *
1088  * @param obj The diskselector object
1089  * @param policy_h Horizontal scrollbar policy
1090  * @param policy_v Vertical scrollbar policy
1091  *
1092  * @ingroup Diskselector
1093  */
1094 EAPI void
1095 elm_diskselector_scroller_policy_set(Evas_Object *obj, Elm_Scroller_Policy policy_h, Elm_Scroller_Policy policy_v)
1096 {
1097    ELM_CHECK_WIDTYPE(obj, widtype);
1098    Widget_Data *wd = elm_widget_data_get(obj);
1099    if (!wd) return;
1100    if ((policy_h >= 3) || (policy_v >= 3)) return;
1101    if (wd->scroller)
1102      elm_smart_scroller_policy_set(wd->scroller, policy_h, policy_v);
1103 }
1104
1105 /**
1106  * Clears a diskselector of all items.
1107  *
1108  * @param obj The diskselector object
1109  *
1110  * @ingroup Diskselector
1111  */
1112 EAPI void
1113 elm_diskselector_clear(Evas_Object *obj)
1114 {
1115    ELM_CHECK_WIDTYPE(obj, widtype);
1116    Widget_Data *wd = elm_widget_data_get(obj);
1117    Elm_Diskselector_Item *it;
1118
1119    if (!wd) return;
1120    if (!wd->items) return;
1121
1122    wd->selected_item = NULL;
1123    EINA_LIST_FREE(wd->items, it) _item_del(it);
1124    _round_items_del(wd);
1125    _sizing_eval(obj);
1126 }
1127
1128 /**
1129  * Returns a list of all the diskselector items.
1130  *
1131  * @param obj The diskselector object
1132  * @return An Eina_List* of the diskselector items, or NULL on failure
1133  *
1134  * @ingroup Diskselector
1135  */
1136 EAPI const Eina_List *
1137 elm_diskselector_items_get(const Evas_Object *obj)
1138 {
1139    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1140    Widget_Data *wd = elm_widget_data_get(obj);
1141    if (!wd) return NULL;
1142    return wd->items;
1143 }
1144
1145 /**
1146  * Appends an item to the diskselector object.
1147  *
1148  * @param obj The diskselector object
1149  * @param label The label of the diskselector item
1150  * @param icon The icon object to use for the left side of the item
1151  * @param func The function to call when the item is selected
1152  * @param data The data to associate with the item for related callbacks
1153  *
1154  * @return The created item or NULL upon failure
1155  *
1156  * @ingroup Diskselector
1157  */
1158 EAPI Elm_Diskselector_Item *
1159 elm_diskselector_item_append(Evas_Object *obj, const char *label, Evas_Object *icon, Evas_Smart_Cb func, const void *data)
1160 {
1161    Elm_Diskselector_Item *it;
1162    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1163    Widget_Data *wd = elm_widget_data_get(obj);
1164    if (!wd) return NULL;
1165
1166    it = _item_new(obj, icon, label, func, data);
1167    wd->items = eina_list_append(wd->items, it);
1168    it->node = eina_list_last(wd->items);
1169    wd->item_count++;
1170    if (wd->round)
1171      {
1172         _round_items_del(wd);
1173         wd->r_items = eina_list_append(wd->r_items, it);
1174         _round_items_add(wd);
1175         if (wd->last)
1176           elm_box_pack_start(wd->main_box, wd->last->base.view);
1177         if (wd->s_last)
1178           elm_box_pack_start(wd->main_box, wd->s_last->base.view);
1179         elm_box_pack_end(wd->main_box, it->base.view);
1180         if (wd->first)
1181           elm_box_pack_end(wd->main_box, wd->first->base.view);
1182         if (wd->second)
1183           elm_box_pack_end(wd->main_box, wd->second->base.view);
1184      }
1185    else
1186      {
1187         elm_box_unpack(wd->main_box, wd->right_blank);
1188         elm_box_pack_end(wd->main_box, it->base.view);
1189         elm_box_pack_end(wd->main_box, wd->right_blank);
1190      }
1191    if (!wd->selected_item)
1192      wd->selected_item = it;
1193    if (!wd->idler)
1194      wd->idler = ecore_idler_add(_move_scroller, obj);
1195    _sizing_eval(obj);
1196    return it;
1197 }
1198
1199 /**
1200  * Delete the item
1201  *
1202  * @param it The item of diskselector
1203  *
1204  * @ingroup Diskselector
1205  */
1206 EAPI void
1207 elm_diskselector_item_del(Elm_Diskselector_Item * it)
1208 {
1209    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it);
1210    Elm_Diskselector_Item *dit;
1211    Elm_Diskselector_Item *item;
1212    Eina_List *l;
1213    int i = 0;
1214    Widget_Data *wd = elm_widget_data_get(it->base.widget);
1215    if (!wd) return;
1216
1217    elm_box_unpack(wd->main_box, it->base.view);
1218
1219    if (wd->round)
1220      wd->r_items = eina_list_remove(wd->r_items, it);
1221
1222    wd->items = eina_list_remove(wd->items, it);
1223
1224    if (wd->selected_item == it)
1225      {
1226         dit = (Elm_Diskselector_Item *) eina_list_nth(wd->items, 0);
1227         if (dit != it)
1228           wd->selected_item = dit;
1229         else
1230           wd->selected_item = eina_list_nth(wd->items, 1);
1231
1232         _selected_item_indicate(wd->selected_item);
1233      }
1234
1235    _item_del(it);
1236    wd->item_count -= 1;
1237
1238    if (wd->round)
1239      {
1240         if (!wd->item_count)
1241           {
1242              evas_object_hide(wd->first->base.view);
1243              evas_object_hide(wd->second->base.view);
1244              evas_object_hide(wd->last->base.view);
1245              evas_object_hide(wd->s_last->base.view);
1246
1247              EINA_LIST_FOREACH(wd->under_items, l, item)
1248                 evas_object_hide(item->base.view);
1249
1250              EINA_LIST_FOREACH(wd->over_items, l, item)
1251                 evas_object_hide(item->base.view);
1252           }
1253         else
1254           {
1255              dit = eina_list_nth(wd->items, 0);
1256              if (dit)
1257                {
1258                   eina_stringshare_replace(&wd->first->label, dit->label);
1259                   edje_object_part_text_set(wd->first->base.view, "elm.text",
1260                                             wd->first->label);
1261                }
1262              dit = eina_list_nth(wd->items, 1);
1263              if (dit)
1264                {
1265                   eina_stringshare_replace(&wd->second->label, dit->label);
1266                   edje_object_part_text_set(wd->second->base.view, "elm.text",
1267                                             wd->second->label);
1268                }
1269              // if more than 3 itmes should be displayed
1270              for (i = 2; i < CEIL(wd->display_item_num); i++)
1271                {
1272                   dit = eina_list_nth(wd->items, i);
1273                   item = eina_list_nth(wd->over_items, i - 2);
1274                   eina_stringshare_replace(&item->label, dit->label);
1275                   edje_object_part_text_set(item->base.view, "elm.text", item->label);
1276                }
1277
1278              dit = eina_list_nth(wd->items, eina_list_count(wd->items) - 1);
1279              if (dit)
1280                {
1281                   eina_stringshare_replace(&wd->last->label, dit->label);
1282                   edje_object_part_text_set(wd->last->base.view, "elm.text",
1283                                             wd->last->label);
1284                }
1285              dit = eina_list_nth(wd->items, eina_list_count(wd->items) - 2);
1286              if (dit)
1287                {
1288                   eina_stringshare_replace(&wd->s_last->label, dit->label);
1289                   edje_object_part_text_set(wd->s_last->base.view, "elm.text",
1290                                             wd->s_last->label);
1291                }
1292              // if more than 3 itmes should be displayed
1293              for (i = 3; i <= CEIL(wd->display_item_num); i++)
1294                {
1295                   dit = eina_list_nth(wd->items, wd->item_count - i);
1296                   item = eina_list_nth(wd->under_items, i - 3);
1297                   eina_stringshare_replace(&item->label, dit->label);
1298                   edje_object_part_text_set(item->base.view, "elm.text", item->label);
1299                }
1300           }
1301      }
1302    wd->check_idler = ecore_idler_add(_check_string, wd);
1303    _sizing_eval(wd->self);
1304 }
1305
1306 /**
1307  * Get the label of item
1308  *
1309  * @param it The item of diskselector
1310  * @return The label of item
1311  *
1312  * @ingroup Diskselector
1313  */
1314 EAPI const char *
1315 elm_diskselector_item_label_get(const Elm_Diskselector_Item * it)
1316 {
1317    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, NULL);
1318    return it->label;
1319 }
1320
1321 /**
1322  * Set the label of item
1323  *
1324  * @param it The item of diskselector
1325  * @param label The label of item
1326  *
1327  * @ingroup Diskselector
1328  */
1329 EAPI void
1330 elm_diskselector_item_label_set(Elm_Diskselector_Item * it, const char *label)
1331 {
1332    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it);
1333    eina_stringshare_replace(&it->label, label);
1334    edje_object_part_text_set(it->base.view, "elm.text", it->label);
1335 }
1336
1337 /**
1338  * Get the selected item
1339  *
1340  * @param obj The diskselector object
1341  * @return The selected diskselector item
1342  *
1343  * @ingroup Diskselector
1344  */
1345 EAPI Elm_Diskselector_Item *
1346 elm_diskselector_selected_item_get(const Evas_Object *obj)
1347 {
1348    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1349    Widget_Data *wd = elm_widget_data_get(obj);
1350    if (!wd) return NULL;
1351    return wd->selected_item;
1352 }
1353
1354 /**
1355  * Set the selected state of an item
1356  *
1357  * This sets the selected state (EINA_TRUE selected, EINA_FALSE not selected)
1358  * of the given item @p it.
1359  * If a new item is selected the previosly selected will be unselected.
1360  * If the item @p it is unselected, the first item will be selected.
1361  *
1362  * @param it The diskselector item
1363  * @param selected The selected state
1364  *
1365  * @ingroup Diskselector
1366  */
1367 EAPI void
1368 elm_diskselector_item_selected_set(Elm_Diskselector_Item *it, Eina_Bool selected)
1369 {
1370    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it);
1371    Widget_Data *wd;
1372    wd = elm_widget_data_get(it->base.widget);
1373    if (!wd) return;
1374
1375    if ((wd->selected_item == it) && (selected))
1376      return;
1377
1378    if ((wd->selected_item == it) && (!selected))
1379      wd->selected_item = eina_list_data_get(wd->items);
1380    else
1381      {
1382         wd->selected_item = it;
1383         _selected_item_indicate(wd->selected_item);
1384      }
1385
1386    if (!wd->idler)
1387      ecore_idler_add(_move_scroller, it->base.widget);
1388 }
1389
1390 /*
1391  * Get the selected state of @p item.
1392  *
1393  * @param it The diskselector item
1394  * @return If true, the item is selected
1395  *
1396  * @ingroup Diskselector
1397  */
1398 EAPI Eina_Bool
1399 elm_diskselector_item_selected_get(const Elm_Diskselector_Item *it)
1400 {
1401    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, EINA_FALSE);
1402    Widget_Data *wd;
1403
1404    wd = elm_widget_data_get(it->base.widget);
1405    if (!wd) return EINA_FALSE;
1406    return (wd->selected_item == it);
1407 }
1408
1409 /**
1410  * Set the function called when a diskselector item is freed.
1411  *
1412  * @param it The item to set the callback on
1413  * @param func The function called
1414  *
1415  * @ingroup Diskselector
1416  */
1417 EAPI void
1418 elm_diskselector_item_del_cb_set(Elm_Diskselector_Item *it, Evas_Smart_Cb func)
1419 {
1420    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it);
1421    elm_widget_item_del_cb_set(it, func);
1422 }
1423
1424 /**
1425  * Returns the data associated with the item.
1426  *
1427  * @param it The diskselector item
1428  * @return The data associated with @p it
1429  *
1430  * @ingroup Diskselector
1431  */
1432 EAPI void *
1433 elm_diskselector_item_data_get(const Elm_Diskselector_Item *it)
1434 {
1435    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, NULL);
1436    return elm_widget_item_data_get(it);
1437 }
1438
1439 /**
1440  * Returns the icon associated with the item.
1441  *
1442  * @param it The diskselector item
1443  * @return The icon associated with @p it
1444  *
1445  * @ingroup Diskselector
1446  */
1447 EAPI Evas_Object *
1448 elm_diskselector_item_icon_get(const Elm_Diskselector_Item *it)
1449 {
1450    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, NULL);
1451    return it->icon;
1452 }
1453
1454 /**
1455  * Sets the icon associated with the item.
1456  *
1457  * Once the icon object is set, a previously set one will be deleted.
1458  * You probably don't want, then, to have the <b>same</b> icon object set
1459  * for more than one item of the diskselector.
1460  *
1461  * @param it The diskselector item
1462  * @param icon The icon object to associate with @p it
1463  *
1464  * @ingroup Diskselector
1465  */
1466 EAPI void
1467 elm_diskselector_item_icon_set(Elm_Diskselector_Item *it, Evas_Object *icon)
1468 {
1469    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it);
1470    if (it->icon == icon) return;
1471    if (it->icon)
1472      evas_object_del(it->icon);
1473    it->icon = icon;
1474    if (it->base.view)
1475      edje_object_part_swallow(it->base.view, "elm.swallow.icon", icon);
1476 }
1477
1478 /**
1479  * Gets the item before @p it in the list.
1480  *
1481  * @param it The diskselector item
1482  * @return The item before @p it, or NULL on failure
1483  *
1484  * @ingroup Diskselector
1485  */
1486 EAPI Elm_Diskselector_Item *
1487 elm_diskselector_item_prev_get(const Elm_Diskselector_Item *it)
1488 {
1489    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, NULL);
1490    if (it->node->prev) return it->node->prev->data;
1491    else return NULL;
1492 }
1493
1494 /**
1495  * Gets the item after @p it in the list.
1496  *
1497  * @param it The diskselector item
1498  * @return The item after @p it, or NULL on failure
1499  *
1500  * @ingroup Diskselector
1501  */
1502 EAPI Elm_Diskselector_Item *
1503 elm_diskselector_item_next_get(const Elm_Diskselector_Item *it)
1504 {
1505    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, NULL);
1506    if (it->node->next) return it->node->next->data;
1507    else return NULL;
1508 }
1509
1510 /**
1511  * Get the first item in the diskselector
1512  *
1513  * @param obj The diskselector object
1514  * @return The first item, or NULL if none
1515  *
1516  * @ingroup Diskselector
1517  */
1518 EAPI Elm_Diskselector_Item *
1519 elm_diskselector_first_item_get(const Evas_Object *obj)
1520 {
1521    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1522    Widget_Data *wd;
1523
1524    wd = elm_widget_data_get(obj);
1525    if (!wd || !wd->items)
1526      return NULL;
1527
1528    return eina_list_data_get(wd->items);
1529 }
1530
1531 /**
1532  * Get the last item in the diskselector
1533  *
1534  * @param obj The diskselector object
1535  * @return The last item, or NULL if none
1536  *
1537  * @ingroup Diskselector
1538  */
1539 EAPI Elm_Diskselector_Item *
1540 elm_diskselector_last_item_get(const Evas_Object *obj)
1541 {
1542    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
1543
1544    Widget_Data *wd;
1545    wd = elm_widget_data_get(obj);
1546    if (!wd || !wd->items)
1547      return NULL;
1548
1549    return eina_list_data_get(eina_list_last(wd->items));
1550 }
1551
1552 /**
1553  * Set the text to be shown in the diskselector item.
1554  *
1555  * @param item Target item
1556  * @param text The text to set in the content
1557  *
1558  * Setup the text as tooltip to object. The item can have only one tooltip,
1559  * so any previous tooltip data is removed.
1560  *
1561  * @ingroup Diskselector
1562  */
1563 EAPI void
1564 elm_diskselector_item_tooltip_text_set(Elm_Diskselector_Item *item, const char *text)
1565 {
1566    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1567    elm_widget_item_tooltip_text_set(item, text);
1568 }
1569
1570 /**
1571  * Set the content to be shown in the tooltip item
1572  *
1573  * Setup the tooltip to item. The item can have only one tooltip,
1574  * so any previous tooltip data is removed. @p func(with @p data) will
1575  * be called every time that need show the tooltip and it should
1576  * return a valid Evas_Object. This object is then managed fully by
1577  * tooltip system and is deleted when the tooltip is gone.
1578  *
1579  * @param item the diskselector item being attached a tooltip.
1580  * @param func the function used to create the tooltip contents.
1581  * @param data what to provide to @a func as callback data/context.
1582  * @param del_cb called when data is not needed anymore, either when
1583  *        another callback replaces @func, the tooltip is unset with
1584  *        elm_diskselector_item_tooltip_unset() or the owner @a item
1585  *        dies. This callback receives as the first parameter the
1586  *        given @a data, and @c event_info is the item.
1587  *
1588  * @ingroup Diskselector
1589  */
1590 EAPI void
1591 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)
1592 {
1593    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1594    elm_widget_item_tooltip_content_cb_set(item, func, data, del_cb);
1595 }
1596
1597 /**
1598  * Unset tooltip from item
1599  *
1600  * @param item diskselector item to remove previously set tooltip.
1601  *
1602  * Remove tooltip from item. The callback provided as del_cb to
1603  * elm_diskselector_item_tooltip_content_cb_set() will be called to notify
1604  * it is not used anymore.
1605  *
1606  * @see elm_diskselector_item_tooltip_content_cb_set()
1607  *
1608  * @ingroup Diskselector
1609  */
1610 EAPI void
1611 elm_diskselector_item_tooltip_unset(Elm_Diskselector_Item *item)
1612 {
1613    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1614    elm_widget_item_tooltip_unset(item);
1615 }
1616
1617 /**
1618  * Sets a different style for this item tooltip.
1619  *
1620  * @note before you set a style you should define a tooltip with
1621  *       elm_diskselector_item_tooltip_content_cb_set() or
1622  *       elm_diskselector_item_tooltip_text_set()
1623  *
1624  * @param item diskselector item with tooltip already set.
1625  * @param style the theme style to use (default, transparent, ...)
1626  *
1627  * @ingroup Diskselector
1628  */
1629 EAPI void
1630 elm_diskselector_item_tooltip_style_set(Elm_Diskselector_Item *item, const char *style)
1631 {
1632    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1633    elm_widget_item_tooltip_style_set(item, style);
1634 }
1635
1636 /**
1637  * Get the style for this item tooltip.
1638  *
1639  * @param item diskselector item with tooltip already set.
1640  * @return style the theme style in use, defaults to "default". If the
1641  *         object does not have a tooltip set, then NULL is returned.
1642  *
1643  * @ingroup Diskselector
1644  */
1645 EAPI const char *
1646 elm_diskselector_item_tooltip_style_get(const Elm_Diskselector_Item *item)
1647 {
1648    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item, NULL);
1649    return elm_widget_item_tooltip_style_get(item);
1650 }
1651
1652 /**
1653  * Set the cursor to be shown when mouse is over the diskselector item
1654  *
1655  * @param item Target item
1656  * @param cursor the cursor name to be used.
1657  *
1658  * @see elm_object_cursor_set()
1659  * @ingroup Diskselector
1660  */
1661 EAPI void
1662 elm_diskselector_item_cursor_set(Elm_Diskselector_Item *item, const char *cursor)
1663 {
1664    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1665    elm_widget_item_cursor_set(item, cursor);
1666 }
1667
1668 /**
1669  * Get the cursor to be shown when mouse is over the diskselector item
1670  *
1671  * @param item diskselector item with cursor already set.
1672  * @return the cursor name.
1673  *
1674  * @ingroup Diskselector
1675  */
1676 EAPI const char *
1677 elm_diskselector_item_cursor_get(const Elm_Diskselector_Item *item)
1678 {
1679    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item, NULL);
1680    return elm_widget_item_cursor_get(item);
1681 }
1682
1683 /**
1684  * Unset the cursor to be shown when mouse is over the diskselector item
1685  *
1686  * @param item Target item
1687  *
1688  * @see elm_object_cursor_unset()
1689  * @ingroup Diskselector
1690  */
1691 EAPI void
1692 elm_diskselector_item_cursor_unset(Elm_Diskselector_Item *item)
1693 {
1694    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1695    elm_widget_item_cursor_unset(item);
1696 }
1697
1698 /**
1699  * Sets a different style for this item cursor.
1700  *
1701  * @note before you set a style you should define a cursor with
1702  *       elm_diskselector_item_cursor_set()
1703  *
1704  * @param item diskselector item with cursor already set.
1705  * @param style the theme style to use (default, transparent, ...)
1706  *
1707  * @ingroup Diskselector
1708  */
1709 EAPI void
1710 elm_diskselector_item_cursor_style_set(Elm_Diskselector_Item *item, const char *style)
1711 {
1712    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1713    elm_widget_item_cursor_style_set(item, style);
1714 }
1715
1716 /**
1717  * Get the style for this item cursor.
1718  *
1719  * @param item diskselector item with cursor already set.
1720  * @return style the theme style in use, defaults to "default". If the
1721  *         object does not have a cursor set, then NULL is returned.
1722  *
1723  * @ingroup Diskselector
1724  */
1725 EAPI const char *
1726 elm_diskselector_item_cursor_style_get(const Elm_Diskselector_Item *item)
1727 {
1728    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item, NULL);
1729    return elm_widget_item_cursor_style_get(item);
1730 }
1731
1732 /**
1733  * Set if the cursor set should be searched on the theme or should use
1734  * the provided by the engine, only.
1735  *
1736  * @note before you set if should look on theme you should define a cursor
1737  * with elm_object_cursor_set(). By default it will only look for cursors
1738  * provided by the engine.
1739  *
1740  * @param item widget item with cursor already set.
1741  * @param engine_only boolean to define it cursors should be looked only
1742  * between the provided by the engine or searched on widget's theme as well.
1743  *
1744  * @ingroup Diskselector
1745  */
1746 EAPI void
1747 elm_diskselector_item_cursor_engine_only_set(Elm_Diskselector_Item *item, Eina_Bool engine_only)
1748 {
1749    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item);
1750    elm_widget_item_cursor_engine_only_set(item, engine_only);
1751 }
1752
1753 /**
1754  * Get the cursor engine only usage for this item cursor.
1755  *
1756  * @param item widget item with cursor already set.
1757  * @return engine_only boolean to define it cursors should be looked only
1758  * between the provided by the engine or searched on widget's theme as well. If
1759  *         the object does not have a cursor set, then EINA_FALSE is returned.
1760  *
1761  * @ingroup Diskselector
1762  */
1763 EAPI Eina_Bool
1764 elm_diskselector_item_cursor_engine_only_get(const Elm_Diskselector_Item *item)
1765 {
1766    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(item, EINA_FALSE);
1767    return elm_widget_item_cursor_engine_only_get(item);
1768 }
1769 /**
1770  * Set the number of items to be displayed
1771  *
1772  * @param obj The diskselector object
1773  * @param num The number of itmes that diskselector will display
1774  *
1775  * @ingroup Diskselector
1776  */
1777 EAPI void
1778 elm_diskselector_display_item_num_set(Evas_Object *obj, int num)
1779 {
1780    ELM_CHECK_WIDTYPE(obj, widtype);
1781    Widget_Data *wd = elm_widget_data_get(obj);
1782    if (!wd) return;
1783    if (num < DISPLAY_ITEM_NUM_MIN) num = DISPLAY_ITEM_NUM_MIN;
1784    wd->display_item_num = num;
1785    wd->display_item_num_by_api = EINA_TRUE;
1786 }