src/lib/elm_diskselector.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3 #include "elm_widget_diskselector.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 EAPI const char ELM_DISKSELECTOR_SMART_NAME[] = "elm_diskselector";
  16
  17 static const char SIG_SELECTED[] = "selected";
  18 static const char SIG_CLICKED[] = "clicked";
  19 static const char SIG_SCROLL_ANIM_START[] = "scroll,anim,start";
  20 static const char SIG_SCROLL_ANIM_STOP[] = "scroll,anim,stop";
  21 static const char SIG_SCROLL_DRAG_START[] = "scroll,drag,start";
  22 static const char SIG_SCROLL_DRAG_STOP[] = "scroll,drag,stop";
  23
  24 static const Evas_Smart_Cb_Description _smart_callbacks[] = {
  25    {SIG_SELECTED, ""},
  26    {SIG_CLICKED, ""},
  27    {SIG_SCROLL_ANIM_START, ""},
  28    {SIG_SCROLL_ANIM_STOP, ""},
  29    {SIG_SCROLL_DRAG_START, ""},
  30    {SIG_SCROLL_DRAG_STOP, ""},
  31    {NULL, NULL}
  32 };
  33
  34 static const Evas_Smart_Interface *_smart_interfaces[] =
  35 {
  36    (Evas_Smart_Interface *)&ELM_SCROLLABLE_IFACE, NULL
  37 };
  38
  39 EVAS_SMART_SUBCLASS_IFACE_NEW
  40   (ELM_DISKSELECTOR_SMART_NAME, _elm_diskselector,
  41   Elm_Diskselector_Smart_Class, Elm_Widget_Smart_Class,
  42   elm_widget_smart_class_get, _smart_callbacks, _smart_interfaces);
  43
  44 static void
  45 _selected_item_indicate(Elm_Diskselector_Item *it)
  46 {
  47    Eina_List *l;
  48    Elm_Diskselector_Item *item;
  49
  50    ELM_DISKSELECTOR_DATA_GET(WIDGET(it), sd);
  51
  52    if (!it->label) return;
  53
  54    EINA_LIST_FOREACH(sd->r_items, l, item)
  55      {
  56         if (item->label && !strcmp(item->label, it->label))
  57           edje_object_signal_emit(VIEW(item), "elm,state,selected", "elm");
  58         else
  59           edje_object_signal_emit(VIEW(item), "elm,state,default", "elm");
  60      }
  61 }
  62
  63 static void
  64 _item_select(Elm_Diskselector_Item *it)
  65 {
  66    if (!it) return;
  67
  68    ELM_DISKSELECTOR_DATA_GET(WIDGET(it), sd);
  69
  70    sd->selected_item = it;
  71    _selected_item_indicate(sd->selected_item);
  72
  73    if (it->func) it->func((void *)it->base.data, WIDGET(it), it);
  74    evas_object_smart_callback_call(WIDGET(it), SIG_SELECTED, it);
  75 }
  76
  77 static int
  78 _letters_count(const char *str)
  79 {
  80    int pos = 0;
  81    int code = 0, chnum;
  82
  83    for (chnum = 0;; chnum++)
  84      {
  85         pos = evas_string_char_next_get(str, pos, &code);
  86         if (code == 0) break;
  87      }
  88
  89    return chnum;
  90 }
  91
  92 static int
  93 _letters_check(const char *str,
  94                int length)
  95 {
  96    int pos = 0;
  97    int code = 0, chnum;
  98
  99    for (chnum = 0;; chnum++)
 100      {
 101         if (chnum == length) break;
 102         pos = evas_string_char_next_get(str, pos, &code);
 103         if (code == 0) break;
 104      }
 105
 106    return pos;
 107 }
 108 static void
 109 _item_signal_emit(Elm_Diskselector_Item *item)
 110 {
 111    if ((item->icon) && (!item->label))
 112      edje_object_signal_emit(VIEW(item), "elm,state,icon,only", "elm");
 113    else if ((!item->icon) && (item->label))
 114      edje_object_signal_emit(VIEW(item), "elm,state,text,only", "elm");
 115    else
 116      edje_object_signal_emit(VIEW(item), "elm,state,text,icon", "elm");
 117 }
 118
 119 static Eina_Bool
 120 _string_check(void *data)
 121 {
 122    Elm_Diskselector_Smart_Data *sd = data;
 123    int mid, steps, length, diff;
 124    Elm_Diskselector_Item *it;
 125    Eina_List *list, *l;
 126    Evas_Coord ox, ow;
 127    char buf[1024];
 128
 129    evas_object_geometry_get(ELM_WIDGET_DATA(sd)->obj, &ox, NULL, &ow, NULL);
 130
 131    if (ow <= 0)
 132      return EINA_FALSE;
 133
 134    if (!sd->init)
 135      return EINA_FALSE;
 136
 137    if (!sd->round)
 138      list = sd->items;
 139    else
 140      list = sd->r_items;
 141
 142    EINA_LIST_FOREACH(list, l, it)
 143      {
 144         Evas_Coord x, w;
 145         int len;
 146
 147         if (it->icon && !it->label)
 148           continue;
 149
 150         evas_object_geometry_get(VIEW(it), &x, NULL, &w, NULL);
 151         /* item not visible */
 152         if ((x + w <= ox) || (x >= ox + ow))
 153           continue;
 154
 155         len = _letters_count(it->label);
 156         // FIXME: len should be # of ut8f letters. ie count using utf8
 157         // string walk, not stringshare len
 158         //len = eina_stringshare_strlen(it->label);
 159
 160         if (x <= ox + 5)
 161           edje_object_signal_emit(VIEW(it), "elm,state,left_side", "elm");
 162         else if (x + w >= ox + ow - 5)
 163           edje_object_signal_emit(VIEW(it), "elm,state,right_side", "elm");
 164         else
 165           {
 166              if ((sd->len_threshold) && (len > sd->len_threshold))
 167                edje_object_signal_emit
 168                  (VIEW(it), "elm,state,center_small", "elm");
 169              else
 170                edje_object_signal_emit(VIEW(it), "elm,state,center", "elm");
 171           }
 172
 173         // if len is les that the limit len, skip anyway
 174         if (len <= sd->len_side)
 175           continue;
 176
 177         steps = len - sd->len_side + 1;
 178         mid = x + w / 2;
 179         if (mid <= ox + ow / 2)
 180           diff = (ox + ow / 2) - mid;
 181         else
 182           diff = mid - (ox + ow / 2);
 183
 184         length = len - (int)(diff * steps / (ow / 3));
 185         length = MAX(length, sd->len_side);
 186         // limit string len to "length" ut8f chars
 187         length = _letters_check(it->label, length);
 188         // cut it off at byte mark returned form _letters_check
 189         strncpy(buf, it->label, length);
 190         buf[length] = '\0';
 191         edje_object_part_text_escaped_set(VIEW(it), "elm.text", buf);
 192      }
 193
 194    if (sd->check_idler)
 195      ecore_idle_enterer_del(sd->check_idler);
 196
 197    sd->check_idler = NULL;
 198
 199    return EINA_FALSE;
 200 }
 201
 202 static Eina_Bool
 203 _scroller_move(void *data)
 204 {
 205    Evas_Object *obj = data;
 206    Elm_Diskselector_Item *dit;
 207    Eina_List *list, *l;
 208    Evas_Coord y, w, h;
 209    int i;
 210
 211    ELM_DISKSELECTOR_DATA_GET(obj, sd);
 212
 213    if (!sd->round)
 214      {
 215         i = 0;
 216         list = sd->items;
 217      }
 218    else
 219      {
 220         i = 1;
 221         list = sd->r_items;
 222      }
 223
 224    EINA_LIST_FOREACH(list, l, dit)
 225      {
 226         if (sd->selected_item == dit)
 227           break;
 228         i++;
 229      }
 230
 231    if (sd->round) i -= CEIL(sd->display_item_num);
 232
 233    if (!dit)
 234      {
 235         sd->selected_item =
 236           (Elm_Diskselector_Item *)eina_list_nth(sd->items, 0);
 237         goto end;
 238      }
 239
 240    evas_object_geometry_get(obj, NULL, &y, &w, &h);
 241    sd->s_iface->content_region_show(obj, w / sd->display_item_num * i, y, w, h);
 242    _item_select(dit);
 243
 244    sd->init = EINA_TRUE;
 245    _string_check(sd);
 246
 247 end:
 248    sd->idler = NULL;
 249    return ECORE_CALLBACK_CANCEL;
 250 }
 251
 252 static void
 253 _resize_cb(void *data __UNUSED__,
 254            Evas *e __UNUSED__,
 255            Evas_Object *obj,
 256            void *event_info __UNUSED__)
 257 {
 258    Evas_Coord w, h;
 259
 260    ELM_DISKSELECTOR_DATA_GET(obj, sd);
 261
 262    if ((sd->minw == -1) && (sd->minh == -1))
 263      elm_coords_finger_size_adjust(6, &sd->minw, 1, &sd->minh);
 264
 265    edje_object_size_min_restricted_calc
 266      (ELM_WIDGET_DATA(sd)->resize_obj, &sd->minw, &sd->minh, sd->minw,
 267      sd->minh);
 268
 269    evas_object_size_hint_min_set(obj, sd->minw, sd->minh);
 270    evas_object_size_hint_max_set(obj, -1, -1);
 271
 272    evas_object_geometry_get(obj, NULL, NULL, &w, &h);
 273    if (sd->round)
 274      evas_object_resize(sd->main_box, (w / sd->display_item_num)
 275                         * (sd->item_count + (CEIL(sd->display_item_num) * 2)),
 276                         h);
 277    else
 278      evas_object_resize(sd->main_box, (w / sd->display_item_num)
 279                         * (sd->item_count + eina_list_count(sd->left_blanks)
 280                            + eina_list_count(sd->right_blanks)), h);
 281
 282    sd->s_iface->paging_set(obj, 0, 0, (int)(w / sd->display_item_num), 0);
 283
 284    if (!sd->idler)
 285      sd->idler = ecore_idle_enterer_before_add(_scroller_move, obj);
 286 }
 287
 288 static void
 289 _item_del(Elm_Diskselector_Item *item)
 290 {
 291    if (!item) return;
 292
 293    eina_stringshare_del(item->label);
 294
 295    if (item->icon)
 296      evas_object_del(item->icon);
 297 }
 298
 299 static void
 300 _sizing_eval(Evas_Object *obj)
 301 {
 302    _resize_cb(NULL, NULL, obj, NULL);
 303 }
 304
 305 static Eina_Bool
 306 _item_del_pre_hook(Elm_Object_Item *it)
 307 {
 308    Elm_Diskselector_Item *item, *item2, *dit;
 309    Eina_List *l;
 310    int i = 0;
 311
 312    item = (Elm_Diskselector_Item *)it;
 313
 314    ELM_DISKSELECTOR_DATA_GET(WIDGET(item), sd);
 315
 316    elm_box_unpack(sd->main_box, VIEW(item));
 317
 318    if (sd->round)
 319      sd->r_items = eina_list_remove(sd->r_items, item);
 320
 321    sd->items = eina_list_remove(sd->items, item);
 322
 323    if (sd->selected_item == item)
 324      {
 325         dit = (Elm_Diskselector_Item *)eina_list_nth(sd->items, 0);
 326
 327         if (dit != item)
 328           sd->selected_item = dit;
 329         else
 330           sd->selected_item = eina_list_nth(sd->items, 1);
 331
 332         _selected_item_indicate(sd->selected_item);
 333      }
 334
 335    _item_del(item);
 336    sd->item_count -= 1;
 337
 338    if (sd->round)
 339      {
 340         if (!sd->item_count)
 341           {
 342              evas_object_hide(sd->VIEW(first));
 343              evas_object_hide(sd->VIEW(second));
 344              evas_object_hide(sd->VIEW(last));
 345              evas_object_hide(sd->VIEW(s_last));
 346
 347              EINA_LIST_FOREACH(sd->under_items, l, item2)
 348                evas_object_hide(VIEW(item2));
 349
 350              EINA_LIST_FOREACH(sd->over_items, l, item2)
 351                evas_object_hide(VIEW(item2));
 352           }
 353         else
 354           {
 355              dit = eina_list_nth(sd->items, 0);
 356              if (dit)
 357                {
 358                   eina_stringshare_replace(&sd->first->label, dit->label);
 359                   edje_object_part_text_escaped_set
 360                     (sd->VIEW(first), "elm.text", sd->first->label);
 361                }
 362
 363              dit = eina_list_nth(sd->items, 1);
 364              if (dit)
 365                {
 366                   eina_stringshare_replace(&sd->second->label, dit->label);
 367                   edje_object_part_text_escaped_set
 368                     (sd->VIEW(second), "elm.text", sd->second->label);
 369                }
 370              // if more than 3 itmes should be displayed
 371              for (i = 2; i < CEIL(sd->display_item_num); i++)
 372                {
 373                   dit = eina_list_nth(sd->items, i);
 374                   item2 = eina_list_nth(sd->over_items, i - 2);
 375                   eina_stringshare_replace(&item2->label, dit->label);
 376                   edje_object_part_text_escaped_set
 377                     (VIEW(item2), "elm.text", item2->label);
 378                }
 379
 380              dit = eina_list_nth(sd->items, eina_list_count(sd->items) - 1);
 381              if (dit)
 382                {
 383                   eina_stringshare_replace(&sd->last->label, dit->label);
 384                   edje_object_part_text_escaped_set
 385                     (sd->VIEW(last), "elm.text", sd->last->label);
 386                }
 387
 388              dit = eina_list_nth(sd->items, eina_list_count(sd->items) - 2);
 389              if (dit)
 390                {
 391                   eina_stringshare_replace(&sd->s_last->label, dit->label);
 392                   edje_object_part_text_escaped_set
 393                     (sd->VIEW(s_last), "elm.text", sd->s_last->label);
 394                }
 395              // if more than 3 itmes should be displayed
 396              for (i = 3; i <= CEIL(sd->display_item_num); i++)
 397                {
 398                   dit = eina_list_nth(sd->items, sd->item_count - i);
 399                   item2 = eina_list_nth(sd->under_items, i - 3);
 400                   eina_stringshare_replace(&item2->label, dit->label);
 401                   edje_object_part_text_escaped_set
 402                     (VIEW(item2), "elm.text", item2->label);
 403                }
 404           }
 405      }
 406
 407    sd->check_idler = ecore_idle_enterer_before_add(_string_check, sd);
 408
 409    _sizing_eval(ELM_WIDGET_DATA(sd)->obj);
 410
 411    return EINA_TRUE;
 412 }
 413
 414 static void
 415 _item_text_set_hook(Elm_Object_Item *it,
 416                     const char *part,
 417                     const char *label)
 418 {
 419    Elm_Diskselector_Item *item;
 420
 421    if (part && strcmp(part, "default")) return;
 422
 423    item = (Elm_Diskselector_Item *)it;
 424    eina_stringshare_replace(&item->label, label);
 425    edje_object_part_text_escaped_set(VIEW(item), "elm.text", item->label);
 426
 427    _item_signal_emit(item);
 428 }
 429
 430 static const char *
 431 _item_text_get_hook(const Elm_Object_Item *it,
 432                     const char *part)
 433 {
 434    if (part && strcmp(part, "default")) return NULL;
 435
 436    return ((Elm_Diskselector_Item *)it)->label;
 437 }
 438
 439 static void
 440 _item_icon_set(Elm_Diskselector_Item *it,
 441                Evas_Object *icon)
 442 {
 443    if (it->icon == icon) return;
 444
 445    if (it->icon) evas_object_del(it->icon);
 446    it->icon = icon;
 447
 448    if (VIEW(it))
 449      {
 450         evas_object_size_hint_min_set(it->icon, 24, 24);
 451         evas_object_size_hint_max_set(it->icon, 40, 40);
 452         edje_object_part_swallow(VIEW(it), "elm.swallow.icon", it->icon);
 453         evas_object_show(it->icon);
 454         elm_widget_sub_object_add(WIDGET(it), it->icon);
 455      }
 456
 457    _item_signal_emit(it);
 458 }
 459
 460 static void
 461 _identical_item_check(Elm_Diskselector_Item *it,
 462                       Evas_Object *icon)
 463 {
 464    Elm_Diskselector_Item *dit;
 465    Eina_List *l;
 466    int idx = 0;
 467    int ic = 0;
 468    int ac = 0;
 469
 470    ELM_DISKSELECTOR_DATA_GET(WIDGET(it), sd);
 471
 472    if (sd->round)
 473      {
 474         // Get index from indentical item from round items
 475         EINA_LIST_FOREACH(sd->r_items, l, dit)
 476           {
 477              if (it == dit) break;
 478              idx++;
 479           }
 480
 481         // No item to match
 482         ic = eina_list_count(sd->r_items);
 483
 484         if (idx >= ic) return;
 485         dit = NULL;
 486
 487         // Number of added items: CEIL(sd->display_item_num)
 488         ac = CEIL(sd->display_item_num);
 489
 490         if (((idx >= 0) && (idx < ac)) ||
 491             ((idx >= ac) && (idx < (2 * ac))))
 492           {
 493              // Selected item: under, low region
 494              dit = eina_list_nth(sd->r_items,
 495                                  idx + ic - (2 * ac));
 496           }
 497         else if (((idx >= (ic - ac)) && (idx < ic)) ||
 498                  ((idx >= (ic - (2 * ac))) && (idx < ic - ac)))
 499           {
 500              // Selected item: over, high region
 501              dit = eina_list_nth(sd->r_items,
 502                                  idx - ic + (2 * ac));
 503           }
 504
 505         if (dit) _item_icon_set(dit, icon);
 506         _sizing_eval(ELM_WIDGET_DATA(sd)->obj);
 507      }
 508 }
 509
 510 static void
 511 _item_content_set_hook(Elm_Object_Item *it,
 512                        const char *part,
 513                        Evas_Object *content)
 514 {
 515    if (part && strcmp(part, "icon")) return;
 516
 517    _item_icon_set((Elm_Diskselector_Item *)it, content);
 518    _identical_item_check((Elm_Diskselector_Item *)it, content);
 519 }
 520
 521 static Evas_Object *
 522 _item_content_get_hook(const Elm_Object_Item *it,
 523                        const char *part)
 524 {
 525    if (part && strcmp(part, "icon")) return NULL;
 526
 527    return ((Elm_Diskselector_Item *)it)->icon;
 528 }
 529
 530 static void
 531 _item_click_cb(void *data,
 532                Evas_Object *obj __UNUSED__,
 533                const char *emission __UNUSED__,
 534                const char *source __UNUSED__)
 535 {
 536    Elm_Diskselector_Item *it = data;
 537
 538    if (!it) return;
 539    ELM_DISKSELECTOR_DATA_GET(WIDGET(it), sd);
 540
 541    if (sd->selected_item != it)
 542      {
 543         sd->selected_item = it;
 544         _selected_item_indicate(sd->selected_item);
 545      }
 546
 547    if (it->func) it->func((void *)it->base.data, WIDGET(it), it);
 548    evas_object_smart_callback_call(WIDGET(it), SIG_CLICKED, it);
 549 }
 550
 551 static char *
 552 _access_info_cb(void *data, Evas_Object *obj __UNUSED__)
 553 {
 554    Elm_Diskselector_Item *it = (Elm_Diskselector_Item *)data;
 555    const char *txt = NULL;
 556    if (!it) return NULL;
 557
 558    if (!txt) txt = it->label;
 559    if (txt) return strdup(txt);
 560
 561    return NULL;
 562 }
 563
 564 static void
 565 _access_on_highlight_cb(void *data)
 566 {
 567    Evas_Coord bx, by, bw, bh;
 568    Evas_Coord x, y, w, h;
 569
 570    Elm_Diskselector_Item *it = (Elm_Diskselector_Item *)data;
 571
 572    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it);
 573    ELM_DISKSELECTOR_DATA_GET(WIDGET(it), sd);
 574
 575    evas_smart_objects_calculate(evas_object_evas_get(sd->main_box));
 576    ELM_WIDGET_ITEM_CHECK_OR_RETURN((Elm_Widget_Item *)it);
 577
 578    evas_object_geometry_get(sd->main_box, &bx, &by, &bw, &bh);
 579    evas_object_geometry_get(VIEW(it), &x, &y, &w, &h);
 580
 581    x -= bx;
 582    y -= by;
 583
 584    sd->s_iface->region_bring_in(WIDGET(it), x, y, w, h);
 585 }
 586
 587 static Elm_Diskselector_Item *
 588 _item_new(Evas_Object *obj,
 589           Evas_Object *icon,
 590           const char *label,
 591           Evas_Smart_Cb func,
 592           const void *data)
 593 {
 594    Elm_Diskselector_Item *it;
 595    const char *style = elm_widget_style_get(obj);
 596
 597    it = elm_widget_item_new(obj, Elm_Diskselector_Item);
 598    if (!it) return NULL;
 599
 600    elm_widget_item_del_pre_hook_set(it, _item_del_pre_hook);
 601    elm_widget_item_text_set_hook_set(it, _item_text_set_hook);
 602    elm_widget_item_text_get_hook_set(it, _item_text_get_hook);
 603    elm_widget_item_content_set_hook_set(it, _item_content_set_hook);
 604    elm_widget_item_content_get_hook_set(it, _item_content_get_hook);
 605
 606    it->label = eina_stringshare_add(label);
 607    it->func = func;
 608    it->base.data = data;
 609    VIEW(it) = edje_object_add(evas_object_evas_get(obj));
 610    elm_widget_theme_object_set(obj, VIEW(it), "diskselector", "item", style);
 611
 612    evas_object_size_hint_weight_set
 613      (VIEW(it), EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 614    evas_object_size_hint_align_set(VIEW(it), EVAS_HINT_FILL, EVAS_HINT_FILL);
 615    evas_object_show(VIEW(it));
 616
 617    if (icon)
 618      _item_content_set_hook((Elm_Object_Item *)it, "icon", icon);
 619
 620    if (it->label)
 621      {
 622         _item_text_set_hook((Elm_Object_Item *)it, "default", it->label);
 623         edje_object_signal_callback_add
 624           (VIEW(it), "elm,action,click", "", _item_click_cb, it);
 625      }
 626
 627    //XXX: ACCESS
 628    if (_elm_config->access_mode == ELM_ACCESS_MODE_ON)
 629      {
 630         _elm_access_widget_item_register((Elm_Widget_Item *)it);
 631
 632         _elm_access_text_set(_elm_access_object_get(it->base.access_obj),
 633                              ELM_ACCESS_TYPE, E_("diskselector item"));
 634         _elm_access_callback_set(_elm_access_object_get(it->base.access_obj),
 635                                  ELM_ACCESS_INFO,
 636                                  _access_info_cb, it);
 637         _elm_access_on_highlight_hook_set(
 638            _elm_access_object_get(it->base.access_obj), _access_on_highlight_cb,
 639            it);
 640      }
 641
 642    return it;
 643 }
 644
 645 static Evas_Object *
 646 _blank_add(Evas_Object *obj)
 647 {
 648    Evas_Object *blank;
 649    blank = edje_object_add(evas_object_evas_get(obj));
 650    elm_widget_theme_object_set(obj, blank, "diskselector", "item", "default");
 651    evas_object_size_hint_weight_set(blank, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 652    evas_object_size_hint_align_set(blank, EVAS_HINT_FILL, EVAS_HINT_FILL);
 653
 654    return blank;
 655 }
 656
 657 static void
 658 _blank_item_check(Evas_Object *obj, int item_num)
 659 {
 660    Evas_Object *blank;
 661    Eina_List *last;
 662    int diff, i;
 663
 664    ELM_DISKSELECTOR_DATA_GET(obj, sd);
 665
 666    diff = (item_num / 2) - eina_list_count(sd->left_blanks);
 667    if (!diff) return;
 668
 669    /* left blank */
 670    for (i = 0; i < ((diff > 0) ? (diff) : (-diff)); i++)
 671      {
 672         if (diff > 0)
 673           {
 674              blank = _blank_add(obj);
 675              elm_box_pack_start(sd->main_box, blank);
 676              evas_object_show(blank);
 677              sd->left_blanks = eina_list_append(sd->left_blanks, blank);
 678           }
 679         else
 680           {
 681              last = eina_list_last(sd->left_blanks);
 682              blank = eina_list_data_get(last);
 683              elm_box_unpack(sd->main_box, blank);
 684              evas_object_del(blank);
 685              sd->left_blanks = eina_list_remove_list(sd->left_blanks, last);
 686           }
 687      }
 688
 689    /* right blank */
 690    for (i = 0; i < ((diff > 0) ? (diff) : (-diff)); i++)
 691      {
 692         if (diff > 0)
 693           {
 694              blank = _blank_add(obj);
 695              elm_box_pack_end(sd->main_box, blank);
 696              evas_object_show(blank);
 697              sd->right_blanks = eina_list_append(sd->right_blanks, blank);
 698           }
 699         else
 700           {
 701              last = eina_list_last(sd->right_blanks);
 702              blank = eina_list_data_get(last);
 703              elm_box_unpack(sd->main_box, blank);
 704              evas_object_del(blank);
 705              sd->right_blanks = eina_list_remove_list(sd->right_blanks, last);
 706           }
 707      }
 708 }
 709
 710 static void
 711 _theme_data_get(Evas_Object *obj)
 712 {
 713    const char *str;
 714    Evas_Object *blank;
 715
 716    ELM_DISKSELECTOR_DATA_GET(obj, sd);
 717
 718    blank = eina_list_data_get(sd->right_blanks);
 719    if (blank) return;
 720
 721    str = edje_object_data_get(blank, "len_threshold");
 722    if (str) sd->len_threshold = MAX(0, atoi(str));
 723    else sd->len_threshold = 0;
 724
 725    if (!sd->display_item_num_by_api)
 726      {
 727         str = edje_object_data_get(blank, "display_item_num");
 728         if (str)
 729           {
 730              sd->display_item_num = MAX(DISPLAY_ITEM_NUM_MIN, atoi(str));
 731              if (!sd->round) _blank_item_check(obj, sd->display_item_num);
 732           }
 733
 734         else sd->display_item_num = DISPLAY_ITEM_NUM_MIN;
 735      }
 736
 737    str = edje_object_data_get(blank, "min_width");
 738    if (str) sd->minw = MAX(-1, atoi(str));
 739    else sd->minw = -1;
 740
 741    str = edje_object_data_get(blank, "min_height");
 742    if (str) sd->minh = MAX(-1, atoi(str));
 743    else sd->minh = -1;
 744 }
 745
 746 static Eina_Bool
 747 _elm_diskselector_smart_theme(Evas_Object *obj)
 748 {
 749    Eina_List *l;
 750    Elm_Diskselector_Item *it;
 751    Evas_Object *blank;
 752
 753    ELM_DISKSELECTOR_DATA_GET(obj, sd);
 754
 755    if (!ELM_WIDGET_CLASS(_elm_diskselector_parent_sc)->theme(obj))
 756      return EINA_FALSE;
 757
 758    if (sd->round)
 759      {
 760         EINA_LIST_FOREACH(sd->r_items, l, it)
 761           {
 762              elm_widget_theme_object_set(obj, VIEW(it), "diskselector", "item",
 763                                          elm_widget_style_get(obj));
 764              edje_object_part_text_escaped_set
 765                (VIEW(it), "elm.text", it->label);
 766           }
 767      }
 768    else
 769      {
 770         EINA_LIST_FOREACH(sd->items, l, it)
 771           {
 772              elm_widget_theme_object_set(obj, VIEW(it), "diskselector", "item",
 773                                          elm_widget_style_get(obj));
 774              edje_object_part_text_escaped_set
 775                (VIEW(it), "elm.text", it->label);
 776           }
 777
 778         /* left blank */
 779         EINA_LIST_FOREACH (sd->left_blanks, l, blank)
 780           {
 781              elm_widget_theme_object_set(obj, blank, "diskselector", "item",
 782                                          elm_widget_style_get(obj));
 783           }
 784
 785         /* right blank */
 786         EINA_LIST_FOREACH (sd->right_blanks, l, blank)
 787           {
 788              elm_widget_theme_object_set(obj, blank, "diskselector", "item",
 789                                          elm_widget_style_get(obj));
 790           }
 791      }
 792
 793    _theme_data_get(obj);
 794    _sizing_eval(obj);
 795
 796    return EINA_TRUE;
 797 }
 798
 799 static Eina_Bool
 800 _elm_diskselector_smart_sub_object_del(Evas_Object *obj,
 801                                        Evas_Object *sobj)
 802 {
 803    Elm_Diskselector_Item *it;
 804    const Eina_List *l;
 805
 806    ELM_DISKSELECTOR_DATA_GET(obj, sd);
 807
 808    if (!ELM_WIDGET_CLASS(_elm_diskselector_parent_sc)->sub_object_del
 809          (obj, sobj))
 810      return EINA_FALSE;
 811
 812    EINA_LIST_FOREACH(sd->items, l, it)
 813      {
 814         if (sobj == it->icon)
 815           {
 816              it->icon = NULL;
 817
 818              _sizing_eval(obj);
 819              break;
 820           }
 821      }
 822
 823    return EINA_TRUE;
 824 }
 825
 826 static Eina_Bool
 827 _elm_diskselector_smart_on_focus(Evas_Object *obj)
 828 {
 829    ELM_DISKSELECTOR_DATA_GET(obj, sd);
 830
 831    if (elm_widget_focus_get(obj))
 832      {
 833         edje_object_signal_emit
 834           (ELM_WIDGET_DATA(sd)->resize_obj, "elm,action,focus", "elm");
 835         evas_object_focus_set(ELM_WIDGET_DATA(sd)->resize_obj, EINA_TRUE);
 836      }
 837    else
 838      {
 839         edje_object_signal_emit
 840           (ELM_WIDGET_DATA(sd)->resize_obj, "elm,action,unfocus", "elm");
 841         evas_object_focus_set(ELM_WIDGET_DATA(sd)->resize_obj, EINA_FALSE);
 842      }
 843
 844    return EINA_TRUE;
 845 }
 846
 847 static Eina_Bool
 848 _elm_diskselector_smart_focus_next(const Evas_Object *obj,
 849                            Elm_Focus_Direction dir,
 850                            Evas_Object **next)
 851 {
 852    Eina_List *items = NULL;
 853    Eina_List *elist = NULL;
 854    Elm_Diskselector_Item *it;
 855
 856    ELM_DISKSELECTOR_CHECK(obj) EINA_FALSE;
 857    ELM_DISKSELECTOR_DATA_GET(obj, sd);
 858
 859    EINA_LIST_FOREACH(sd->items, elist, it)
 860      items = eina_list_append(items, it->base.access_obj);
 861
 862    if (!sd->round)
 863      return elm_widget_focus_list_next_get
 864               (obj, items, eina_list_data_get, dir, next);
 865
 866    if (!elm_widget_focus_list_next_get
 867           (obj, items, eina_list_data_get, dir, next))
 868      {
 869         elm_widget_focused_object_clear((Evas_Object *)obj);
 870         elm_widget_focus_list_next_get
 871           (obj, items, eina_list_data_get, dir, next);
 872      }
 873    return EINA_TRUE;
 874 }
 875
 876 static Eina_Bool
 877 _elm_diskselector_smart_event(Evas_Object *obj,
 878                               Evas_Object *src __UNUSED__,
 879                               Evas_Callback_Type type,
 880                               void *event_info)
 881 {
 882    Evas_Event_Key_Down *ev = event_info;
 883    Elm_Diskselector_Item *it = NULL;
 884    Eina_List *l;
 885
 886    ELM_DISKSELECTOR_DATA_GET(obj, sd);
 887
 888    if (type != EVAS_CALLBACK_KEY_DOWN) return EINA_FALSE;
 889    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return EINA_FALSE;
 890    if (elm_widget_disabled_get(obj)) return EINA_FALSE;
 891
 892    if (!sd->selected_item)
 893      {
 894         ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 895
 896         return EINA_TRUE;
 897      }
 898
 899    if ((!strcmp(ev->keyname, "Left")) ||
 900        ((!strcmp(ev->keyname, "KP_Left")) && (!ev->string)) ||
 901        (!strcmp(ev->keyname, "Up")) ||
 902        ((!strcmp(ev->keyname, "KP_Up")) && (!ev->string)))
 903      {
 904         l = sd->selected_item->node->prev;
 905         if ((!l) && (sd->round))
 906           l = eina_list_last(sd->items);
 907      }
 908    else if ((!strcmp(ev->keyname, "Right")) ||
 909             ((!strcmp(ev->keyname, "KP_Right")) && (!ev->string)) ||
 910             (!strcmp(ev->keyname, "Down")) ||
 911             ((!strcmp(ev->keyname, "KP_Down")) && (!ev->string)))
 912      {
 913         l = sd->selected_item->node->next;
 914         if ((!l) && (sd->round))
 915           l = sd->items;
 916      }
 917    else if ((!strcmp(ev->keyname, "Home")) ||
 918             ((!strcmp(ev->keyname, "KP_Home")) && (!ev->string)))
 919      l = sd->items;
 920    else if ((!strcmp(ev->keyname, "End")) ||
 921             ((!strcmp(ev->keyname, "KP_End")) && (!ev->string)))
 922      l = eina_list_last(sd->items);
 923    else return EINA_FALSE;
 924
 925    if (l)
 926      it = eina_list_data_get(l);
 927
 928    if (it)
 929      {
 930         sd->selected_item = it;
 931         if (!sd->idler)
 932           sd->idler = ecore_idle_enterer_before_add(_scroller_move, obj);
 933      }
 934
 935    ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 936
 937    return EINA_TRUE;
 938 }
 939
 940 static void
 941 _scroll_cb(Evas_Object *obj,
 942            void *data __UNUSED__)
 943 {
 944    Evas_Coord x, y, w, h, bw, x_boundary;
 945    unsigned int adjust_pixels;
 946    Eina_Bool h_bounce;
 947
 948    ELM_DISKSELECTOR_DATA_GET(obj, sd);
 949
 950    _string_check(sd);
 951    sd->s_iface->content_pos_get(obj, &x, &y);
 952    sd->s_iface->content_viewport_size_get(obj, &w, &h);
 953    if (sd->round)
 954      {
 955         evas_object_geometry_get(sd->main_box, NULL, NULL, &bw, NULL);
 956         x_boundary = bw - w;
 957
 958         if (x >= x_boundary)
 959           {
 960               if (sd->left_boundary_reached) return;
 961
 962               sd->right_boundary_reached = EINA_TRUE;
 963               sd->s_iface->bounce_allow_get(obj, &h_bounce, NULL);
 964               /* If scroller's bounce effect is disabled, add 1 pixel
 965                *  to provide circular effect */
 966               adjust_pixels = (_elm_config->thumbscroll_bounce_enable
 967                                && h_bounce) ? 0 : 1;
 968               sd->s_iface->content_region_show
 969                  (obj, x - x_boundary + adjust_pixels, y, w, h);
 970               sd->left_boundary_reached = EINA_FALSE;
 971           }
 972         else if (x <= 0)
 973           {
 974               if (sd->right_boundary_reached) return;
 975
 976               sd->left_boundary_reached = EINA_TRUE;
 977               sd->s_iface->bounce_allow_get(obj, &h_bounce, NULL);
 978               /* If scroller's bounce effect is disabled, subtract 1 pixel
 979                *  to provide circular effect */
 980               adjust_pixels = (_elm_config->thumbscroll_bounce_enable
 981                                && h_bounce) ? 0 : 1;
 982               sd->s_iface->content_region_show
 983                  (obj, x + x_boundary - adjust_pixels, y, w, h);
 984               sd->right_boundary_reached = EINA_FALSE;
 985           }
 986         else
 987           {
 988               sd->left_boundary_reached = EINA_FALSE;
 989               sd->right_boundary_reached = EINA_FALSE;
 990           }
 991      }
 992 }
 993
 994 static void
 995 _scroll_animate_stop_cb(Evas_Object *obj,
 996                         void *data __UNUSED__)
 997 {
 998    Elm_Diskselector_Item *it;
 999    Evas_Coord x, w, ox, ow;
1000    Eina_List *l, *list;
1001
1002    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1003
1004    if (sd->idler) return;
1005
1006    if (!sd->round)
1007      list = sd->items;
1008    else
1009      list = sd->r_items;
1010
1011    evas_object_geometry_get(obj, &ox, NULL, &ow, NULL);
1012    EINA_LIST_FOREACH(list, l, it)
1013      {
1014         evas_object_geometry_get(VIEW(it), &x, NULL, &w, NULL);
1015         if (abs((int)(ox + (ow / 2)) - (int)(x + (w / 2))) < 10) break;
1016      }
1017
1018    if (!it) return;
1019    _item_select(it);
1020    evas_object_smart_callback_call(data, SIG_SCROLL_ANIM_STOP, it);
1021 }
1022
1023 static void
1024 _scroll_animate_start_cb(Evas_Object *obj,
1025                          void *data __UNUSED__)
1026 {
1027    evas_object_smart_callback_call
1028      (obj, SIG_SCROLL_ANIM_START, elm_diskselector_selected_item_get(obj));
1029 }
1030
1031 static void
1032 _scroll_drag_start_cb(Evas_Object *obj,
1033                       void *data __UNUSED__)
1034 {
1035    evas_object_smart_callback_call
1036      (obj, SIG_SCROLL_DRAG_START, elm_diskselector_selected_item_get(obj));
1037 }
1038
1039 static void
1040 _scroll_drag_stop_cb(Evas_Object *obj,
1041                      void *data __UNUSED__)
1042 {
1043    evas_object_smart_callback_call
1044      (obj, SIG_SCROLL_DRAG_STOP, elm_diskselector_selected_item_get(obj));
1045 }
1046
1047 static void
1048 _round_item_del(Elm_Diskselector_Smart_Data *sd,
1049                 Elm_Diskselector_Item *it)
1050 {
1051    if (!it) return;
1052
1053    elm_box_unpack(sd->main_box, VIEW(it));
1054    sd->r_items = eina_list_remove(sd->r_items, it);
1055    eina_stringshare_del(it->label);
1056    elm_widget_item_free(it);
1057 }
1058
1059 static void
1060 _round_items_del(Elm_Diskselector_Smart_Data *sd)
1061 {
1062    Eina_List *l;
1063    Elm_Diskselector_Item *it;
1064
1065    _round_item_del(sd, sd->last);
1066    sd->last = NULL;
1067    _round_item_del(sd, sd->s_last);
1068    sd->s_last = NULL;
1069    _round_item_del(sd, sd->second);
1070    sd->second = NULL;
1071    _round_item_del(sd, sd->first);
1072    sd->first = NULL;
1073
1074    EINA_LIST_FOREACH(sd->under_items, l, it)
1075      {
1076         _round_item_del(sd, it);
1077      }
1078    sd->under_items = eina_list_free(sd->under_items);
1079
1080    EINA_LIST_FOREACH(sd->over_items, l, it)
1081      {
1082         _round_item_del(sd, it);
1083      }
1084    sd->over_items = eina_list_free(sd->over_items);
1085 }
1086
1087 static Evas_Object *
1088 _icon_duplicate(Evas_Object *icon)
1089 {
1090    Evas_Object *ic;
1091    const char *file;
1092    const char *group;
1093
1094    if (!icon) return NULL;
1095
1096    elm_image_file_get(icon, &file, &group);
1097    ic = elm_icon_add(icon);
1098    elm_image_file_set(ic, file, group);
1099    elm_image_resizable_set(ic, 1, 1);
1100
1101    return ic;
1102 }
1103
1104 static void
1105 _round_items_add(Elm_Diskselector_Smart_Data *sd)
1106 {
1107    Elm_Diskselector_Item *temp_it;
1108    Elm_Diskselector_Item *dit;
1109    Elm_Diskselector_Item *it;
1110    int i = 0;
1111
1112    dit = it = eina_list_nth(sd->items, 0);
1113    if (!dit) return;
1114
1115    if (!sd->first)
1116      {
1117         sd->first = _item_new
1118             (WIDGET(it), _icon_duplicate(it->icon), it->label, it->func,
1119             it->base.data);
1120         sd->first->node = it->node;
1121         sd->r_items = eina_list_append(sd->r_items, sd->first);
1122      }
1123
1124    it = eina_list_nth(sd->items, 1);
1125    if (!it)
1126      it = dit;
1127
1128    if (!sd->second)
1129      {
1130         sd->second = _item_new
1131             (WIDGET(it), _icon_duplicate(it->icon), it->label, it->func,
1132             it->base.data);
1133         sd->second->node = it->node;
1134         sd->r_items = eina_list_append(sd->r_items, sd->second);
1135      }
1136
1137    // if more than 3 itmes should be displayed
1138    for (i = 2; i < CEIL(sd->display_item_num); i++)
1139      {
1140         it = eina_list_nth(sd->items, i);
1141
1142         if (!it) it = dit;
1143         temp_it = _item_new
1144             (WIDGET(it), _icon_duplicate
1145               (it->icon), it->label, it->func, it->base.data);
1146         sd->over_items = eina_list_append(sd->over_items, temp_it);
1147         sd->r_items = eina_list_append(sd->r_items, temp_it);
1148      }
1149
1150    it = eina_list_nth(sd->items, sd->item_count - 1);
1151    if (!it)
1152      it = dit;
1153    if (!sd->last)
1154      {
1155         sd->last = _item_new
1156             (WIDGET(it), _icon_duplicate(it->icon), it->label, it->func,
1157             it->base.data);
1158         sd->last->node = it->node;
1159         sd->r_items = eina_list_prepend(sd->r_items, sd->last);
1160      }
1161
1162    it = eina_list_nth(sd->items, sd->item_count - 2);
1163    if (!it)
1164      it = dit;
1165    if (!sd->s_last)
1166      {
1167         sd->s_last = _item_new
1168             (WIDGET(it), _icon_duplicate(it->icon), it->label, it->func,
1169             it->base.data);
1170         sd->s_last->node = it->node;
1171         sd->r_items = eina_list_prepend(sd->r_items, sd->s_last);
1172      }
1173
1174    // if more than 3 itmes should be displayed
1175    for (i = 3; i <= CEIL(sd->display_item_num); i++)
1176      {
1177         it = eina_list_nth(sd->items, sd->item_count - i);
1178         if (!it) it = dit;
1179         temp_it = _item_new
1180             (WIDGET(it), _icon_duplicate
1181               (it->icon), it->label, it->func, it->base.data);
1182         sd->under_items = eina_list_append(sd->under_items, temp_it);
1183         sd->r_items = eina_list_prepend(sd->r_items, temp_it);
1184      }
1185 }
1186
1187 static void
1188 _elm_diskselector_smart_add(Evas_Object *obj)
1189 {
1190    EVAS_SMART_DATA_ALLOC(obj, Elm_Diskselector_Smart_Data);
1191
1192    ELM_WIDGET_DATA(priv)->resize_obj =
1193      edje_object_add(evas_object_evas_get(obj));
1194
1195    ELM_WIDGET_CLASS(_elm_diskselector_parent_sc)->base.add(obj);
1196
1197    elm_widget_theme_object_set
1198      (obj, ELM_WIDGET_DATA(priv)->resize_obj, "diskselector", "base",
1199      elm_widget_style_get(obj));
1200
1201    priv->hit_rect = evas_object_rectangle_add(evas_object_evas_get(obj));
1202    evas_object_smart_member_add(priv->hit_rect, obj);
1203    elm_widget_sub_object_add(obj, priv->hit_rect);
1204
1205    /* common scroller hit rectangle setup */
1206    evas_object_color_set(priv->hit_rect, 0, 0, 0, 0);
1207    evas_object_show(priv->hit_rect);
1208    evas_object_repeat_events_set(priv->hit_rect, EINA_TRUE);
1209
1210    elm_widget_can_focus_set(obj, EINA_TRUE);
1211
1212    priv->s_iface = evas_object_smart_interface_get
1213        (obj, ELM_SCROLLABLE_IFACE_NAME);
1214
1215    priv->s_iface->objects_set
1216      (obj, ELM_WIDGET_DATA(priv)->resize_obj, priv->hit_rect);
1217
1218    priv->item_count = 0;
1219    priv->round = EINA_FALSE;
1220    priv->init = EINA_FALSE;
1221    priv->len_side = 3;
1222    priv->display_item_num_by_api = EINA_FALSE;
1223
1224    _elm_diskselector_smart_theme(obj);
1225    priv->s_iface->policy_set
1226      (obj, ELM_SCROLLER_POLICY_OFF, ELM_SCROLLER_POLICY_OFF);
1227    priv->s_iface->bounce_allow_set(obj, EINA_TRUE, EINA_FALSE);
1228
1229    priv->s_iface->animate_start_cb_set(obj, _scroll_animate_start_cb);
1230    priv->s_iface->animate_stop_cb_set(obj, _scroll_animate_stop_cb);
1231    priv->s_iface->drag_start_cb_set(obj, _scroll_drag_start_cb);
1232    priv->s_iface->drag_stop_cb_set(obj, _scroll_drag_stop_cb);
1233    priv->s_iface->scroll_cb_set(obj, _scroll_cb);
1234
1235    evas_object_event_callback_add(obj, EVAS_CALLBACK_RESIZE, _resize_cb, NULL);
1236
1237    priv->main_box = elm_box_add(obj);
1238    elm_box_horizontal_set(priv->main_box, EINA_TRUE);
1239    elm_box_homogeneous_set(priv->main_box, EINA_TRUE);
1240    evas_object_size_hint_weight_set
1241      (priv->main_box, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
1242    evas_object_size_hint_align_set
1243      (priv->main_box, EVAS_HINT_FILL, EVAS_HINT_FILL);
1244    elm_widget_theme_object_set
1245      (obj, priv->main_box, "diskselector", "base", "default");
1246
1247    elm_widget_sub_object_add(obj, priv->main_box);
1248
1249    priv->s_iface->content_set(obj, priv->main_box);
1250
1251    /* left blank */
1252    Evas_Object *blank;
1253    blank = _blank_add(obj);
1254    elm_box_pack_start(priv->main_box, blank);
1255    evas_object_show(blank);
1256    priv->left_blanks = eina_list_append(priv->left_blanks, blank);
1257
1258    /* right blank */
1259    blank = _blank_add(obj);
1260    elm_box_pack_end(priv->main_box, blank);
1261    evas_object_show(blank);
1262    priv->right_blanks = eina_list_append(priv->right_blanks, blank);
1263
1264    _theme_data_get(obj);
1265
1266    _sizing_eval(obj);
1267 }
1268
1269 static void
1270 _elm_diskselector_smart_del(Evas_Object *obj)
1271 {
1272    Elm_Diskselector_Item *it;
1273    Eina_List *l;
1274    Evas_Object *blank;
1275
1276    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1277
1278    /* left blank */
1279    EINA_LIST_FOREACH (sd->left_blanks, l, blank)
1280      evas_object_del(blank);
1281
1282    /* right blank */
1283    EINA_LIST_FOREACH (sd->right_blanks, l, blank)
1284      evas_object_del(blank);
1285
1286    if (sd->last)
1287      {
1288         eina_stringshare_del(sd->last->label);
1289         evas_object_del(sd->VIEW(last));
1290         free(sd->last);
1291      }
1292
1293    if (sd->s_last)
1294      {
1295         eina_stringshare_del(sd->s_last->label);
1296         evas_object_del(sd->VIEW(s_last));
1297         free(sd->s_last);
1298      }
1299
1300    if (sd->second)
1301      {
1302         eina_stringshare_del(sd->second->label);
1303         evas_object_del(sd->VIEW(second));
1304         free(sd->second);
1305      }
1306
1307    if (sd->first)
1308      {
1309         eina_stringshare_del(sd->first->label);
1310         evas_object_del(sd->VIEW(first));
1311         free(sd->first);
1312      }
1313
1314    EINA_LIST_FOREACH(sd->under_items, l, it)
1315      {
1316         if (it)
1317           {
1318              eina_stringshare_del(it->label);
1319              evas_object_del(VIEW(it));
1320              free(it);
1321           }
1322      }
1323
1324    EINA_LIST_FOREACH(sd->over_items, l, it)
1325      {
1326         if (it)
1327           {
1328              eina_stringshare_del(it->label);
1329              evas_object_del(VIEW(it));
1330              free(it);
1331           }
1332      }
1333
1334    EINA_LIST_FREE (sd->items, it)
1335      {
1336         _item_del(it);
1337         elm_widget_item_free(it);
1338      }
1339    eina_list_free(sd->r_items);
1340
1341    if (sd->idler)
1342      {
1343         ecore_idle_enterer_del(sd->idler);
1344         sd->idler = NULL;
1345      }
1346
1347    if (sd->check_idler)
1348      {
1349         ecore_idle_enterer_del(sd->check_idler);
1350         sd->check_idler = NULL;
1351      }
1352
1353    ELM_WIDGET_CLASS(_elm_diskselector_parent_sc)->base.del(obj);
1354 }
1355
1356 static void
1357 _elm_diskselector_smart_move(Evas_Object *obj,
1358                              Evas_Coord x,
1359                              Evas_Coord y)
1360 {
1361    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1362
1363    ELM_WIDGET_CLASS(_elm_diskselector_parent_sc)->base.move(obj, x, y);
1364
1365    evas_object_move(sd->hit_rect, x, y);
1366 }
1367
1368 static void
1369 _elm_diskselector_smart_resize(Evas_Object *obj,
1370                                Evas_Coord w,
1371                                Evas_Coord h)
1372 {
1373    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1374
1375    ELM_WIDGET_CLASS(_elm_diskselector_parent_sc)->base.resize(obj, w, h);
1376
1377    evas_object_resize(sd->hit_rect, w, h);
1378 }
1379
1380 static void
1381 _elm_diskselector_smart_member_add(Evas_Object *obj,
1382                                    Evas_Object *member)
1383 {
1384    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1385
1386    ELM_WIDGET_CLASS(_elm_diskselector_parent_sc)->base.member_add(obj, member);
1387
1388    if (sd->hit_rect)
1389      evas_object_raise(sd->hit_rect);
1390 }
1391
1392 static void
1393 _access_hook(Evas_Object *obj, Eina_Bool is_access)
1394 {
1395    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1396
1397    if (is_access)
1398      ELM_WIDGET_CLASS(ELM_WIDGET_DATA(sd)->api)->focus_next =  _elm_diskselector_smart_focus_next;
1399    else
1400      ELM_WIDGET_CLASS(ELM_WIDGET_DATA(sd)->api)->focus_next = NULL;
1401 }
1402
1403
1404 static void
1405 _elm_diskselector_smart_set_user(Elm_Diskselector_Smart_Class *sc)
1406 {
1407    ELM_WIDGET_CLASS(sc)->base.add = _elm_diskselector_smart_add;
1408    ELM_WIDGET_CLASS(sc)->base.del = _elm_diskselector_smart_del;
1409    ELM_WIDGET_CLASS(sc)->base.move = _elm_diskselector_smart_move;
1410    ELM_WIDGET_CLASS(sc)->base.resize = _elm_diskselector_smart_resize;
1411    ELM_WIDGET_CLASS(sc)->base.member_add = _elm_diskselector_smart_member_add;
1412
1413    ELM_WIDGET_CLASS(sc)->sub_object_del =
1414      _elm_diskselector_smart_sub_object_del;
1415    ELM_WIDGET_CLASS(sc)->on_focus = _elm_diskselector_smart_on_focus;
1416    ELM_WIDGET_CLASS(sc)->theme = _elm_diskselector_smart_theme;
1417    ELM_WIDGET_CLASS(sc)->event = _elm_diskselector_smart_event;
1418
1419    //XXX: ACCESS
1420    if (_elm_config->access_mode == ELM_ACCESS_MODE_ON)
1421      ELM_WIDGET_CLASS(sc)->focus_next = _elm_diskselector_smart_focus_next;
1422
1423    ELM_WIDGET_CLASS(sc)->access = _access_hook;
1424 }
1425
1426 EAPI const Elm_Diskselector_Smart_Class *
1427 elm_diskselector_smart_class_get(void)
1428 {
1429    static Elm_Diskselector_Smart_Class _sc =
1430      ELM_DISKSELECTOR_SMART_CLASS_INIT_NAME_VERSION
1431        (ELM_DISKSELECTOR_SMART_NAME);
1432    static const Elm_Diskselector_Smart_Class *class = NULL;
1433    Evas_Smart_Class *esc = (Evas_Smart_Class *)&_sc;
1434
1435    if (class) return class;
1436
1437    _elm_diskselector_smart_set(&_sc);
1438    esc->callbacks = _smart_callbacks;
1439    class = &_sc;
1440
1441    return class;
1442 }
1443
1444 EAPI Evas_Object *
1445 elm_diskselector_add(Evas_Object *parent)
1446 {
1447    Evas_Object *obj;
1448
1449    EINA_SAFETY_ON_NULL_RETURN_VAL(parent, NULL);
1450
1451    obj = elm_widget_add(_elm_diskselector_smart_class_new(), parent);
1452    if (!obj) return NULL;
1453
1454    if (!elm_widget_sub_object_add(parent, obj))
1455      ERR("could not add %p as sub object of %p", obj, parent);
1456
1457    return obj;
1458 }
1459
1460 EAPI Eina_Bool
1461 elm_diskselector_round_enabled_get(const Evas_Object *obj)
1462 {
1463    ELM_DISKSELECTOR_CHECK(obj) EINA_FALSE;
1464    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1465
1466    return sd->round;
1467 }
1468
1469 EAPI void
1470 elm_diskselector_round_enabled_set(Evas_Object *obj,
1471                                    Eina_Bool enabled)
1472 {
1473    Eina_List *elist;
1474    Elm_Diskselector_Item *it;
1475    Evas_Object *blank;
1476
1477    ELM_DISKSELECTOR_CHECK(obj);
1478    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1479
1480    if (sd->round == enabled)
1481      return;
1482
1483    sd->round = !!enabled;
1484    if (enabled)
1485      {
1486         sd->r_items = eina_list_clone(sd->items);
1487         _blank_item_check(obj, DISPLAY_ITEM_NUM_MIN);
1488
1489         /* left blank */
1490         EINA_LIST_FOREACH (sd->left_blanks, elist, blank)
1491           {
1492              elm_box_unpack(sd->main_box, blank);
1493              evas_object_hide(blank);
1494           }
1495
1496         /* right blank */
1497         EINA_LIST_FOREACH (sd->right_blanks, elist, blank)
1498           {
1499              elm_box_unpack(sd->main_box, blank);
1500              evas_object_hide(blank);
1501           }
1502
1503         if (!sd->items)
1504           return;
1505
1506         _round_items_add(sd);
1507
1508         if (sd->last)
1509           elm_box_pack_start(sd->main_box, sd->VIEW(last));
1510         if (sd->s_last)
1511           elm_box_pack_start(sd->main_box, sd->VIEW(s_last));
1512
1513         // if more than 3 items should be displayed
1514         EINA_LIST_FOREACH(sd->under_items, elist, it)
1515           elm_box_pack_start(sd->main_box, VIEW(it));
1516
1517         if (sd->first)
1518           elm_box_pack_end(sd->main_box, sd->VIEW(first));
1519         if (sd->second)
1520           elm_box_pack_end(sd->main_box, sd->VIEW(second));
1521
1522         // if more than 3 items should be displayed
1523         EINA_LIST_FOREACH(sd->over_items, elist, it)
1524           elm_box_pack_end(sd->main_box, VIEW(it));
1525      }
1526    else
1527      {
1528         _round_items_del(sd);
1529
1530         /* left blank */
1531         EINA_LIST_FOREACH (sd->left_blanks, elist, blank)
1532           {
1533              elm_box_pack_start(sd->main_box, blank);
1534              evas_object_show(blank);
1535           }
1536
1537         /* right blank */
1538         EINA_LIST_FOREACH (sd->right_blanks, elist, blank)
1539           {
1540              elm_box_pack_end(sd->main_box, blank);
1541              evas_object_show(blank);
1542           }
1543
1544         _blank_item_check(obj, sd->display_item_num);
1545
1546         eina_list_free(sd->r_items);
1547         sd->r_items = NULL;
1548      }
1549
1550    if (sd->selected_item) _selected_item_indicate(sd->selected_item);
1551    _sizing_eval(obj);
1552 }
1553
1554 EAPI int
1555 elm_diskselector_side_text_max_length_get(const Evas_Object *obj)
1556 {
1557    ELM_DISKSELECTOR_CHECK(obj) 0;
1558    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1559
1560    return sd->len_side;
1561 }
1562
1563 EAPI void
1564 elm_diskselector_side_text_max_length_set(Evas_Object *obj,
1565                                           int len)
1566 {
1567    ELM_DISKSELECTOR_CHECK(obj);
1568    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1569
1570    sd->len_side = len;
1571 }
1572
1573 EAPI void
1574 elm_diskselector_bounce_set(Evas_Object *obj,
1575                             Eina_Bool h_bounce,
1576                             Eina_Bool v_bounce)
1577 {
1578    ELM_DISKSELECTOR_CHECK(obj);
1579    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1580
1581    sd->s_iface->bounce_allow_set(obj, h_bounce, v_bounce);
1582 }
1583
1584 EAPI void
1585 elm_diskselector_bounce_get(const Evas_Object *obj,
1586                             Eina_Bool *h_bounce,
1587                             Eina_Bool *v_bounce)
1588 {
1589    ELM_DISKSELECTOR_CHECK(obj);
1590    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1591
1592    sd->s_iface->bounce_allow_get(obj, h_bounce, v_bounce);
1593 }
1594
1595 EAPI void
1596 elm_diskselector_scroller_policy_get(const Evas_Object *obj,
1597                                      Elm_Scroller_Policy *policy_h,
1598                                      Elm_Scroller_Policy *policy_v)
1599 {
1600    Elm_Scroller_Policy s_policy_h, s_policy_v;
1601
1602    ELM_DISKSELECTOR_CHECK(obj);
1603    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1604
1605    sd->s_iface->policy_get(obj, &s_policy_h, &s_policy_v);
1606    if (policy_h) *policy_h = (Elm_Scroller_Policy)s_policy_h;
1607    if (policy_v) *policy_v = (Elm_Scroller_Policy)s_policy_v;
1608 }
1609
1610 EAPI void
1611 elm_diskselector_scroller_policy_set(Evas_Object *obj,
1612                                      Elm_Scroller_Policy policy_h,
1613                                      Elm_Scroller_Policy policy_v)
1614 {
1615    ELM_DISKSELECTOR_CHECK(obj);
1616    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1617
1618    if ((policy_h >= ELM_SCROLLER_POLICY_LAST) ||
1619        (policy_v >= ELM_SCROLLER_POLICY_LAST))
1620      return;
1621
1622    sd->s_iface->policy_set(obj, policy_h, policy_v);
1623 }
1624
1625 EAPI void
1626 elm_diskselector_clear(Evas_Object *obj)
1627 {
1628    Elm_Diskselector_Item *it;
1629
1630    ELM_DISKSELECTOR_CHECK(obj);
1631    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1632
1633    if (!sd->items) return;
1634
1635    sd->selected_item = NULL;
1636    EINA_LIST_FREE (sd->items, it)
1637      {
1638         _item_del(it);
1639         elm_widget_item_free(it);
1640      }
1641
1642    _round_items_del(sd);
1643    sd->r_items = eina_list_free(sd->r_items);
1644    _sizing_eval(obj);
1645 }
1646
1647 EAPI const Eina_List *
1648 elm_diskselector_items_get(const Evas_Object *obj)
1649 {
1650    ELM_DISKSELECTOR_CHECK(obj) NULL;
1651    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1652
1653    return sd->items;
1654 }
1655
1656 EAPI Elm_Object_Item *
1657 elm_diskselector_item_append(Evas_Object *obj,
1658                              const char *label,
1659                              Evas_Object *icon,
1660                              Evas_Smart_Cb func,
1661                              const void *data)
1662 {
1663    Elm_Diskselector_Item *it, *dit;
1664    Eina_List *elist;
1665
1666    ELM_DISKSELECTOR_CHECK(obj) NULL;
1667    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1668
1669    it = _item_new(obj, icon, label, func, data);
1670    sd->items = eina_list_append(sd->items, it);
1671    it->node = eina_list_last(sd->items);
1672    sd->item_count++;
1673    if (sd->round)
1674      {
1675         _round_items_del(sd);
1676         sd->r_items = eina_list_append(sd->r_items, it);
1677         _round_items_add(sd);
1678
1679         if (sd->last)
1680           elm_box_pack_start(sd->main_box, sd->VIEW(last));
1681         if (sd->s_last)
1682           elm_box_pack_start(sd->main_box, sd->VIEW(s_last));
1683
1684         // if more than 3 items should be displayed
1685          EINA_LIST_FOREACH (sd->under_items, elist, dit)
1686            elm_box_pack_start(sd->main_box, VIEW(dit));
1687
1688         elm_box_pack_end(sd->main_box, VIEW(it));
1689
1690         if (sd->first)
1691           elm_box_pack_end(sd->main_box, sd->VIEW(first));
1692         if (sd->second)
1693           elm_box_pack_end(sd->main_box, sd->VIEW(second));
1694
1695         // if more than 3 items should be displayed
1696          EINA_LIST_FOREACH (sd->over_items, elist, dit)
1697            elm_box_pack_end(sd->main_box, VIEW(dit));
1698      }
1699    else
1700      {
1701         Evas_Object *blank;
1702         blank = eina_list_data_get(sd->right_blanks);
1703         elm_box_pack_before(sd->main_box, VIEW(it), blank);
1704      }
1705
1706    if (!sd->selected_item)
1707      sd->selected_item = it;
1708
1709    if (!sd->idler)
1710      sd->idler = ecore_idle_enterer_before_add(_scroller_move, obj);
1711
1712    _sizing_eval(obj);
1713    return (Elm_Object_Item *)it;
1714 }
1715
1716 EAPI Elm_Object_Item *
1717 elm_diskselector_selected_item_get(const Evas_Object *obj)
1718 {
1719    ELM_DISKSELECTOR_CHECK(obj) NULL;
1720    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1721
1722    return (Elm_Object_Item *)sd->selected_item;
1723 }
1724
1725 EAPI void
1726 elm_diskselector_item_selected_set(Elm_Object_Item *it,
1727                                    Eina_Bool selected)
1728 {
1729    Elm_Diskselector_Item *item = (Elm_Diskselector_Item *)it;
1730
1731    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it);
1732    ELM_DISKSELECTOR_DATA_GET(WIDGET(item), sd);
1733
1734    if ((sd->selected_item == item) && (selected))
1735      return;
1736
1737    if ((sd->selected_item == item) && (!selected))
1738      sd->selected_item = eina_list_data_get(sd->items);
1739    else
1740      {
1741         sd->selected_item = item;
1742         _selected_item_indicate(sd->selected_item);
1743      }
1744
1745    if (!sd->idler)
1746      sd->idler = ecore_idle_enterer_before_add(_scroller_move, WIDGET(item));
1747 }
1748
1749 EAPI Eina_Bool
1750 elm_diskselector_item_selected_get(const Elm_Object_Item *it)
1751 {
1752    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, EINA_FALSE);
1753    ELM_DISKSELECTOR_DATA_GET(WIDGET(it), sd);
1754
1755    return sd->selected_item == ((Elm_Diskselector_Item *)it);
1756 }
1757
1758 EAPI Elm_Object_Item *
1759 elm_diskselector_item_prev_get(const Elm_Object_Item *it)
1760 {
1761    Elm_Diskselector_Item *item = (Elm_Diskselector_Item *)it;
1762
1763    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, NULL);
1764
1765    if (item->node->prev) return item->node->prev->data;
1766    else return NULL;
1767 }
1768
1769 EAPI Elm_Object_Item *
1770 elm_diskselector_item_next_get(const Elm_Object_Item *it)
1771 {
1772    Elm_Diskselector_Item *item = (Elm_Diskselector_Item *)it;
1773
1774    ELM_DISKSELECTOR_ITEM_CHECK_OR_RETURN(it, NULL);
1775
1776    if (item->node->next) return item->node->next->data;
1777    else return NULL;
1778 }
1779
1780 EAPI Elm_Object_Item *
1781 elm_diskselector_first_item_get(const Evas_Object *obj)
1782 {
1783    ELM_DISKSELECTOR_CHECK(obj) NULL;
1784    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1785    if (!sd || !sd->items) return NULL;
1786    return eina_list_data_get(sd->items);
1787 }
1788
1789 EAPI Elm_Object_Item *
1790 elm_diskselector_last_item_get(const Evas_Object *obj)
1791 {
1792    ELM_DISKSELECTOR_CHECK(obj) NULL;
1793    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1794
1795    if (!sd->items) return NULL;
1796    return eina_list_data_get(eina_list_last(sd->items));
1797 }
1798
1799 EAPI void
1800 elm_diskselector_display_item_num_set(Evas_Object *obj,
1801                                       int num)
1802 {
1803    ELM_DISKSELECTOR_CHECK(obj);
1804    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1805
1806    if (num < DISPLAY_ITEM_NUM_MIN) num = DISPLAY_ITEM_NUM_MIN;
1807    sd->display_item_num = num;
1808    sd->display_item_num_by_api = EINA_TRUE;
1809
1810    if (!sd->round) _blank_item_check(obj, num);
1811 }
1812
1813 EAPI int
1814 elm_diskselector_display_item_num_get(const Evas_Object *obj)
1815 {
1816    ELM_DISKSELECTOR_CHECK(obj) (-1);
1817    ELM_DISKSELECTOR_DATA_GET(obj, sd);
1818
1819    return sd->display_item_num;
1820 }