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