src/lib/elm_index.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3
   4 /**
   5  * @defgroup Index Index
   6  *
   7  * An index object is a type of list that categorizes items in it
   8  * by letter.
   9  *
  10  * Signals that you can add callbacks for are:
  11  *
  12  * "changed" - when the selected index item changes
  13  * "delay,changed" - when the selected index item changes, but after some small i
  14  *                   dle period
  15  * "selected" - when the user releases a finger and selects an item
  16  * "level,up" - when the user moves a finger from the first level to the second
  17  *              level
  18  * "level,down" - when the user moves a finger from the second level to the first *                level
  19  */
  20
  21 typedef struct _Widget_Data Widget_Data;
  22
  23 struct _Widget_Data
  24 {
  25    Evas_Object *base;
  26    Evas_Object *event[2];
  27    Evas_Object *bx[2]; // 2 - for now all that's supported
  28    Eina_List *items; // 1 list. yes N levels, but only 2 for now and # of items will be small
  29    int level;
  30    Evas_Coord dx, dy;
  31    Ecore_Timer *delay;
  32    Eina_Bool level_active[2];
  33    Eina_Bool horizontal : 1;
  34    Eina_Bool active : 1;
  35    Eina_Bool down : 1;
  36 };
  37
  38 struct _Elm_Index_Item
  39 {
  40    Elm_Widget_Item base;
  41    const char *letter;
  42    int level;
  43    Eina_Bool selected : 1;
  44 };
  45
  46 static const char *widtype = NULL;
  47 static void _mirrored_set(Evas_Object *obj, Eina_Bool rtl);
  48 static void _theme_hook(Evas_Object *obj);
  49 static void _sizing_eval(Evas_Object *obj);
  50 static void _index_box_auto_fill(Evas_Object *obj, Evas_Object *box, int level);
  51 static void _index_box_clear(Evas_Object *obj, Evas_Object *box, int level);
  52 static void _item_free(Elm_Index_Item *it);
  53
  54 static const char SIG_CHANGED[] = "changed";
  55 static const char SIG_DELAY_CHANGED[] = "delay,changed";
  56 static const char SIG_SELECTED[] = "selected";
  57 static const char SIG_LEVEL_UP[] = "level,up";
  58 static const char SIG_LEVEL_DOWN[] = "level,down";
  59
  60 static const Evas_Smart_Cb_Description _signals[] = {
  61    {SIG_CHANGED, ""},
  62    {SIG_DELAY_CHANGED, ""},
  63    {SIG_SELECTED, ""},
  64    {SIG_LEVEL_UP, ""},
  65    {SIG_LEVEL_DOWN, ""},
  66    {NULL, NULL}
  67 };
  68
  69 static void
  70 _del_pre_hook(Evas_Object *obj)
  71 {
  72    Widget_Data *wd = elm_widget_data_get(obj);
  73    if (!wd) return;
  74    _index_box_clear(obj, wd->bx[wd->level], wd->level);
  75    _index_box_clear(obj, wd->bx[0], 0);
  76    while (wd->items) _item_free(wd->items->data);
  77    if (wd->delay) ecore_timer_del(wd->delay);
  78 }
  79
  80 static void
  81 _del_hook(Evas_Object *obj)
  82 {
  83    Widget_Data *wd = elm_widget_data_get(obj);
  84    free(wd);
  85 }
  86
  87 static void
  88 _layout(Evas_Object *o, Evas_Object_Box_Data *priv, void *data)
  89 {
  90    Widget_Data *wd = data;
  91    if (!wd) return;
  92    _els_box_layout(o, priv, wd->horizontal, 1, 0);
  93 }
  94
  95 static void
  96 _signal_emit_hook(Evas_Object *obj, const char *emission, const char *source)
  97 {
  98    Widget_Data *wd = elm_widget_data_get(obj);
  99    if (!wd) return;
 100    edje_object_signal_emit(wd->base, emission, source);
 101 }
 102
 103 static void
 104 _signal_callback_add_hook(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func_cb, void *data)
 105 {
 106    Widget_Data *wd = elm_widget_data_get(obj);
 107    if (!wd) return;
 108    edje_object_signal_callback_add(wd->base, emission, source, func_cb, data);
 109 }
 110
 111 static void
 112 _signal_callback_del_hook(Evas_Object *obj, const char *emission, const char *source, Edje_Signal_Cb func_cb, void *data)
 113 {
 114    Widget_Data *wd = elm_widget_data_get(obj);
 115    edje_object_signal_callback_del_full(wd->base, emission, source, func_cb,
 116                                         data);
 117 }
 118
 119 static void
 120 _mirrored_set(Evas_Object *obj, Eina_Bool rtl)
 121 {
 122    Widget_Data *wd = elm_widget_data_get(obj);
 123    if (!wd) return;
 124    if (!wd->horizontal)
 125      edje_object_mirrored_set(wd->base, rtl);
 126 }
 127
 128 static void
 129 _theme_hook(Evas_Object *obj)
 130 {
 131    Evas_Coord minw = 0, minh = 0;
 132    Widget_Data *wd = elm_widget_data_get(obj);
 133    if (!wd) return;
 134    _elm_widget_mirrored_reload(obj);
 135
 136    _index_box_clear(obj, wd->bx[0], 0);
 137    _index_box_clear(obj, wd->bx[1], 1);
 138    if (wd->horizontal)
 139      _elm_theme_object_set(obj, wd->base, "index", "base/horizontal", elm_widget_style_get(obj));
 140    else
 141      {
 142         _elm_theme_object_set(obj, wd->base, "index", "base/vertical", elm_widget_style_get(obj));
 143         _mirrored_set(obj, elm_widget_mirrored_get(obj));
 144      }
 145    edje_object_part_swallow(wd->base, "elm.swallow.event.0", wd->event[0]);
 146    elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 147    evas_object_size_hint_min_set(wd->event[0], minw, minh);
 148    edje_object_part_swallow(wd->base, "elm.swallow.index.0", wd->bx[0]);
 149    if (edje_object_part_exists(wd->base, "elm.swallow.index.1"))
 150      {
 151         if (!wd->bx[1])
 152           {
 153              wd->bx[1] = evas_object_box_add(evas_object_evas_get(wd->base));
 154              evas_object_box_layout_set(wd->bx[1], _layout, wd, NULL);
 155              elm_widget_sub_object_add(obj, wd->bx[1]);
 156           }
 157         edje_object_part_swallow(wd->base, "elm.swallow.index.1", wd->bx[1]);
 158         evas_object_show(wd->bx[1]);
 159      }
 160    else if (wd->bx[1])
 161      {
 162         evas_object_del(wd->bx[1]);
 163         wd->bx[1] = NULL;
 164      }
 165    if (edje_object_part_exists(wd->base, "elm.swallow.event.1"))
 166      {
 167         if (!wd->event[1])
 168           {
 169              wd->event[1] = evas_object_rectangle_add(evas_object_evas_get(wd->base));
 170              evas_object_color_set(wd->event[1], 0, 0, 0, 0);
 171              elm_widget_sub_object_add(obj, wd->event[1]);
 172           }
 173         edje_object_part_swallow(wd->base, "elm.swallow.event.1", wd->event[1]);
 174         evas_object_size_hint_min_set(wd->event[1], minw, minh);
 175      }
 176    else if (wd->event[1])
 177      {
 178         evas_object_del(wd->event[1]);
 179         wd->event[1] = NULL;
 180      }
 181    edje_object_message_signal_process(wd->base);
 182    edje_object_scale_set(wd->base, elm_widget_scale_get(obj) * _elm_config->scale);
 183    _sizing_eval(obj);
 184    _index_box_auto_fill(obj, wd->bx[0], 0);
 185    if (wd->active)
 186      if (wd->level == 1)
 187        _index_box_auto_fill(obj, wd->bx[1], 1);
 188 }
 189
 190 static void
 191 _sizing_eval(Evas_Object *obj)
 192 {
 193    Widget_Data *wd = elm_widget_data_get(obj);
 194    Evas_Coord minw = -1, minh = -1, maxw = -1, maxh = -1;
 195    if (!wd) return;
 196    edje_object_size_min_calc(wd->base, &minw, &minh);
 197    evas_object_size_hint_min_set(obj, minw, minh);
 198    evas_object_size_hint_max_set(obj, maxw, maxh);
 199 }
 200
 201 static Elm_Index_Item *
 202 _item_new(Evas_Object *obj, const char *letter, const void *item)
 203 {
 204    Widget_Data *wd = elm_widget_data_get(obj);
 205    Elm_Index_Item *it;
 206    if (!wd) return NULL;
 207    it = elm_widget_item_new(obj, Elm_Index_Item);
 208    if (!it) return NULL;
 209    it->letter = eina_stringshare_add(letter);
 210    it->base.data = item;
 211    it->level = wd->level;
 212    return it;
 213 }
 214
 215 static Elm_Index_Item *
 216 _item_find(Evas_Object *obj, const void *item)
 217 {
 218    Widget_Data *wd = elm_widget_data_get(obj);
 219    Eina_List *l;
 220    Elm_Index_Item *it;
 221    if (!wd) return NULL;
 222    EINA_LIST_FOREACH(wd->items, l, it)
 223       if (it->base.data == item) return it;
 224    return NULL;
 225 }
 226
 227 static void
 228 _item_free(Elm_Index_Item *it)
 229 {
 230    Widget_Data *wd = elm_widget_data_get(it->base.widget);
 231    if (!wd) return;
 232    wd->items = eina_list_remove(wd->items, it);
 233    elm_widget_item_pre_notify_del(it);
 234    eina_stringshare_del(it->letter);
 235    elm_widget_item_del(it);
 236 }
 237
 238 // FIXME: always have index filled
 239 static void
 240 _index_box_auto_fill(Evas_Object *obj, Evas_Object *box, int level)
 241 {
 242    Widget_Data *wd = elm_widget_data_get(obj);
 243    Eina_Bool rtl;
 244    Eina_List *l;
 245    Elm_Index_Item *it;
 246    Evas_Coord mw, mh, w, h;
 247    int i = 0;
 248    if (!wd) return;
 249    if (wd->level_active[level]) return;
 250    rtl = elm_widget_mirrored_get(obj);
 251    evas_object_geometry_get(box, NULL, NULL, &w, &h);
 252    EINA_LIST_FOREACH(wd->items, l, it)
 253      {
 254         Evas_Object *o;
 255         const char *stacking;
 256
 257         if (it->level != level) continue;
 258         o = edje_object_add(evas_object_evas_get(obj));
 259         it->base.view = o;
 260         edje_object_mirrored_set(it->base.view, rtl);
 261         if (i & 0x1)
 262           _elm_theme_object_set(obj, o, "index", "item_odd/vertical", elm_widget_style_get(obj));
 263         else
 264           _elm_theme_object_set(obj, o, "index", "item/vertical", elm_widget_style_get(obj));
 265         edje_object_part_text_set(o, "elm.text", it->letter);
 266         edje_object_size_min_restricted_calc(o, &mw, &mh, 0, 0);
 267         evas_object_size_hint_min_set(o, mw, mh);
 268         evas_object_size_hint_weight_set(o, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 269         evas_object_size_hint_align_set(o, EVAS_HINT_FILL, EVAS_HINT_FILL);
 270         elm_widget_sub_object_add(obj, o);
 271         evas_object_box_append(box, o);
 272         stacking = edje_object_data_get(o, "stacking");
 273         if (stacking)
 274           {
 275              if (!strcmp(stacking, "below")) evas_object_lower(o);
 276              else if (!strcmp(stacking, "above")) evas_object_raise(o);
 277           }
 278         evas_object_show(o);
 279         i++;
 280         evas_object_smart_calculate(box); // force a calc so we know the size
 281         evas_object_size_hint_min_get(box, &mw, &mh);
 282         if (mh > h)
 283           {
 284              _index_box_clear(obj, box, level);
 285              if (i > 0)
 286                {
 287                   // FIXME: only i objects fit! try again. overflows right now
 288                }
 289           }
 290      }
 291    evas_object_smart_calculate(box);
 292    wd->level_active[level] = 1;
 293 }
 294
 295 static void
 296 _index_box_clear(Evas_Object *obj, Evas_Object *box __UNUSED__, int level)
 297 {
 298    Widget_Data *wd = elm_widget_data_get(obj);
 299    Eina_List *l;
 300    Elm_Index_Item *it;
 301    if (!wd) return;
 302    if (!wd->level_active[level]) return;
 303    EINA_LIST_FOREACH(wd->items, l, it)
 304      {
 305         if (!it->base.view) continue;
 306         if (it->level != level) continue;
 307         evas_object_del(it->base.view);
 308         it->base.view = NULL;
 309      }
 310    wd->level_active[level] = 0;
 311 }
 312
 313 static Eina_Bool
 314 _delay_change(void *data)
 315 {
 316    Widget_Data *wd = elm_widget_data_get(data);
 317    void *d;
 318    if (!wd) return ECORE_CALLBACK_CANCEL;
 319    wd->delay = NULL;
 320    d = (void *)elm_index_item_selected_get(data, wd->level);
 321    if (d) evas_object_smart_callback_call(data, SIG_DELAY_CHANGED, d);
 322    return ECORE_CALLBACK_CANCEL;
 323 }
 324
 325 static void
 326 _sel_eval(Evas_Object *obj, Evas_Coord evx, Evas_Coord evy)
 327 {
 328    Widget_Data *wd = elm_widget_data_get(obj);
 329    Elm_Index_Item *it, *it_closest, *it_last;
 330    Eina_List *l;
 331    Evas_Coord x, y, w, h, bx, by, bw, bh, xx, yy;
 332    double cdv = 0.5;
 333    Evas_Coord dist;
 334    char *label = NULL, *last = NULL;
 335    int i;
 336    if (!wd) return;
 337    for (i = 0; i <= wd->level; i++)
 338      {
 339         it_last = NULL;
 340         it_closest  = NULL;
 341         dist = 0x7fffffff;
 342         evas_object_geometry_get(wd->bx[i], &bx, &by, &bw, &bh);
 343         EINA_LIST_FOREACH(wd->items, l, it)
 344           {
 345              if (!((it->level == i) && (it->base.view))) continue;
 346              if ((it->base.view) && (it->level != wd->level))
 347                {
 348                   if (it->selected)
 349                     {
 350                        it_closest = it;
 351                        break;
 352                     }
 353                   continue;
 354                }
 355              if (it->selected)
 356                {
 357                   it_last = it;
 358                   it->selected = 0;
 359                }
 360              evas_object_geometry_get(it->base.view, &x, &y, &w, &h);
 361              xx = x + (w / 2);
 362              yy = y + (h / 2);
 363              x = evx - xx;
 364              y = evy - yy;
 365              x = (x * x) + (y * y);
 366              if ((x < dist) || (!it_closest))
 367                {
 368                   if (wd->horizontal)
 369                     cdv = (double)(xx - bx) / (double)bw;
 370                   else
 371                     cdv = (double)(yy - by) / (double)bh;
 372                   it_closest = it;
 373                   dist = x;
 374                }
 375           }
 376         if ((!i) && (!wd->level))
 377           edje_object_part_drag_value_set(wd->base, "elm.dragable.index.1",
 378                                           cdv, cdv);
 379         if (it_closest) it_closest->selected = 1;
 380         if (it_closest != it_last)
 381           {
 382              if (it_last)
 383                {
 384                   const char *stacking, *selectraise;
 385
 386                   it = it_last;
 387                   edje_object_signal_emit(it->base.view, "elm,state,inactive", "elm");
 388                   stacking = edje_object_data_get(it->base.view, "stacking");
 389                   selectraise = edje_object_data_get(it->base.view, "selectraise");
 390                   if ((selectraise) && (!strcmp(selectraise, "on")))
 391                     {
 392                        if ((stacking) && (!strcmp(stacking, "below")))
 393                          evas_object_lower(it->base.view);
 394                     }
 395                }
 396              if (it_closest)
 397                {
 398                   const char *selectraise;
 399
 400                   it = it_closest;
 401                   edje_object_signal_emit(it->base.view, "elm,state,active", "elm");
 402                   selectraise = edje_object_data_get(it->base.view, "selectraise");
 403                   if ((selectraise) && (!strcmp(selectraise, "on")))
 404                     evas_object_raise(it->base.view);
 405                   evas_object_smart_callback_call((void *)obj, SIG_CHANGED, (void *)it->base.data);
 406                   if (wd->delay) ecore_timer_del(wd->delay);
 407                   wd->delay = ecore_timer_add(0.2, _delay_change, obj);
 408                }
 409           }
 410         if (it_closest)
 411           {
 412              it = it_closest;
 413              if (!last)
 414                last = strdup(it->letter);
 415              else
 416                {
 417                   if (!label) label = strdup(last);
 418                   else
 419                     {
 420                        /* FIXME: realloc return NULL if the request fails */
 421                        label = realloc(label, strlen(label) + strlen(last) + 1);
 422                        strcat(label, last);
 423                     }
 424                   free(last);
 425                   last = strdup(it->letter);
 426                }
 427           }
 428      }
 429    if (!label) label = strdup("");
 430    if (!last) last = strdup("");
 431    edje_object_part_text_set(wd->base, "elm.text.body", label);
 432    edje_object_part_text_set(wd->base, "elm.text", last);
 433    free(label);
 434    free(last);
 435 }
 436
 437 static void
 438 _wheel(void *data, Evas *e __UNUSED__, Evas_Object *o __UNUSED__, void *event_info __UNUSED__)
 439 {
 440    Widget_Data *wd = elm_widget_data_get(data);
 441    //   Evas_Event_Mouse_Wheel *ev = event_info;
 442    //   Evas_Object *obj = o;
 443    if (!wd) return;
 444 }
 445
 446 static void
 447 _mouse_down(void *data, Evas *e __UNUSED__, Evas_Object *o __UNUSED__, void *event_info)
 448 {
 449    Widget_Data *wd = elm_widget_data_get(data);
 450    Evas_Event_Mouse_Down *ev = event_info;
 451    Evas_Coord x, y, w;
 452    if (!wd) return;
 453    if (ev->button != 1) return;
 454    wd->down = 1;
 455    evas_object_geometry_get(wd->base, &x, &y, &w, NULL);
 456    wd->dx = ev->canvas.x - x;
 457    wd->dy = ev->canvas.y - y;
 458    elm_index_active_set(data, 1);
 459    _sel_eval(data, ev->canvas.x, ev->canvas.y);
 460    edje_object_part_drag_value_set(wd->base, "elm.dragable.pointer",
 461                                    (!edje_object_mirrored_get(wd->base)) ? wd->dx : (wd->dx - w), wd->dy);
 462 }
 463
 464 static void
 465 _mouse_up(void *data, Evas *e __UNUSED__, Evas_Object *o __UNUSED__, void *event_info)
 466 {
 467    Widget_Data *wd = elm_widget_data_get(data);
 468    Evas_Event_Mouse_Up *ev = event_info;
 469    void *d;
 470    if (!wd) return;
 471    if (ev->button != 1) return;
 472    wd->down = 0;
 473    d = (void *)elm_index_item_selected_get(data, wd->level);
 474    if (d) evas_object_smart_callback_call(data, SIG_SELECTED, d);
 475    elm_index_active_set(data, 0);
 476    edje_object_signal_emit(wd->base, "elm,state,level,0", "elm");
 477 }
 478
 479 static void
 480 _mouse_move(void *data, Evas *e __UNUSED__, Evas_Object *o __UNUSED__, void *event_info)
 481 {
 482    Widget_Data *wd = elm_widget_data_get(data);
 483    Evas_Event_Mouse_Move *ev = event_info;
 484    Evas_Coord minw = 0, minh = 0, x, y, dx, adx, w;
 485    char buf[1024];
 486    if (!wd) return;
 487    if (!wd->down) return;
 488    elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 489    evas_object_geometry_get(wd->base, &x, &y, &w, NULL);
 490    x = ev->cur.canvas.x - x;
 491    y = ev->cur.canvas.y - y;
 492    dx = x - wd->dx;
 493    adx = dx;
 494    if (adx < 0) adx = -dx;
 495    edje_object_part_drag_value_set(wd->base, "elm.dragable.pointer"
 496                                    , (!edje_object_mirrored_get(wd->base)) ? x : (x - w), y);
 497    if (!wd->horizontal)
 498      {
 499         if (adx > minw)
 500           {
 501              if (!wd->level)
 502                {
 503                   wd->level = 1;
 504                   snprintf(buf, sizeof(buf), "elm,state,level,%i", wd->level);
 505                   edje_object_signal_emit(wd->base, buf, "elm");
 506                   evas_object_smart_callback_call(data, SIG_LEVEL_UP, NULL);
 507                }
 508           }
 509         else
 510           {
 511              if (wd->level == 1)
 512                {
 513                   wd->level = 0;
 514                   snprintf(buf, sizeof(buf), "elm,state,level,%i", wd->level);
 515                   edje_object_signal_emit(wd->base, buf, "elm");
 516                   evas_object_smart_callback_call(data, SIG_LEVEL_DOWN, NULL);
 517                }
 518           }
 519      }
 520    _sel_eval(data, ev->cur.canvas.x, ev->cur.canvas.y);
 521 }
 522
 523 /**
 524  * Add a new index to the parent
 525  *
 526  * @param parent The parent object
 527  * @return The new object or NULL if it cannot be created
 528  *
 529  * @ingroup Index
 530  */
 531 EAPI Evas_Object *
 532 elm_index_add(Evas_Object *parent)
 533 {
 534    Evas_Object *obj;
 535    Evas_Object *o;
 536    Evas *e;
 537    Widget_Data *wd;
 538    Evas_Coord minw, minh;
 539
 540    ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
 541
 542    ELM_SET_WIDTYPE(widtype, "index");
 543    elm_widget_type_set(obj, "index");
 544    elm_widget_sub_object_add(parent, obj);
 545    elm_widget_data_set(obj, wd);
 546    elm_widget_del_hook_set(obj, _del_hook);
 547    elm_widget_del_pre_hook_set(obj, _del_pre_hook);
 548    elm_widget_theme_hook_set(obj, _theme_hook);
 549    elm_widget_signal_emit_hook_set(obj, _signal_emit_hook);
 550    elm_widget_signal_callback_add_hook_set(obj, _signal_callback_add_hook);
 551    elm_widget_signal_callback_del_hook_set(obj, _signal_callback_del_hook);
 552    elm_widget_can_focus_set(obj, EINA_FALSE);
 553
 554    wd->horizontal = EINA_FALSE;
 555
 556    wd->base = edje_object_add(e);
 557    _elm_theme_object_set(obj, wd->base, "index", "base/vertical", "default");
 558    elm_widget_resize_object_set(obj, wd->base);
 559
 560    o = evas_object_rectangle_add(e);
 561    wd->event[0] = o;
 562    evas_object_color_set(o, 0, 0, 0, 0);
 563    minw = minh = 0;
 564    elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 565    evas_object_size_hint_min_set(o, minw, minh);
 566    edje_object_part_swallow(wd->base, "elm.swallow.event.0", o);
 567    elm_widget_sub_object_add(obj, o);
 568    evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_WHEEL, _wheel, obj);
 569    evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_DOWN, _mouse_down, obj);
 570    evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_UP, _mouse_up, obj);
 571    evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_MOVE, _mouse_move, obj);
 572    evas_object_show(o);
 573    if (edje_object_part_exists(wd->base, "elm.swallow.event.1"))
 574      {
 575         o = evas_object_rectangle_add(e);
 576         wd->event[1] = o;
 577         evas_object_color_set(o, 0, 0, 0, 0);
 578         evas_object_size_hint_min_set(o, minw, minh);
 579         edje_object_part_swallow(wd->base, "elm.swallow.event.1", o);
 580         elm_widget_sub_object_add(obj, o);
 581      }
 582
 583    wd->bx[0] = evas_object_box_add(e);
 584    evas_object_box_layout_set(wd->bx[0], _layout, wd, NULL);
 585    elm_widget_sub_object_add(obj, wd->bx[0]);
 586    edje_object_part_swallow(wd->base, "elm.swallow.index.0", wd->bx[0]);
 587    evas_object_show(wd->bx[0]);
 588
 589    if (edje_object_part_exists(wd->base, "elm.swallow.index.1"))
 590      {
 591         wd->bx[1] = evas_object_box_add(e);
 592         evas_object_box_layout_set(wd->bx[1], _layout, wd, NULL);
 593         elm_widget_sub_object_add(obj, wd->bx[1]);
 594         edje_object_part_swallow(wd->base, "elm.swallow.index.1", wd->bx[1]);
 595         evas_object_show(wd->bx[1]);
 596      }
 597
 598    evas_object_smart_callbacks_descriptions_set(obj, _signals);
 599
 600    _mirrored_set(obj, elm_widget_mirrored_get(obj));
 601    _sizing_eval(obj);
 602    return obj;
 603 }
 604
 605 /**
 606  * Set the active state of the index programatically
 607  *
 608  * @param obj The index object
 609  * @param active The active starte
 610  *
 611  * @ingroup Index
 612  */
 613 EAPI void
 614 elm_index_active_set(Evas_Object *obj, Eina_Bool active)
 615 {
 616    ELM_CHECK_WIDTYPE(obj, widtype);
 617    Widget_Data *wd = elm_widget_data_get(obj);
 618    if (!wd) return;
 619    if (wd->active == active) return;
 620    wd->active = active;
 621    wd->level = 0;
 622    if (wd->active)
 623      {
 624         _index_box_clear(obj, wd->bx[1], 1);
 625         _index_box_auto_fill(obj, wd->bx[0], 0);
 626         edje_object_signal_emit(wd->base, "elm,state,active", "elm");
 627      }
 628    else
 629      edje_object_signal_emit(wd->base, "elm,state,inactive", "elm");
 630 }
 631
 632 /**
 633  * Sets the level of the item.
 634  *
 635  * @param obj The index object.
 636  * @param level To be documented.
 637  *
 638  * @ingroup Index
 639  */
 640 EAPI void
 641 elm_index_item_level_set(Evas_Object *obj, int level)
 642 {
 643    ELM_CHECK_WIDTYPE(obj, widtype);
 644    Widget_Data *wd = elm_widget_data_get(obj);
 645    if (!wd) return;
 646    if (wd->level == level) return;
 647    wd->level = level;
 648 }
 649
 650 /**
 651  * Gets the level of the item.
 652  *
 653  * @param obj The index object
 654  *
 655  * @ingroup Index
 656  */
 657 EAPI int
 658 elm_index_item_level_get(const Evas_Object *obj)
 659 {
 660    ELM_CHECK_WIDTYPE(obj, widtype) 0;
 661    Widget_Data *wd = elm_widget_data_get(obj);
 662    if (!wd) return 0;
 663    return wd->level;
 664 }
 665
 666 /**
 667  * Returns the selected item.
 668  *
 669  * @param obj The index object.
 670  * @param level to be documented.
 671  *
 672  * @ingroup Index
 673  */
 674 EAPI void *
 675 elm_index_item_selected_get(const Evas_Object *obj, int level)
 676 {
 677    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 678    Widget_Data *wd = elm_widget_data_get(obj);
 679    Eina_List *l;
 680    Elm_Index_Item *it;
 681    if (!wd) return NULL;
 682    EINA_LIST_FOREACH(wd->items, l, it)
 683       if ((it->selected) && (it->level == level))
 684         return elm_widget_item_data_get(it);
 685    return NULL;
 686 }
 687
 688 /**
 689  * Appends a new item.
 690  *
 691  * @param obj The index object.
 692  * @param letter Letter under which the item should be indexed
 693  * @param item The item to put in the index
 694  *
 695  * @ingroup Index
 696  */
 697 EAPI void
 698 elm_index_item_append(Evas_Object *obj, const char *letter, const void *item)
 699 {
 700    ELM_CHECK_WIDTYPE(obj, widtype);
 701    Widget_Data *wd = elm_widget_data_get(obj);
 702    Elm_Index_Item *it;
 703    if (!wd) return;
 704    it = _item_new(obj, letter, item);
 705    if (!it) return;
 706    wd->items = eina_list_append(wd->items, it);
 707    _index_box_clear(obj, wd->bx[wd->level], wd->level);
 708 }
 709
 710 /**
 711  * Prepends a new item.
 712  *
 713  * @param obj The index object.
 714  * @param letter Letter under which the item should be indexed
 715  * @param item The item to put in the index
 716  *
 717  * @ingroup Index
 718  */
 719 EAPI void
 720 elm_index_item_prepend(Evas_Object *obj, const char *letter, const void *item)
 721 {
 722    ELM_CHECK_WIDTYPE(obj, widtype);
 723    Widget_Data *wd = elm_widget_data_get(obj);
 724    Elm_Index_Item *it;
 725
 726    if (!wd) return;
 727    it = _item_new(obj, letter, item);
 728    if (!it) return;
 729    wd->items = eina_list_prepend(wd->items, it);
 730    _index_box_clear(obj, wd->bx[wd->level], wd->level);
 731 }
 732
 733 /**
 734  * Append an item after @p relative in letter @p letter.
 735  *
 736  * @param obj The index object
 737  * @param letter Letter under which the item should be indexed
 738  * @param item The item to put in the index
 739  * @param relative The item to put @p item after
 740  *
 741  * @ingroup Index
 742  */
 743 EAPI void
 744 elm_index_item_append_relative(Evas_Object *obj, const char *letter, const void *item, const void *relative)
 745 {
 746    ELM_CHECK_WIDTYPE(obj, widtype);
 747    Widget_Data *wd = elm_widget_data_get(obj);
 748    Elm_Index_Item *it, *it_rel;
 749    if (!wd) return;
 750    if (!relative)
 751      {
 752         elm_index_item_append(obj, letter, item);
 753         return;
 754      }
 755    it = _item_new(obj, letter, item);
 756    it_rel = _item_find(obj, relative);
 757    if (!it_rel)
 758      {
 759         elm_index_item_append(obj, letter, item);
 760         return;
 761      }
 762    if (!it) return;
 763    wd->items = eina_list_append_relative(wd->items, it, it_rel);
 764    _index_box_clear(obj, wd->bx[wd->level], wd->level);
 765 }
 766
 767 /**
 768  * Prepend an item before @p relative in letter @p letter.
 769  *
 770  * @param obj The index object
 771  * @param letter Letter under which the item should be indexed
 772  * @param item The item to put in the index
 773  * @param relative The item to put @p item before
 774  *
 775  * @ingroup Index
 776  */
 777 EAPI void
 778 elm_index_item_prepend_relative(Evas_Object *obj, const char *letter, const void *item, const void *relative)
 779 {
 780    ELM_CHECK_WIDTYPE(obj, widtype);
 781    Widget_Data *wd = elm_widget_data_get(obj);
 782    Elm_Index_Item *it, *it_rel;
 783    if (!wd) return;
 784    if (!relative)
 785      {
 786         elm_index_item_prepend(obj, letter, item);
 787         return;
 788      }
 789    it = _item_new(obj, letter, item);
 790    it_rel = _item_find(obj, relative);
 791    if (!it_rel)
 792      {
 793         elm_index_item_append(obj, letter, item);
 794         return;
 795      }
 796    if (!it) return;
 797    wd->items = eina_list_prepend_relative(wd->items, it, it_rel);
 798    _index_box_clear(obj, wd->bx[wd->level], wd->level);
 799 }
 800
 801 /**
 802  * Insert a new @p item into the sorted index @p obj in @p letter.
 803  *
 804  * @param obj The index object
 805  * @param letter Letter under which the item should be indexed
 806  * @param item The item to put in the index
 807  * @param cmp_func The function called for the sort of index items.
 808  * @param cmp_data_func The function called for the sort of the data. It will
 809  * be used when cmp_func return 0. It means the index item already exists.
 810  * So, to decide which data item should be pointed by the index item, a function
 811  * to compare them is needed. If this function is not provided, index items
 812  * will be duplicated. If cmp_data_func returns a non-negative value, the
 813  * previous index item data will be replaced by the inserted @p item. So
 814  * if the previous data need to be free, it should be done in this function,
 815  * because the reference will be lost.
 816  *
 817  * @ingroup Index
 818  */
 819 EAPI void
 820 elm_index_item_sorted_insert(Evas_Object *obj, const char *letter, const void *item, Eina_Compare_Cb cmp_func, Eina_Compare_Cb cmp_data_func)
 821 {
 822    ELM_CHECK_WIDTYPE(obj, widtype);
 823    Widget_Data *wd = elm_widget_data_get(obj);
 824    Eina_List *lnear;
 825    Elm_Index_Item *it;
 826    int cmp;
 827
 828    if (!wd) return;
 829    if (!(wd->items))
 830      {
 831         elm_index_item_append(obj, letter, item);
 832         return;
 833      }
 834
 835    it = _item_new(obj, letter, item);
 836    if (!it) return;
 837
 838    lnear = eina_list_search_sorted_near_list(wd->items, cmp_func, it, &cmp);
 839    if (cmp < 0)
 840      wd->items =  eina_list_append_relative_list(wd->items, it, lnear);
 841    else if (cmp > 0)
 842      wd->items = eina_list_prepend_relative_list(wd->items, it, lnear);
 843    else
 844      {
 845         /* If cmp_data_func is not provided, append a duplicated item */
 846         if (!cmp_data_func)
 847           wd->items =  eina_list_append_relative_list(wd->items, it, lnear);
 848         else
 849           {
 850              Elm_Index_Item *p_it = eina_list_data_get(lnear);
 851              if (cmp_data_func(p_it->base.data, it->base.data) >= 0)
 852                p_it->base.data = it->base.data;
 853              _item_free(it);
 854           }
 855      }
 856
 857    _index_box_clear(obj, wd->bx[wd->level], wd->level);
 858 }
 859
 860 /**
 861  * Remove an item from the index.
 862  *
 863  * @param obj The index object
 864  * @param item The item to remove from the index
 865  *
 866  * @ingroup Index
 867  */
 868 EAPI void
 869 elm_index_item_del(Evas_Object *obj, const void *item)
 870 {
 871    ELM_CHECK_WIDTYPE(obj, widtype);
 872    Widget_Data *wd = elm_widget_data_get(obj);
 873    Elm_Index_Item *it;
 874    if (!wd) return;
 875    it = _item_find(obj, item);
 876    if (!it) return;
 877    _item_free(it);
 878    _index_box_clear(obj, wd->bx[wd->level], wd->level);
 879 }
 880
 881 /**
 882  * Find an index item using item data.
 883  *
 884  * @param obj The index object
 885  * @param item The item pointed by index item
 886  * @return The index item pointing to @p item
 887  *
 888  * @ingroup Index
 889  */
 890 EAPI Elm_Index_Item *
 891 elm_index_item_find(Evas_Object *obj, const void *item)
 892 {
 893    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
 894    Widget_Data *wd = elm_widget_data_get(obj);
 895    if (!wd) return NULL;
 896    return _item_find(obj, item);
 897 }
 898
 899 /**
 900  * Clears an index of its items.
 901  *
 902  * @param obj The index object.
 903  *
 904  * @ingroup Index
 905  */
 906 EAPI void
 907 elm_index_item_clear(Evas_Object *obj)
 908 {
 909    ELM_CHECK_WIDTYPE(obj, widtype);
 910    Widget_Data *wd = elm_widget_data_get(obj);
 911    Elm_Index_Item *it;
 912    Eina_List *l, *clear = NULL;
 913    if (!wd) return;
 914    _index_box_clear(obj, wd->bx[wd->level], wd->level);
 915    EINA_LIST_FOREACH(wd->items, l, it)
 916      {
 917         if (it->level != wd->level) continue;
 918         clear = eina_list_append(clear, it);
 919      }
 920    EINA_LIST_FREE(clear, it) _item_free(it);
 921 }
 922
 923 /**
 924  * Go to item at @p level
 925  *
 926  * @param obj The index object
 927  * @param level The index level
 928  *
 929  * @ingroup Index
 930  */
 931 EAPI void
 932 elm_index_item_go(Evas_Object *obj, int level __UNUSED__)
 933 {
 934    ELM_CHECK_WIDTYPE(obj, widtype);
 935    Widget_Data *wd = elm_widget_data_get(obj);
 936    if (!wd) return;
 937    _index_box_auto_fill(obj, wd->bx[0], 0);
 938    if (wd->level == 1) _index_box_auto_fill(obj, wd->bx[1], 1);
 939 }
 940
 941 /**
 942  * Returns the data associated with the item.
 943  *
 944  * @param it The list item
 945  * @return The data associated with @p it
 946  *
 947  * @ingroup Index
 948  */
 949 EAPI void *
 950 elm_index_item_data_get(const Elm_Index_Item *it)
 951 {
 952    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
 953    return elm_widget_item_data_get(it);
 954 }
 955
 956 /**
 957  * Set the data item from the index item
 958  *
 959  * This set a new data value.
 960  *
 961  * @param it The item
 962  * @param data The new data pointer to set
 963  *
 964  * @ingroup Index
 965  */
 966 EAPI void
 967 elm_index_item_data_set(Elm_Index_Item *it, const void *data)
 968 {
 969    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
 970    elm_widget_item_data_set(it, data);
 971 }
 972
 973 /**
 974  * Set the function called when a index item is freed.
 975  *
 976  * @param it The item to set the callback on
 977  * @param func The function called
 978  *
 979  * @ingroup Index
 980  */
 981 EAPI void
 982 elm_index_item_del_cb_set(Elm_Index_Item *it, Evas_Smart_Cb func)
 983 {
 984    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
 985    elm_widget_item_del_cb_set(it, func);
 986 }
 987
 988 /**
 989  * Gets the letter of the item.
 990  *
 991  * @param it The list item
 992  * @return The letter of @p it
 993  *
 994  * @ingroup Index
 995  */
 996 EAPI const char *
 997 elm_index_item_letter_get(const Elm_Index_Item *it)
 998 {
 999    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
1000    return it->letter;
1001 }
1002