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