src/lib/elm_diskselector.c

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