src/lib/elm_index.c

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