src/lib/elm_genlist.c

   1 #include <assert.h>
   2 #include <fnmatch.h>
   3 #include <Elementary.h>
   4 #include <Elementary_Cursor.h>
   5 #include "elm_priv.h"
   6 #include "els_scroller.h"
   7 #include "elm_gen_common.h"
   8
   9 #define MAX_ITEMS_PER_BLOCK 32
  10 #define REORDER_EFFECT_TIME 0.5
  11
  12 #define ELM_GEN_SETUP(wd) \
  13    (wd)->calc_cb = (Ecore_Cb)_calc_job; \
  14    (wd)->clear_cb = (Ecore_Cb)_clear_cb; \
  15    (wd)->sizing_cb = (Ecore_Cb)_sizing_eval
  16
  17 #define ELM_GEN_ITEM_SETUP(it) \
  18    (it)->del_cb = (Ecore_Cb)_item_del; \
  19    (it)->highlight_cb = (Ecore_Cb)_item_highlight; \
  20    (it)->unsel_cb = (Ecore_Cb)_item_unselect; \
  21    (it)->unhighlight_cb = (Ecore_Cb)_item_unhighlight; \
  22    (it)->unrealize_cb = (Ecore_Cb)_item_unrealize_cb
  23
  24 typedef struct _Item_Block  Item_Block;
  25 typedef struct _Item_Cache  Item_Cache;
  26
  27 struct Elm_Gen_Item_Type
  28 {
  29    Elm_Gen_Item                 *it;
  30    Item_Block                   *block;
  31    Eina_List                    *items;
  32    Evas_Coord                    w, h, minw, minh;
  33    Elm_Gen_Item                 *group_item;
  34    Elm_Genlist_Item_Flags        flags;
  35    Eina_List                    *mode_texts, *mode_contents, *mode_states, *mode_content_objs;
  36    Eina_List                    *edit_texts, *edit_contents, *edit_states, *edit_content_objs;
  37    Ecore_Timer                  *swipe_timer;
  38    Evas_Coord                    scrl_x, scrl_y, old_scrl_y;
  39
  40    Elm_Gen_Item                 *rel;
  41    Evas_Object                  *mode_view;
  42    int                           expanded_depth;
  43    int                           order_num_in;
  44
  45    Eina_Bool                     before : 1;
  46
  47    Eina_Bool                     want_realize : 1;
  48    Eina_Bool                     expanded : 1;
  49    Eina_Bool                     mincalcd : 1;
  50    Eina_Bool                     queued : 1;
  51    Eina_Bool                     showme : 1;
  52    Eina_Bool                     updateme : 1;
  53    Eina_Bool                     nocache : 1;
  54    Eina_Bool                     stacking_even : 1;
  55    Eina_Bool                     nostacking : 1;
  56    Eina_Bool                     move_effect_enabled : 1;
  57    Eina_Bool                     edit_mode_item_realized : 1;
  58 };
  59
  60 struct _Item_Block
  61 {
  62    EINA_INLIST;
  63    int          count;
  64    int          num;
  65    int          reorder_offset;
  66    Widget_Data *wd;
  67    Eina_List   *items;
  68    Evas_Coord   x, y, w, h, minw, minh;
  69    int          position;
  70    int          item_position_stamp;
  71
  72    Eina_Bool    position_update : 1;
  73    Eina_Bool    want_unrealize : 1;
  74    Eina_Bool    realized : 1;
  75    Eina_Bool    changed : 1;
  76    Eina_Bool    updateme : 1;
  77    Eina_Bool    showme : 1;
  78    Eina_Bool    must_recalc : 1;
  79 };
  80
  81 struct _Item_Cache
  82 {
  83    EINA_INLIST;
  84
  85    Evas_Object *base_view, *spacer;
  86
  87    const char  *item_style; // it->itc->item_style
  88    Eina_Bool    tree : 1; // it->group
  89    Eina_Bool    compress : 1; // it->wd->compress
  90
  91    Eina_Bool    selected : 1; // it->selected
  92    Eina_Bool    disabled : 1; // it->disabled
  93    Eina_Bool    expanded : 1; // it->item->expanded
  94 };
  95
  96 static const char *widtype = NULL;
  97 static void      _item_cache_zero(Widget_Data *wd);
  98 static void      _del_hook(Evas_Object *obj);
  99 static void      _mirrored_set(Evas_Object *obj,
 100                                Eina_Bool    rtl);
 101 static void      _theme_hook(Evas_Object *obj);
 102 static void      _show_region_hook(void        *data,
 103                                    Evas_Object *obj);
 104 static void      _sizing_eval(Evas_Object *obj);
 105 static void      _item_realize(Elm_Gen_Item *it,
 106                                int           in,
 107                                Eina_Bool     calc);
 108 static void      _item_unrealize_cb(Elm_Gen_Item *it);
 109 static void      _item_block_unrealize(Item_Block *itb);
 110 static void      _calc_job(void *data);
 111 static void      _on_focus_hook(void        *data,
 112                                 Evas_Object *obj);
 113 static Eina_Bool _item_multi_select_up(Widget_Data *wd);
 114 static Eina_Bool _item_multi_select_down(Widget_Data *wd);
 115 static Eina_Bool _item_single_select_up(Widget_Data *wd);
 116 static Eina_Bool _item_single_select_down(Widget_Data *wd);
 117 static Eina_Bool _event_hook(Evas_Object       *obj,
 118                              Evas_Object       *src,
 119                              Evas_Callback_Type type,
 120                              void              *event_info);
 121 static void      _signal_emit_hook(Evas_Object *obj,
 122                                    const char  *emission,
 123                                    const char  *source);
 124 static Eina_Bool _deselect_all_items(Widget_Data *wd);
 125 static void      _pan_calculate(Evas_Object *obj);
 126 static void      _pan_max_get(Evas_Object *obj,
 127                               Evas_Coord  *x,
 128                               Evas_Coord  *y);
 129 static void      _item_position(Elm_Gen_Item *it,
 130                                 Evas_Object  *obj,
 131                                 Evas_Coord    it_x,
 132                                 Evas_Coord    it_y);
 133 static void      _mode_item_realize(Elm_Gen_Item *it);
 134 static void      _mode_item_unrealize(Elm_Gen_Item *it);
 135 static void      _item_mode_set(Elm_Gen_Item *it);
 136 static void      _item_mode_unset(Widget_Data *wd);
 137 static void      _edit_mode_item_position(Elm_Gen_Item *it, int itx, int ity);
 138 static void      _edit_mode_item_realize(Elm_Gen_Item *it, Eina_Bool effect_on);
 139 static void      _edit_mode_item_unrealize(Elm_Gen_Item *it);
 140 static void      _group_items_recalc(void *data);
 141 static void      _item_move_after(Elm_Gen_Item *it,
 142                                   Elm_Gen_Item *after);
 143 static void      _item_move_before(Elm_Gen_Item *it,
 144                                    Elm_Gen_Item *before);
 145 static void      _item_auto_scroll(Widget_Data *wd);
 146 static void      _elm_genlist_clear(Evas_Object *obj,
 147                                     Eina_Bool    standby);
 148 static void      _pan_child_size_get(Evas_Object *obj,
 149                                      Evas_Coord  *w,
 150                                      Evas_Coord  *h);
 151
 152 static Evas_Smart_Class _pan_sc = EVAS_SMART_CLASS_INIT_VERSION;
 153
 154 static const char SIG_ACTIVATED[] = "activated";
 155 static const char SIG_CLICKED_DOUBLE[] = "clicked,double";
 156 static const char SIG_SELECTED[] = "selected";
 157 static const char SIG_UNSELECTED[] = "unselected";
 158 static const char SIG_EXPANDED[] = "expanded";
 159 static const char SIG_CONTRACTED[] = "contracted";
 160 static const char SIG_EXPAND_REQUEST[] = "expand,request";
 161 static const char SIG_CONTRACT_REQUEST[] = "contract,request";
 162 static const char SIG_REALIZED[] = "realized";
 163 static const char SIG_UNREALIZED[] = "unrealized";
 164 static const char SIG_DRAG_START_UP[] = "drag,start,up";
 165 static const char SIG_DRAG_START_DOWN[] = "drag,start,down";
 166 static const char SIG_DRAG_START_LEFT[] = "drag,start,left";
 167 static const char SIG_DRAG_START_RIGHT[] = "drag,start,right";
 168 static const char SIG_DRAG_STOP[] = "drag,stop";
 169 static const char SIG_DRAG[] = "drag";
 170 static const char SIG_LONGPRESSED[] = "longpressed";
 171 static const char SIG_SCROLL_ANIM_START[] = "scroll,anim,start";
 172 static const char SIG_SCROLL_ANIM_STOP[] = "scroll,anim,stop";
 173 static const char SIG_SCROLL_DRAG_START[] = "scroll,drag,start";
 174 static const char SIG_SCROLL_DRAG_STOP[] = "scroll,drag,stop";
 175 static const char SIG_EDGE_TOP[] = "edge,top";
 176 static const char SIG_EDGE_BOTTOM[] = "edge,bottom";
 177 static const char SIG_EDGE_LEFT[] = "edge,left";
 178 static const char SIG_EDGE_RIGHT[] = "edge,right";
 179 static const char SIG_MULTI_SWIPE_LEFT[] = "multi,swipe,left";
 180 static const char SIG_MULTI_SWIPE_RIGHT[] = "multi,swipe,right";
 181 static const char SIG_MULTI_SWIPE_UP[] = "multi,swipe,up";
 182 static const char SIG_MULTI_SWIPE_DOWN[] = "multi,swipe,down";
 183 static const char SIG_MULTI_PINCH_OUT[] = "multi,pinch,out";
 184 static const char SIG_MULTI_PINCH_IN[] = "multi,pinch,in";
 185 static const char SIG_SWIPE[] = "swipe";
 186 static const char SIG_MOVED[] = "moved";
 187 static const char SIG_INDEX_UPDATE[] = "index,update";
 188
 189 static const Evas_Smart_Cb_Description _signals[] = {
 190    {SIG_CLICKED_DOUBLE, ""},
 191    {SIG_ACTIVATED, ""},
 192    {SIG_SELECTED, ""},
 193    {SIG_UNSELECTED, ""},
 194    {SIG_EXPANDED, ""},
 195    {SIG_CONTRACTED, ""},
 196    {SIG_EXPAND_REQUEST, ""},
 197    {SIG_CONTRACT_REQUEST, ""},
 198    {SIG_REALIZED, ""},
 199    {SIG_UNREALIZED, ""},
 200    {SIG_DRAG_START_UP, ""},
 201    {SIG_DRAG_START_DOWN, ""},
 202    {SIG_DRAG_START_LEFT, ""},
 203    {SIG_DRAG_START_RIGHT, ""},
 204    {SIG_DRAG_STOP, ""},
 205    {SIG_DRAG, ""},
 206    {SIG_LONGPRESSED, ""},
 207    {SIG_SCROLL_ANIM_START, ""},
 208    {SIG_SCROLL_ANIM_STOP, ""},
 209    {SIG_SCROLL_DRAG_START, ""},
 210    {SIG_SCROLL_DRAG_STOP, ""},
 211    {SIG_EDGE_TOP, ""},
 212    {SIG_EDGE_BOTTOM, ""},
 213    {SIG_EDGE_LEFT, ""},
 214    {SIG_EDGE_RIGHT, ""},
 215    {SIG_MULTI_SWIPE_LEFT, ""},
 216    {SIG_MULTI_SWIPE_RIGHT, ""},
 217    {SIG_MULTI_SWIPE_UP, ""},
 218    {SIG_MULTI_SWIPE_DOWN, ""},
 219    {SIG_MULTI_PINCH_OUT, ""},
 220    {SIG_MULTI_PINCH_IN, ""},
 221    {SIG_SWIPE, ""},
 222    {SIG_MOVED, ""},
 223    {NULL, NULL}
 224 };
 225
 226 /* TEMPORARY */
 227 #undef ELM_CHECK_WIDTYPE
 228 #define ELM_CHECK_WIDTYPE(obj, widtype) \
 229    if ((!obj) || (!elm_genlist_type_check((obj), __func__))) return
 230 #undef ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN
 231 #define ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, ...)                \
 232    ELM_WIDGET_ITEM_CHECK_OR_RETURN((Elm_Widget_Item *)it, __VA_ARGS__); \
 233    ELM_CHECK_WIDTYPE(WIDGET((it)), widtype) __VA_ARGS__;
 234
 235 static const char *_gengrid = NULL;
 236 static const char *_genlist = NULL;
 237
 238 /* THIS FUNCTION IS HACKY AND TEMPORARY!!! */
 239 Eina_Bool
 240 elm_genlist_type_check(const Evas_Object *obj,
 241                        const char        *func)
 242 {
 243    const char *provided, *expected = "(unknown)";
 244    static int abort_on_warn = -1;
 245    provided = elm_widget_type_get(obj);
 246    if (!_genlist) _genlist = eina_stringshare_add("genlist");
 247    if (!_gengrid) _gengrid = eina_stringshare_add("gengrid");
 248    if (EINA_LIKELY(provided == _genlist) || EINA_LIKELY(provided == _gengrid))
 249      return EINA_TRUE;
 250    if ((!provided) || (!provided[0]))
 251      {
 252         provided = evas_object_type_get(obj);
 253         if ((!provided) || (!provided[0]))
 254           provided = "(unknown)";
 255      }
 256    ERR("Passing Object: %p in function: %s, of type: '%s' when expecting type: '%s'", obj, func, provided, expected);
 257    if (abort_on_warn == -1)
 258      {
 259         if (getenv("ELM_ERROR_ABORT")) abort_on_warn = 1;
 260         else abort_on_warn = 0;
 261      }
 262    if (abort_on_warn == 1) abort();
 263    return EINA_FALSE;
 264 }
 265
 266 static Eina_Bool
 267 _event_hook(Evas_Object       *obj,
 268             Evas_Object       *src __UNUSED__,
 269             Evas_Callback_Type type,
 270             void              *event_info)
 271 {
 272    if (type != EVAS_CALLBACK_KEY_DOWN) return EINA_FALSE;
 273    Evas_Event_Key_Down *ev = event_info;
 274    Widget_Data *wd = elm_widget_data_get(obj);
 275    Evas_Coord pan_max_x = 0, pan_max_y = 0;
 276    if (!wd) return EINA_FALSE;
 277    if (!wd->items) return EINA_FALSE;
 278    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return EINA_FALSE;
 279    if (elm_widget_disabled_get(obj)) return EINA_FALSE;
 280
 281    Elm_Object_Item *it = NULL;
 282    Evas_Coord x = 0;
 283    Evas_Coord y = 0;
 284    Evas_Coord step_x = 0;
 285    Evas_Coord step_y = 0;
 286    Evas_Coord v_w = 0;
 287    Evas_Coord v_h = 0;
 288    Evas_Coord page_x = 0;
 289    Evas_Coord page_y = 0;
 290
 291    elm_smart_scroller_child_pos_get(wd->scr, &x, &y);
 292    elm_smart_scroller_step_size_get(wd->scr, &step_x, &step_y);
 293    elm_smart_scroller_page_size_get(wd->scr, &page_x, &page_y);
 294    elm_smart_scroller_child_viewport_size_get(wd->scr, &v_w, &v_h);
 295
 296    if ((!strcmp(ev->keyname, "Left")) || (!strcmp(ev->keyname, "KP_Left")))
 297      {
 298         x -= step_x;
 299      }
 300    else if ((!strcmp(ev->keyname, "Right")) || (!strcmp(ev->keyname, "KP_Right")))
 301      {
 302         x += step_x;
 303      }
 304    else if ((!strcmp(ev->keyname, "Up")) || (!strcmp(ev->keyname, "KP_Up")))
 305      {
 306         if (((evas_key_modifier_is_set(ev->modifiers, "Shift")) &&
 307              (_item_multi_select_up(wd)))
 308             || (_item_single_select_up(wd)))
 309           {
 310              ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 311              return EINA_TRUE;
 312           }
 313         else
 314           y -= step_y;
 315      }
 316    else if ((!strcmp(ev->keyname, "Down")) || (!strcmp(ev->keyname, "KP_Down")))
 317      {
 318         if (((evas_key_modifier_is_set(ev->modifiers, "Shift")) &&
 319              (_item_multi_select_down(wd)))
 320             || (_item_single_select_down(wd)))
 321           {
 322              ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 323              return EINA_TRUE;
 324           }
 325         else
 326           y += step_y;
 327      }
 328    else if ((!strcmp(ev->keyname, "Home")) || (!strcmp(ev->keyname, "KP_Home")))
 329      {
 330         it = elm_genlist_first_item_get(obj);
 331         elm_genlist_item_bring_in(it);
 332         elm_genlist_item_selected_set(it, EINA_TRUE);
 333         ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 334         return EINA_TRUE;
 335      }
 336    else if ((!strcmp(ev->keyname, "End")) || (!strcmp(ev->keyname, "KP_End")))
 337      {
 338         it = elm_genlist_last_item_get(obj);
 339         elm_genlist_item_bring_in(it);
 340         elm_genlist_item_selected_set(it, EINA_TRUE);
 341         ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 342         return EINA_TRUE;
 343      }
 344    else if ((!strcmp(ev->keyname, "Prior")) || (!strcmp(ev->keyname, "KP_Prior")))
 345      {
 346         if (page_y < 0)
 347           y -= -(page_y * v_h) / 100;
 348         else
 349           y -= page_y;
 350      }
 351    else if ((!strcmp(ev->keyname, "Next")) || (!strcmp(ev->keyname, "KP_Next")))
 352      {
 353         if (page_y < 0)
 354           y += -(page_y * v_h) / 100;
 355         else
 356           y += page_y;
 357      }
 358    else if (!strcmp(ev->keyname, "Escape"))
 359      {
 360         if (!_deselect_all_items(wd)) return EINA_FALSE;
 361         ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 362         return EINA_TRUE;
 363      }
 364    else if (((!strcmp(ev->keyname, "Return")) ||
 365              (!strcmp(ev->keyname, "KP_Enter")) ||
 366              (!strcmp(ev->keyname, "space")))
 367             && (!wd->multi) && (wd->selected))
 368      {
 369         it = elm_genlist_selected_item_get(obj);
 370         elm_genlist_item_expanded_set(it,
 371                                       !elm_genlist_item_expanded_get(it));
 372         evas_object_smart_callback_call(WIDGET(it), SIG_ACTIVATED, it);
 373      }
 374    else return EINA_FALSE;
 375
 376    ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 377    _pan_max_get(wd->pan_smart, &pan_max_x, &pan_max_y);
 378    if (x < 0) x = 0;
 379    if (x > pan_max_x) x = pan_max_x;
 380    if (y < 0) y = 0;
 381    if (y > pan_max_y) y = pan_max_y;
 382    elm_smart_scroller_child_pos_set(wd->scr, x, y);
 383    return EINA_TRUE;
 384 }
 385
 386 static Eina_Bool
 387 _deselect_all_items(Widget_Data *wd)
 388 {
 389    if (!wd->selected) return EINA_FALSE;
 390    while (wd->selected)
 391      elm_genlist_item_selected_set(wd->selected->data, EINA_FALSE);
 392
 393    return EINA_TRUE;
 394 }
 395
 396 static Eina_Bool
 397 _item_multi_select_up(Widget_Data *wd)
 398 {
 399    if (!wd->selected) return EINA_FALSE;
 400    if (!wd->multi) return EINA_FALSE;
 401
 402    Elm_Object_Item *prev = elm_genlist_item_prev_get(wd->last_selected_item);
 403    if (!prev) return EINA_TRUE;
 404
 405    if (elm_genlist_item_selected_get(prev))
 406      {
 407         elm_genlist_item_selected_set(wd->last_selected_item, EINA_FALSE);
 408         wd->last_selected_item = prev;
 409         elm_genlist_item_show(wd->last_selected_item);
 410      }
 411    else
 412      {
 413         elm_genlist_item_selected_set(prev, EINA_TRUE);
 414         elm_genlist_item_show(prev);
 415      }
 416    return EINA_TRUE;
 417 }
 418
 419 static Eina_Bool
 420 _item_multi_select_down(Widget_Data *wd)
 421 {
 422    if (!wd->selected) return EINA_FALSE;
 423    if (!wd->multi) return EINA_FALSE;
 424
 425    Elm_Object_Item *next;
 426    next = elm_genlist_item_next_get(wd->last_selected_item);
 427    if (!next) return EINA_TRUE;
 428
 429    if (elm_genlist_item_selected_get(next))
 430      {
 431         elm_genlist_item_selected_set(wd->last_selected_item, EINA_FALSE);
 432         wd->last_selected_item = next;
 433         elm_genlist_item_show(wd->last_selected_item);
 434      }
 435    else
 436      {
 437         elm_genlist_item_selected_set(next, EINA_TRUE);
 438         elm_genlist_item_show(next);
 439      }
 440    return EINA_TRUE;
 441 }
 442
 443 static Eina_Bool
 444 _item_single_select_up(Widget_Data *wd)
 445 {
 446    Elm_Gen_Item *prev;
 447    if (!wd->selected)
 448      {
 449         prev = ELM_GEN_ITEM_FROM_INLIST(wd->items->last);
 450         while ((prev) && (prev->generation < wd->generation))
 451           prev = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(prev)->prev);
 452      }
 453    else prev = (Elm_Gen_Item *) elm_genlist_item_prev_get(wd->last_selected_item);
 454
 455    if (!prev) return EINA_FALSE;
 456
 457    _deselect_all_items(wd);
 458
 459    elm_genlist_item_selected_set((Elm_Object_Item *) prev, EINA_TRUE);
 460    elm_genlist_item_show((Elm_Object_Item *) prev);
 461    return EINA_TRUE;
 462 }
 463
 464 static Eina_Bool
 465 _item_single_select_down(Widget_Data *wd)
 466 {
 467    Elm_Gen_Item *next;
 468    if (!wd->selected)
 469      {
 470         next = ELM_GEN_ITEM_FROM_INLIST(wd->items);
 471         while ((next) && (next->generation < wd->generation))
 472           next = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(next)->next);
 473      }
 474    else next = (Elm_Gen_Item *) elm_genlist_item_next_get(wd->last_selected_item);
 475
 476    if (!next) return EINA_FALSE;
 477
 478    _deselect_all_items(wd);
 479
 480    elm_genlist_item_selected_set((Elm_Object_Item *) next, EINA_TRUE);
 481    elm_genlist_item_show((Elm_Object_Item *) next);
 482    return EINA_TRUE;
 483 }
 484
 485 static void
 486 _on_focus_hook(void        *data __UNUSED__,
 487                Evas_Object *obj)
 488 {
 489    Widget_Data *wd = elm_widget_data_get(obj);
 490    if (!wd) return;
 491    if (elm_widget_focus_get(obj))
 492      {
 493         elm_object_signal_emit(wd->obj, "elm,action,focus", "elm");
 494         evas_object_focus_set(wd->obj, EINA_TRUE);
 495         if ((wd->selected) && (!wd->last_selected_item))
 496           wd->last_selected_item = eina_list_data_get(wd->selected);
 497      }
 498    else
 499      {
 500         elm_object_signal_emit(wd->obj, "elm,action,unfocus", "elm");
 501         evas_object_focus_set(wd->obj, EINA_FALSE);
 502      }
 503 }
 504
 505 static void
 506 _del_hook(Evas_Object *obj)
 507 {
 508    Widget_Data *wd = elm_widget_data_get(obj);
 509    if (!wd) return;
 510    _item_cache_zero(wd);
 511    if (wd->calc_job) ecore_job_del(wd->calc_job);
 512    if (wd->update_job) ecore_job_del(wd->update_job);
 513    if (wd->queue_idle_enterer) ecore_idle_enterer_del(wd->queue_idle_enterer);
 514    if (wd->must_recalc_idler) ecore_idler_del(wd->must_recalc_idler);
 515    if (wd->multi_timer) ecore_timer_del(wd->multi_timer);
 516    if (wd->mode_type) eina_stringshare_del(wd->mode_type);
 517    if (wd->scr_hold_timer) ecore_timer_del(wd->scr_hold_timer);
 518    free(wd);
 519 }
 520
 521 static void
 522 _del_pre_hook(Evas_Object *obj)
 523 {
 524    Widget_Data *wd = elm_widget_data_get(obj);
 525    if (!wd) return;
 526    if (wd->edit_mode) elm_genlist_edit_mode_set(wd->obj, EINA_FALSE);
 527    elm_genlist_clear(obj);
 528    evas_object_del(wd->pan_smart);
 529    wd->pan_smart = NULL;
 530 }
 531
 532 static void
 533 _mirrored_set(Evas_Object *obj,
 534               Eina_Bool    rtl)
 535 {
 536    Widget_Data *wd = elm_widget_data_get(obj);
 537    if (!wd) return;
 538    _item_cache_zero(wd);
 539    elm_smart_scroller_mirrored_set(wd->scr, rtl);
 540 }
 541
 542 static void
 543 _theme_hook(Evas_Object *obj)
 544 {
 545    Widget_Data *wd = elm_widget_data_get(obj);
 546    Item_Block *itb;
 547    if (!wd) return;
 548    evas_event_freeze(evas_object_evas_get(wd->obj));
 549    _item_cache_zero(wd);
 550    _elm_widget_mirrored_reload(obj);
 551    _mirrored_set(obj, elm_widget_mirrored_get(obj));
 552    elm_smart_scroller_object_theme_set(obj, wd->scr, "genlist", "base",
 553                                        elm_widget_style_get(obj));
 554    edje_object_scale_set(wd->scr, elm_widget_scale_get(obj) * _elm_config->scale);
 555    wd->item_width = wd->item_height = 0;
 556    wd->group_item_width = wd->group_item_height = 0;
 557    wd->minw = wd->minh = wd->realminw = 0;
 558    EINA_INLIST_FOREACH(wd->blocks, itb)
 559      {
 560         Eina_List *l;
 561         Elm_Gen_Item *it;
 562
 563         if (itb->realized) _item_block_unrealize(itb);
 564         EINA_LIST_FOREACH(itb->items, l, it)
 565           it->item->mincalcd = EINA_FALSE;
 566
 567         itb->changed = EINA_TRUE;
 568      }
 569    if (wd->calc_job) ecore_job_del(wd->calc_job);
 570    wd->calc_job = ecore_job_add(_calc_job, wd);
 571    _sizing_eval(obj);
 572    evas_event_thaw(evas_object_evas_get(wd->obj));
 573    evas_event_thaw_eval(evas_object_evas_get(wd->obj));
 574 }
 575
 576 static void
 577 _show_region_hook(void        *data,
 578                   Evas_Object *obj)
 579 {
 580    Widget_Data *wd = elm_widget_data_get(data);
 581    Evas_Coord x, y, w, h;
 582    if (!wd) return;
 583    elm_widget_show_region_get(obj, &x, &y, &w, &h);
 584    //x & y are screen coordinates, Add with pan coordinates
 585    x += wd->pan_x;
 586    y += wd->pan_y;
 587    elm_smart_scroller_child_region_show(wd->scr, x, y, w, h);
 588 }
 589
 590 static void
 591 _translate_hook(Evas_Object *obj)
 592 {
 593    evas_object_smart_callback_call(obj, "language,changed", NULL);
 594 }
 595
 596 static void
 597 _sizing_eval(Evas_Object *obj)
 598 {
 599    Widget_Data *wd = elm_widget_data_get(obj);
 600    Evas_Coord minw = -1, minh = -1, maxw = -1, maxh = -1;
 601    if (!wd) return;
 602    evas_object_size_hint_min_get(wd->scr, &minw, &minh);
 603    evas_object_size_hint_max_get(wd->scr, &maxw, &maxh);
 604    minh = -1;
 605    if (wd->height_for_width)
 606      {
 607         Evas_Coord vw, vh;
 608
 609         elm_smart_scroller_child_viewport_size_get(wd->scr, &vw, &vh);
 610         if ((vw != 0) && (vw != wd->prev_viewport_w))
 611           {
 612              Item_Block *itb;
 613
 614              wd->prev_viewport_w = vw;
 615              EINA_INLIST_FOREACH(wd->blocks, itb)
 616                {
 617                   itb->must_recalc = EINA_TRUE;
 618                }
 619              if (wd->calc_job) ecore_job_del(wd->calc_job);
 620              wd->calc_job = ecore_job_add(_calc_job, wd);
 621           }
 622      }
 623    if (wd->mode == ELM_LIST_LIMIT)
 624      {
 625         Evas_Coord vmw, vmh;
 626
 627         minw = wd->realminw;
 628         maxw = -1;
 629         elm_smart_scroller_child_viewport_size_get(wd->scr, &vmw, &vmh);
 630         edje_object_size_min_calc
 631           (elm_smart_scroller_edje_object_get(wd->scr), &vmw, &vmh);
 632         minw = vmw + minw;
 633      }
 634    else
 635      {
 636         Evas_Coord vmw, vmh;
 637
 638         edje_object_size_min_calc
 639           (elm_smart_scroller_edje_object_get(wd->scr), &vmw, &vmh);
 640         minw = vmw;
 641         minh = vmh;
 642      }
 643    evas_object_size_hint_min_set(obj, minw, minh);
 644    evas_object_size_hint_max_set(obj, maxw, maxh);
 645 }
 646
 647 static void
 648 _signal_emit_hook(Evas_Object *obj,
 649                   const char  *emission,
 650                   const char  *source)
 651 {
 652    Widget_Data *wd = elm_widget_data_get(obj);
 653    edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr),
 654                            emission, source);
 655 }
 656
 657 static void
 658 _item_highlight(Elm_Gen_Item *it)
 659 {
 660    const char *selectraise;
 661    if ((it->wd->no_select) || (it->generation < it->wd->generation) ||
 662        (it->highlighted) || elm_widget_item_disabled_get(it) ||
 663        (it->display_only) || (it->item->mode_view))
 664      return;
 665    edje_object_signal_emit(VIEW(it), "elm,state,selected", "elm");
 666    if (it->edit_obj) edje_object_signal_emit(it->edit_obj, "elm,state,selected", "elm");
 667    selectraise = edje_object_data_get(VIEW(it), "selectraise");
 668    if ((selectraise) && (!strcmp(selectraise, "on")))
 669      {
 670         if (it->edit_obj) evas_object_raise(it->edit_obj);
 671         else evas_object_raise(VIEW(it));
 672         if ((it->item->group_item) && (it->item->group_item->realized))
 673           evas_object_raise(it->item->VIEW(group_item));
 674      }
 675    it->highlighted = EINA_TRUE;
 676 }
 677
 678 static void
 679 _item_unhighlight(Elm_Gen_Item *it)
 680 {
 681    if ((it->generation < it->wd->generation) || (!it->highlighted)) return;
 682    edje_object_signal_emit(VIEW(it), "elm,state,unselected", "elm");
 683    if (it->edit_obj) edje_object_signal_emit(it->edit_obj, "elm,state,unselected", "elm");
 684    if (!it->item->nostacking)
 685      {
 686        if ((it->item->order_num_in & 0x1) ^ it->item->stacking_even)
 687          {
 688              if (it->edit_obj) evas_object_lower(it->edit_obj);
 689              else evas_object_lower(VIEW(it));
 690          }
 691        else
 692          {
 693              if (it->edit_obj) evas_object_raise(it->edit_obj);
 694              else evas_object_raise(VIEW(it));
 695          }
 696      }
 697    it->highlighted = EINA_FALSE;
 698 }
 699
 700 static void
 701 _item_block_position_update(Eina_Inlist *list, int idx)
 702 {
 703    Item_Block *tmp;
 704
 705    EINA_INLIST_FOREACH(list, tmp)
 706      {
 707         tmp->position = idx++;
 708         tmp->position_update = EINA_TRUE;
 709      }
 710 }
 711
 712 static void
 713 _item_position_update(Eina_List *list, int idx)
 714 {
 715    Elm_Gen_Item *it;
 716    Eina_List *l;
 717
 718    EINA_LIST_FOREACH(list, l, it)
 719      {
 720         it->position = idx++;
 721         it->position_update = EINA_TRUE;
 722      }
 723 }
 724
 725 static void
 726 _item_block_del(Elm_Gen_Item *it)
 727 {
 728    Eina_Inlist *il;
 729    Item_Block *itb = it->item->block;
 730
 731    itb->items = eina_list_remove(itb->items, it);
 732    itb->count--;
 733    itb->changed = EINA_TRUE;
 734    if (it->wd->calc_job) ecore_job_del(it->wd->calc_job);
 735    it->wd->calc_job = ecore_job_add(_calc_job, it->wd);
 736    if (itb->count < 1)
 737      {
 738         il = EINA_INLIST_GET(itb);
 739         Item_Block *itbn = (Item_Block *)(il->next);
 740         if (it->parent)
 741           it->parent->item->items = eina_list_remove(it->parent->item->items, it);
 742         else
 743           {
 744              _item_block_position_update(il->next, itb->position);
 745              it->wd->blocks = eina_inlist_remove(it->wd->blocks, il);
 746           }
 747         free(itb);
 748         if (itbn) itbn->changed = EINA_TRUE;
 749      }
 750    else
 751      {
 752         if (itb->count < itb->wd->max_items_per_block/2)
 753           {
 754              il = EINA_INLIST_GET(itb);
 755              Item_Block *itbp = (Item_Block *)(il->prev);
 756              Item_Block *itbn = (Item_Block *)(il->next);
 757              if ((itbp) && ((itbp->count + itb->count) < itb->wd->max_items_per_block + itb->wd->max_items_per_block/2))
 758                {
 759                   Elm_Gen_Item *it2;
 760
 761                   EINA_LIST_FREE(itb->items, it2)
 762                     {
 763                        it2->item->block = itbp;
 764                        itbp->items = eina_list_append(itbp->items, it2);
 765                        itbp->count++;
 766                        itbp->changed = EINA_TRUE;
 767                     }
 768                   _item_block_position_update(EINA_INLIST_GET(itb)->next,
 769                                               itb->position);
 770                   it->wd->blocks = eina_inlist_remove(it->wd->blocks,
 771                                                       EINA_INLIST_GET(itb));
 772                   free(itb);
 773                }
 774              else if ((itbn) && ((itbn->count + itb->count) < itb->wd->max_items_per_block + itb->wd->max_items_per_block/2))
 775                {
 776                   while (itb->items)
 777                     {
 778                        Eina_List *last = eina_list_last(itb->items);
 779                        Elm_Gen_Item *it2 = last->data;
 780
 781                        it2->item->block = itbn;
 782                        itb->items = eina_list_remove_list(itb->items, last);
 783                        itbn->items = eina_list_prepend(itbn->items, it2);
 784                        itbn->count++;
 785                        itbn->changed = EINA_TRUE;
 786                     }
 787                   _item_block_position_update(EINA_INLIST_GET(itb)->next,
 788                                               itb->position);
 789                   it->wd->blocks =
 790                     eina_inlist_remove(it->wd->blocks, EINA_INLIST_GET(itb));
 791                   free(itb);
 792                }
 793           }
 794      }
 795 }
 796
 797 static void
 798 _item_del(Elm_Gen_Item *it)
 799 {
 800    Evas_Object *obj = WIDGET(it);
 801
 802    evas_event_freeze(evas_object_evas_get(obj));
 803    elm_genlist_item_subitems_clear((Elm_Object_Item *) it);
 804    if (it->wd->show_item == it) it->wd->show_item = NULL;
 805    if (it->realized) _elm_genlist_item_unrealize(it, EINA_FALSE);
 806    if (it->item->edit_mode_item_realized) _edit_mode_item_unrealize(it);
 807    if (it->item->block) _item_block_del(it);
 808    if (it->item->queued)
 809      it->wd->queue = eina_list_remove(it->wd->queue, it);
 810    if (it->wd->anchor_item == it)
 811      {
 812         it->wd->anchor_item = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->next);
 813         if (!it->wd->anchor_item)
 814           it->wd->anchor_item = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->prev);
 815      }
 816    if (it->wd->expanded_item == it) it->wd->expanded_item = NULL;
 817    if (it->parent)
 818      it->parent->item->items = eina_list_remove(it->parent->item->items, it);
 819    if (it->item->swipe_timer) ecore_timer_del(it->item->swipe_timer);
 820    _elm_genlist_item_del_serious(it);
 821    elm_genlist_item_class_unref((Elm_Genlist_Item_Class *)it->itc);
 822    evas_event_thaw(evas_object_evas_get(obj));
 823    evas_event_thaw_eval(evas_object_evas_get(obj));
 824 }
 825
 826 static void
 827 _clear_cb(Widget_Data *wd)
 828 {
 829    wd->anchor_item = NULL;
 830    while (wd->blocks)
 831      {
 832         Item_Block *itb = (Item_Block *)(wd->blocks);
 833
 834         wd->blocks = eina_inlist_remove(wd->blocks, wd->blocks);
 835         if (itb->items) eina_list_free(itb->items);
 836         free(itb);
 837      }
 838    if (wd->queue_idle_enterer)
 839      {
 840         ecore_idle_enterer_del(wd->queue_idle_enterer);
 841         wd->queue_idle_enterer = NULL;
 842      }
 843    if (wd->must_recalc_idler)
 844      {
 845         ecore_idler_del(wd->must_recalc_idler);
 846         wd->must_recalc_idler = NULL;
 847      }
 848    if (wd->queue) wd->queue = eina_list_free(wd->queue);
 849    if (wd->reorder_move_animator)
 850      {
 851         ecore_animator_del(wd->reorder_move_animator);
 852         wd->reorder_move_animator = NULL;
 853      }
 854    wd->show_item = NULL;
 855    wd->reorder_old_pan_y = 0;
 856 }
 857
 858 static void
 859 _item_unselect(Elm_Gen_Item *it)
 860 {
 861    if ((it->generation < it->wd->generation) || (!it->selected)) return;
 862    it->selected = EINA_FALSE;
 863    it->wd->selected = eina_list_remove(it->wd->selected, it);
 864    evas_object_smart_callback_call(WIDGET(it), SIG_UNSELECTED, it);
 865 }
 866
 867 static void
 868 _mouse_move(void        *data,
 869             Evas        *evas __UNUSED__,
 870             Evas_Object *obj,
 871             void        *event_info)
 872 {
 873    Elm_Gen_Item *it = data;
 874    Evas_Event_Mouse_Move *ev = event_info;
 875    Evas_Coord minw = 0, minh = 0, x, y, dx, dy, adx, ady;
 876    Evas_Coord ox, oy, ow, oh, it_scrl_y, y_pos;
 877
 878    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
 879      {
 880         if (!it->wd->on_hold)
 881           {
 882              it->wd->on_hold = EINA_TRUE;
 883              if (!it->wd->wasselected)
 884                {
 885                   _item_unhighlight(it);
 886                   _item_unselect(it);
 887                }
 888           }
 889      }
 890    if (it->wd->multitouched)
 891      {
 892         it->wd->cur_x = ev->cur.canvas.x;
 893         it->wd->cur_y = ev->cur.canvas.y;
 894         return;
 895      }
 896    if ((it->dragging) && (it->down))
 897      {
 898         if (it->wd->movements == SWIPE_MOVES) it->wd->swipe = EINA_TRUE;
 899         else
 900           {
 901              it->wd->history[it->wd->movements].x = ev->cur.canvas.x;
 902              it->wd->history[it->wd->movements].y = ev->cur.canvas.y;
 903              if (abs((it->wd->history[it->wd->movements].x -
 904                       it->wd->history[0].x)) > 40)
 905                it->wd->swipe = EINA_TRUE;
 906              else
 907                it->wd->movements++;
 908           }
 909         if (it->long_timer)
 910           {
 911              ecore_timer_del(it->long_timer);
 912              it->long_timer = NULL;
 913           }
 914         evas_object_smart_callback_call(WIDGET(it), SIG_DRAG, it);
 915         return;
 916      }
 917    if ((!it->down) /* || (it->wd->on_hold)*/ || (it->wd->longpressed))
 918      {
 919         if (it->long_timer)
 920           {
 921              ecore_timer_del(it->long_timer);
 922              it->long_timer = NULL;
 923           }
 924         if ((it->wd->reorder_mode) && (it->wd->reorder_it))
 925           {
 926              evas_object_geometry_get(it->wd->pan_smart, &ox, &oy, &ow, &oh);
 927              it_scrl_y = ev->cur.canvas.y - it->wd->reorder_it->dy;
 928
 929              if (!it->wd->reorder_start_y)
 930                it->wd->reorder_start_y = it->item->block->y + it->y;
 931
 932              if (it_scrl_y < oy)
 933                y_pos = oy;
 934              else if (it_scrl_y + it->wd->reorder_it->item->h > oy + oh)
 935                y_pos = oy + oh - it->wd->reorder_it->item->h;
 936              else
 937                y_pos = it_scrl_y;
 938
 939              if (it->edit_obj)
 940                _item_position(it, it->edit_obj, it->item->scrl_x, y_pos);
 941              else
 942              _item_position(it, VIEW(it), it->item->scrl_x, y_pos);
 943
 944              if (it->wd->calc_job) ecore_job_del(it->wd->calc_job);
 945              it->wd->calc_job = ecore_job_add(_calc_job, it->wd);
 946           }
 947         return;
 948      }
 949    if (!it->display_only)
 950      elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 951    evas_object_geometry_get(obj, &x, &y, NULL, NULL);
 952    x = ev->cur.canvas.x - x;
 953    y = ev->cur.canvas.y - y;
 954    dx = x - it->dx;
 955    adx = dx;
 956    if (adx < 0) adx = -dx;
 957    dy = y - it->dy;
 958    ady = dy;
 959    if (ady < 0) ady = -dy;
 960    minw /= 2;
 961    minh /= 2;
 962    if ((adx > minw) || (ady > minh))
 963      {
 964         it->dragging = EINA_TRUE;
 965         if (it->long_timer)
 966           {
 967              ecore_timer_del(it->long_timer);
 968              it->long_timer = NULL;
 969           }
 970         if (!it->wd->wasselected)
 971           {
 972              _item_unhighlight(it);
 973              _item_unselect(it);
 974           }
 975         if (dy < 0)
 976           {
 977              if (ady > adx)
 978                evas_object_smart_callback_call(WIDGET(it),
 979                                                SIG_DRAG_START_UP, it);
 980              else
 981                {
 982                   if (dx < 0)
 983                     evas_object_smart_callback_call(WIDGET(it),
 984                                                     SIG_DRAG_START_LEFT, it);
 985                   else
 986                     evas_object_smart_callback_call(WIDGET(it),
 987                                                     SIG_DRAG_START_RIGHT, it);
 988                }
 989           }
 990         else
 991           {
 992              if (ady > adx)
 993                evas_object_smart_callback_call(WIDGET(it),
 994                                                SIG_DRAG_START_DOWN, it);
 995              else
 996                {
 997                   if (dx < 0)
 998                     evas_object_smart_callback_call(WIDGET(it),
 999                                                     SIG_DRAG_START_LEFT, it);
1000                   else
1001                     evas_object_smart_callback_call(WIDGET(it),
1002                                                     SIG_DRAG_START_RIGHT, it);
1003                }
1004           }
1005      }
1006 }
1007
1008 static Eina_Bool
1009 _long_press(void *data)
1010 {
1011    Elm_Gen_Item *it = data, *it_tmp;
1012    Eina_List *list, *l;
1013
1014    it->long_timer = NULL;
1015    if (elm_widget_item_disabled_get(it) || (it->dragging) || (it->display_only))
1016      return ECORE_CALLBACK_CANCEL;
1017    it->wd->longpressed = EINA_TRUE;
1018    evas_object_smart_callback_call(WIDGET(it), SIG_LONGPRESSED, it);
1019    if ((it->wd->reorder_mode) && (!it->group))
1020      {
1021         it->wd->reorder_it = it;
1022         it->wd->reorder_start_y = 0;
1023         if (it->edit_obj)
1024           evas_object_raise(it->edit_obj);
1025         else
1026           evas_object_raise(VIEW(it));
1027
1028         elm_smart_scroller_hold_set(it->wd->scr, EINA_TRUE);
1029         elm_smart_scroller_bounce_allow_set(it->wd->scr, EINA_FALSE, EINA_FALSE);
1030
1031         list = elm_genlist_realized_items_get(it->wd->obj);
1032         EINA_LIST_FOREACH(list, l, it_tmp)
1033           {
1034              if (it != it_tmp) _item_unselect(it_tmp);
1035           }
1036         if (elm_genlist_item_expanded_get((Elm_Object_Item *) it))
1037           {
1038              elm_genlist_item_expanded_set((Elm_Object_Item *) it, EINA_FALSE);
1039              return ECORE_CALLBACK_RENEW;
1040           }
1041
1042         if (!it->wd->edit_mode)
1043           edje_object_signal_emit(VIEW(it), "elm,state,reorder,enabled", "elm");
1044      }
1045    return ECORE_CALLBACK_CANCEL;
1046 }
1047
1048 static void
1049 _swipe(Elm_Gen_Item *it)
1050 {
1051    int i, sum = 0;
1052
1053    if (!it) return;
1054    if ((it->display_only) || elm_widget_item_disabled_get(it)) return;
1055    it->wd->swipe = EINA_FALSE;
1056    for (i = 0; i < it->wd->movements; i++)
1057      {
1058         sum += it->wd->history[i].x;
1059         if (abs(it->wd->history[0].y - it->wd->history[i].y) > 10) return;
1060      }
1061
1062    sum /= it->wd->movements;
1063    if (abs(sum - it->wd->history[0].x) <= 10) return;
1064    evas_object_smart_callback_call(WIDGET(it), SIG_SWIPE, it);
1065 }
1066
1067 static Eina_Bool
1068 _swipe_cancel(void *data)
1069 {
1070    Elm_Gen_Item *it = data;
1071
1072    if (!it) return ECORE_CALLBACK_CANCEL;
1073    it->wd->swipe = EINA_FALSE;
1074    it->wd->movements = 0;
1075    return ECORE_CALLBACK_RENEW;
1076 }
1077
1078 static Eina_Bool
1079 _multi_cancel(void *data)
1080 {
1081    Widget_Data *wd = data;
1082
1083    if (!wd) return ECORE_CALLBACK_CANCEL;
1084    wd->multi_timeout = EINA_TRUE;
1085    return ECORE_CALLBACK_RENEW;
1086 }
1087
1088 static void
1089 _multi_touch_gesture_eval(void *data)
1090 {
1091    Elm_Gen_Item *it = data;
1092
1093    it->wd->multitouched = EINA_FALSE;
1094    if (it->wd->multi_timer)
1095      {
1096         ecore_timer_del(it->wd->multi_timer);
1097         it->wd->multi_timer = NULL;
1098      }
1099    if (it->wd->multi_timeout)
1100      {
1101         it->wd->multi_timeout = EINA_FALSE;
1102         return;
1103      }
1104
1105    Evas_Coord minw = 0, minh = 0;
1106    Evas_Coord off_x, off_y, off_mx, off_my;
1107
1108    elm_coords_finger_size_adjust(1, &minw, 1, &minh);
1109    off_x = abs(it->wd->cur_x - it->wd->prev_x);
1110    off_y = abs(it->wd->cur_y - it->wd->prev_y);
1111    off_mx = abs(it->wd->cur_mx - it->wd->prev_mx);
1112    off_my = abs(it->wd->cur_my - it->wd->prev_my);
1113
1114    if (((off_x > minw) || (off_y > minh)) && ((off_mx > minw) || (off_my > minh)))
1115      {
1116         if ((off_x + off_mx) > (off_y + off_my))
1117           {
1118              if ((it->wd->cur_x > it->wd->prev_x) && (it->wd->cur_mx > it->wd->prev_mx))
1119                evas_object_smart_callback_call(WIDGET(it),
1120                                                SIG_MULTI_SWIPE_RIGHT, it);
1121              else if ((it->wd->cur_x < it->wd->prev_x) && (it->wd->cur_mx < it->wd->prev_mx))
1122                evas_object_smart_callback_call(WIDGET(it),
1123                                                SIG_MULTI_SWIPE_LEFT, it);
1124              else if (abs(it->wd->cur_x - it->wd->cur_mx) > abs(it->wd->prev_x - it->wd->prev_mx))
1125                evas_object_smart_callback_call(WIDGET(it),
1126                                                SIG_MULTI_PINCH_OUT, it);
1127              else
1128                evas_object_smart_callback_call(WIDGET(it),
1129                                                SIG_MULTI_PINCH_IN, it);
1130           }
1131         else
1132           {
1133              if ((it->wd->cur_y > it->wd->prev_y) && (it->wd->cur_my > it->wd->prev_my))
1134                evas_object_smart_callback_call(WIDGET(it),
1135                                                SIG_MULTI_SWIPE_DOWN, it);
1136              else if ((it->wd->cur_y < it->wd->prev_y) && (it->wd->cur_my < it->wd->prev_my))
1137                evas_object_smart_callback_call(WIDGET(it),
1138                                                SIG_MULTI_SWIPE_UP, it);
1139              else if (abs(it->wd->cur_y - it->wd->cur_my) > abs(it->wd->prev_y - it->wd->prev_my))
1140                evas_object_smart_callback_call(WIDGET(it),
1141                                                SIG_MULTI_PINCH_OUT, it);
1142              else
1143                evas_object_smart_callback_call(WIDGET(it),
1144                                                SIG_MULTI_PINCH_IN, it);
1145           }
1146      }
1147    it->wd->multi_timeout = EINA_FALSE;
1148 }
1149
1150 static void
1151 _multi_down(void        *data,
1152             Evas        *evas __UNUSED__,
1153             Evas_Object *obj __UNUSED__,
1154             void        *event_info)
1155 {
1156    Elm_Gen_Item *it = data;
1157    Evas_Event_Multi_Down *ev = event_info;
1158
1159    if ((it->wd->multi_device != 0) || (it->wd->multitouched) || (it->wd->multi_timeout)) return;
1160    it->wd->multi_device = ev->device;
1161    it->wd->multi_down = EINA_TRUE;
1162    it->wd->multitouched = EINA_TRUE;
1163    it->wd->prev_mx = ev->canvas.x;
1164    it->wd->prev_my = ev->canvas.y;
1165    if (!it->wd->wasselected)
1166      {
1167         _item_unhighlight(it);
1168         _item_unselect(it);
1169      }
1170    it->wd->wasselected = EINA_FALSE;
1171    it->wd->longpressed = EINA_FALSE;
1172    if (it->long_timer)
1173      {
1174         ecore_timer_del(it->long_timer);
1175         it->long_timer = NULL;
1176      }
1177    if (it->dragging)
1178      {
1179         it->dragging = EINA_FALSE;
1180         evas_object_smart_callback_call(WIDGET(it), SIG_DRAG_STOP, it);
1181      }
1182    if (it->item->swipe_timer)
1183      {
1184         ecore_timer_del(it->item->swipe_timer);
1185         it->item->swipe_timer = NULL;
1186      }
1187    if (it->wd->on_hold)
1188      {
1189         it->wd->swipe = EINA_FALSE;
1190         it->wd->movements = 0;
1191         it->wd->on_hold = EINA_FALSE;
1192      }
1193 }
1194
1195 static void
1196 _multi_up(void        *data,
1197           Evas        *evas __UNUSED__,
1198           Evas_Object *obj __UNUSED__,
1199           void        *event_info)
1200 {
1201    Elm_Gen_Item *it = data;
1202    Evas_Event_Multi_Up *ev = event_info;
1203
1204    if (it->wd->multi_device != ev->device) return;
1205    it->wd->multi_device = 0;
1206    it->wd->multi_down = EINA_FALSE;
1207    if (it->wd->mouse_down) return;
1208    _multi_touch_gesture_eval(data);
1209 }
1210
1211 static void
1212 _multi_move(void        *data,
1213             Evas        *evas __UNUSED__,
1214             Evas_Object *obj __UNUSED__,
1215             void        *event_info)
1216 {
1217    Elm_Gen_Item *it = data;
1218    Evas_Event_Multi_Move *ev = event_info;
1219
1220    if (it->wd->multi_device != ev->device) return;
1221    it->wd->cur_mx = ev->cur.canvas.x;
1222    it->wd->cur_my = ev->cur.canvas.y;
1223 }
1224
1225 static void
1226 _mouse_down(void        *data,
1227             Evas        *evas __UNUSED__,
1228             Evas_Object *obj,
1229             void        *event_info)
1230 {
1231    Elm_Gen_Item *it = data;
1232    Evas_Event_Mouse_Down *ev = event_info;
1233    Evas_Coord x, y;
1234
1235    if (ev->button != 1) return;
1236    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
1237      {
1238         it->wd->on_hold = EINA_TRUE;
1239      }
1240
1241    it->down = EINA_TRUE;
1242    it->dragging = EINA_FALSE;
1243    evas_object_geometry_get(obj, &x, &y, NULL, NULL);
1244    it->dx = ev->canvas.x - x;
1245    it->dy = ev->canvas.y - y;
1246    it->wd->mouse_down = EINA_TRUE;
1247    if (!it->wd->multitouched)
1248      {
1249         it->wd->prev_x = ev->canvas.x;
1250         it->wd->prev_y = ev->canvas.y;
1251         it->wd->multi_timeout = EINA_FALSE;
1252         if (it->wd->multi_timer) ecore_timer_del(it->wd->multi_timer);
1253         it->wd->multi_timer = ecore_timer_add(1, _multi_cancel, it->wd);
1254      }
1255    it->wd->longpressed = EINA_FALSE;
1256    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) it->wd->on_hold = EINA_TRUE;
1257    else it->wd->on_hold = EINA_FALSE;
1258    if (it->wd->on_hold) return;
1259    it->wd->wasselected = it->selected;
1260    _item_highlight(it);
1261    if (ev->flags & EVAS_BUTTON_DOUBLE_CLICK)
1262      if ((!elm_widget_item_disabled_get(it)) && (!it->display_only))
1263        {
1264           evas_object_smart_callback_call(WIDGET(it), SIG_CLICKED_DOUBLE, it);
1265           evas_object_smart_callback_call(WIDGET(it), SIG_ACTIVATED, it);
1266        }
1267    if (it->long_timer) ecore_timer_del(it->long_timer);
1268    if (it->item->swipe_timer) ecore_timer_del(it->item->swipe_timer);
1269    it->item->swipe_timer = ecore_timer_add(0.4, _swipe_cancel, it);
1270    if (it->realized)
1271      it->long_timer = ecore_timer_add(it->wd->longpress_timeout, _long_press,
1272                                       it);
1273    else
1274      it->long_timer = NULL;
1275    it->wd->swipe = EINA_FALSE;
1276    it->wd->movements = 0;
1277 }
1278
1279 static void
1280 _mouse_up(void        *data,
1281           Evas        *evas __UNUSED__,
1282           Evas_Object *obj __UNUSED__,
1283           void        *event_info)
1284 {
1285    Elm_Gen_Item *it = data;
1286    Evas_Event_Mouse_Up *ev = event_info;
1287    Eina_Bool dragged = EINA_FALSE;
1288
1289    if (ev->button != 1) return;
1290    it->down = EINA_FALSE;
1291    it->wd->mouse_down = EINA_FALSE;
1292    if (it->wd->multitouched)
1293      {
1294         if ((!it->wd->multi) && (!it->selected) && (it->highlighted)) _item_unhighlight(it);
1295         if (it->wd->multi_down) return;
1296         _multi_touch_gesture_eval(data);
1297         return;
1298      }
1299    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) it->wd->on_hold = EINA_TRUE;
1300    else it->wd->on_hold = EINA_FALSE;
1301    if (it->long_timer)
1302      {
1303         ecore_timer_del(it->long_timer);
1304         it->long_timer = NULL;
1305      }
1306    if (it->dragging)
1307      {
1308         it->dragging = EINA_FALSE;
1309         evas_object_smart_callback_call(WIDGET(it), SIG_DRAG_STOP, it);
1310         dragged = 1;
1311      }
1312    if (it->item->swipe_timer)
1313      {
1314         ecore_timer_del(it->item->swipe_timer);
1315         it->item->swipe_timer = NULL;
1316      }
1317    if (it->wd->multi_timer)
1318      {
1319         ecore_timer_del(it->wd->multi_timer);
1320         it->wd->multi_timer = NULL;
1321         it->wd->multi_timeout = EINA_FALSE;
1322      }
1323    if (it->wd->on_hold)
1324      {
1325         if (it->wd->swipe) _swipe(data);
1326         it->wd->longpressed = EINA_FALSE;
1327         it->wd->on_hold = EINA_FALSE;
1328         return;
1329      }
1330    if ((it->wd->reorder_mode) && (it->wd->reorder_it))
1331      {
1332         Evas_Coord it_scrl_y = ev->canvas.y - it->wd->reorder_it->dy;
1333
1334         if (it->wd->reorder_rel && (it->wd->reorder_it->parent == it->wd->reorder_rel->parent))
1335           {
1336              if (it_scrl_y <= it->wd->reorder_rel->item->scrl_y)
1337                _item_move_before(it->wd->reorder_it, it->wd->reorder_rel);
1338              else
1339                _item_move_after(it->wd->reorder_it, it->wd->reorder_rel);
1340           }
1341         else
1342           {
1343              if (it->wd->calc_job) ecore_job_del(it->wd->calc_job);
1344              it->wd->calc_job = ecore_job_add(_calc_job, it->wd);
1345           }
1346         edje_object_signal_emit(VIEW(it), "elm,state,reorder,disabled", "elm");
1347         it->wd->reorder_it = it->wd->reorder_rel = NULL;
1348         elm_smart_scroller_hold_set(it->wd->scr, EINA_FALSE);
1349         elm_smart_scroller_bounce_allow_set(it->wd->scr, it->wd->h_bounce, it->wd->v_bounce);
1350      }
1351    if (it->wd->longpressed)
1352      {
1353         it->wd->longpressed = EINA_FALSE;
1354         if (!it->wd->wasselected)
1355           {
1356              _item_unhighlight(it);
1357              _item_unselect(it);
1358           }
1359         it->wd->wasselected = EINA_FALSE;
1360         return;
1361      }
1362    if (dragged)
1363      {
1364         if (it->want_unrealize)
1365           {
1366              _elm_genlist_item_unrealize(it, EINA_FALSE);
1367              if (it->item->block->want_unrealize)
1368                _item_block_unrealize(it->item->block);
1369           }
1370      }
1371    if (elm_widget_item_disabled_get(it) || (dragged) || (it->display_only))
1372      return;
1373    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return;
1374    if (it->wd->multi)
1375      {
1376         if (!it->selected)
1377           {
1378              _item_highlight(it);
1379              it->sel_cb(it);
1380           }
1381         else
1382           {
1383              _item_unhighlight(it);
1384              _item_unselect(it);
1385           }
1386      }
1387    else
1388      {
1389         if (!it->selected)
1390           {
1391              Widget_Data *wd = it->wd;
1392              if (wd)
1393                {
1394                   while (wd->selected)
1395                     {
1396                        _item_unhighlight(wd->selected->data);
1397                        _item_unselect(wd->selected->data);
1398                     }
1399                }
1400           }
1401         else
1402           {
1403              const Eina_List *l, *l_next;
1404              Elm_Gen_Item *it2;
1405
1406              EINA_LIST_FOREACH_SAFE(it->wd->selected, l, l_next, it2)
1407                if (it2 != it)
1408                   {
1409                      _item_unhighlight(it2);
1410                      _item_unselect(it2);
1411                   }
1412              //_item_highlight(it);
1413              //_item_select(it);
1414           }
1415         _item_highlight(it);
1416         it->sel_cb(it);
1417      }
1418 }
1419
1420 static void
1421 _signal_expand_toggle(void        *data,
1422                       Evas_Object *obj __UNUSED__,
1423                       const char  *emission __UNUSED__,
1424                       const char  *source __UNUSED__)
1425 {
1426    Elm_Gen_Item *it = data;
1427
1428    if (it->item->expanded)
1429      evas_object_smart_callback_call(WIDGET(it), SIG_CONTRACT_REQUEST, it);
1430    else
1431      evas_object_smart_callback_call(WIDGET(it), SIG_EXPAND_REQUEST, it);
1432 }
1433
1434 static void
1435 _signal_expand(void        *data,
1436                Evas_Object *obj __UNUSED__,
1437                const char  *emission __UNUSED__,
1438                const char  *source __UNUSED__)
1439 {
1440    Elm_Gen_Item *it = data;
1441
1442    if (!it->item->expanded)
1443      evas_object_smart_callback_call(WIDGET(it), SIG_EXPAND_REQUEST, it);
1444 }
1445
1446 static void
1447 _signal_contract(void        *data,
1448                  Evas_Object *obj __UNUSED__,
1449                  const char  *emission __UNUSED__,
1450                  const char  *source __UNUSED__)
1451 {
1452    Elm_Gen_Item *it = data;
1453
1454    if (it->item->expanded)
1455      evas_object_smart_callback_call(WIDGET(it), SIG_CONTRACT_REQUEST, it);
1456 }
1457
1458 static Eina_Bool
1459 _scr_hold_timer_cb(void *data)
1460 {
1461    if (!data) return ECORE_CALLBACK_CANCEL;
1462    Widget_Data *wd = data;
1463    elm_smart_scroller_hold_set(wd->scr, EINA_FALSE);
1464    wd->scr_hold_timer = NULL;
1465    return ECORE_CALLBACK_CANCEL;
1466 }
1467
1468 static void
1469 _mode_finished_signal_cb(void        *data,
1470                          Evas_Object *obj,
1471                          const char  *emission __UNUSED__,
1472                          const char  *source __UNUSED__)
1473 {
1474    if (!data) return;
1475    if (!obj) return;
1476    Elm_Gen_Item *it = data;
1477    if ((it->generation < it->wd->generation) || (!it->realized) || (!it->item->mode_view)) return;
1478    char buf[1024];
1479    Evas *te = evas_object_evas_get(obj);
1480
1481    evas_event_freeze(te);
1482    it->item->nocache = EINA_FALSE;
1483    _mode_item_unrealize(it);
1484    if (it->item->group_item)
1485      evas_object_raise(it->item->VIEW(group_item));
1486    snprintf(buf, sizeof(buf), "elm,state,%s,passive,finished", it->wd->mode_type);
1487    edje_object_signal_callback_del_full(obj, buf, "elm", _mode_finished_signal_cb, it);
1488    evas_event_thaw(te);
1489    evas_event_thaw_eval(te);
1490 }
1491
1492 static void
1493 _item_cache_clean(Widget_Data *wd)
1494 {
1495    evas_event_freeze(evas_object_evas_get(wd->obj));
1496    while ((wd->item_cache) && (wd->item_cache_count > wd->item_cache_max))
1497      {
1498         Item_Cache *itc;
1499
1500         itc = EINA_INLIST_CONTAINER_GET(wd->item_cache->last, Item_Cache);
1501         wd->item_cache = eina_inlist_remove(wd->item_cache,
1502                                             wd->item_cache->last);
1503         wd->item_cache_count--;
1504         if (itc->spacer) evas_object_del(itc->spacer);
1505         if (itc->base_view) evas_object_del(itc->base_view);
1506         if (itc->item_style) eina_stringshare_del(itc->item_style);
1507         free(itc);
1508      }
1509    evas_event_thaw(evas_object_evas_get(wd->obj));
1510    evas_event_thaw_eval(evas_object_evas_get(wd->obj));
1511 }
1512
1513 static void
1514 _item_cache_zero(Widget_Data *wd)
1515 {
1516    int pmax = wd->item_cache_max;
1517    wd->item_cache_max = 0;
1518    _item_cache_clean(wd);
1519    wd->item_cache_max = pmax;
1520 }
1521
1522 static void
1523 _item_cache_add(Elm_Gen_Item *it)
1524 {
1525    Item_Cache *itc;
1526
1527    evas_event_freeze(evas_object_evas_get(it->wd->obj));
1528    if (it->wd->item_cache_max <= 0)
1529      {
1530         evas_object_del(VIEW(it));
1531         VIEW(it) = NULL;
1532         evas_object_del(it->spacer);
1533         it->spacer = NULL;
1534         evas_event_thaw(evas_object_evas_get(it->wd->obj));
1535         evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
1536         return;
1537      }
1538
1539    it->wd->item_cache_count++;
1540    itc = calloc(1, sizeof(Item_Cache));
1541    if (!itc)
1542      {
1543         evas_event_thaw(evas_object_evas_get(it->wd->obj));
1544         evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
1545         return;
1546      }
1547    it->wd->item_cache = eina_inlist_prepend(it->wd->item_cache,
1548                                             EINA_INLIST_GET(itc));
1549    itc->spacer = it->spacer;
1550    it->spacer = NULL;
1551    itc->base_view = VIEW(it);
1552    VIEW(it) = NULL;
1553    edje_object_signal_emit(itc->base_view, "elm,state,unselected", "elm");
1554    evas_object_hide(itc->base_view);
1555    evas_object_move(itc->base_view, -9999, -9999);
1556    itc->item_style = eina_stringshare_add(it->itc->item_style);
1557    if (it->item->flags & ELM_GENLIST_ITEM_SUBITEMS) itc->tree = 1;
1558    itc->compress = (it->wd->compress);
1559    itc->selected = it->selected;
1560    itc->disabled = elm_widget_item_disabled_get(it);
1561    itc->expanded = it->item->expanded;
1562    if (it->long_timer)
1563      {
1564         ecore_timer_del(it->long_timer);
1565         it->long_timer = NULL;
1566      }
1567    if (it->item->swipe_timer)
1568      {
1569         ecore_timer_del(it->item->swipe_timer);
1570         it->item->swipe_timer = NULL;
1571      }
1572    // FIXME: other callbacks?
1573    edje_object_signal_callback_del_full(itc->base_view,
1574                                         "elm,action,expand,toggle",
1575                                         "elm", _signal_expand_toggle, it);
1576    edje_object_signal_callback_del_full(itc->base_view, "elm,action,expand",
1577                                         "elm",
1578                                         _signal_expand, it);
1579    edje_object_signal_callback_del_full(itc->base_view, "elm,action,contract",
1580                                         "elm", _signal_contract, it);
1581    evas_object_event_callback_del_full(itc->base_view, EVAS_CALLBACK_MOUSE_DOWN,
1582                                        _mouse_down, it);
1583    evas_object_event_callback_del_full(itc->base_view, EVAS_CALLBACK_MOUSE_UP,
1584                                        _mouse_up, it);
1585    evas_object_event_callback_del_full(itc->base_view, EVAS_CALLBACK_MOUSE_MOVE,
1586                                        _mouse_move, it);
1587    evas_object_event_callback_del_full(itc->base_view, EVAS_CALLBACK_MULTI_DOWN,
1588                                        _multi_down, it);
1589    evas_object_event_callback_del_full(itc->base_view, EVAS_CALLBACK_MULTI_UP,
1590                                        _multi_up, it);
1591    evas_object_event_callback_del_full(itc->base_view, EVAS_CALLBACK_MULTI_MOVE,
1592                                        _multi_move, it);
1593    _item_cache_clean(it->wd);
1594    evas_event_thaw(evas_object_evas_get(it->wd->obj));
1595    evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
1596 }
1597
1598 static Item_Cache *
1599 _item_cache_find(Elm_Gen_Item *it)
1600 {
1601    Item_Cache *itc;
1602    Eina_Bool tree = 0;
1603
1604    if (it->item->flags & ELM_GENLIST_ITEM_SUBITEMS) tree = 1;
1605    EINA_INLIST_FOREACH(it->wd->item_cache, itc)
1606      {
1607         if ((itc->selected) || (itc->disabled) || (itc->expanded))
1608           continue;
1609         if ((itc->tree == tree) &&
1610             (itc->compress == it->wd->compress) &&
1611             (!strcmp(it->itc->item_style, itc->item_style)))
1612           {
1613              it->wd->item_cache = eina_inlist_remove(it->wd->item_cache,
1614                                                      EINA_INLIST_GET(itc));
1615              it->wd->item_cache_count--;
1616              return itc;
1617           }
1618      }
1619    return NULL;
1620 }
1621
1622 static void
1623 _elm_genlist_item_index_update(Elm_Gen_Item *it)
1624 {
1625    if (it->position_update || it->item->block->position_update)
1626      {
1627         evas_object_smart_callback_call(WIDGET(it), SIG_INDEX_UPDATE, it);
1628         it->position_update = EINA_FALSE;
1629      }
1630 }
1631
1632 static void
1633 _elm_genlist_item_odd_even_update(Elm_Gen_Item *it)
1634 {
1635    if (!it->item->nostacking)
1636      {
1637         if ((it->item->order_num_in & 0x1) ^ it->item->stacking_even)
1638           {
1639              if (it->edit_obj) evas_object_lower(it->edit_obj);
1640              else evas_object_lower(VIEW(it));
1641           }
1642         else
1643           {
1644              if (it->edit_obj) evas_object_raise(it->edit_obj);
1645              else evas_object_raise(VIEW(it));
1646           }
1647      }
1648
1649    if (it->item->order_num_in & 0x1)
1650      {
1651         edje_object_signal_emit(VIEW(it), "elm,state,odd", "elm");
1652         if (it->edit_obj) edje_object_signal_emit(it->edit_obj, "elm,state,odd", "elm");
1653      }
1654    else
1655      {
1656         edje_object_signal_emit(VIEW(it), "elm,state,even", "elm");
1657         if (it->edit_obj) edje_object_signal_emit(it->edit_obj, "elm,state,even", "elm");
1658      }
1659 }
1660
1661 static void
1662 _elm_genlist_item_state_update(Elm_Gen_Item *it, Item_Cache *itc)
1663 {
1664    if (itc)
1665      {
1666         if (it->selected != itc->selected)
1667           {
1668              if (it->selected)
1669                edje_object_signal_emit(VIEW(it),
1670                                        "elm,state,selected", "elm");
1671
1672              if (it->edit_obj)
1673                edje_object_signal_emit(it->edit_obj,
1674                                        "elm,state,selected", "elm");
1675           }
1676         if (elm_widget_item_disabled_get(it) != itc->disabled)
1677           {
1678              if (elm_widget_item_disabled_get(it))
1679                edje_object_signal_emit(VIEW(it),
1680                                        "elm,state,disabled", "elm");
1681              if (it->edit_obj)
1682                edje_object_signal_emit(it->edit_obj,
1683                                        "elm,state,disabled", "elm");
1684           }
1685         if (it->item->expanded != itc->expanded)
1686           {
1687              if (it->item->expanded)
1688                edje_object_signal_emit(VIEW(it),
1689                                        "elm,state,expanded", "elm");
1690              if (it->edit_obj)
1691                edje_object_signal_emit(it->edit_obj,
1692                                        "elm,state,expanded", "elm");
1693           }
1694      }
1695    else
1696      {
1697         if (it->selected)
1698           {
1699              edje_object_signal_emit(VIEW(it),
1700                                      "elm,state,selected", "elm");
1701              if (it->edit_obj)
1702                edje_object_signal_emit(it->edit_obj,
1703                                        "elm,state,selected", "elm");
1704           }
1705
1706         if (elm_widget_item_disabled_get(it))
1707           {
1708              edje_object_signal_emit(VIEW(it),
1709                                      "elm,state,disabled", "elm");
1710              if (it->edit_obj)
1711                edje_object_signal_emit(it->edit_obj,
1712                                        "elm,state,disabled", "elm");
1713           }
1714         if (it->item->expanded)
1715           {
1716              edje_object_signal_emit(VIEW(it),
1717                                      "elm,state,expanded", "elm");
1718              if (it->edit_obj)
1719                edje_object_signal_emit(it->edit_obj,
1720                                        "elm,state,expanded", "elm");
1721           }
1722      }
1723 }
1724
1725 static void
1726 _item_cache_free(Item_Cache *itc)
1727 {
1728    if (itc->spacer) evas_object_del(itc->spacer);
1729    if (itc->base_view) evas_object_del(itc->base_view);
1730    if (itc->item_style) eina_stringshare_del(itc->item_style);
1731    free(itc);
1732 }
1733
1734 static void
1735 _item_text_realize(Elm_Gen_Item *it,
1736                     Evas_Object *target,
1737                     Eina_List **source,
1738                     const char *parts)
1739 {
1740    if (it->itc->func.text_get)
1741      {
1742         const Eina_List *l;
1743         const char *key;
1744
1745         *source = elm_widget_stringlist_get(edje_object_data_get(target, "texts"));
1746         EINA_LIST_FOREACH(*source, l, key)
1747           {
1748              if (parts && fnmatch(parts, key, FNM_PERIOD))
1749                continue;
1750
1751              char *s = it->itc->func.text_get
1752                 ((void *)it->base.data, WIDGET(it), key);
1753
1754              if (s)
1755                {
1756                   edje_object_part_text_set(target, key, s);
1757                   free(s);
1758                }
1759              else
1760                {
1761                   edje_object_part_text_set(target, key, "");
1762                }
1763           }
1764      }
1765 }
1766
1767 static Eina_List *
1768 _item_content_unrealize(Elm_Gen_Item *it,
1769                    Evas_Object *target,
1770                    Eina_List **source,
1771                    const char *parts)
1772 {
1773    Eina_List *res = it->content_objs;
1774
1775    if (it->itc->func.content_get)
1776      {
1777         const Eina_List *l;
1778         const char *key;
1779         Evas_Object *ic = NULL;
1780
1781         EINA_LIST_FOREACH(*source, l, key)
1782           {
1783              if (parts && fnmatch(parts, key, FNM_PERIOD))
1784                continue;
1785
1786              ic = edje_object_part_swallow_get(target, key);
1787              if (ic)
1788                {
1789                   res = eina_list_remove(res, ic);
1790                   edje_object_part_unswallow(target, ic);
1791                   evas_object_del(ic);
1792                }
1793           }
1794      }
1795
1796    return res;
1797 }
1798
1799 static Eina_List *
1800 _item_content_realize(Elm_Gen_Item *it,
1801                    Evas_Object *target,
1802                    Eina_List **source,
1803                    const char *parts)
1804 {
1805    Eina_List *res = NULL;
1806
1807    if (it->itc->func.content_get)
1808      {
1809         const Eina_List *l;
1810         const char *key;
1811         Evas_Object *ic = NULL;
1812
1813         *source = elm_widget_stringlist_get(edje_object_data_get(target, "contents"));
1814
1815         if (parts && (eina_list_count(*source) != eina_list_count(it->content_objs)))
1816           res = it->content_objs;
1817
1818         EINA_LIST_FOREACH(*source, l, key)
1819           {
1820              if (parts && fnmatch(parts, key, FNM_PERIOD))
1821                continue;
1822
1823              if (it->itc->func.content_get)
1824                ic = it->itc->func.content_get
1825                   ((void *)it->base.data, WIDGET(it), key);
1826              if (ic)
1827                {
1828                   res = eina_list_append(res, ic);
1829                   edje_object_part_swallow(target, key, ic);
1830                   evas_object_show(ic);
1831                   elm_widget_sub_object_add(WIDGET(it), ic);
1832                   if (elm_widget_item_disabled_get(it))
1833                     elm_widget_disabled_set(ic, EINA_TRUE);
1834                }
1835           }
1836      }
1837
1838    return res;
1839 }
1840
1841 static void
1842 _item_state_realize(Elm_Gen_Item *it,
1843                     Evas_Object *target,
1844                     Eina_List **source,
1845                     const char *parts)
1846 {
1847    if (it->itc->func.state_get)
1848      {
1849         const Eina_List *l;
1850         const char *key;
1851         char buf[4096];
1852
1853         *source = elm_widget_stringlist_get(edje_object_data_get(target, "states"));
1854         EINA_LIST_FOREACH(*source, l, key)
1855           {
1856              if (parts && fnmatch(parts, key, FNM_PERIOD))
1857                continue;
1858
1859              Eina_Bool on = it->itc->func.state_get
1860                 ((void *)it->base.data, WIDGET(it), key);
1861
1862              if (on)
1863                {
1864                   snprintf(buf, sizeof(buf), "elm,state,%s,active", key);
1865                   edje_object_signal_emit(target, buf, "elm");
1866                }
1867              else
1868                {
1869                   snprintf(buf, sizeof(buf), "elm,state,%s,passive", key);
1870                   edje_object_signal_emit(target, buf, "elm");
1871                }
1872           }
1873      }
1874 }
1875
1876 static void
1877 _item_realize(Elm_Gen_Item *it,
1878               int               in,
1879               Eina_Bool         calc)
1880 {
1881    const char *treesize;
1882    char buf[1024];
1883    int tsize = 20;
1884    Item_Cache *itc = NULL;
1885
1886    if (it->generation < it->wd->generation) return;
1887    //evas_event_freeze(evas_object_evas_get(it->wd->obj));
1888    if (it->realized)
1889      {
1890         if (it->item->order_num_in != in)
1891           {
1892              it->item->order_num_in = in;
1893              _elm_genlist_item_odd_even_update(it);
1894              _elm_genlist_item_state_update(it, NULL);
1895              _elm_genlist_item_index_update(it);
1896           }
1897         //evas_event_thaw(evas_object_evas_get(it->wd->obj));
1898         //evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
1899         return;
1900      }
1901    it->item->order_num_in = in;
1902
1903    if (it->item->nocache)
1904      it->item->nocache = EINA_FALSE;
1905    else
1906      itc = _item_cache_find(it);
1907    if (itc)
1908      {
1909         VIEW(it) = itc->base_view;
1910         itc->base_view = NULL;
1911         it->spacer = itc->spacer;
1912         itc->spacer = NULL;
1913      }
1914    else
1915      {
1916         const char *stacking_even;
1917         const char *stacking;
1918
1919         VIEW(it) = edje_object_add(evas_object_evas_get(WIDGET(it)));
1920         edje_object_scale_set(VIEW(it),
1921                               elm_widget_scale_get(WIDGET(it)) *
1922                               _elm_config->scale);
1923         evas_object_smart_member_add(VIEW(it), it->wd->pan_smart);
1924         elm_widget_sub_object_add(WIDGET(it), VIEW(it));
1925
1926         if (it->item->flags & ELM_GENLIST_ITEM_SUBITEMS)
1927           strncpy(buf, "tree", sizeof(buf));
1928         else strncpy(buf, "item", sizeof(buf));
1929         if (it->wd->compress)
1930           strncat(buf, "_compress", sizeof(buf) - strlen(buf));
1931
1932         strncat(buf, "/", sizeof(buf) - strlen(buf));
1933         strncat(buf, it->itc->item_style, sizeof(buf) - strlen(buf));
1934
1935         _elm_theme_object_set(WIDGET(it), VIEW(it), "genlist", buf,
1936                               elm_widget_style_get(WIDGET(it)));
1937
1938         stacking_even = edje_object_data_get(VIEW(it), "stacking_even");
1939         if (!stacking_even) stacking_even = "above";
1940         it->item->stacking_even = !!strcmp("above", stacking_even);
1941
1942         stacking = edje_object_data_get(VIEW(it), "stacking");
1943         if (!stacking) stacking = "yes";
1944         it->item->nostacking = !!strcmp("yes", stacking);
1945
1946         edje_object_mirrored_set(VIEW(it),
1947                                  elm_widget_mirrored_get(WIDGET(it)));
1948         it->spacer =
1949           evas_object_rectangle_add(evas_object_evas_get(WIDGET(it)));
1950         evas_object_color_set(it->spacer, 0, 0, 0, 0);
1951         elm_widget_sub_object_add(WIDGET(it), it->spacer);
1952      }
1953
1954    _elm_genlist_item_odd_even_update(it);
1955
1956    treesize = edje_object_data_get(VIEW(it), "treesize");
1957    if (treesize) tsize = atoi(treesize);
1958    evas_object_size_hint_min_set(it->spacer,
1959                                  (it->item->expanded_depth * tsize) * _elm_config->scale, 1);
1960    edje_object_part_swallow(VIEW(it), "elm.swallow.pad", it->spacer);
1961    if (!calc)
1962      {
1963         edje_object_signal_callback_add(VIEW(it),
1964                                         "elm,action,expand,toggle",
1965                                         "elm", _signal_expand_toggle, it);
1966         edje_object_signal_callback_add(VIEW(it), "elm,action,expand",
1967                                         "elm", _signal_expand, it);
1968         edje_object_signal_callback_add(VIEW(it), "elm,action,contract",
1969                                         "elm", _signal_contract, it);
1970         evas_object_event_callback_add(VIEW(it), EVAS_CALLBACK_MOUSE_DOWN,
1971                                        _mouse_down, it);
1972         evas_object_event_callback_add(VIEW(it), EVAS_CALLBACK_MOUSE_UP,
1973                                        _mouse_up, it);
1974         evas_object_event_callback_add(VIEW(it), EVAS_CALLBACK_MOUSE_MOVE,
1975                                        _mouse_move, it);
1976         evas_object_event_callback_add(VIEW(it), EVAS_CALLBACK_MULTI_DOWN,
1977                                        _multi_down, it);
1978         evas_object_event_callback_add(VIEW(it), EVAS_CALLBACK_MULTI_UP,
1979                                        _multi_up, it);
1980         evas_object_event_callback_add(VIEW(it), EVAS_CALLBACK_MULTI_MOVE,
1981                                        _multi_move, it);
1982
1983         if ((it->wd->edit_mode) && (!it->edit_obj) &&
1984             (it->item->flags != ELM_GENLIST_ITEM_GROUP) && (it->itc->edit_item_style))
1985           _edit_mode_item_realize(it, EINA_FALSE);
1986
1987         _elm_genlist_item_state_update(it, itc);
1988         _elm_genlist_item_index_update(it);
1989      }
1990
1991    if ((calc) && (it->wd->homogeneous) &&
1992        ((it->wd->item_width) ||
1993         ((it->wd->item_width) && (it->wd->group_item_width))))
1994      {
1995         /* homogenous genlist shortcut */
1996         if (!it->item->mincalcd)
1997           {
1998              if (it->group)
1999                {
2000                   it->item->w = it->item->minw = it->wd->group_item_width;
2001                   it->item->h = it->item->minh = it->wd->group_item_height;
2002                }
2003              else
2004                {
2005                   it->item->w = it->item->minw = it->wd->item_width;
2006                   it->item->h = it->item->minh = it->wd->item_height;
2007                }
2008              it->item->mincalcd = EINA_TRUE;
2009           }
2010      }
2011    else
2012      {
2013         /* FIXME: If you see that assert, please notify us and we
2014            will clean our mess */
2015         assert(eina_list_count(it->content_objs) == 0);
2016
2017         _item_text_realize(it, VIEW(it), &it->texts, NULL);
2018         it->content_objs = _item_content_realize(it, VIEW(it), &it->contents, NULL);
2019         _item_state_realize(it, VIEW(it), &it->states, NULL);
2020
2021         if (!it->item->mincalcd)
2022           {
2023              Evas_Coord mw = -1, mh = -1;
2024
2025              if (!it->display_only)
2026                elm_coords_finger_size_adjust(1, &mw, 1, &mh);
2027              if (it->wd->height_for_width) mw = it->wd->prev_viewport_w;
2028              edje_object_size_min_restricted_calc(VIEW(it), &mw, &mh, mw,
2029                                                   mh);
2030              if (!it->display_only)
2031                elm_coords_finger_size_adjust(1, &mw, 1, &mh);
2032              it->item->w = it->item->minw = mw;
2033              it->item->h = it->item->minh = mh;
2034              it->item->mincalcd = EINA_TRUE;
2035
2036              if ((!it->wd->group_item_width) && (it->group))
2037                {
2038                   it->wd->group_item_width = mw;
2039                   it->wd->group_item_height = mh;
2040                }
2041              else if ((!it->wd->item_width) && (it->item->flags == ELM_GENLIST_ITEM_NONE))
2042                {
2043                   it->wd->item_width = mw;
2044                   it->wd->item_height = mh;
2045                }
2046           }
2047         if (!calc) evas_object_show(VIEW(it));
2048      }
2049
2050    if (it->tooltip.content_cb)
2051      {
2052         elm_widget_item_tooltip_content_cb_set(it,
2053                                                it->tooltip.content_cb,
2054                                                it->tooltip.data, NULL);
2055         elm_widget_item_tooltip_style_set(it, it->tooltip.style);
2056         elm_widget_item_tooltip_window_mode_set(it, it->tooltip.free_size);
2057      }
2058
2059    if (it->mouse_cursor)
2060      elm_widget_item_cursor_set(it, it->mouse_cursor);
2061
2062    it->realized = EINA_TRUE;
2063    it->want_unrealize = EINA_FALSE;
2064
2065    if (itc) _item_cache_free(itc);
2066    //evas_event_thaw(evas_object_evas_get(it->wd->obj));
2067    //evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
2068    if (!calc)
2069      evas_object_smart_callback_call(WIDGET(it), SIG_REALIZED, it);
2070
2071    if ((!calc) && (it->wd->edit_mode) && (it->item->flags != ELM_GENLIST_ITEM_GROUP))
2072      {
2073         if (it->itc->edit_item_style)
2074           {
2075              if (!it->edit_obj) _edit_mode_item_realize(it, EINA_FALSE);
2076              edje_object_message_signal_process(it->edit_obj);
2077           }
2078      }
2079    edje_object_message_signal_process(VIEW(it));
2080 }
2081
2082 static void
2083 _item_unrealize_cb(Elm_Gen_Item *it)
2084 {
2085    if (it->item->nocache)
2086      {
2087         evas_object_del(VIEW(it));
2088         VIEW(it) = NULL;
2089         evas_object_del(it->spacer);
2090         it->spacer = NULL;
2091      }
2092    else
2093      {
2094         edje_object_mirrored_set(VIEW(it),
2095                                  elm_widget_mirrored_get(WIDGET(it)));
2096         edje_object_scale_set(VIEW(it),
2097                               elm_widget_scale_get(WIDGET(it))
2098                               * _elm_config->scale);
2099         _item_cache_add(it);
2100      }
2101
2102    _mode_item_unrealize(it);
2103    it->states = NULL;
2104    it->realized = EINA_FALSE;
2105    it->want_unrealize = EINA_FALSE;
2106    if (it->wd->edit_mode) _edit_mode_item_unrealize(it);
2107 }
2108
2109 static Eina_Bool
2110 _item_block_recalc(Item_Block *itb,
2111                    int         in,
2112                    Eina_Bool   qadd)
2113 {
2114    const Eina_List *l;
2115    Elm_Gen_Item *it;
2116    Evas_Coord minw = 0, minh = 0;
2117    Eina_Bool showme = EINA_FALSE, changed = EINA_FALSE;
2118    Evas_Coord y = 0;
2119
2120    //evas_event_freeze(evas_object_evas_get(itb->wd->obj));
2121    itb->num = in;
2122    EINA_LIST_FOREACH(itb->items, l, it)
2123      {
2124         if (it->generation < it->wd->generation) continue;
2125         showme |= it->item->showme;
2126         if (!itb->realized)
2127           {
2128              if (qadd)
2129                {
2130                   if (!it->item->mincalcd) changed = EINA_TRUE;
2131                   if (changed)
2132                     {
2133                        _item_realize(it, in, EINA_TRUE);
2134                        _elm_genlist_item_unrealize(it, EINA_TRUE);
2135                     }
2136                }
2137              else
2138                {
2139                   _item_realize(it, in, EINA_TRUE);
2140                   _elm_genlist_item_unrealize(it, EINA_TRUE);
2141                }
2142           }
2143         else
2144           _item_realize(it, in, EINA_FALSE);
2145         minh += it->item->minh;
2146         if (minw < it->item->minw) minw = it->item->minw;
2147         in++;
2148         it->x = 0;
2149         it->y = y;
2150         y += it->item->h;
2151      }
2152    itb->minw = minw;
2153    itb->minh = minh;
2154    itb->changed = EINA_FALSE;
2155    itb->position_update = EINA_FALSE;
2156    //evas_event_thaw(evas_object_evas_get(itb->wd->obj));
2157    //evas_event_thaw_eval(evas_object_evas_get(itb->wd->obj));
2158    return showme;
2159 }
2160
2161 static void
2162 _item_block_realize(Item_Block *itb)
2163 {
2164    if (itb->realized) return;
2165    itb->realized = EINA_TRUE;
2166    itb->want_unrealize = EINA_FALSE;
2167 }
2168
2169 static void
2170 _item_block_unrealize(Item_Block *itb)
2171 {
2172    const Eina_List *l;
2173    Elm_Gen_Item *it;
2174    Eina_Bool dragging = EINA_FALSE;
2175
2176    if (!itb->realized) return;
2177    evas_event_freeze(evas_object_evas_get(itb->wd->obj));
2178    EINA_LIST_FOREACH(itb->items, l, it)
2179      {
2180         if (itb->must_recalc || !it->group)
2181           {
2182              if (it->dragging)
2183                {
2184                   dragging = EINA_TRUE;
2185                   it->want_unrealize = EINA_TRUE;
2186                }
2187              else
2188                _elm_genlist_item_unrealize(it, EINA_FALSE);
2189           }
2190      }
2191    if (!dragging)
2192      {
2193         itb->realized = EINA_FALSE;
2194         itb->want_unrealize = EINA_TRUE;
2195      }
2196    else
2197      itb->want_unrealize = EINA_FALSE;
2198    evas_event_thaw(evas_object_evas_get(itb->wd->obj));
2199    evas_event_thaw_eval(evas_object_evas_get(itb->wd->obj));
2200 }
2201
2202 static int
2203 _get_space_for_reorder_item(Elm_Gen_Item *it)
2204 {
2205    Evas_Coord rox, roy, row, roh, oy, oh;
2206    Eina_Bool top = EINA_FALSE;
2207    Elm_Gen_Item *reorder_it = it->wd->reorder_it;
2208    if (!reorder_it) return 0;
2209
2210    evas_object_geometry_get(it->wd->pan_smart, NULL, &oy, NULL, &oh);
2211    evas_object_geometry_get(it->wd->VIEW(reorder_it), &rox, &roy, &row, &roh);
2212
2213    if ((it->wd->reorder_start_y < it->item->block->y) &&
2214        (roy - oy + (roh / 2) >= it->item->block->y - it->wd->pan_y))
2215      {
2216         it->item->block->reorder_offset = it->wd->reorder_it->item->h * -1;
2217         if (it->item->block->count == 1)
2218           it->wd->reorder_rel = it;
2219      }
2220    else if ((it->wd->reorder_start_y >= it->item->block->y) &&
2221             (roy - oy + (roh / 2) <= it->item->block->y - it->wd->pan_y))
2222      {
2223         it->item->block->reorder_offset = it->wd->reorder_it->item->h;
2224      }
2225    else
2226      it->item->block->reorder_offset = 0;
2227
2228    it->item->scrl_y += it->item->block->reorder_offset;
2229
2230    top = (ELM_RECTS_INTERSECT(it->item->scrl_x, it->item->scrl_y, it->item->w, it->item->h,
2231                               rox, roy + (roh / 2), row, 1));
2232    if (top)
2233      {
2234         it->wd->reorder_rel = it;
2235         it->item->scrl_y += it->wd->reorder_it->item->h;
2236         return it->wd->reorder_it->item->h;
2237      }
2238    else
2239      return 0;
2240 }
2241
2242 static Eina_Bool
2243 _reorder_move_animator_cb(void *data)
2244 {
2245    Elm_Gen_Item *it = data;
2246    Eina_Bool down = EINA_FALSE;
2247    double t;
2248    int y, dy = it->item->h / 10 * _elm_config->scale, diff;
2249
2250    t = ((0.0 > (t = ecore_loop_time_get()-it->wd->start_time)) ? 0.0 : t);
2251
2252    if (t <= REORDER_EFFECT_TIME) y = (1 * sin((t / REORDER_EFFECT_TIME) * (M_PI / 2)) * dy);
2253    else y = dy;
2254
2255    diff = abs(it->item->old_scrl_y - it->item->scrl_y);
2256    if (diff > it->item->h) y = diff / 2;
2257
2258    if (it->item->old_scrl_y < it->item->scrl_y)
2259      {
2260         it->item->old_scrl_y += y;
2261         down = EINA_TRUE;
2262      }
2263    else if (it->item->old_scrl_y > it->item->scrl_y)
2264      {
2265         it->item->old_scrl_y -= y;
2266         down = EINA_FALSE;
2267      }
2268
2269    if (it->edit_obj)
2270      _item_position(it, it->edit_obj, it->item->scrl_x, it->item->old_scrl_y);
2271    else
2272      _item_position(it, VIEW(it), it->item->scrl_x, it->item->old_scrl_y);
2273    _group_items_recalc(it->wd);
2274
2275    if ((it->wd->reorder_pan_move) ||
2276        (down && it->item->old_scrl_y >= it->item->scrl_y) ||
2277        (!down && it->item->old_scrl_y <= it->item->scrl_y))
2278      {
2279         it->item->old_scrl_y = it->item->scrl_y;
2280         it->item->move_effect_enabled = EINA_FALSE;
2281         it->wd->reorder_move_animator = NULL;
2282         return ECORE_CALLBACK_CANCEL;
2283      }
2284    return ECORE_CALLBACK_RENEW;
2285 }
2286
2287 static void
2288 _item_position(Elm_Gen_Item *it,
2289                Evas_Object      *view,
2290                Evas_Coord        it_x,
2291                Evas_Coord        it_y)
2292 {
2293    if (!it) return;
2294    if (!view) return;
2295
2296    evas_event_freeze(evas_object_evas_get(it->wd->obj));
2297    evas_object_resize(view, it->item->w, it->item->h);
2298    evas_object_move(view, it_x, it_y);
2299    evas_object_show(view);
2300    evas_event_thaw(evas_object_evas_get(it->wd->obj));
2301    evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
2302 }
2303
2304 static void
2305 _item_block_position(Item_Block *itb,
2306                      int         in)
2307 {
2308    const Eina_List *l;
2309    Elm_Gen_Item *it;
2310    Elm_Gen_Item *git;
2311    Evas_Coord y = 0, ox, oy, ow, oh, cvx, cvy, cvw, cvh;
2312    Eina_Bool vis = EINA_FALSE;
2313
2314    evas_event_freeze(evas_object_evas_get(itb->wd->obj));
2315    evas_object_geometry_get(itb->wd->pan_smart, &ox, &oy, &ow, &oh);
2316    evas_output_viewport_get(evas_object_evas_get(itb->wd->obj), &cvx, &cvy,
2317                             &cvw, &cvh);
2318    EINA_LIST_FOREACH(itb->items, l, it)
2319      {
2320         if (it->generation < it->wd->generation) continue;
2321         else if (it->wd->reorder_it == it) continue;
2322         it->x = 0;
2323         it->y = y;
2324         it->item->w = itb->w;
2325         it->item->scrl_x = itb->x + it->x - it->wd->pan_x + ox;
2326         it->item->scrl_y = itb->y + it->y - it->wd->pan_y + oy;
2327
2328         vis = (ELM_RECTS_INTERSECT(it->item->scrl_x, it->item->scrl_y, it->item->w, it->item->h,
2329                                    cvx, cvy, cvw, cvh));
2330         if (!it->group)
2331           {
2332              if ((itb->realized) && (!it->realized))
2333                {
2334                   if (vis) _item_realize(it, in, EINA_FALSE);
2335                }
2336              if (it->realized)
2337                {
2338                   if (vis)
2339                     {
2340                        if (it->wd->reorder_mode)
2341                          y += _get_space_for_reorder_item(it);
2342                        git = it->item->group_item;
2343                        if (git)
2344                          {
2345                             if (git->item->scrl_y < oy)
2346                               git->item->scrl_y = oy;
2347                             if ((git->item->scrl_y + git->item->h) > (it->item->scrl_y + it->item->h))
2348                               git->item->scrl_y = (it->item->scrl_y + it->item->h) - git->item->h;
2349                             git->item->want_realize = EINA_TRUE;
2350                          }
2351                        if ((it->wd->reorder_it) && (it->item->old_scrl_y != it->item->scrl_y))
2352                          {
2353                             if (!it->item->move_effect_enabled)
2354                               {
2355                                  it->item->move_effect_enabled = EINA_TRUE;
2356                                  it->wd->reorder_move_animator =
2357                                     ecore_animator_add(
2358                                        _reorder_move_animator_cb, it);
2359                               }
2360                          }
2361                        if (!it->item->move_effect_enabled)
2362                          {
2363                             if ((it->wd->edit_mode) && (it->itc->edit_item_style))
2364                               _edit_mode_item_position(it, it->item->scrl_x,
2365                                                        it->item->scrl_y);
2366                             else
2367                               {
2368                                  if (it->item->mode_view)
2369                                    _item_position(it, it->item->mode_view,
2370                                                   it->item->scrl_x,
2371                                                   it->item->scrl_y);
2372                                  else
2373                                    _item_position(it, VIEW(it), it->item->scrl_x,
2374                                                   it->item->scrl_y);
2375                               }
2376                             it->item->old_scrl_y = it->item->scrl_y;
2377                          }
2378                     }
2379                   else
2380                     {
2381                        if (!it->dragging) _elm_genlist_item_unrealize(it, EINA_FALSE);
2382                     }
2383                }
2384              in++;
2385           }
2386         else
2387           {
2388              if (vis) it->item->want_realize = EINA_TRUE;
2389           }
2390         y += it->item->h;
2391      }
2392    evas_event_thaw(evas_object_evas_get(itb->wd->obj));
2393    evas_event_thaw_eval(evas_object_evas_get(itb->wd->obj));
2394 }
2395
2396 static void
2397 _group_items_recalc(void *data)
2398 {
2399    Widget_Data *wd = data;
2400    Eina_List *l;
2401    Elm_Gen_Item *git;
2402
2403    evas_event_freeze(evas_object_evas_get(wd->obj));
2404    EINA_LIST_FOREACH(wd->group_items, l, git)
2405      {
2406         if (git->item->want_realize)
2407           {
2408              if (!git->realized)
2409                _item_realize(git, 0, EINA_FALSE);
2410              evas_object_resize(VIEW(git), wd->minw, git->item->h);
2411              evas_object_move(VIEW(git), git->item->scrl_x, git->item->scrl_y);
2412              evas_object_show(VIEW(git));
2413              evas_object_raise(VIEW(git));
2414           }
2415         else if (!git->item->want_realize && git->realized)
2416           {
2417              if (!git->dragging)
2418                _elm_genlist_item_unrealize(git, EINA_FALSE);
2419           }
2420      }
2421    evas_event_thaw(evas_object_evas_get(wd->obj));
2422    evas_event_thaw_eval(evas_object_evas_get(wd->obj));
2423 }
2424
2425 static Eina_Bool
2426 _must_recalc_idler(void *data)
2427 {
2428    Widget_Data *wd = data;
2429    if (wd->calc_job) ecore_job_del(wd->calc_job);
2430    wd->calc_job = ecore_job_add(_calc_job, wd);
2431    wd->must_recalc_idler = NULL;
2432    return ECORE_CALLBACK_CANCEL;
2433 }
2434
2435 static void
2436 _scroll_item(Widget_Data *wd)
2437 {
2438    Elm_Gen_Item *it = NULL;
2439    Evas_Coord gith = 0;
2440    Evas_Coord ow, oh, dx = 0, dy = 0, dw = 0, dh = 0;
2441
2442    evas_object_geometry_get(wd->pan_smart, NULL, NULL, &ow, &oh);
2443    it = wd->show_item;
2444    dx = it->x + it->item->block->x;
2445    dy = it->y + it->item->block->y;
2446    dw = it->item->block->w;
2447    dh = oh;
2448    switch (wd->scrollto_type)
2449      {
2450       case ELM_GENLIST_ITEM_SCROLLTO_TOP:
2451          if (it->item->group_item) gith = it->item->group_item->item->h;
2452          dy -= gith;
2453          break;
2454       case ELM_GENLIST_ITEM_SCROLLTO_MIDDLE:
2455          dy += (it->item->h / 2 - oh / 2);
2456          break;
2457       case ELM_GENLIST_ITEM_SCROLLTO_IN:
2458       default:
2459          if ((wd->expanded_item) &&
2460              ((wd->show_item->y + wd->show_item->item->block->y + wd->show_item->item->h)
2461               - (wd->expanded_item->y + wd->expanded_item->item->block->y) > oh))
2462            {
2463               it = wd->expanded_item;
2464               if (it->item->group_item) gith = it->item->group_item->item->h;
2465               dx = it->x + it->item->block->x;
2466               dy = it->y + it->item->block->y - gith;
2467               dw = it->item->block->w;
2468            }
2469          else
2470            {
2471               if ((it->item->group_item) && (wd->pan_y > (it->y + it->item->block->y)))
2472                 gith = it->item->group_item->item->h;
2473               dy -= gith;
2474               dh = it->item->h;
2475            }
2476          break;
2477      }
2478    if (wd->bring_in)
2479      elm_smart_scroller_region_bring_in(wd->scr, dx, dy, dw, dh);
2480    else
2481      elm_smart_scroller_child_region_show(wd->scr, dx, dy, dw, dh);
2482
2483    it->item->showme = EINA_FALSE;
2484    wd->show_item = NULL;
2485    wd->auto_scroll_enabled = EINA_FALSE;
2486    wd->check_scroll = EINA_FALSE;
2487 }
2488
2489 static void
2490 _calc_job(void *data)
2491 {
2492    Widget_Data *wd = data;
2493    Item_Block *itb, *chb = NULL;
2494    Evas_Coord minw = -1, minh = 0, y = 0, ow, dy = 0, vw;
2495    Evas_Coord pan_w = 0, pan_h = 0;
2496    int in = 0;
2497    Eina_Bool minw_change = EINA_FALSE;
2498    Eina_Bool did_must_recalc = EINA_FALSE;
2499    if (!wd) return;
2500
2501    evas_object_geometry_get(wd->pan_smart, NULL, NULL, &ow, &wd->h);
2502    elm_smart_scroller_child_viewport_size_get(wd->scr, &vw, NULL);
2503
2504    if (wd->w != ow)
2505      wd->w = ow;
2506
2507    evas_event_freeze(evas_object_evas_get(wd->obj));
2508    EINA_INLIST_FOREACH(wd->blocks, itb)
2509      {
2510         Eina_Bool showme = EINA_FALSE;
2511
2512         itb->num = in;
2513         showme = itb->showme;
2514         itb->showme = EINA_FALSE;
2515         if (chb)
2516           {
2517              if (itb->realized) _item_block_unrealize(itb);
2518           }
2519         if ((itb->changed) || ((itb->must_recalc) && (!did_must_recalc)))
2520           {
2521              if (itb->must_recalc)
2522                {
2523                   Eina_List *l;
2524                   Elm_Gen_Item *it;
2525                   EINA_LIST_FOREACH(itb->items, l, it)
2526                     if (it->item->mincalcd) it->item->mincalcd = EINA_FALSE;
2527                   itb->changed = EINA_TRUE;
2528                   if (itb->must_recalc) did_must_recalc = EINA_TRUE;
2529                   if (itb->realized) _item_block_unrealize(itb);
2530                   itb->must_recalc = EINA_FALSE;
2531                }
2532              showme = _item_block_recalc(itb, in, EINA_FALSE);
2533              chb = itb;
2534           }
2535         itb->y = y;
2536         itb->x = 0;
2537         minh += itb->minh;
2538         if (minw == -1) minw = itb->minw;
2539         else if ((!itb->must_recalc) && (minw < itb->minw))
2540           {
2541              minw = itb->minw;
2542              minw_change = EINA_TRUE;
2543           }
2544         if (minw > vw)
2545           {
2546              minw = vw;
2547              minw_change = EINA_TRUE;
2548           }
2549         itb->w = minw;
2550         itb->h = itb->minh;
2551         y += itb->h;
2552         in += itb->count;
2553         if ((showme) && (wd->show_item) && (!wd->show_item->item->queued))
2554           wd->check_scroll = EINA_TRUE;
2555      }
2556    if (minw_change)
2557      {
2558         EINA_INLIST_FOREACH(wd->blocks, itb)
2559           {
2560              itb->minw = minw;
2561              itb->w = itb->minw;
2562           }
2563      }
2564    if ((chb) && (EINA_INLIST_GET(chb)->next))
2565      {
2566         EINA_INLIST_FOREACH(EINA_INLIST_GET(chb)->next, itb)
2567           {
2568              if (itb->realized) _item_block_unrealize(itb);
2569           }
2570      }
2571    wd->realminw = minw;
2572    if (minw < wd->w) minw = wd->w;
2573    if ((minw != wd->minw) || (minh != wd->minh))
2574      {
2575         wd->minw = minw;
2576         wd->minh = minh;
2577         evas_object_smart_callback_call(wd->pan_smart, "changed", NULL);
2578         _sizing_eval(wd->obj);
2579         if ((wd->anchor_item) && (wd->anchor_item->item->block) && (!wd->auto_scroll_enabled))
2580           {
2581              Elm_Gen_Item *it;
2582              Evas_Coord it_y;
2583
2584              it = wd->anchor_item;
2585              it_y = wd->anchor_y;
2586              elm_smart_scroller_child_pos_set(wd->scr, wd->pan_x,
2587                                               it->item->block->y + it->y + it_y);
2588              wd->anchor_item = it;
2589              wd->anchor_y = it_y;
2590           }
2591      }
2592    if (did_must_recalc)
2593      {
2594         if (!wd->must_recalc_idler)
2595           wd->must_recalc_idler = ecore_idler_add(_must_recalc_idler, wd);
2596      }
2597    if (wd->check_scroll)
2598      {
2599         _pan_child_size_get(wd->pan_smart, &pan_w, &pan_h);
2600         if (EINA_INLIST_GET(wd->show_item) == wd->items->last)
2601           wd->scrollto_type = ELM_GENLIST_ITEM_SCROLLTO_IN;
2602        switch (wd->scrollto_type)
2603           {
2604            case ELM_GENLIST_ITEM_SCROLLTO_TOP:
2605               dy = wd->h;
2606               break;
2607            case ELM_GENLIST_ITEM_SCROLLTO_MIDDLE:
2608               dy = wd->h / 2;
2609               break;
2610            case ELM_GENLIST_ITEM_SCROLLTO_IN:
2611            default:
2612               dy = 0;
2613               break;
2614           }
2615         if ((pan_w > (wd->show_item->x + wd->show_item->item->block->x)) &&
2616             (pan_h > (wd->show_item->y + wd->show_item->item->block->y + dy)))
2617           {
2618              _scroll_item(wd);
2619           }
2620      }
2621    wd->calc_job = NULL;
2622    evas_object_smart_changed(wd->pan_smart);
2623    evas_event_thaw(evas_object_evas_get(wd->obj));
2624    evas_event_thaw_eval(evas_object_evas_get(wd->obj));
2625 }
2626
2627 static void
2628 _update_job(void *data)
2629 {
2630    Widget_Data *wd = data;
2631    Eina_List *l2;
2632    Item_Block *itb;
2633    int num, num0;
2634    Eina_Bool position = EINA_FALSE, recalc = EINA_FALSE;
2635    if (!wd) return;
2636    wd->update_job = NULL;
2637    num = 0;
2638
2639    evas_event_freeze(evas_object_evas_get(wd->obj));
2640    EINA_INLIST_FOREACH(wd->blocks, itb)
2641      {
2642         Evas_Coord itminw, itminh;
2643         Elm_Gen_Item *it;
2644
2645         if (!itb->updateme)
2646           {
2647              num += itb->count;
2648              if (position)
2649                _item_block_position(itb, num);
2650              continue;
2651           }
2652         num0 = num;
2653         recalc = EINA_FALSE;
2654         EINA_LIST_FOREACH(itb->items, l2, it)
2655           {
2656              if (it->item->updateme)
2657                {
2658                   itminw = it->item->minw;
2659                   itminh = it->item->minh;
2660
2661                   it->item->updateme = EINA_FALSE;
2662                   if (it->realized)
2663                     {
2664                        _elm_genlist_item_unrealize(it, EINA_FALSE);
2665                        _item_realize(it, num, EINA_FALSE);
2666                        position = EINA_TRUE;
2667                     }
2668                   else
2669                     {
2670                        _item_realize(it, num, EINA_TRUE);
2671                        _elm_genlist_item_unrealize(it, EINA_TRUE);
2672                     }
2673                   if ((it->item->minw != itminw) || (it->item->minh != itminh))
2674                     recalc = EINA_TRUE;
2675                }
2676              num++;
2677           }
2678         itb->updateme = EINA_FALSE;
2679         if (recalc)
2680           {
2681              position = EINA_TRUE;
2682              itb->changed = EINA_TRUE;
2683              _item_block_recalc(itb, num0, EINA_FALSE);
2684              _item_block_position(itb, num0);
2685           }
2686      }
2687    if (position)
2688      {
2689         if (wd->calc_job) ecore_job_del(wd->calc_job);
2690         wd->calc_job = ecore_job_add(_calc_job, wd);
2691      }
2692    evas_event_thaw(evas_object_evas_get(wd->obj));
2693    evas_event_thaw_eval(evas_object_evas_get(wd->obj));
2694 }
2695
2696 static void
2697 _pan_set(Evas_Object *obj,
2698          Evas_Coord   x,
2699          Evas_Coord   y)
2700 {
2701    Pan *sd = evas_object_smart_data_get(obj);
2702    Item_Block *itb;
2703
2704    if (!sd) return;
2705    //   Evas_Coord ow, oh;
2706    //   evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
2707    //   ow = sd->wd->minw - ow;
2708    //   if (ow < 0) ow = 0;
2709    //   oh = sd->wd->minh - oh;
2710    //   if (oh < 0) oh = 0;
2711    //   if (x < 0) x = 0;
2712    //   if (y < 0) y = 0;
2713    //   if (x > ow) x = ow;
2714    //   if (y > oh) y = oh;
2715    if ((x == sd->wd->pan_x) && (y == sd->wd->pan_y)) return;
2716    sd->wd->pan_x = x;
2717    sd->wd->pan_y = y;
2718
2719    EINA_INLIST_FOREACH(sd->wd->blocks, itb)
2720      {
2721         if ((itb->y + itb->h) > y)
2722           {
2723              Elm_Gen_Item *it;
2724              Eina_List *l2;
2725
2726              EINA_LIST_FOREACH(itb->items, l2, it)
2727                {
2728                   if ((itb->y + it->y) >= y)
2729                     {
2730                        sd->wd->anchor_item = it;
2731                        sd->wd->anchor_y = -(itb->y + it->y - y);
2732                        goto done;
2733                     }
2734                }
2735           }
2736      }
2737 done:
2738    if (!sd->wd->reorder_move_animator) evas_object_smart_changed(obj);
2739 }
2740
2741 static void
2742 _pan_get(Evas_Object *obj,
2743          Evas_Coord  *x,
2744          Evas_Coord  *y)
2745 {
2746    Pan *sd = evas_object_smart_data_get(obj);
2747
2748    if (!sd) return;
2749    if (x) *x = sd->wd->pan_x;
2750    if (y) *y = sd->wd->pan_y;
2751 }
2752
2753 static void
2754 _pan_max_get(Evas_Object *obj,
2755              Evas_Coord  *x,
2756              Evas_Coord  *y)
2757 {
2758    Pan *sd = evas_object_smart_data_get(obj);
2759    Evas_Coord ow, oh;
2760
2761    if (!sd) return;
2762    evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
2763    ow = sd->wd->minw - ow;
2764    if (ow < 0) ow = 0;
2765    oh = sd->wd->minh - oh;
2766    if (oh < 0) oh = 0;
2767    if (x) *x = ow;
2768    if (y) *y = oh;
2769 }
2770
2771 static void
2772 _pan_min_get(Evas_Object *obj __UNUSED__,
2773              Evas_Coord  *x,
2774              Evas_Coord  *y)
2775 {
2776    if (x) *x = 0;
2777    if (y) *y = 0;
2778 }
2779
2780 static void
2781 _pan_child_size_get(Evas_Object *obj,
2782                     Evas_Coord  *w,
2783                     Evas_Coord  *h)
2784 {
2785    Pan *sd = evas_object_smart_data_get(obj);
2786
2787    if (!sd) return;
2788    if (w) *w = sd->wd->minw;
2789    if (h) *h = sd->wd->minh;
2790 }
2791
2792 static void
2793 _pan_add(Evas_Object *obj)
2794 {
2795    Pan *sd;
2796    Evas_Object_Smart_Clipped_Data *cd;
2797
2798    _pan_sc.add(obj);
2799    cd = evas_object_smart_data_get(obj);
2800    sd = ELM_NEW(Pan);
2801    if (!sd) return;
2802    sd->__clipped_data = *cd;
2803    free(cd);
2804    evas_object_smart_data_set(obj, sd);
2805 }
2806
2807 static void
2808 _pan_del(Evas_Object *obj)
2809 {
2810    Pan *sd = evas_object_smart_data_get(obj);
2811
2812    if (!sd) return;
2813    if (sd->resize_job)
2814      {
2815         ecore_job_del(sd->resize_job);
2816         sd->resize_job = NULL;
2817      }
2818    _pan_sc.del(obj);
2819 }
2820
2821 static void
2822 _pan_resize_job(void *data)
2823 {
2824    Pan *sd = data;
2825    if (!sd) return;
2826    _sizing_eval(sd->wd->obj);
2827    sd->resize_job = NULL;
2828 }
2829
2830 static void
2831 _pan_resize(Evas_Object *obj,
2832             Evas_Coord   w,
2833             Evas_Coord   h)
2834 {
2835    Pan *sd = evas_object_smart_data_get(obj);
2836    Evas_Coord ow, oh;
2837
2838    if (!sd) return;
2839    evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
2840    if ((ow == w) && (oh == h)) return;
2841    if ((sd->wd->height_for_width) && (ow != w))
2842      {
2843         /* fix me later */
2844         if (sd->resize_job) ecore_job_del(sd->resize_job);
2845         sd->resize_job = ecore_job_add(_pan_resize_job, sd);
2846      }
2847    sd->wd->pan_changed = EINA_TRUE;
2848    evas_object_smart_changed(obj);
2849    if (sd->wd->calc_job) ecore_job_del(sd->wd->calc_job);
2850    sd->wd->calc_job = NULL;
2851 /* OLD
2852    if (sd->wd->calc_job) ecore_job_del(sd->wd->calc_job);
2853    sd->wd->calc_job = ecore_job_add(_calc_job, sd->wd);
2854  */
2855 }
2856
2857 static void
2858 _pan_calculate(Evas_Object *obj)
2859 {
2860    Pan *sd = evas_object_smart_data_get(obj);
2861    Item_Block *itb;
2862    Evas_Coord ox, oy, ow, oh, cvx, cvy, cvw, cvh;
2863    int in = 0;
2864    Elm_Gen_Item *git;
2865    Eina_List *l;
2866
2867    if (!sd) return;
2868    evas_event_freeze(evas_object_evas_get(obj));
2869
2870    if (sd->wd->pan_changed)
2871      {
2872         _calc_job(sd->wd);
2873         sd->wd->pan_changed = EINA_FALSE;
2874      }
2875
2876    evas_object_geometry_get(obj, &ox, &oy, &ow, &oh);
2877    evas_output_viewport_get(evas_object_evas_get(obj), &cvx, &cvy, &cvw, &cvh);
2878    EINA_LIST_FOREACH(sd->wd->group_items, l, git)
2879      {
2880         git->item->want_realize = EINA_FALSE;
2881      }
2882    EINA_INLIST_FOREACH(sd->wd->blocks, itb)
2883      {
2884         itb->w = sd->wd->minw;
2885         if (ELM_RECTS_INTERSECT(itb->x - sd->wd->pan_x + ox,
2886                                 itb->y - sd->wd->pan_y + oy,
2887                                 itb->w, itb->h,
2888                                 cvx, cvy, cvw, cvh))
2889           {
2890              if ((!itb->realized) || (itb->changed))
2891                _item_block_realize(itb);
2892              _item_block_position(itb, in);
2893           }
2894         else
2895           {
2896              if (itb->realized) _item_block_unrealize(itb);
2897           }
2898         in += itb->count;
2899      }
2900    if ((!sd->wd->reorder_it) || (sd->wd->reorder_pan_move))
2901       _group_items_recalc(sd->wd);
2902    if ((sd->wd->reorder_mode) && (sd->wd->reorder_it))
2903      {
2904         if (sd->wd->pan_y != sd->wd->reorder_old_pan_y)
2905            sd->wd->reorder_pan_move = EINA_TRUE;
2906         else sd->wd->reorder_pan_move = EINA_FALSE;
2907         evas_object_raise(sd->wd->VIEW(reorder_it));
2908         sd->wd->reorder_old_pan_y = sd->wd->pan_y;
2909         sd->wd->start_time = ecore_loop_time_get();
2910      }
2911    _item_auto_scroll(sd->wd);
2912    evas_event_thaw(evas_object_evas_get(obj));
2913    evas_event_thaw_eval(evas_object_evas_get(obj));
2914 }
2915
2916 static void
2917 _pan_move(Evas_Object *obj,
2918           Evas_Coord   x __UNUSED__,
2919           Evas_Coord   y __UNUSED__)
2920 {
2921    Pan *sd = evas_object_smart_data_get(obj);
2922
2923    if (!sd) return;
2924
2925    sd->wd->pan_changed = EINA_TRUE;
2926    evas_object_smart_changed(obj);
2927    if (sd->wd->calc_job) ecore_job_del(sd->wd->calc_job);
2928    sd->wd->calc_job = NULL;
2929 }
2930
2931 static void
2932 _hold_on(void        *data __UNUSED__,
2933          Evas_Object *obj,
2934          void        *event_info __UNUSED__)
2935 {
2936    Widget_Data *wd = elm_widget_data_get(obj);
2937    if (!wd) return;
2938    elm_smart_scroller_hold_set(wd->scr, 1);
2939 }
2940
2941 static void
2942 _hold_off(void        *data __UNUSED__,
2943           Evas_Object *obj,
2944           void        *event_info __UNUSED__)
2945 {
2946    Widget_Data *wd = elm_widget_data_get(obj);
2947    if (!wd) return;
2948    elm_smart_scroller_hold_set(wd->scr, 0);
2949 }
2950
2951 static void
2952 _freeze_on(void        *data __UNUSED__,
2953            Evas_Object *obj,
2954            void        *event_info __UNUSED__)
2955 {
2956    Widget_Data *wd = elm_widget_data_get(obj);
2957    if (!wd) return;
2958    elm_smart_scroller_freeze_set(wd->scr, 1);
2959 }
2960
2961 static void
2962 _freeze_off(void        *data __UNUSED__,
2963             Evas_Object *obj,
2964             void        *event_info __UNUSED__)
2965 {
2966    Widget_Data *wd = elm_widget_data_get(obj);
2967    if (!wd) return;
2968    elm_smart_scroller_freeze_set(wd->scr, 0);
2969 }
2970
2971 static void
2972 _scr_anim_start(void        *data,
2973                 Evas_Object *obj __UNUSED__,
2974                 void        *event_info __UNUSED__)
2975 {
2976    evas_object_smart_callback_call(data, SIG_SCROLL_ANIM_START, NULL);
2977 }
2978
2979 static void
2980 _scr_anim_stop(void        *data,
2981                Evas_Object *obj __UNUSED__,
2982                void        *event_info __UNUSED__)
2983 {
2984    evas_object_smart_callback_call(data, SIG_SCROLL_ANIM_STOP, NULL);
2985 }
2986
2987 static void
2988 _scr_drag_start(void            *data,
2989                 Evas_Object     *obj __UNUSED__,
2990                 void            *event_info __UNUSED__)
2991 {
2992    evas_object_smart_callback_call(data, SIG_SCROLL_DRAG_START, NULL);
2993 }
2994
2995 static void
2996 _scr_drag_stop(void            *data,
2997                Evas_Object     *obj __UNUSED__,
2998                void            *event_info __UNUSED__)
2999 {
3000    evas_object_smart_callback_call(data, SIG_SCROLL_DRAG_STOP, NULL);
3001 }
3002
3003 static void
3004 _edge_left(void        *data,
3005            Evas_Object *scr __UNUSED__,
3006            void        *event_info __UNUSED__)
3007 {
3008    Evas_Object *obj = data;
3009    evas_object_smart_callback_call(obj, SIG_EDGE_LEFT, NULL);
3010 }
3011
3012 static void
3013 _edge_right(void        *data,
3014             Evas_Object *scr __UNUSED__,
3015             void        *event_info __UNUSED__)
3016 {
3017    Evas_Object *obj = data;
3018    evas_object_smart_callback_call(obj, SIG_EDGE_RIGHT, NULL);
3019 }
3020
3021 static void
3022 _edge_top(void        *data,
3023           Evas_Object *scr __UNUSED__,
3024           void        *event_info __UNUSED__)
3025 {
3026    Evas_Object *obj = data;
3027    evas_object_smart_callback_call(obj, SIG_EDGE_TOP, NULL);
3028 }
3029
3030 static void
3031 _edge_bottom(void        *data,
3032              Evas_Object *scr __UNUSED__,
3033              void        *event_info __UNUSED__)
3034 {
3035    Evas_Object *obj = data;
3036    evas_object_smart_callback_call(obj, SIG_EDGE_BOTTOM, NULL);
3037 }
3038
3039 static void
3040 _mode_item_realize(Elm_Gen_Item *it)
3041 {
3042    char buf[1024];
3043
3044    if ((it->item->mode_view) || (it->generation < it->wd->generation)) return;
3045
3046    evas_event_freeze(evas_object_evas_get(it->wd->obj));
3047    it->item->mode_view = edje_object_add(evas_object_evas_get(WIDGET(it)));
3048    edje_object_scale_set(it->item->mode_view,
3049                          elm_widget_scale_get(WIDGET(it)) *
3050                          _elm_config->scale);
3051    evas_object_smart_member_add(it->item->mode_view, it->wd->pan_smart);
3052    elm_widget_sub_object_add(WIDGET(it), it->item->mode_view);
3053
3054    strncpy(buf, "item", sizeof(buf));
3055    if (it->wd->compress)
3056      strncat(buf, "_compress", sizeof(buf) - strlen(buf));
3057
3058    if (it->item->order_num_in & 0x1) strncat(buf, "_odd", sizeof(buf) - strlen(buf));
3059    strncat(buf, "/", sizeof(buf) - strlen(buf));
3060    strncat(buf, it->itc->mode_item_style, sizeof(buf) - strlen(buf));
3061
3062    _elm_theme_object_set(WIDGET(it), it->item->mode_view, "genlist", buf,
3063                          elm_widget_style_get(WIDGET(it)));
3064    edje_object_mirrored_set(it->item->mode_view,
3065                             elm_widget_mirrored_get(WIDGET(it)));
3066
3067    /* signal callback add */
3068    evas_object_event_callback_add(it->item->mode_view, EVAS_CALLBACK_MOUSE_DOWN,
3069                                   _mouse_down, it);
3070    evas_object_event_callback_add(it->item->mode_view, EVAS_CALLBACK_MOUSE_UP,
3071                                   _mouse_up, it);
3072    evas_object_event_callback_add(it->item->mode_view, EVAS_CALLBACK_MOUSE_MOVE,
3073                                   _mouse_move, it);
3074
3075    /* text_get, content_get, state_get */
3076    /* FIXME: If you see that assert, please notify us and we
3077       will clean our mess */
3078    assert(eina_list_count(it->item->mode_content_objs) == 0);
3079
3080    _item_text_realize(it, it->item->mode_view, &it->item->mode_texts, NULL);
3081    it->item->mode_content_objs =
3082      _item_content_realize(it, it->item->mode_view,
3083                            &it->item->mode_contents, NULL);
3084    _item_state_realize(it, it->item->mode_view, &it->item->mode_states, NULL);
3085
3086    edje_object_part_swallow(it->item->mode_view,
3087                             edje_object_data_get(it->item->mode_view, "mode_part"),
3088                             VIEW(it));
3089
3090    it->want_unrealize = EINA_FALSE;
3091    evas_event_thaw(evas_object_evas_get(it->wd->obj));
3092    evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
3093 }
3094
3095 static void
3096 _mode_item_unrealize(Elm_Gen_Item *it)
3097 {
3098    Widget_Data *wd = it->wd;
3099    Evas_Object *content;
3100    if (!it->item->mode_view) return;
3101
3102    evas_event_freeze(evas_object_evas_get(it->wd->obj));
3103    elm_widget_stringlist_free(it->item->mode_texts);
3104    it->item->mode_texts = NULL;
3105    elm_widget_stringlist_free(it->item->mode_contents);
3106    it->item->mode_contents = NULL;
3107    elm_widget_stringlist_free(it->item->mode_states);
3108
3109    EINA_LIST_FREE(it->item->mode_content_objs, content)
3110      evas_object_del(content);
3111
3112    edje_object_part_unswallow(it->item->mode_view, VIEW(it));
3113    evas_object_smart_member_add(VIEW(it), wd->pan_smart);
3114    evas_object_del(it->item->mode_view);
3115    it->item->mode_view = NULL;
3116
3117    if (wd->mode_item == it)
3118      wd->mode_item = NULL;
3119    evas_event_thaw(evas_object_evas_get(it->wd->obj));
3120    evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
3121 }
3122
3123 static void
3124 _item_mode_set(Elm_Gen_Item *it)
3125 {
3126    if (!it) return;
3127    Widget_Data *wd = it->wd;
3128    if (!wd) return;
3129    char buf[1024];
3130
3131    wd->mode_item = it;
3132    it->item->nocache = EINA_TRUE;
3133
3134    if (wd->scr_hold_timer)
3135      {
3136         ecore_timer_del(wd->scr_hold_timer);
3137         wd->scr_hold_timer = NULL;
3138      }
3139    elm_smart_scroller_hold_set(wd->scr, EINA_TRUE);
3140    wd->scr_hold_timer = ecore_timer_add(0.1, _scr_hold_timer_cb, wd);
3141
3142    evas_event_freeze(evas_object_evas_get(it->wd->obj));
3143    _mode_item_realize(it);
3144    if (it->item->group_item)
3145      evas_object_raise(it->item->VIEW(group_item));
3146    _item_position(it, it->item->mode_view, it->item->scrl_x, it->item->scrl_y);
3147    evas_event_thaw(evas_object_evas_get(it->wd->obj));
3148    evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
3149
3150    snprintf(buf, sizeof(buf), "elm,state,%s,active", wd->mode_type);
3151    edje_object_signal_emit(it->item->mode_view, buf, "elm");
3152 }
3153
3154 static void
3155 _item_mode_unset(Widget_Data *wd)
3156 {
3157    if (!wd) return;
3158    if (!wd->mode_item) return;
3159    char buf[1024], buf2[1024];
3160    Elm_Gen_Item *it;
3161
3162    it = wd->mode_item;
3163    it->item->nocache = EINA_TRUE;
3164
3165    snprintf(buf, sizeof(buf), "elm,state,%s,passive", wd->mode_type);
3166    snprintf(buf2, sizeof(buf2), "elm,state,%s,passive,finished", wd->mode_type);
3167
3168    edje_object_signal_emit(it->item->mode_view, buf, "elm");
3169    edje_object_signal_callback_add(it->item->mode_view, buf2, "elm", _mode_finished_signal_cb, it);
3170
3171    wd->mode_item = NULL;
3172 }
3173
3174 static void
3175 _edit_mode_item_position(Elm_Gen_Item *it, int itx, int ity)
3176 {
3177    if ((!it) || (!it->wd->edit_mode)) return;
3178    evas_object_resize(it->edit_obj, it->item->w, it->item->h);
3179    evas_object_move(it->edit_obj, itx, ity);
3180 }
3181
3182 static void
3183 _edit_mode_item_realize(Elm_Gen_Item *it, Eina_Bool effect_on)
3184 {
3185    char buf[1024];
3186    const char *stacking_even;
3187    const char *stacking;
3188
3189    if ((!it) || (it->item->edit_mode_item_realized) ||
3190        (it->generation < it->wd->generation))
3191      return;
3192
3193    it->edit_obj = edje_object_add(evas_object_evas_get(WIDGET(it)));
3194    edje_object_scale_set(it->edit_obj, elm_widget_scale_get(WIDGET(it)) *
3195                          _elm_config->scale);
3196    evas_object_smart_member_add(it->edit_obj, it->wd->pan_smart);
3197    elm_widget_sub_object_add(WIDGET(it), it->edit_obj);
3198
3199    if (it->item->flags & ELM_GENLIST_ITEM_SUBITEMS)
3200       strncpy(buf, "tree", sizeof(buf));
3201    else strncpy(buf, "item", sizeof(buf));
3202    if (it->wd->compress)
3203       strncat(buf, "_compress", sizeof(buf) - strlen(buf));
3204
3205    strncat(buf, "/", sizeof(buf) - strlen(buf));
3206    strncat(buf, it->itc->edit_item_style, sizeof(buf) - strlen(buf));
3207
3208    _elm_theme_object_set(WIDGET(it),  it->edit_obj, "genlist", buf,
3209                          elm_widget_style_get(WIDGET(it)));
3210
3211    stacking_even = edje_object_data_get(VIEW(it), "stacking_even");
3212    if (!stacking_even) stacking_even = "above";
3213    it->item->stacking_even = !!strcmp("above", stacking_even);
3214
3215    stacking = edje_object_data_get(VIEW(it), "stacking");
3216    if (!stacking) stacking = "yes";
3217    it->item->nostacking = !!strcmp("yes", stacking);
3218
3219    edje_object_mirrored_set(it->edit_obj,
3220                             elm_widget_mirrored_get(WIDGET(it)));
3221
3222    _elm_genlist_item_odd_even_update(it);
3223    _elm_genlist_item_state_update(it, NULL);
3224
3225    if (effect_on) edje_object_signal_emit(it->edit_obj, "elm,state,edit,enabled,effect", "elm");
3226    else edje_object_signal_emit(it->edit_obj, "elm,state,edit,enabled", "elm");
3227
3228    evas_object_event_callback_add(it->edit_obj, EVAS_CALLBACK_MOUSE_DOWN,
3229                                   _mouse_down, it);
3230    evas_object_event_callback_add(it->edit_obj, EVAS_CALLBACK_MOUSE_UP,
3231                                   _mouse_up, it);
3232    evas_object_event_callback_add(it->edit_obj, EVAS_CALLBACK_MOUSE_MOVE,
3233                                   _mouse_move, it);
3234    evas_object_event_callback_add(it->edit_obj, EVAS_CALLBACK_MULTI_DOWN,
3235                                   _multi_down, it);
3236    evas_object_event_callback_add(it->edit_obj, EVAS_CALLBACK_MULTI_UP,
3237                                   _multi_up, it);
3238    evas_object_event_callback_add(it->edit_obj, EVAS_CALLBACK_MULTI_MOVE,
3239                                   _multi_move, it);
3240
3241    _item_text_realize(it, it->edit_obj, &it->item->edit_texts, NULL);
3242    it->item->edit_content_objs =
3243      _item_content_realize(it, it->edit_obj, &it->item->edit_contents, NULL);
3244    _item_state_realize(it, it->edit_obj, &it->item->edit_states, NULL);
3245    edje_object_part_swallow(it->edit_obj, "elm.swallow.edit.content", VIEW(it));
3246
3247    _edit_mode_item_position(it, it->item->scrl_x, it->item->scrl_y);
3248    evas_object_show(it->edit_obj);
3249
3250    it->item->edit_mode_item_realized = EINA_TRUE;
3251    it->want_unrealize = EINA_FALSE;
3252 }
3253
3254 static void
3255 _edit_mode_item_unrealize(Elm_Gen_Item *it)
3256 {
3257    Evas_Object *icon;
3258    if ((!it) || (!it->item->edit_mode_item_realized)) return;
3259
3260    edje_object_part_unswallow(it->edit_obj, VIEW(it));
3261    evas_object_smart_member_add(VIEW(it), it->wd->pan_smart);
3262    elm_widget_sub_object_add(WIDGET(it), VIEW(it));
3263    _elm_genlist_item_odd_even_update(it);
3264    _elm_genlist_item_state_update(it, NULL);
3265
3266    evas_object_del(it->edit_obj);
3267    it->edit_obj = NULL;
3268    elm_widget_stringlist_free(it->item->edit_texts);
3269    it->item->edit_texts = NULL;
3270    elm_widget_stringlist_free(it->item->edit_contents);
3271    it->item->edit_contents = NULL;
3272    elm_widget_stringlist_free(it->item->edit_states);
3273    it->item->edit_states = NULL;
3274    EINA_LIST_FREE(it->item->edit_content_objs, icon)
3275       evas_object_del(icon);
3276    edje_object_message_signal_process(it->edit_obj);
3277
3278    evas_object_event_callback_del_full(it->edit_obj, EVAS_CALLBACK_MOUSE_DOWN,
3279                                        _mouse_down, it);
3280    evas_object_event_callback_del_full(it->edit_obj, EVAS_CALLBACK_MOUSE_UP,
3281                                        _mouse_up, it);
3282    evas_object_event_callback_del_full(it->edit_obj, EVAS_CALLBACK_MOUSE_MOVE,
3283                                        _mouse_move, it);
3284    evas_object_event_callback_del_full(it->edit_obj, EVAS_CALLBACK_MULTI_DOWN,
3285                                        _multi_down, it);
3286    evas_object_event_callback_del_full(it->edit_obj, EVAS_CALLBACK_MULTI_UP,
3287                                        _multi_up, it);
3288    evas_object_event_callback_del_full(it->edit_obj, EVAS_CALLBACK_MULTI_MOVE,
3289                                        _multi_move, it);
3290    it->item->edit_mode_item_realized = EINA_FALSE;
3291 }
3292
3293 static void
3294 _item_auto_scroll(Widget_Data *wd)
3295 {
3296    if (!wd) return;
3297    Elm_Gen_Item  *tmp_item = NULL;
3298
3299    if ((wd->expanded_item) && (wd->auto_scroll_enabled))
3300      {
3301         tmp_item = eina_list_data_get(eina_list_last(wd->expanded_item->item->items));
3302         if (!tmp_item) return;
3303         wd->show_item = tmp_item;
3304         wd->bring_in = EINA_TRUE;
3305         wd->scrollto_type = ELM_GENLIST_ITEM_SCROLLTO_IN;
3306         if ((wd->show_item->item->queued) || (!wd->show_item->item->mincalcd))
3307           {
3308              wd->show_item->item->showme = EINA_TRUE;
3309              wd->auto_scroll_enabled = EINA_FALSE;
3310           }
3311         else
3312           _scroll_item(wd);
3313      }
3314 }
3315
3316 EAPI Evas_Object *
3317 elm_genlist_add(Evas_Object *parent)
3318 {
3319    Evas_Object *obj;
3320    Evas *e;
3321    Widget_Data *wd;
3322    Evas_Coord minw, minh;
3323    static Evas_Smart *smart = NULL;
3324
3325    if (!smart)
3326      {
3327         static Evas_Smart_Class sc;
3328
3329         evas_object_smart_clipped_smart_set(&_pan_sc);
3330         sc = _pan_sc;
3331         sc.name = "elm_genlist_pan";
3332         sc.version = EVAS_SMART_CLASS_VERSION;
3333         sc.add = _pan_add;
3334         sc.del = _pan_del;
3335         sc.resize = _pan_resize;
3336         sc.move = _pan_move;
3337         sc.calculate = _pan_calculate;
3338         if (!(smart = evas_smart_class_new(&sc))) return NULL;
3339      }
3340
3341    ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
3342
3343    ELM_SET_WIDTYPE(widtype, "genlist");
3344    ELM_GEN_SETUP(wd);
3345    elm_widget_type_set(obj, "genlist");
3346    elm_widget_sub_object_add(parent, obj);
3347    elm_widget_on_focus_hook_set(obj, _on_focus_hook, NULL);
3348    elm_widget_signal_emit_hook_set(obj, _signal_emit_hook);
3349    elm_widget_data_set(obj, wd);
3350    elm_widget_del_hook_set(obj, _del_hook);
3351    elm_widget_del_pre_hook_set(obj, _del_pre_hook);
3352    elm_widget_theme_hook_set(obj, _theme_hook);
3353    elm_widget_can_focus_set(obj, EINA_TRUE);
3354    elm_widget_event_hook_set(obj, _event_hook);
3355    elm_widget_on_show_region_hook_set(obj, _show_region_hook, obj);
3356    elm_widget_translate_hook_set(obj, _translate_hook);
3357
3358    wd->generation = 1;
3359    wd->scr = elm_smart_scroller_add(e);
3360    elm_smart_scroller_widget_set(wd->scr, obj);
3361    elm_smart_scroller_object_theme_set(obj, wd->scr, "genlist", "base",
3362                                        elm_widget_style_get(obj));
3363    elm_smart_scroller_bounce_allow_set(wd->scr, EINA_FALSE,
3364                                        _elm_config->thumbscroll_bounce_enable);
3365    elm_widget_resize_object_set(obj, wd->scr);
3366
3367    evas_object_smart_callback_add(wd->scr, "animate,start", _scr_anim_start, obj);
3368    evas_object_smart_callback_add(wd->scr, "animate,stop", _scr_anim_stop, obj);
3369    evas_object_smart_callback_add(wd->scr, "drag,start", _scr_drag_start, obj);
3370    evas_object_smart_callback_add(wd->scr, "drag,stop", _scr_drag_stop, obj);
3371    evas_object_smart_callback_add(wd->scr, "edge,left", _edge_left, obj);
3372    evas_object_smart_callback_add(wd->scr, "edge,right", _edge_right, obj);
3373    evas_object_smart_callback_add(wd->scr, "edge,top", _edge_top, obj);
3374    evas_object_smart_callback_add(wd->scr, "edge,bottom", _edge_bottom, obj);
3375
3376    wd->obj = obj;
3377    wd->mode = ELM_LIST_SCROLL;
3378    wd->max_items_per_block = MAX_ITEMS_PER_BLOCK;
3379    wd->item_cache_max = wd->max_items_per_block * 2;
3380    wd->longpress_timeout = _elm_config->longpress_timeout;
3381
3382    evas_object_smart_callback_add(obj, "scroll-hold-on", _hold_on, obj);
3383    evas_object_smart_callback_add(obj, "scroll-hold-off", _hold_off, obj);
3384    evas_object_smart_callback_add(obj, "scroll-freeze-on", _freeze_on, obj);
3385    evas_object_smart_callback_add(obj, "scroll-freeze-off", _freeze_off, obj);
3386
3387    wd->pan_smart = evas_object_smart_add(e, smart);
3388    wd->pan = evas_object_smart_data_get(wd->pan_smart);
3389    wd->pan->wd = wd;
3390
3391    elm_smart_scroller_extern_pan_set(wd->scr, wd->pan_smart,
3392                                      _pan_set, _pan_get, _pan_max_get,
3393                                      _pan_min_get, _pan_child_size_get);
3394
3395    edje_object_size_min_calc(elm_smart_scroller_edje_object_get(wd->scr),
3396                              &minw, &minh);
3397    evas_object_size_hint_min_set(obj, minw, minh);
3398
3399    evas_object_smart_callbacks_descriptions_set(obj, _signals);
3400
3401    _mirrored_set(obj, elm_widget_mirrored_get(obj));
3402    _sizing_eval(obj);
3403    return obj;
3404 }
3405
3406 void
3407 _item_select(Elm_Gen_Item *it)
3408 {
3409    if ((it->wd->no_select) || (it->generation < it->wd->generation) || (it->mode_set)) return;
3410    if (!it->selected)
3411      {
3412         it->selected = EINA_TRUE;
3413         it->wd->selected = eina_list_append(it->wd->selected, it);
3414      }
3415    else if (!it->wd->always_select) return;
3416
3417    evas_object_ref(WIDGET(it));
3418    it->walking++;
3419    it->wd->walking++;
3420    if (it->func.func) it->func.func((void *)it->func.data, WIDGET(it), it);
3421    if (it->generation == it->wd->generation)
3422      evas_object_smart_callback_call(WIDGET(it), SIG_SELECTED, it);
3423    it->walking--;
3424    it->wd->walking--;
3425    evas_object_unref(WIDGET(it));
3426    if ((it->wd->clear_me) && (!it->wd->walking))
3427      _elm_genlist_clear(WIDGET(it), EINA_TRUE);
3428    else
3429      {
3430         if ((!it->walking) && (it->generation < it->wd->generation))
3431           {
3432              if (!it->relcount)
3433                {
3434                   it->del_cb(it);
3435                   elm_widget_item_free(it);
3436                }
3437           }
3438         else
3439           it->wd->last_selected_item = (Elm_Object_Item *) it;
3440      }
3441 }
3442
3443 static Evas_Object *
3444 _item_content_get_hook(Elm_Gen_Item *it, const char *part)
3445 {
3446    return edje_object_part_swallow_get(VIEW(it), part);
3447 }
3448
3449 static void
3450 _item_content_set_hook(Elm_Gen_Item *it, const char *part, Evas_Object *content)
3451 {
3452    if (content && part)
3453      {
3454         it->content_objs = eina_list_append(it->content_objs, content);
3455         edje_object_part_swallow(VIEW(it), part, content);
3456      }
3457 }
3458
3459 static Evas_Object *
3460 _item_content_unset_hook(Elm_Gen_Item *it, const char *part)
3461 {
3462    Evas_Object *obj;
3463    obj = edje_object_part_swallow_get(VIEW(it), part);
3464    if (!obj) return NULL;
3465    it->content_objs = eina_list_remove(it->content_objs, obj);
3466    edje_object_part_unswallow(VIEW(it), obj);
3467    return obj;
3468 }
3469
3470 static const char *
3471 _item_text_hook(Elm_Gen_Item *it, const char *part)
3472 {
3473    if (!it->itc->func.text_get) return NULL;
3474    return edje_object_part_text_get(VIEW(it), part);
3475 }
3476
3477 static void
3478 _item_disable_hook(Elm_Object_Item *it)
3479 {
3480    Eina_List *l;
3481    Evas_Object *obj;
3482    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
3483
3484    if (_it->generation < _it->wd->generation) return;
3485
3486    if (_it->selected)
3487      elm_genlist_item_selected_set(it, EINA_FALSE);
3488
3489    if (_it->realized)
3490      {
3491         if (elm_widget_item_disabled_get(it))
3492           {
3493              edje_object_signal_emit(VIEW(_it), "elm,state,disabled", "elm");
3494              if (_it->edit_obj)
3495                edje_object_signal_emit(_it->edit_obj, "elm,state,disabled", "elm");
3496           }
3497         else
3498           {
3499              edje_object_signal_emit(VIEW(_it), "elm,state,enabled", "elm");
3500              if (_it->edit_obj)
3501                edje_object_signal_emit(_it->edit_obj, "elm,state,enabled", "elm");
3502           }
3503         EINA_LIST_FOREACH(_it->content_objs, l, obj)
3504           elm_widget_disabled_set(obj, elm_widget_item_disabled_get(_it));
3505      }
3506 }
3507
3508 static Eina_Bool
3509 _item_del_pre_hook(Elm_Object_Item *it)
3510 {
3511    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
3512
3513    if ((_it->relcount > 0) || (_it->walking > 0))
3514      {
3515         elm_genlist_item_subitems_clear(it);
3516         if (_it->wd->show_item == _it) _it->wd->show_item = NULL;
3517         _elm_genlist_item_del_notserious(_it);
3518         if (_it->item->block)
3519           {
3520              if (_it->realized) _elm_genlist_item_unrealize(_it, EINA_FALSE);
3521              _it->item->block->changed = EINA_TRUE;
3522              if (_it->wd->calc_job) ecore_job_del(_it->wd->calc_job);
3523              _it->wd->calc_job = ecore_job_add(_calc_job, _it->wd);
3524           }
3525         if (_it->parent)
3526           {
3527              _it->parent->item->items =
3528                 eina_list_remove(_it->parent->item->items, it);
3529              _it->parent = NULL;
3530           }
3531         return EINA_FALSE;
3532      }
3533    _item_del(_it);
3534    return EINA_TRUE;
3535 }
3536
3537 Elm_Gen_Item *
3538 _elm_genlist_item_new(Widget_Data              *wd,
3539                       const Elm_Gen_Item_Class *itc,
3540                       const void               *data,
3541                       Elm_Gen_Item             *parent,
3542                       Evas_Smart_Cb             func,
3543                       const void               *func_data)
3544 {
3545    Elm_Gen_Item *it;
3546
3547    it = elm_widget_item_new(wd->obj, Elm_Gen_Item);
3548    if (!it) return NULL;
3549    it->wd = wd;
3550    it->generation = wd->generation;
3551    it->itc = itc;
3552    elm_genlist_item_class_ref((Elm_Genlist_Item_Class *)itc);
3553    it->base.data = data;
3554    it->parent = parent;
3555    it->func.func = func;
3556    it->func.data = func_data;
3557    elm_widget_item_content_get_hook_set(it, _item_content_get_hook);
3558    elm_widget_item_content_set_hook_set(it, _item_content_set_hook);
3559    elm_widget_item_content_unset_hook_set(it, _item_content_unset_hook);
3560    elm_widget_item_text_get_hook_set(it, _item_text_hook);
3561    elm_widget_item_disable_hook_set(it, _item_disable_hook);
3562    elm_widget_item_del_pre_hook_set(it, _item_del_pre_hook);
3563    /* TEMPORARY */
3564    it->sel_cb = (Ecore_Cb)_item_select;
3565
3566    return it;
3567 }
3568
3569 static Elm_Gen_Item *
3570 _item_new(Widget_Data                  *wd,
3571           const Elm_Genlist_Item_Class *itc,
3572           const void                   *data,
3573           Elm_Gen_Item                 *parent,
3574           Elm_Genlist_Item_Flags        flags,
3575           Evas_Smart_Cb                 func,
3576           const void                   *func_data)
3577 {
3578    Elm_Gen_Item *it, *it2;
3579    int depth = 0;
3580
3581    it = _elm_genlist_item_new(wd, itc, data, parent, func, func_data);
3582    if (!it) return NULL;
3583    it->item = ELM_NEW(Elm_Gen_Item_Type);
3584    it->item->flags = flags;
3585    if (flags & ELM_GENLIST_ITEM_GROUP) it->group++;
3586    it->item->expanded_depth = 0;
3587    ELM_GEN_ITEM_SETUP(it);
3588    if (it->parent)
3589      {
3590         if (it->parent->group)
3591           it->item->group_item = parent;
3592         else if (it->parent->item->group_item)
3593           it->item->group_item = it->parent->item->group_item;
3594      }
3595    for (it2 = it, depth = 0; it2->parent; it2 = it2->parent)
3596      {
3597         if (!it2->parent->group) depth += 1;
3598      }
3599    it->item->expanded_depth = depth;
3600    wd->item_count++;
3601    return it;
3602 }
3603
3604 static Item_Block *
3605 _item_block_new(Widget_Data *wd, Eina_Bool prepend)
3606 {
3607    Item_Block *itb;
3608
3609    itb = calloc(1, sizeof(Item_Block));
3610    if (!itb) return NULL;
3611    itb->wd = wd;
3612    if (prepend)
3613      {
3614         wd->blocks = eina_inlist_prepend(wd->blocks, EINA_INLIST_GET(itb));
3615         _item_block_position_update(wd->blocks, 0);
3616      }
3617    else
3618      {
3619         wd->blocks = eina_inlist_append(wd->blocks, EINA_INLIST_GET(itb));
3620         itb->position_update = EINA_TRUE;
3621         if (wd->blocks != EINA_INLIST_GET(itb))
3622           {
3623              itb->position = ((Item_Block *) (EINA_INLIST_GET(itb)->prev))->position + 1;
3624           }
3625         else
3626           {
3627              itb->position = 0;
3628           }
3629      }
3630    return itb;
3631 }
3632
3633 static Eina_Bool
3634 _item_block_add(Widget_Data *wd,
3635                 Elm_Gen_Item *it)
3636 {
3637    Item_Block *itb = NULL;
3638
3639    if (!it->item->rel)
3640      {
3641 newblock:
3642         if (it->item->rel)
3643           {
3644              itb = calloc(1, sizeof(Item_Block));
3645              if (!itb) return EINA_FALSE;
3646              itb->wd = wd;
3647              if (!it->item->rel->item->block)
3648                {
3649                   wd->blocks =
3650                     eina_inlist_append(wd->blocks, EINA_INLIST_GET(itb));
3651                   itb->items = eina_list_append(itb->items, it);
3652                   itb->position_update = EINA_TRUE;
3653                   it->position = eina_list_count(itb->items);
3654                   it->position_update = EINA_TRUE;
3655
3656                   if (wd->blocks != EINA_INLIST_GET(itb))
3657                     {
3658                        itb->position = ((Item_Block *) (EINA_INLIST_GET(itb)->prev))->position + 1;
3659                     }
3660                   else
3661                     {
3662                        itb->position = 0;
3663                     }
3664                }
3665              else
3666                {
3667                   Eina_List *tmp;
3668
3669                   tmp = eina_list_data_find_list(itb->items, it->item->rel);
3670                   if (it->item->before)
3671                     {
3672                        wd->blocks = eina_inlist_prepend_relative
3673                            (wd->blocks, EINA_INLIST_GET(itb),
3674                            EINA_INLIST_GET(it->item->rel->item->block));
3675                        itb->items =
3676                          eina_list_prepend_relative_list(itb->items, it, tmp);
3677
3678                        /* Update index from where we prepended */
3679                        _item_position_update(eina_list_prev(tmp), it->item->rel->position);
3680                        _item_block_position_update(EINA_INLIST_GET(itb),
3681                                                    it->item->rel->item->block->position);
3682                     }
3683                   else
3684                     {
3685                        wd->blocks = eina_inlist_append_relative
3686                            (wd->blocks, EINA_INLIST_GET(itb),
3687                            EINA_INLIST_GET(it->item->rel->item->block));
3688                        itb->items =
3689                          eina_list_append_relative_list(itb->items, it, tmp);
3690
3691                        /* Update block index from where we appended */
3692                        _item_position_update(eina_list_next(tmp), it->item->rel->position + 1);
3693                        _item_block_position_update(EINA_INLIST_GET(itb),
3694                                                    it->item->rel->item->block->position + 1);
3695                     }
3696                }
3697           }
3698         else
3699           {
3700              if (it->item->before)
3701                {
3702                   if (wd->blocks)
3703                     {
3704                        itb = (Item_Block *)(wd->blocks);
3705                        if (itb->count >= wd->max_items_per_block)
3706                          {
3707                             itb = _item_block_new(wd, EINA_TRUE);
3708                             if (!itb) return EINA_FALSE;
3709                          }
3710                     }
3711                   else
3712                     {
3713                        itb = _item_block_new(wd, EINA_TRUE);
3714                        if (!itb) return EINA_FALSE;
3715                     }
3716                   itb->items = eina_list_prepend(itb->items, it);
3717
3718                   _item_position_update(itb->items, 0);
3719                }
3720              else
3721                {
3722                   if (wd->blocks)
3723                     {
3724                        itb = (Item_Block *)(wd->blocks->last);
3725                        if (itb->count >= wd->max_items_per_block)
3726                          {
3727                             itb = _item_block_new(wd, EINA_FALSE);
3728                             if (!itb) return EINA_FALSE;
3729                          }
3730                     }
3731                   else
3732                     {
3733                        itb = _item_block_new(wd, EINA_FALSE);
3734                        if (!itb) return EINA_FALSE;
3735                     }
3736                   itb->items = eina_list_append(itb->items, it);
3737                   it->position = eina_list_count(itb->items);
3738                }
3739           }
3740      }
3741    else
3742      {
3743         Eina_List *tmp;
3744
3745         if (it->item->rel->item->queued)
3746           {
3747              /* NOTE: for a strange reason eina_list and eina_inlist don't have the same property
3748                 on sorted insertion order, so the queue is not always ordered like the item list.
3749                 This lead to issue where we depend on an item that is not yet created. As a quick
3750                 work around, we reschedule the calc of the item and stop reordering the list to
3751                 prevent any nasty issue to show up here.
3752               */
3753              wd->queue = eina_list_append(wd->queue, it);
3754              wd->requeued = EINA_TRUE;
3755              it->item->queued = EINA_TRUE;
3756              return EINA_FALSE;
3757           }
3758         itb = it->item->rel->item->block;
3759         if (!itb) goto newblock;
3760         tmp = eina_list_data_find_list(itb->items, it->item->rel);
3761         if (it->item->before)
3762           {
3763              itb->items = eina_list_prepend_relative_list(itb->items, it, tmp);
3764              _item_position_update(eina_list_prev(tmp), it->item->rel->position);
3765           }
3766         else
3767           {
3768              itb->items = eina_list_append_relative_list(itb->items, it, tmp);
3769              _item_position_update(eina_list_next(tmp), it->item->rel->position + 1);
3770           }
3771      }
3772    itb->count++;
3773    itb->changed = EINA_TRUE;
3774    it->item->block = itb;
3775    if (itb->wd->calc_job) ecore_job_del(itb->wd->calc_job);
3776    itb->wd->calc_job = ecore_job_add(_calc_job, itb->wd);
3777    if (it->item->rel)
3778      {
3779         it->item->rel->relcount--;
3780         if ((it->item->rel->generation < it->wd->generation) && (!it->item->rel->relcount))
3781           {
3782              _item_del(it->item->rel);
3783              elm_widget_item_free(it->item->rel);
3784           }
3785         it->item->rel = NULL;
3786      }
3787    if (itb->count > itb->wd->max_items_per_block)
3788      {
3789         Item_Block *itb2;
3790         Elm_Gen_Item *it2;
3791         int newc;
3792         Eina_Bool done = EINA_FALSE;
3793
3794         newc = itb->count / 2;
3795
3796         if (EINA_INLIST_GET(itb)->prev)
3797           {
3798              Item_Block *itbp = (Item_Block *)(EINA_INLIST_GET(itb)->prev);
3799
3800              if (itbp->count + newc < wd->max_items_per_block / 2)
3801                {
3802                   /* moving items to previous block */
3803                   while ((itb->count > newc) && (itb->items))
3804                     {
3805                        it2 = eina_list_data_get(itb->items);
3806                        itb->items = eina_list_remove_list(itb->items, itb->items);
3807                        itb->count--;
3808
3809                        itbp->items = eina_list_append(itbp->items, it2);
3810                        it2->item->block = itbp;
3811                        itbp->count++;
3812                     }
3813
3814                   done = EINA_TRUE;
3815                }
3816           }
3817
3818         if (!done && EINA_INLIST_GET(itb)->next)
3819           {
3820              Item_Block *itbn = (Item_Block *)(EINA_INLIST_GET(itb)->next);
3821
3822              if (itbn->count + newc < wd->max_items_per_block / 2)
3823                {
3824                   /* moving items to next block */
3825                   while ((itb->count > newc) && (itb->items))
3826                     {
3827                        Eina_List *l;
3828
3829                        l = eina_list_last(itb->items);
3830                        it2 = eina_list_data_get(l);
3831                        itb->items = eina_list_remove_list(itb->items, l);
3832                        itb->count--;
3833
3834                        itbn->items = eina_list_prepend(itbn->items, it2);
3835                        it2->item->block = itbn;
3836                        itbn->count++;
3837                     }
3838
3839                   done = EINA_TRUE;
3840                }
3841           }
3842
3843         if (!done)
3844           {
3845              /* moving items to new block */
3846              itb2 = calloc(1, sizeof(Item_Block));
3847              if (!itb2) return EINA_FALSE;
3848              itb2->wd = wd;
3849              wd->blocks =
3850                eina_inlist_append_relative(wd->blocks, EINA_INLIST_GET(itb2),
3851                                            EINA_INLIST_GET(itb));
3852              itb2->changed = EINA_TRUE;
3853              while ((itb->count > newc) && (itb->items))
3854                {
3855                   Eina_List *l;
3856
3857                   l = eina_list_last(itb->items);
3858                   it2 = l->data;
3859                   itb->items = eina_list_remove_list(itb->items, l);
3860                   itb->count--;
3861
3862                   itb2->items = eina_list_prepend(itb2->items, it2);
3863                   it2->item->block = itb2;
3864                   itb2->count++;
3865                }
3866           }
3867      }
3868
3869    return EINA_TRUE;
3870 }
3871
3872 static int
3873 _queue_process(Widget_Data *wd)
3874 {
3875    int n;
3876    Eina_Bool showme = EINA_FALSE;
3877    double t0, t;
3878
3879    t0 = ecore_loop_time_get();
3880    //evas_event_freeze(evas_object_evas_get(wd->obj));
3881    for (n = 0; (wd->queue) && (n < 128); n++)
3882      {
3883         Elm_Gen_Item *it;
3884
3885         it = eina_list_data_get(wd->queue);
3886         wd->queue = eina_list_remove_list(wd->queue, wd->queue);
3887         it->item->queued = EINA_FALSE;
3888         if (!_item_block_add(wd, it)) continue;
3889         if (!wd->blocks)
3890           _item_block_realize(it->item->block);
3891         t = ecore_time_get();
3892         if (it->item->block->changed)
3893           {
3894              showme = _item_block_recalc(it->item->block, it->item->block->num, EINA_TRUE);
3895              it->item->block->changed = 0;
3896              if (wd->pan_changed)
3897                {
3898                   if (wd->calc_job) ecore_job_del(wd->calc_job);
3899                   wd->calc_job = NULL;
3900                   _calc_job(wd);
3901                   wd->pan_changed = EINA_FALSE;
3902                }
3903           }
3904         if (showme) it->item->block->showme = EINA_TRUE;
3905         /* same as eina_inlist_count > 1 */
3906         if (wd->blocks && wd->blocks->next)
3907           {
3908              if ((t - t0) > (ecore_animator_frametime_get())) break;
3909           }
3910      }
3911    //evas_event_thaw(evas_object_evas_get(wd->obj));
3912    //evas_event_thaw_eval(evas_object_evas_get(wd->obj));
3913    return n;
3914 }
3915
3916 static Eina_Bool
3917 _idle_process(void *data, Eina_Bool *wakeup)
3918 {
3919    Widget_Data *wd = data;
3920
3921    //xxx
3922    //static double q_start = 0.0;
3923    //if (q_start == 0.0) q_start = ecore_time_get();
3924    //xxx
3925    if (_queue_process(wd) > 0) *wakeup = EINA_TRUE;
3926    if (!wd->queue)
3927      {
3928         //xxx
3929         //printf("PROCESS TIME: %3.3f\n", ecore_time_get() - q_start);
3930         //xxx
3931         return ECORE_CALLBACK_CANCEL;
3932      }
3933    return ECORE_CALLBACK_RENEW;
3934 }
3935
3936 static Eina_Bool
3937 _item_idle_enterer(void *data)
3938 {
3939    Widget_Data *wd = data;
3940    Eina_Bool wakeup = EINA_FALSE;
3941    Eina_Bool ok = _idle_process(data, &wakeup);
3942
3943    if (wakeup)
3944      {
3945         // wake up mainloop
3946         if (wd->calc_job) ecore_job_del(wd->calc_job);
3947         wd->calc_job = ecore_job_add(_calc_job, wd);
3948      }
3949    if (ok == ECORE_CALLBACK_CANCEL) wd->queue_idle_enterer = NULL;
3950    return ok;
3951 }
3952
3953 static void
3954 _item_queue(Widget_Data *wd,
3955             Elm_Gen_Item *it,
3956             Eina_Compare_Cb cb)
3957 {
3958    if (it->item->queued) return;
3959    it->item->queued = EINA_TRUE;
3960    if (cb && !wd->requeued)
3961      wd->queue = eina_list_sorted_insert(wd->queue, cb, it);
3962    else
3963      wd->queue = eina_list_append(wd->queue, it);
3964 // FIXME: why does a freeze then thaw here cause some genlist
3965 // elm_genlist_item_append() to be much much slower?
3966 //   evas_event_freeze(evas_object_evas_get(wd->obj));
3967    while ((wd->queue) && ((!wd->blocks) || (!wd->blocks->next)))
3968      {
3969         if (wd->queue_idle_enterer)
3970           {
3971              ecore_idle_enterer_del(wd->queue_idle_enterer);
3972              wd->queue_idle_enterer = NULL;
3973           }
3974         _queue_process(wd);
3975      }
3976 //   evas_event_thaw(evas_object_evas_get(wd->obj));
3977 //   evas_event_thaw_eval(evas_object_evas_get(wd->obj));
3978    if (!wd->queue_idle_enterer)
3979      wd->queue_idle_enterer = ecore_idle_enterer_add(_item_idle_enterer, wd);
3980 }
3981
3982 static int
3983 _elm_genlist_item_compare(const void *data, const void *data1)
3984 {
3985    const Elm_Gen_Item *it, *item1;
3986    it = ELM_GEN_ITEM_FROM_INLIST(data);
3987    item1 = ELM_GEN_ITEM_FROM_INLIST(data1);
3988    return it->wd->item_compare_cb(it, item1);
3989 }
3990
3991 static int
3992 _elm_genlist_item_list_compare(const void *data, const void *data1)
3993 {
3994    const Elm_Gen_Item *it = data;
3995    const Elm_Gen_Item *item1 = data1;
3996    return it->wd->item_compare_cb(it, item1);
3997 }
3998
3999 static void
4000 _item_move_after(Elm_Gen_Item *it, Elm_Gen_Item *after)
4001 {
4002    if (!it) return;
4003    if (!after) return;
4004
4005    it->wd->items = eina_inlist_remove(it->wd->items, EINA_INLIST_GET(it));
4006    _item_block_del(it);
4007
4008    it->wd->items = eina_inlist_append_relative(it->wd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(after));
4009    it->item->rel = after;
4010    it->item->rel->relcount++;
4011    it->item->before = EINA_FALSE;
4012    if (after->item->group_item) it->item->group_item = after->item->group_item;
4013    _item_queue(it->wd, it, NULL);
4014
4015    evas_object_smart_callback_call(WIDGET(it), SIG_MOVED, it);
4016 }
4017
4018 static void
4019 _item_move_before(Elm_Gen_Item *it, Elm_Gen_Item *before)
4020 {
4021    if (!it) return;
4022    if (!before) return;
4023
4024    it->wd->items = eina_inlist_remove(it->wd->items, EINA_INLIST_GET(it));
4025    _item_block_del(it);
4026    it->wd->items = eina_inlist_prepend_relative(it->wd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(before));
4027    it->item->rel = before;
4028    it->item->rel->relcount++;
4029    it->item->before = EINA_TRUE;
4030    if (before->item->group_item) it->item->group_item = before->item->group_item;
4031    _item_queue(it->wd, it, NULL);
4032
4033    evas_object_smart_callback_call(WIDGET(it), SIG_MOVED, it);
4034 }
4035
4036 EAPI unsigned int
4037 elm_genlist_items_count(const Evas_Object *obj)
4038 {
4039    ELM_CHECK_WIDTYPE(obj, widtype) 0;
4040    Widget_Data *wd = elm_widget_data_get(obj);
4041    if (!wd) return 0;
4042    return wd->item_count;
4043 }
4044
4045 EAPI Elm_Object_Item *
4046 elm_genlist_item_append(Evas_Object                  *obj,
4047                         const Elm_Genlist_Item_Class *itc,
4048                         const void                   *data,
4049                         Elm_Object_Item              *parent,
4050                         Elm_Genlist_Item_Flags        flags,
4051                         Evas_Smart_Cb                 func,
4052                         const void                   *func_data)
4053 {
4054    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
4055    Widget_Data *wd = elm_widget_data_get(obj);
4056    if (!wd) return NULL;
4057    Elm_Gen_Item *it = _item_new(wd, itc, data, (Elm_Gen_Item *) parent, flags,
4058                                 func, func_data);
4059    if (!it) return NULL;
4060    if (!it->parent)
4061      {
4062         if (it->group)
4063           wd->group_items = eina_list_append(wd->group_items, it);
4064         wd->items = eina_inlist_append(wd->items, EINA_INLIST_GET(it));
4065         it->item->rel = NULL;
4066      }
4067    else
4068      {
4069         Elm_Gen_Item *it2 = NULL;
4070         Eina_List *ll = eina_list_last(it->parent->item->items);
4071         if (ll) it2 = ll->data;
4072         it->parent->item->items = eina_list_append(it->parent->item->items, it);
4073         if (!it2) it2 = it->parent;
4074         wd->items =
4075           eina_inlist_append_relative(wd->items, EINA_INLIST_GET(it),
4076                                       EINA_INLIST_GET(it2));
4077         it->item->rel = it2;
4078         it->item->rel->relcount++;
4079      }
4080    it->item->before = EINA_FALSE;
4081    _item_queue(wd, it, NULL);
4082    return (Elm_Object_Item *) it;
4083 }
4084
4085 EAPI Elm_Object_Item *
4086 elm_genlist_item_prepend(Evas_Object                  *obj,
4087                          const Elm_Genlist_Item_Class *itc,
4088                          const void                   *data,
4089                          Elm_Object_Item              *parent,
4090                          Elm_Genlist_Item_Flags        flags,
4091                          Evas_Smart_Cb                 func,
4092                          const void                   *func_data)
4093 {
4094    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
4095    Widget_Data *wd = elm_widget_data_get(obj);
4096    if (!wd) return NULL;
4097    Elm_Gen_Item *it = _item_new(wd, itc, data, (Elm_Gen_Item *) parent, flags,
4098                                 func, func_data);
4099    if (!it) return NULL;
4100    if (!it->parent)
4101      {
4102         if (it->group)
4103           wd->group_items = eina_list_prepend(wd->group_items, it);
4104         wd->items = eina_inlist_prepend(wd->items, EINA_INLIST_GET(it));
4105         it->item->rel = NULL;
4106      }
4107    else
4108      {
4109         Elm_Gen_Item *it2 = NULL;
4110         Eina_List *ll = it->parent->item->items;
4111         if (ll) it2 = ll->data;
4112         it->parent->item->items = eina_list_prepend(it->parent->item->items, it);
4113         if (!it2) it2 = it->parent;
4114         wd->items =
4115           eina_inlist_prepend_relative(wd->items, EINA_INLIST_GET(it),
4116                                        EINA_INLIST_GET(it2));
4117         it->item->rel = it2;
4118         it->item->rel->relcount++;
4119      }
4120    it->item->before = EINA_TRUE;
4121    _item_queue(wd, it, NULL);
4122    return (Elm_Object_Item *) it;
4123 }
4124
4125 EAPI Elm_Object_Item *
4126 elm_genlist_item_insert_after(Evas_Object                  *obj,
4127                               const Elm_Genlist_Item_Class *itc,
4128                               const void                   *data,
4129                               Elm_Object_Item              *parent,
4130                               Elm_Object_Item              *after,
4131                               Elm_Genlist_Item_Flags        flags,
4132                               Evas_Smart_Cb                 func,
4133                               const void                   *func_data)
4134 {
4135    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
4136    ELM_OBJ_ITEM_CHECK_OR_RETURN(after, NULL);
4137    Widget_Data *wd = elm_widget_data_get(obj);
4138    Elm_Gen_Item *_after = (Elm_Gen_Item *) after;
4139    if (!wd) return NULL;
4140    /* It makes no sense to insert after in an empty list with after != NULL, something really bad is happening in your app. */
4141    EINA_SAFETY_ON_NULL_RETURN_VAL(wd->items, NULL);
4142
4143    Elm_Gen_Item *it = _item_new(wd, itc, data, (Elm_Gen_Item *) parent, flags,
4144                                 func, func_data);
4145    if (!it) return NULL;
4146    if (!it->parent)
4147      {
4148         if ((it->group) && (_after->group))
4149           wd->group_items = eina_list_append_relative(wd->group_items, it,
4150                                                       _after);
4151      }
4152    else
4153      {
4154         it->parent->item->items =
4155            eina_list_append_relative(it->parent->item->items, it, _after);
4156      }
4157    wd->items = eina_inlist_append_relative(wd->items, EINA_INLIST_GET(it),
4158                                            EINA_INLIST_GET(_after));
4159    it->item->rel = _after;
4160    it->item->rel->relcount++;
4161    it->item->before = EINA_FALSE;
4162    _item_queue(wd, it, NULL);
4163    return (Elm_Object_Item *) it;
4164 }
4165
4166 EAPI Elm_Object_Item *
4167 elm_genlist_item_insert_before(Evas_Object                  *obj,
4168                                const Elm_Genlist_Item_Class *itc,
4169                                const void                   *data,
4170                                Elm_Object_Item              *parent,
4171                                Elm_Object_Item              *before,
4172                                Elm_Genlist_Item_Flags        flags,
4173                                Evas_Smart_Cb                 func,
4174                                const void                   *func_data)
4175 {
4176    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
4177    ELM_OBJ_ITEM_CHECK_OR_RETURN(before, NULL);
4178    Widget_Data *wd = elm_widget_data_get(obj);
4179    Elm_Gen_Item *_before = (Elm_Gen_Item *) before;
4180    if (!wd) return NULL;
4181    /* It makes no sense to insert before in an empty list with before != NULL, something really bad is happening in your app. */
4182    EINA_SAFETY_ON_NULL_RETURN_VAL(wd->items, NULL);
4183
4184    Elm_Gen_Item *it = _item_new(wd, itc, data, (Elm_Gen_Item *) parent, flags,
4185                                 func, func_data);
4186    if (!it) return NULL;
4187    if (!it->parent)
4188      {
4189         if (it->group && _before->group)
4190           wd->group_items = eina_list_prepend_relative(wd->group_items, it,
4191                                                        _before);
4192      }
4193    else
4194      {
4195         it->parent->item->items =
4196            eina_list_prepend_relative(it->parent->item->items, it, _before);
4197      }
4198    wd->items = eina_inlist_prepend_relative(wd->items, EINA_INLIST_GET(it),
4199                                             EINA_INLIST_GET(_before));
4200    it->item->rel = _before;
4201    it->item->rel->relcount++;
4202    it->item->before = EINA_TRUE;
4203    _item_queue(wd, it, NULL);
4204    return (Elm_Object_Item *) it;
4205 }
4206
4207 EAPI Elm_Object_Item *
4208 elm_genlist_item_sorted_insert(Evas_Object                  *obj,
4209                                const Elm_Genlist_Item_Class *itc,
4210                                const void                   *data,
4211                                Elm_Object_Item              *parent,
4212                                Elm_Genlist_Item_Flags        flags,
4213                                Eina_Compare_Cb               comp,
4214                                Evas_Smart_Cb                 func,
4215                                const void                   *func_data)
4216 {
4217    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
4218    Widget_Data *wd = elm_widget_data_get(obj);
4219    if (!wd) return NULL;
4220    Elm_Gen_Item *rel = NULL;
4221    Elm_Gen_Item *it = _item_new(wd, itc, data, (Elm_Gen_Item *) parent, flags,
4222                                 func, func_data);
4223    if (!it) return NULL;
4224
4225    wd->item_compare_cb = comp;
4226
4227    if (it->parent)
4228      {
4229         Eina_List *l;
4230         int cmp_result;
4231
4232         l = eina_list_search_sorted_near_list(it->parent->item->items,
4233                                               _elm_genlist_item_list_compare,
4234                                               it,
4235                                               &cmp_result);
4236         if (l)
4237           rel = eina_list_data_get(l);
4238         else
4239           rel = it->parent;
4240
4241         if (cmp_result >= 0)
4242           {
4243              it->parent->item->items = eina_list_prepend_relative_list(it->parent->item->items, it, l);
4244              wd->items = eina_inlist_prepend_relative(wd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(rel));
4245              it->item->before = EINA_FALSE;
4246           }
4247         else if (cmp_result < 0)
4248           {
4249              it->parent->item->items = eina_list_append_relative_list(it->parent->item->items, it, l);
4250              wd->items = eina_inlist_append_relative(wd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(rel));
4251              it->item->before = EINA_TRUE;
4252           }
4253      }
4254    else
4255      {
4256         if (!wd->state)
4257           {
4258              wd->state = eina_inlist_sorted_state_new();
4259              eina_inlist_sorted_state_init(wd->state, wd->items);
4260              wd->requeued = EINA_FALSE;
4261           }
4262
4263         if (it->group)
4264           wd->group_items = eina_list_append(wd->group_items, it);
4265
4266         wd->items = eina_inlist_sorted_state_insert(wd->items, EINA_INLIST_GET(it),
4267                                                     _elm_genlist_item_compare, wd->state);
4268
4269         if (EINA_INLIST_GET(it)->next)
4270           {
4271              rel = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->next);
4272              it->item->before = EINA_TRUE;
4273           }
4274         else if (EINA_INLIST_GET(it)->prev)
4275           {
4276              rel = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->prev);
4277              it->item->before = EINA_FALSE;
4278           }
4279      }
4280
4281    if (rel)
4282      {
4283         it->item->rel = rel;
4284         it->item->rel->relcount++;
4285      }
4286
4287    _item_queue(wd, it, _elm_genlist_item_list_compare);
4288
4289    return (Elm_Object_Item *) it;
4290 }
4291
4292 static void
4293 _elm_genlist_clear(Evas_Object *obj, Eina_Bool standby)
4294 {
4295    Eina_Inlist *next, *l;
4296
4297    ELM_CHECK_WIDTYPE(obj, widtype);
4298    Widget_Data *wd = elm_widget_data_get(obj);
4299    if (!wd) return;
4300
4301    if (!standby) wd->generation++;
4302
4303    if (wd->state)
4304      {
4305         eina_inlist_sorted_state_free(wd->state);
4306         wd->state = NULL;
4307      }
4308
4309    if (wd->walking > 0)
4310      {
4311         wd->clear_me = EINA_TRUE;
4312         return;
4313      }
4314    evas_event_freeze(evas_object_evas_get(wd->obj));
4315    for (l = wd->items, next = l ? l->next : NULL;
4316         l;
4317         l = next, next = next ? next->next : NULL)
4318      {
4319         Elm_Gen_Item *it = ELM_GEN_ITEM_FROM_INLIST(l);
4320
4321         if (it->generation < wd->generation)
4322           {
4323              Elm_Gen_Item *itn = NULL;
4324
4325              if (next) itn = ELM_GEN_ITEM_FROM_INLIST(next);
4326              if (itn) itn->walking++; /* prevent early death of subitem */
4327              it->del_cb(it);
4328              elm_widget_item_free(it);
4329              if (itn) itn->walking--;
4330           }
4331      }
4332    wd->clear_me = EINA_FALSE;
4333    wd->pan_changed = EINA_TRUE;
4334    if (wd->calc_job)
4335      {
4336         ecore_job_del(wd->calc_job);
4337         wd->calc_job = NULL;
4338      }
4339    if (wd->selected) wd->selected = eina_list_free(wd->selected);
4340    if (wd->clear_cb) wd->clear_cb(wd);
4341    wd->pan_x = 0;
4342    wd->pan_y = 0;
4343    wd->minw = 0;
4344    wd->minh = 0;
4345    if (wd->pan_smart)
4346      {
4347         evas_object_size_hint_min_set(wd->pan_smart, wd->minw, wd->minh);
4348         evas_object_smart_callback_call(wd->pan_smart, "changed", NULL);
4349      }
4350    if (wd->sizing_cb) wd->sizing_cb(wd->obj);
4351    elm_smart_scroller_child_region_show(wd->scr, 0, 0, 0, 0);
4352    evas_event_thaw(evas_object_evas_get(wd->obj));
4353    evas_event_thaw_eval(evas_object_evas_get(wd->obj));
4354 }
4355
4356 EAPI void
4357 elm_genlist_clear(Evas_Object *obj)
4358 {
4359    _elm_genlist_clear(obj, EINA_FALSE);
4360 }
4361
4362 EAPI void
4363 elm_genlist_multi_select_set(Evas_Object *obj,
4364                              Eina_Bool    multi)
4365 {
4366    ELM_CHECK_WIDTYPE(obj, widtype);
4367    Widget_Data *wd = elm_widget_data_get(obj);
4368    if (!wd) return;
4369    wd->multi = !!multi;
4370 }
4371
4372 EAPI Eina_Bool
4373 elm_genlist_multi_select_get(const Evas_Object *obj)
4374 {
4375    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
4376    Widget_Data *wd = elm_widget_data_get(obj);
4377    if (!wd) return EINA_FALSE;
4378    return wd->multi;
4379 }
4380
4381 EAPI Elm_Object_Item *
4382 elm_genlist_selected_item_get(const Evas_Object *obj)
4383 {
4384    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
4385    Widget_Data *wd = elm_widget_data_get(obj);
4386    if (!wd) return NULL;
4387    if (wd->selected) return wd->selected->data;
4388    return NULL;
4389 }
4390
4391 EAPI const Eina_List *
4392 elm_genlist_selected_items_get(const Evas_Object *obj)
4393 {
4394    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
4395    Widget_Data *wd = elm_widget_data_get(obj);
4396    if (!wd) return NULL;
4397    return wd->selected;
4398 }
4399
4400 EAPI Eina_List *
4401 elm_genlist_realized_items_get(const Evas_Object *obj)
4402 {
4403    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
4404    Widget_Data *wd = elm_widget_data_get(obj);
4405    Eina_List *list = NULL;
4406    Item_Block *itb;
4407    Eina_Bool done = EINA_FALSE;
4408    if (!wd) return NULL;
4409    EINA_INLIST_FOREACH(wd->blocks, itb)
4410      {
4411         if (itb->realized)
4412           {
4413              Eina_List *l;
4414              Elm_Gen_Item *it;
4415
4416              done = EINA_TRUE;
4417              EINA_LIST_FOREACH(itb->items, l, it)
4418                {
4419                   if (it->realized) list = eina_list_append(list, it);
4420                }
4421           }
4422         else
4423           {
4424              if (done) break;
4425           }
4426      }
4427    return list;
4428 }
4429
4430 EAPI Elm_Object_Item *
4431 elm_genlist_at_xy_item_get(const Evas_Object *obj,
4432                            Evas_Coord         x,
4433                            Evas_Coord         y,
4434                            int               *posret)
4435 {
4436    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
4437    Widget_Data *wd = elm_widget_data_get(obj);
4438    Evas_Coord ox, oy, ow, oh;
4439    Item_Block *itb;
4440    Evas_Coord lasty;
4441    if (!wd) return NULL;
4442    evas_object_geometry_get(wd->pan_smart, &ox, &oy, &ow, &oh);
4443    lasty = oy;
4444    EINA_INLIST_FOREACH(wd->blocks, itb)
4445      {
4446         Eina_List *l;
4447         Elm_Gen_Item *it;
4448
4449         if (!ELM_RECTS_INTERSECT(ox + itb->x - itb->wd->pan_x,
4450                                  oy + itb->y - itb->wd->pan_y,
4451                                  itb->w, itb->h, x, y, 1, 1))
4452           continue;
4453         EINA_LIST_FOREACH(itb->items, l, it)
4454           {
4455              Evas_Coord itx, ity;
4456
4457              itx = ox + itb->x + it->x - itb->wd->pan_x;
4458              ity = oy + itb->y + it->y - itb->wd->pan_y;
4459              if (ELM_RECTS_INTERSECT(itx, ity, it->item->w, it->item->h, x, y, 1, 1))
4460                {
4461                   if (posret)
4462                     {
4463                        if (y <= (ity + (it->item->h / 4))) *posret = -1;
4464                        else if (y >= (ity + it->item->h - (it->item->h / 4)))
4465                          *posret = 1;
4466                        else *posret = 0;
4467                     }
4468                   return (Elm_Object_Item *) it;
4469                }
4470              lasty = ity + it->item->h;
4471           }
4472      }
4473    if (posret)
4474      {
4475         if (y > lasty) *posret = 1;
4476         else *posret = -1;
4477      }
4478    return NULL;
4479 }
4480
4481 EAPI Elm_Object_Item *
4482 elm_genlist_first_item_get(const Evas_Object *obj)
4483 {
4484    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
4485    Widget_Data *wd = elm_widget_data_get(obj);
4486    if (!wd) return NULL;
4487    if (!wd->items) return NULL;
4488    Elm_Gen_Item *it = ELM_GEN_ITEM_FROM_INLIST(wd->items);
4489    while ((it) && (it->generation < wd->generation))
4490      it = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->next);
4491    return (Elm_Object_Item *) it;
4492 }
4493
4494 EAPI Elm_Object_Item *
4495 elm_genlist_last_item_get(const Evas_Object *obj)
4496 {
4497    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
4498    Widget_Data *wd = elm_widget_data_get(obj);
4499    if (!wd) return NULL;
4500    if (!wd->items) return NULL;
4501    Elm_Gen_Item *it = ELM_GEN_ITEM_FROM_INLIST(wd->items->last);
4502    while ((it) && (it->generation < wd->generation))
4503      it = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->prev);
4504    return (Elm_Object_Item *) it;
4505 }
4506
4507 EAPI Elm_Object_Item *
4508 elm_genlist_item_next_get(const Elm_Object_Item *it)
4509 {
4510    ELM_OBJ_ITEM_CHECK_OR_RETURN(it, NULL);
4511    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
4512    while (_it)
4513      {
4514         _it = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(_it)->next);
4515         if ((_it) && (_it->generation == _it->wd->generation)) break;
4516      }
4517    return (Elm_Object_Item *) _it;
4518 }
4519
4520 EAPI Elm_Object_Item *
4521 elm_genlist_item_prev_get(const Elm_Object_Item *it)
4522 {
4523    ELM_OBJ_ITEM_CHECK_OR_RETURN(it, NULL);
4524    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
4525    while (_it)
4526      {
4527         _it = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(_it)->prev);
4528         if ((_it) && (_it->generation == _it->wd->generation)) break;
4529      }
4530    return (Elm_Object_Item *) _it;
4531 }
4532
4533 EINA_DEPRECATED EAPI Evas_Object *
4534 elm_genlist_item_genlist_get(const Elm_Object_Item *it)
4535 {
4536    return elm_object_item_widget_get(it);
4537 }
4538
4539 EAPI Elm_Object_Item *
4540 elm_genlist_item_parent_get(const Elm_Object_Item *it)
4541 {
4542    ELM_OBJ_ITEM_CHECK_OR_RETURN(it, NULL);
4543    return (Elm_Object_Item *) ((Elm_Gen_Item *) it)->parent;
4544 }
4545
4546 EAPI void
4547 elm_genlist_item_subitems_clear(Elm_Object_Item *it)
4548 {
4549    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
4550    Eina_List *tl = NULL, *l;
4551    Elm_Gen_Item *_it;
4552    Elm_Object_Item *it2;
4553    _it = (Elm_Gen_Item *) it;
4554
4555    EINA_LIST_FOREACH(_it->item->items, l, it2)
4556      tl = eina_list_append(tl, it2);
4557    EINA_LIST_FREE(tl, it2)
4558      elm_object_item_del(it2);
4559 }
4560
4561 EAPI void
4562 elm_genlist_item_selected_set(Elm_Object_Item *it,
4563                               Eina_Bool selected)
4564 {
4565    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
4566    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
4567    Widget_Data *wd = _it->wd;
4568    if (!wd) return;
4569    if ((_it->generation < wd->generation) || elm_widget_item_disabled_get(_it))
4570      return;
4571    selected = !!selected;
4572    if (_it->selected == selected) return;
4573
4574    if (selected)
4575      {
4576         if (!wd->multi)
4577           {
4578              while (wd->selected)
4579                {
4580                   if (_it->unhighlight_cb) _it->unhighlight_cb(wd->selected->data);
4581                   _it->unsel_cb(wd->selected->data);
4582                }
4583           }
4584         _it->highlight_cb(_it);
4585         _item_select(_it);
4586         return;
4587      }
4588    if (_it->unhighlight_cb) _it->unhighlight_cb(_it);
4589    _it->unsel_cb(_it);
4590 }
4591
4592 EAPI Eina_Bool
4593 elm_genlist_item_selected_get(const Elm_Object_Item *it)
4594 {
4595    ELM_OBJ_ITEM_CHECK_OR_RETURN(it, EINA_FALSE);
4596    return ((Elm_Gen_Item *) it)->selected;
4597 }
4598
4599 EAPI void
4600 elm_genlist_item_expanded_set(Elm_Object_Item  *it,
4601                               Eina_Bool         expanded)
4602 {
4603    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
4604    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
4605    expanded = !!expanded;
4606    if (_it->item->expanded == expanded) return;
4607    _it->item->expanded = expanded;
4608    if (_it->item->expanded)
4609      {
4610         if (_it->realized)
4611           edje_object_signal_emit(VIEW(_it), "elm,state,expanded", "elm");
4612         evas_object_smart_callback_call(WIDGET(_it), SIG_EXPANDED, _it);
4613         _it->wd->auto_scroll_enabled = EINA_TRUE;
4614         _it->wd->expanded_item = _it;
4615      }
4616    else
4617      {
4618         if (_it->realized)
4619           edje_object_signal_emit(VIEW(_it), "elm,state,contracted", "elm");
4620         evas_object_smart_callback_call(WIDGET(_it), SIG_CONTRACTED, _it);
4621         _it->wd->auto_scroll_enabled = EINA_FALSE;
4622         _it->wd->expanded_item = NULL;
4623      }
4624 }
4625
4626 EAPI Eina_Bool
4627 elm_genlist_item_expanded_get(const Elm_Object_Item *it)
4628 {
4629    ELM_OBJ_ITEM_CHECK_OR_RETURN(it, EINA_FALSE);
4630    return ((Elm_Gen_Item *) it)->item->expanded;
4631 }
4632
4633 EAPI int
4634 elm_genlist_item_expanded_depth_get(const Elm_Object_Item *it)
4635 {
4636    ELM_OBJ_ITEM_CHECK_OR_RETURN(it, 0);
4637    return ((Elm_Gen_Item *) it)->item->expanded_depth;
4638 }
4639
4640 EINA_DEPRECATED EAPI void
4641 elm_genlist_item_disabled_set(Elm_Object_Item  *it,
4642                               Eina_Bool         disabled)
4643 {
4644    elm_object_item_disabled_set(it, disabled);
4645 }
4646
4647 EINA_DEPRECATED EAPI Eina_Bool
4648 elm_genlist_item_disabled_get(const Elm_Object_Item *it)
4649 {
4650    return elm_object_item_disabled_get(it);
4651 }
4652
4653 EAPI void
4654 elm_genlist_item_display_only_set(Elm_Object_Item  *it,
4655                                   Eina_Bool         display_only)
4656 {
4657    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
4658    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
4659    display_only = !!display_only;
4660    if (_it->display_only == display_only) return;
4661    if (_it->generation < _it->wd->generation) return;
4662    _it->display_only = display_only;
4663    _it->item->mincalcd = EINA_FALSE;
4664    _it->item->updateme = EINA_TRUE;
4665    if (_it->item->block) _it->item->block->updateme = EINA_TRUE;
4666    if (_it->wd->update_job) ecore_job_del(_it->wd->update_job);
4667    _it->wd->update_job = ecore_job_add(_update_job, _it->wd);
4668 }
4669
4670 EAPI Eina_Bool
4671 elm_genlist_item_display_only_get(const Elm_Object_Item *it)
4672 {
4673    ELM_OBJ_ITEM_CHECK_OR_RETURN(it, EINA_FALSE);
4674    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
4675    if (_it->generation < _it->wd->generation) return EINA_FALSE;
4676    return _it->display_only;
4677 }
4678
4679 EAPI void
4680 elm_genlist_item_show(Elm_Object_Item *it)
4681 {
4682    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
4683    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
4684    Evas_Coord gith = 0;
4685    if (_it->generation < _it->wd->generation) return;
4686    if ((_it->item->queued) || (!_it->item->mincalcd))
4687      {
4688         _it->wd->show_item = _it;
4689         _it->wd->bring_in = EINA_FALSE;
4690         _it->wd->scrollto_type = ELM_GENLIST_ITEM_SCROLLTO_IN;
4691         _it->item->showme = EINA_TRUE;
4692         return;
4693      }
4694    if (_it->wd->show_item)
4695      {
4696         _it->wd->show_item->item->showme = EINA_FALSE;
4697         _it->wd->show_item = NULL;
4698      }
4699    if ((_it->item->group_item) &&
4700        (_it->wd->pan_y > (_it->y + _it->item->block->y)))
4701      gith = _it->item->group_item->item->h;
4702    elm_smart_scroller_child_region_show(_it->wd->scr,
4703                                         _it->x + _it->item->block->x,
4704                                         _it->y + _it->item->block->y - gith,
4705                                         _it->item->block->w, _it->item->h);
4706 }
4707
4708 EAPI void
4709 elm_genlist_item_promote(Elm_Object_Item *it)
4710 {
4711    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
4712    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
4713    if (_it->generation < _it->wd->generation) return;
4714    _item_move_before(_it,
4715                      (Elm_Gen_Item *) elm_genlist_first_item_get(WIDGET(_it)));
4716 }
4717
4718 EAPI void
4719 elm_genlist_item_demote(Elm_Object_Item *it)
4720 {
4721    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
4722    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
4723    if (_it->generation < _it->wd->generation) return;
4724    _item_move_after(_it,
4725                     (Elm_Gen_Item *) elm_genlist_last_item_get(WIDGET(_it)));
4726 }
4727
4728 EAPI void
4729 elm_genlist_item_bring_in(Elm_Object_Item *it)
4730 {
4731    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
4732    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
4733    Evas_Coord gith = 0;
4734    if (_it->generation < _it->wd->generation) return;
4735    if ((_it->item->queued) || (!_it->item->mincalcd))
4736      {
4737         _it->wd->show_item = _it;
4738         _it->wd->bring_in = EINA_TRUE;
4739         _it->wd->scrollto_type = ELM_GENLIST_ITEM_SCROLLTO_IN;
4740         _it->item->showme = EINA_TRUE;
4741         return;
4742      }
4743    if (_it->wd->show_item)
4744      {
4745         _it->wd->show_item->item->showme = EINA_FALSE;
4746         _it->wd->show_item = NULL;
4747      }
4748    if ((_it->item->group_item) &&
4749        (_it->wd->pan_y > (_it->y + _it->item->block->y)))
4750      gith = _it->item->group_item->item->h;
4751    elm_smart_scroller_region_bring_in(_it->wd->scr,
4752                                       _it->x + _it->item->block->x,
4753                                       _it->y + _it->item->block->y - gith,
4754                                       _it->item->block->w, _it->item->h);
4755 }
4756
4757 EAPI void
4758 elm_genlist_item_top_show(Elm_Object_Item *it)
4759 {
4760    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
4761    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
4762    Evas_Coord ow, oh;
4763    Evas_Coord gith = 0;
4764
4765    if (_it->generation < _it->wd->generation) return;
4766    if ((_it->item->queued) || (!_it->item->mincalcd))
4767      {
4768         _it->wd->show_item = _it;
4769         _it->wd->bring_in = EINA_FALSE;
4770         _it->wd->scrollto_type = ELM_GENLIST_ITEM_SCROLLTO_TOP;
4771         _it->item->showme = EINA_TRUE;
4772         return;
4773      }
4774    if (_it->wd->show_item)
4775      {
4776         _it->wd->show_item->item->showme = EINA_FALSE;
4777         _it->wd->show_item = NULL;
4778      }
4779    evas_object_geometry_get(_it->wd->pan_smart, NULL, NULL, &ow, &oh);
4780    if (_it->item->group_item) gith = _it->item->group_item->item->h;
4781    elm_smart_scroller_child_region_show(_it->wd->scr,
4782                                         _it->x + _it->item->block->x,
4783                                         _it->y + _it->item->block->y - gith,
4784                                         _it->item->block->w, oh);
4785 }
4786
4787 EAPI void
4788 elm_genlist_item_top_bring_in(Elm_Object_Item *it)
4789 {
4790    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
4791    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
4792    Evas_Coord ow, oh;
4793    Evas_Coord gith = 0;
4794
4795    if (_it->generation < _it->wd->generation) return;
4796    if ((_it->item->queued) || (!_it->item->mincalcd))
4797      {
4798         _it->wd->show_item = _it;
4799         _it->wd->bring_in = EINA_TRUE;
4800         _it->wd->scrollto_type = ELM_GENLIST_ITEM_SCROLLTO_TOP;
4801         _it->item->showme = EINA_TRUE;
4802         return;
4803      }
4804    if (_it->wd->show_item)
4805      {
4806         _it->wd->show_item->item->showme = EINA_FALSE;
4807         _it->wd->show_item = NULL;
4808      }
4809    evas_object_geometry_get(_it->wd->pan_smart, NULL, NULL, &ow, &oh);
4810    if (_it->item->group_item) gith = _it->item->group_item->item->h;
4811    elm_smart_scroller_region_bring_in(_it->wd->scr,
4812                                       _it->x + _it->item->block->x,
4813                                       _it->y + _it->item->block->y - gith,
4814                                       _it->item->block->w, oh);
4815 }
4816
4817 EAPI void
4818 elm_genlist_item_middle_show(Elm_Object_Item *it)
4819 {
4820    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
4821    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
4822    Evas_Coord ow, oh;
4823
4824    if (_it->generation < _it->wd->generation) return;
4825    if ((_it->item->queued) || (!_it->item->mincalcd))
4826      {
4827         _it->wd->show_item = _it;
4828         _it->wd->bring_in = EINA_FALSE;
4829         _it->wd->scrollto_type = ELM_GENLIST_ITEM_SCROLLTO_MIDDLE;
4830         _it->item->showme = EINA_TRUE;
4831         return;
4832      }
4833    if (_it->wd->show_item)
4834      {
4835         _it->wd->show_item->item->showme = EINA_FALSE;
4836         _it->wd->show_item = NULL;
4837      }
4838    evas_object_geometry_get(_it->wd->pan_smart, NULL, NULL, &ow, &oh);
4839    elm_smart_scroller_child_region_show(_it->wd->scr,
4840                                         _it->x + _it->item->block->x,
4841                                         _it->y + _it->item->block->y - oh / 2 +
4842                                         _it->item->h / 2, _it->item->block->w,
4843                                         oh);
4844 }
4845
4846 EAPI void
4847 elm_genlist_item_middle_bring_in(Elm_Object_Item *it)
4848 {
4849    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
4850    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
4851    Evas_Coord ow, oh;
4852
4853    if (_it->generation < _it->wd->generation) return;
4854    if ((_it->item->queued) || (!_it->item->mincalcd))
4855      {
4856         _it->wd->show_item = _it;
4857         _it->wd->bring_in = EINA_TRUE;
4858         _it->wd->scrollto_type = ELM_GENLIST_ITEM_SCROLLTO_MIDDLE;
4859         _it->item->showme = EINA_TRUE;
4860         return;
4861      }
4862    if (_it->wd->show_item)
4863      {
4864         _it->wd->show_item->item->showme = EINA_FALSE;
4865         _it->wd->show_item = NULL;
4866      }
4867    evas_object_geometry_get(_it->wd->pan_smart, NULL, NULL, &ow, &oh);
4868    elm_smart_scroller_region_bring_in(_it->wd->scr,
4869                                       _it->x + _it->item->block->x,
4870                                       _it->y + _it->item->block->y - oh / 2 +
4871                                       _it->item->h / 2, _it->item->block->w,
4872                                       oh);
4873 }
4874
4875 EAPI void
4876 elm_genlist_item_del(Elm_Object_Item *it)
4877 {
4878    elm_object_item_del(it);
4879 }
4880
4881 EAPI void
4882 elm_genlist_item_data_set(Elm_Object_Item  *it,
4883                           const void       *data)
4884 {
4885    elm_object_item_data_set(it, (void *) data);
4886 }
4887
4888 EAPI void *
4889 elm_genlist_item_data_get(const Elm_Object_Item *it)
4890 {
4891    return elm_object_item_data_get(it);
4892 }
4893
4894 EAPI void
4895 elm_genlist_item_icons_orphan(Elm_Object_Item *it)
4896 {
4897    elm_genlist_item_contents_orphan(it);
4898 }
4899
4900 EAPI void
4901 elm_genlist_item_contents_orphan(Elm_Object_Item *it)
4902 {
4903    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
4904
4905    Evas_Object *content;
4906    EINA_LIST_FREE(((Elm_Gen_Item *) it)->content_objs, content)
4907      {
4908         elm_widget_sub_object_del(WIDGET(it), content);
4909         evas_object_smart_member_del(content);
4910         evas_object_hide(content);
4911      }
4912 }
4913
4914 EINA_DEPRECATED EAPI const Evas_Object *
4915 elm_genlist_item_object_get(const Elm_Object_Item *it)
4916 {
4917    ELM_OBJ_ITEM_CHECK_OR_RETURN(it, NULL);
4918    return VIEW(it);
4919 }
4920
4921 EAPI void
4922 elm_genlist_item_update(Elm_Object_Item *it)
4923 {
4924    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
4925    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
4926
4927    if (!_it->item->block) return;
4928    if (_it->generation < _it->wd->generation) return;
4929    _it->item->mincalcd = EINA_FALSE;
4930    _it->item->updateme = EINA_TRUE;
4931    _it->item->block->updateme = EINA_TRUE;
4932    if (_it->wd->update_job) ecore_job_del(_it->wd->update_job);
4933    _it->wd->update_job = ecore_job_add(_update_job, _it->wd);
4934 }
4935
4936 EAPI void
4937 elm_genlist_item_fields_update(Elm_Object_Item *it,
4938                                const char *parts,
4939                                Elm_Genlist_Item_Field_Flags itf)
4940 {
4941    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
4942    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
4943
4944    if (!_it->item->block) return;
4945    if (_it->generation < _it->wd->generation) return;
4946
4947    if ((!itf) || (itf & ELM_GENLIST_ITEM_FIELD_LABEL))
4948      _item_text_realize(_it, VIEW(_it), &_it->texts, parts);
4949    if ((!itf) || (itf & ELM_GENLIST_ITEM_FIELD_CONTENT))
4950      {
4951         _it->content_objs = _item_content_unrealize(_it, VIEW(_it),
4952                                                    &_it->contents, parts);
4953         _it->content_objs = _item_content_realize(_it, VIEW(_it),
4954                                                  &_it->contents, parts);
4955      }
4956    if ((!itf) || (itf & ELM_GENLIST_ITEM_FIELD_STATE))
4957      _item_state_realize(_it, VIEW(_it), &_it->states, parts);
4958 }
4959
4960 EAPI void
4961 elm_genlist_item_item_class_update(Elm_Object_Item *it,
4962                                    const Elm_Genlist_Item_Class *itc)
4963 {
4964    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
4965    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
4966
4967    if (!_it->item->block) return;
4968    EINA_SAFETY_ON_NULL_RETURN(itc);
4969    if (_it->generation < _it->wd->generation) return;
4970    _it->itc = itc;
4971    _it->item->nocache = EINA_TRUE;
4972    elm_genlist_item_update(it);
4973 }
4974
4975 EAPI const Elm_Genlist_Item_Class *
4976 elm_genlist_item_item_class_get(const Elm_Object_Item *it)
4977 {
4978    ELM_OBJ_ITEM_CHECK_OR_RETURN(it, NULL);
4979    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
4980    if (_it->generation < _it->wd->generation) return NULL;
4981    return _it->itc;
4982 }
4983
4984 static Evas_Object *
4985 _elm_genlist_item_label_create(void        *data,
4986                                Evas_Object *obj __UNUSED__,
4987                                Evas_Object *tooltip,
4988                                void        *it __UNUSED__)
4989 {
4990    Evas_Object *label = elm_label_add(tooltip);
4991    if (!label)
4992      return NULL;
4993    elm_object_style_set(label, "tooltip");
4994    elm_object_text_set(label, data);
4995    return label;
4996 }
4997
4998 static void
4999 _elm_genlist_item_label_del_cb(void        *data,
5000                                Evas_Object *obj __UNUSED__,
5001                                void        *event_info __UNUSED__)
5002 {
5003    eina_stringshare_del(data);
5004 }
5005
5006 EAPI void
5007 elm_genlist_item_tooltip_text_set(Elm_Object_Item *it,
5008                                   const char      *text)
5009 {
5010    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
5011    text = eina_stringshare_add(text);
5012    elm_genlist_item_tooltip_content_cb_set(it, _elm_genlist_item_label_create,
5013                                            text,
5014                                            _elm_genlist_item_label_del_cb);
5015 }
5016
5017 EAPI void
5018 elm_genlist_item_tooltip_content_cb_set(Elm_Object_Item           *it,
5019                                         Elm_Tooltip_Item_Content_Cb func,
5020                                         const void                 *data,
5021                                         Evas_Smart_Cb               del_cb)
5022 {
5023    ELM_OBJ_ITEM_CHECK_OR_GOTO(it, error);
5024    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
5025
5026    if ((_it->tooltip.content_cb == func) && (_it->tooltip.data == data))
5027      return;
5028
5029    if (_it->tooltip.del_cb)
5030      _it->tooltip.del_cb((void *) _it->tooltip.data, WIDGET(it), it);
5031
5032    _it->tooltip.content_cb = func;
5033    _it->tooltip.data = data;
5034    _it->tooltip.del_cb = del_cb;
5035
5036    if (VIEW(_it))
5037      {
5038         elm_widget_item_tooltip_content_cb_set(_it,
5039                                                _it->tooltip.content_cb,
5040                                                _it->tooltip.data, NULL);
5041         elm_widget_item_tooltip_style_set(_it, _it->tooltip.style);
5042         elm_widget_item_tooltip_window_mode_set(_it, _it->tooltip.free_size);
5043      }
5044
5045    return;
5046
5047 error:
5048    if (del_cb) del_cb((void *)data, NULL, NULL);
5049 }
5050
5051 EAPI void
5052 elm_genlist_item_tooltip_unset(Elm_Object_Item *it)
5053 {
5054    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
5055    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
5056
5057    if ((VIEW(_it)) && (_it->tooltip.content_cb))
5058      elm_widget_item_tooltip_unset(_it);
5059
5060    if (_it->tooltip.del_cb)
5061      _it->tooltip.del_cb((void *) _it->tooltip.data, WIDGET(_it), _it);
5062    _it->tooltip.del_cb = NULL;
5063    _it->tooltip.content_cb = NULL;
5064    _it->tooltip.data = NULL;
5065    _it->tooltip.free_size = EINA_FALSE;
5066    if (_it->tooltip.style)
5067      elm_genlist_item_tooltip_style_set(it, NULL);
5068 }
5069
5070 EAPI void
5071 elm_genlist_item_tooltip_style_set(Elm_Object_Item  *it,
5072                                    const char       *style)
5073 {
5074    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
5075    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
5076
5077    eina_stringshare_replace(&_it->tooltip.style, style);
5078    if (VIEW(_it)) elm_widget_item_tooltip_style_set(_it, style);
5079 }
5080
5081 EAPI const char *
5082 elm_genlist_item_tooltip_style_get(const Elm_Object_Item *it)
5083 {
5084    return elm_object_item_tooltip_style_get(it);
5085 }
5086
5087 EAPI Eina_Bool
5088 elm_genlist_item_tooltip_window_mode_set(Elm_Object_Item *it,
5089                                          Eina_Bool disable)
5090 {
5091    ELM_OBJ_ITEM_CHECK_OR_RETURN(it, EINA_FALSE);
5092    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
5093
5094    _it->tooltip.free_size = disable;
5095    if (VIEW(_it)) return elm_widget_item_tooltip_window_mode_set(_it, disable);
5096    return EINA_TRUE;
5097 }
5098
5099 EAPI Eina_Bool
5100 elm_genlist_item_tooltip_window_mode_get(const Elm_Object_Item *it)
5101 {
5102    return elm_object_tooltip_window_mode_get(VIEW(it));
5103 }
5104
5105 EAPI void
5106 elm_genlist_item_cursor_set(Elm_Object_Item  *it,
5107                             const char       *cursor)
5108 {
5109    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
5110    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
5111    eina_stringshare_replace(&_it->mouse_cursor, cursor);
5112    if (VIEW(_it)) elm_widget_item_cursor_set(_it, cursor);
5113 }
5114
5115 EAPI const char *
5116 elm_genlist_item_cursor_get(const Elm_Object_Item *it)
5117 {
5118    return elm_widget_item_cursor_get(it);
5119 }
5120
5121 EAPI void
5122 elm_genlist_item_cursor_unset(Elm_Object_Item *it)
5123 {
5124    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
5125    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
5126
5127    if (!_it->mouse_cursor) return;
5128
5129    if (VIEW(_it)) elm_widget_item_cursor_unset(_it);
5130
5131    eina_stringshare_del(_it->mouse_cursor);
5132    _it->mouse_cursor = NULL;
5133 }
5134
5135 EAPI void
5136 elm_genlist_item_cursor_style_set(Elm_Object_Item  *it,
5137                                   const char       *style)
5138 {
5139    elm_widget_item_cursor_style_set(it, style);
5140 }
5141
5142 EAPI const char *
5143 elm_genlist_item_cursor_style_get(const Elm_Object_Item *it)
5144 {
5145    return elm_widget_item_cursor_style_get(it);
5146 }
5147
5148 EAPI void
5149 elm_genlist_item_cursor_engine_only_set(Elm_Object_Item *it,
5150                                         Eina_Bool        engine_only)
5151 {
5152    elm_widget_item_cursor_engine_only_set(it, engine_only);
5153 }
5154
5155 EAPI Eina_Bool
5156 elm_genlist_item_cursor_engine_only_get(const Elm_Object_Item *it)
5157 {
5158    return elm_widget_item_cursor_engine_only_get(it);
5159 }
5160
5161 EAPI int
5162 elm_genlist_item_index_get(const Elm_Object_Item *it)
5163 {
5164    ELM_OBJ_ITEM_CHECK_OR_RETURN(it, -1);
5165    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
5166
5167    if (_it->item->block)
5168      return _it->position + _it->item->block->position;
5169    return -1;
5170 }
5171
5172 EAPI void
5173 elm_genlist_mode_set(Evas_Object  *obj,
5174                      Elm_List_Mode mode)
5175 {
5176    ELM_CHECK_WIDTYPE(obj, widtype);
5177    Widget_Data *wd = elm_widget_data_get(obj);
5178    if (!wd) return;
5179    if (wd->mode == mode) return;
5180    wd->mode = mode;
5181    _sizing_eval(obj);
5182 }
5183
5184 EAPI void
5185 elm_genlist_horizontal_set(Evas_Object  *obj,
5186                            Elm_List_Mode mode)
5187 {
5188    elm_genlist_mode_set(obj, mode);
5189 }
5190
5191 EAPI void
5192 elm_genlist_horizontal_mode_set(Evas_Object  *obj,
5193                                 Elm_List_Mode mode)
5194 {
5195    elm_genlist_mode_set(obj, mode);
5196 }
5197
5198 EAPI Elm_List_Mode
5199 elm_genlist_mode_get(const Evas_Object *obj)
5200 {
5201    ELM_CHECK_WIDTYPE(obj, widtype) ELM_LIST_LAST;
5202    Widget_Data *wd = elm_widget_data_get(obj);
5203    if (!wd) return ELM_LIST_LAST;
5204    return wd->mode;
5205 }
5206
5207 EINA_DEPRECATED EAPI Elm_List_Mode
5208 elm_genlist_horizontal_get(const Evas_Object *obj)
5209 {
5210    return elm_genlist_mode_get(obj);
5211 }
5212
5213 EINA_DEPRECATED EAPI Elm_List_Mode
5214 elm_genlist_horizontal_mode_get(const Evas_Object *obj)
5215 {
5216    return elm_genlist_mode_get(obj);
5217 }
5218
5219 EAPI void
5220 elm_genlist_always_select_mode_set(Evas_Object *obj,
5221                                    Eina_Bool    always_select)
5222 {
5223    ELM_CHECK_WIDTYPE(obj, widtype);
5224    Widget_Data *wd = elm_widget_data_get(obj);
5225    if (!wd) return;
5226    wd->always_select = !!always_select;
5227 }
5228
5229 EAPI Eina_Bool
5230 elm_genlist_always_select_mode_get(const Evas_Object *obj)
5231 {
5232    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
5233    Widget_Data *wd = elm_widget_data_get(obj);
5234    if (!wd) return EINA_FALSE;
5235    return wd->always_select;
5236 }
5237
5238 EAPI void
5239 elm_genlist_no_select_mode_set(Evas_Object *obj,
5240                                Eina_Bool    no_select)
5241 {
5242    ELM_CHECK_WIDTYPE(obj, widtype);
5243    Widget_Data *wd = elm_widget_data_get(obj);
5244    if (!wd) return;
5245    wd->no_select = !!no_select;
5246 }
5247
5248 EAPI Eina_Bool
5249 elm_genlist_no_select_mode_get(const Evas_Object *obj)
5250 {
5251    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
5252    Widget_Data *wd = elm_widget_data_get(obj);
5253    if (!wd) return EINA_FALSE;
5254    return wd->no_select;
5255 }
5256
5257 EAPI void
5258 elm_genlist_compress_mode_set(Evas_Object *obj,
5259                               Eina_Bool    compress)
5260 {
5261    ELM_CHECK_WIDTYPE(obj, widtype);
5262    Widget_Data *wd = elm_widget_data_get(obj);
5263    if (!wd) return;
5264    wd->compress = !!compress;
5265    if (!compress) elm_genlist_homogeneous_set(obj, EINA_FALSE);
5266 }
5267
5268 EAPI Eina_Bool
5269 elm_genlist_compress_mode_get(const Evas_Object *obj)
5270 {
5271    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
5272    Widget_Data *wd = elm_widget_data_get(obj);
5273    if (!wd) return EINA_FALSE;
5274    return wd->compress;
5275 }
5276
5277 EAPI void
5278 elm_genlist_height_for_width_mode_set(Evas_Object *obj,
5279                                       Eina_Bool    height_for_width)
5280 {
5281    ELM_CHECK_WIDTYPE(obj, widtype);
5282    Widget_Data *wd = elm_widget_data_get(obj);
5283    if (!wd) return;
5284    wd->height_for_width = !!height_for_width;
5285    if (wd->height_for_width)
5286      {
5287         elm_genlist_homogeneous_set(obj, EINA_FALSE);
5288         elm_genlist_compress_mode_set(obj, EINA_TRUE);
5289      }
5290 }
5291
5292 EAPI Eina_Bool
5293 elm_genlist_height_for_width_mode_get(const Evas_Object *obj)
5294 {
5295    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
5296    Widget_Data *wd = elm_widget_data_get(obj);
5297    if (!wd) return EINA_FALSE;
5298    return wd->height_for_width;
5299 }
5300
5301 EAPI void
5302 elm_genlist_bounce_set(Evas_Object *obj,
5303                        Eina_Bool    h_bounce,
5304                        Eina_Bool    v_bounce)
5305 {
5306    ELM_CHECK_WIDTYPE(obj, widtype);
5307    Widget_Data *wd = elm_widget_data_get(obj);
5308    if (!wd) return;
5309    wd->h_bounce = !!h_bounce;
5310    wd->v_bounce = !!v_bounce;
5311    elm_smart_scroller_bounce_allow_set(wd->scr, wd->h_bounce, wd->v_bounce);
5312 }
5313
5314 EAPI void
5315 elm_genlist_bounce_get(const Evas_Object *obj,
5316                        Eina_Bool         *h_bounce,
5317                        Eina_Bool         *v_bounce)
5318 {
5319    ELM_CHECK_WIDTYPE(obj, widtype);
5320    Widget_Data *wd = elm_widget_data_get(obj);
5321    if (!wd) return;
5322    if (h_bounce) *h_bounce = wd->h_bounce;
5323    if (v_bounce) *v_bounce = wd->v_bounce;
5324 }
5325
5326 EAPI void
5327 elm_genlist_homogeneous_set(Evas_Object *obj,
5328                             Eina_Bool    homogeneous)
5329 {
5330    ELM_CHECK_WIDTYPE(obj, widtype);
5331    Widget_Data *wd = elm_widget_data_get(obj);
5332    if (!wd) return;
5333    if (homogeneous) elm_genlist_compress_mode_set(obj, EINA_TRUE);
5334    wd->homogeneous = !!homogeneous;
5335 }
5336
5337 EAPI Eina_Bool
5338 elm_genlist_homogeneous_get(const Evas_Object *obj)
5339 {
5340    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
5341    Widget_Data *wd = elm_widget_data_get(obj);
5342    if (!wd) return EINA_FALSE;
5343    return wd->homogeneous;
5344 }
5345
5346 EAPI void
5347 elm_genlist_block_count_set(Evas_Object *obj,
5348                             int          count)
5349 {
5350    ELM_CHECK_WIDTYPE(obj, widtype);
5351    Widget_Data *wd = elm_widget_data_get(obj);
5352    if (!wd) return;
5353    wd->max_items_per_block = count;
5354    wd->item_cache_max = wd->max_items_per_block * 2;
5355    _item_cache_clean(wd);
5356 }
5357
5358 EAPI int
5359 elm_genlist_block_count_get(const Evas_Object *obj)
5360 {
5361    ELM_CHECK_WIDTYPE(obj, widtype) 0;
5362    Widget_Data *wd = elm_widget_data_get(obj);
5363    if (!wd) return 0;
5364    return wd->max_items_per_block;
5365 }
5366
5367 EAPI void
5368 elm_genlist_longpress_timeout_set(Evas_Object *obj,
5369                                   double       timeout)
5370 {
5371    ELM_CHECK_WIDTYPE(obj, widtype);
5372    Widget_Data *wd = elm_widget_data_get(obj);
5373    if (!wd) return;
5374    wd->longpress_timeout = timeout;
5375 }
5376
5377 EAPI double
5378 elm_genlist_longpress_timeout_get(const Evas_Object *obj)
5379 {
5380    ELM_CHECK_WIDTYPE(obj, widtype) 0;
5381    Widget_Data *wd = elm_widget_data_get(obj);
5382    if (!wd) return 0;
5383    return wd->longpress_timeout;
5384 }
5385
5386 EAPI void
5387 elm_genlist_scroller_policy_set(Evas_Object        *obj,
5388                                 Elm_Scroller_Policy policy_h,
5389                                 Elm_Scroller_Policy policy_v)
5390 {
5391    ELM_CHECK_WIDTYPE(obj, widtype);
5392    Widget_Data *wd = elm_widget_data_get(obj);
5393    if ((!wd) || (!wd->scr)) return;
5394    if ((policy_h >= ELM_SCROLLER_POLICY_LAST) ||
5395        (policy_v >= ELM_SCROLLER_POLICY_LAST))
5396      return;
5397    elm_smart_scroller_policy_set(wd->scr, policy_h, policy_v);
5398 }
5399
5400 EAPI void
5401 elm_genlist_scroller_policy_get(const Evas_Object   *obj,
5402                                 Elm_Scroller_Policy *policy_h,
5403                                 Elm_Scroller_Policy *policy_v)
5404 {
5405    ELM_CHECK_WIDTYPE(obj, widtype);
5406    Widget_Data *wd = elm_widget_data_get(obj);
5407    Elm_Smart_Scroller_Policy s_policy_h, s_policy_v;
5408    if ((!wd) || (!wd->scr)) return;
5409    elm_smart_scroller_policy_get(wd->scr, &s_policy_h, &s_policy_v);
5410    if (policy_h) *policy_h = (Elm_Scroller_Policy)s_policy_h;
5411    if (policy_v) *policy_v = (Elm_Scroller_Policy)s_policy_v;
5412 }
5413
5414 EAPI void
5415 elm_genlist_realized_items_update(Evas_Object *obj)
5416 {
5417    ELM_CHECK_WIDTYPE(obj, widtype);
5418
5419    Eina_List *list, *l;
5420    Elm_Object_Item *it;
5421
5422    list = elm_genlist_realized_items_get(obj);
5423    EINA_LIST_FOREACH(list, l, it)
5424      elm_genlist_item_update(it);
5425 }
5426
5427 EAPI void
5428 elm_genlist_item_mode_set(Elm_Object_Item  *it,
5429                           const char       *mode_type,
5430                           Eina_Bool         mode_set)
5431 {
5432    ELM_OBJ_ITEM_CHECK_OR_RETURN(it);
5433    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
5434
5435    Widget_Data *wd = _it->wd;
5436    Eina_List *l;
5437    Elm_Object_Item *it2;
5438
5439    if (!wd) return;
5440    if (!mode_type) return;
5441    if ((_it->generation < _it->wd->generation) ||
5442        elm_widget_item_disabled_get(_it)) return;
5443    if (wd->edit_mode) return;
5444
5445    if ((wd->mode_item == _it) &&
5446        (!strcmp(mode_type, wd->mode_type)) &&
5447        (mode_set))
5448       return;
5449    if (!_it->itc->mode_item_style) return;
5450    _it->mode_set = mode_set;
5451
5452    if (wd->multi)
5453      {
5454         EINA_LIST_FOREACH(wd->selected, l, it2)
5455           if (((Elm_Gen_Item *) it2)->realized)
5456             elm_genlist_item_selected_set(it2, EINA_FALSE);
5457      }
5458    else
5459      {
5460         it2 = elm_genlist_selected_item_get(wd->obj);
5461         if ((it2) && (((Elm_Gen_Item *) it2)->realized))
5462           elm_genlist_item_selected_set(it2, EINA_FALSE);
5463      }
5464
5465    if (((wd->mode_type) && (strcmp(mode_type, wd->mode_type))) ||
5466        (mode_set) ||
5467        ((_it == wd->mode_item) && (!mode_set)))
5468      _item_mode_unset(wd);
5469
5470    eina_stringshare_replace(&wd->mode_type, mode_type);
5471    if (mode_set) _item_mode_set(_it);
5472 }
5473
5474 EAPI const char *
5475 elm_genlist_mode_item_style_get(const Evas_Object *obj)
5476 {
5477    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
5478    Widget_Data *wd = elm_widget_data_get(obj);
5479    if (!wd) return NULL;
5480    return wd->mode_item->itc->mode_item_style;
5481 }
5482
5483 EAPI void
5484 elm_genlist_mode_item_style_set(Evas_Object *obj, const char *style)
5485 {
5486    ELM_CHECK_WIDTYPE(obj, widtype);
5487    Widget_Data *wd = elm_widget_data_get(obj);
5488    if (!wd) return;
5489    if ((style == wd->mode_item->itc->mode_item_style) ||
5490        (style && wd->mode_item->itc->mode_item_style &&
5491        (!strcmp(style, wd->mode_item->itc->mode_item_style))))
5492      return;
5493    eina_stringshare_replace((const char**)&wd->mode_item->itc->mode_item_style, style);
5494    elm_genlist_realized_items_update(obj);
5495 }
5496
5497 EAPI const char *
5498 elm_genlist_mode_type_get(const Evas_Object *obj)
5499 {
5500    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
5501    Widget_Data *wd = elm_widget_data_get(obj);
5502    if (!wd) return NULL;
5503    return wd->mode_type;
5504 }
5505
5506 EAPI const Elm_Object_Item *
5507 elm_genlist_mode_item_get(const Evas_Object *obj)
5508 {
5509    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
5510    Widget_Data *wd = elm_widget_data_get(obj);
5511    if (!wd) return NULL;
5512    return (Elm_Object_Item *) wd->mode_item;
5513 }
5514
5515 EAPI Eina_Bool
5516 elm_genlist_edit_mode_get(const Evas_Object *obj)
5517 {
5518    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
5519    Widget_Data *wd = elm_widget_data_get(obj);
5520    if (!wd) return EINA_FALSE;
5521
5522    return wd->edit_mode;
5523 }
5524
5525 EAPI void
5526 elm_genlist_edit_mode_set(Evas_Object *obj, Eina_Bool edit_mode)
5527 {
5528    ELM_CHECK_WIDTYPE(obj, widtype);
5529    Eina_List *list, *l;
5530    Elm_Gen_Item *it;
5531
5532    Widget_Data *wd = elm_widget_data_get(obj);
5533    if (!wd) return;
5534    edit_mode = !!edit_mode;
5535    if (wd->edit_mode == edit_mode) return;
5536
5537    list = elm_genlist_realized_items_get(obj);
5538    if (!wd->edit_mode)
5539      {
5540         EINA_LIST_FOREACH(list, l, it)
5541           {
5542              if (it->item->flags != ELM_GENLIST_ITEM_GROUP)
5543                _edit_mode_item_unrealize(it);
5544           }
5545         _item_cache_zero(wd);
5546      }
5547    else
5548      {
5549         EINA_LIST_FOREACH(list, l, it)
5550           {
5551              if (it->item->flags != ELM_GENLIST_ITEM_GROUP)
5552                {
5553                   if (it->selected) _item_unselect(it);
5554                   if (it->itc->edit_item_style)
5555                      _edit_mode_item_realize(it, EINA_TRUE);
5556                }
5557           }
5558      }
5559    if (wd->calc_job) ecore_job_del(wd->calc_job);
5560    wd->calc_job = ecore_job_add(_calc_job, wd);
5561 }
5562
5563 EAPI void
5564 elm_genlist_reorder_mode_set(Evas_Object *obj,
5565                              Eina_Bool    reorder_mode)
5566 {
5567    ELM_CHECK_WIDTYPE(obj, widtype);
5568    Widget_Data *wd = elm_widget_data_get(obj);
5569    if (!wd) return;
5570    wd->reorder_mode = !!reorder_mode;
5571 }
5572
5573 EAPI Eina_Bool
5574 elm_genlist_reorder_mode_get(const Evas_Object *obj)
5575 {
5576    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
5577    Widget_Data *wd = elm_widget_data_get(obj);
5578    if (!wd) return EINA_FALSE;
5579    return wd->reorder_mode;
5580 }
5581
5582 EAPI Elm_Genlist_Item_Flags
5583 elm_genlist_item_flags_get(const Elm_Object_Item *it)
5584 {
5585    ELM_OBJ_ITEM_CHECK_OR_RETURN(it, ELM_GENLIST_ITEM_MAX);
5586    Elm_Gen_Item *_it = (Elm_Gen_Item *) it;
5587    return _it->item->flags;
5588 }
5589
5590 EAPI Elm_Genlist_Item_Class *
5591 elm_genlist_item_class_new(void)
5592 {
5593    Elm_Genlist_Item_Class *itc;
5594
5595    itc = calloc(1, sizeof(Elm_Genlist_Item_Class));
5596    if (!itc)
5597      return NULL;
5598    itc->version = ELM_GENLIST_ITEM_CLASS_VERSION;
5599    itc->refcount = 1;
5600    itc->delete_me = EINA_FALSE;
5601
5602    return itc;
5603 }
5604
5605 //XXX: notify the class version if it is mismatched
5606 EAPI void
5607 elm_genlist_item_class_free(Elm_Genlist_Item_Class *itc)
5608 {
5609    if (itc && (itc->version == ELM_GENLIST_ITEM_CLASS_VERSION))
5610      {
5611         if (!itc->delete_me) itc->delete_me = EINA_TRUE;
5612         if (itc->refcount > 0) elm_genlist_item_class_unref(itc);
5613         else
5614           {
5615              itc->version = 0;
5616              free(itc);
5617           }
5618      }
5619 }
5620
5621 //XXX: notify the class version if it is mismatched
5622 EAPI void
5623 elm_genlist_item_class_ref(Elm_Genlist_Item_Class *itc)
5624 {
5625    if (itc && (itc->version == ELM_GENLIST_ITEM_CLASS_VERSION))
5626      {
5627         itc->refcount++;
5628         if (itc->refcount == 0) itc->refcount--;
5629      }
5630 }
5631
5632 //XXX: notify the class version if it is mismatched
5633 EAPI void
5634 elm_genlist_item_class_unref(Elm_Genlist_Item_Class *itc)
5635 {
5636    if (itc && (itc->version == ELM_GENLIST_ITEM_CLASS_VERSION))
5637      {
5638         if (itc->refcount > 0) itc->refcount--;
5639         if (itc->delete_me && (!itc->refcount))
5640           elm_genlist_item_class_free(itc);
5641      }
5642 }
5643
5644 /* for gengrid as of now */
5645 void
5646 _elm_genlist_page_relative_set(Evas_Object *obj,
5647                                double       h_pagerel,
5648                                double       v_pagerel)
5649 {
5650    Evas_Coord pagesize_h;
5651    Evas_Coord pagesize_v;
5652
5653    ELM_CHECK_WIDTYPE(obj, widtype);
5654    Widget_Data *wd = elm_widget_data_get(obj);
5655    if (!wd) return;
5656
5657    elm_smart_scroller_paging_get(wd->scr, NULL, NULL, &pagesize_h, &pagesize_v);
5658    elm_smart_scroller_paging_set(wd->scr, h_pagerel, v_pagerel, pagesize_h,
5659                                  pagesize_v);
5660 }
5661
5662 /* for gengrid as of now */
5663 void
5664 _elm_genlist_page_relative_get(const Evas_Object *obj,
5665                                double            *h_pagerel,
5666                                double            *v_pagerel)
5667 {
5668    ELM_CHECK_WIDTYPE(obj, widtype);
5669    Widget_Data *wd = elm_widget_data_get(obj);
5670    if (!wd) return;
5671
5672    elm_smart_scroller_paging_get(wd->scr, h_pagerel, v_pagerel, NULL, NULL);
5673 }
5674
5675 /* for gengrid as of now */
5676 void
5677 _elm_genlist_page_size_set(Evas_Object *obj,
5678                            Evas_Coord   h_pagesize,
5679                            Evas_Coord   v_pagesize)
5680 {
5681    double pagerel_h;
5682    double pagerel_v;
5683
5684    ELM_CHECK_WIDTYPE(obj, widtype);
5685    Widget_Data *wd = elm_widget_data_get(obj);
5686    if (!wd) return;
5687    elm_smart_scroller_paging_get(wd->scr, &pagerel_h, &pagerel_v, NULL, NULL);
5688    elm_smart_scroller_paging_set(wd->scr, pagerel_h, pagerel_v, h_pagesize,
5689                                  v_pagesize);
5690 }
5691
5692 /* for gengrid as of now */
5693 void
5694 _elm_genlist_current_page_get(const Evas_Object *obj,
5695                               int               *h_pagenumber,
5696                               int               *v_pagenumber)
5697 {
5698    ELM_CHECK_WIDTYPE(obj, widtype);
5699    Widget_Data *wd = elm_widget_data_get(obj);
5700    if (!wd) return;
5701    elm_smart_scroller_current_page_get(wd->scr, h_pagenumber, v_pagenumber);
5702 }
5703
5704 /* for gengrid as of now */
5705 void
5706 _elm_genlist_last_page_get(const Evas_Object *obj,
5707                            int               *h_pagenumber,
5708                            int               *v_pagenumber)
5709 {
5710    ELM_CHECK_WIDTYPE(obj, widtype);
5711    Widget_Data *wd = elm_widget_data_get(obj);
5712    if (!wd) return;
5713    elm_smart_scroller_last_page_get(wd->scr, h_pagenumber, v_pagenumber);
5714 }
5715
5716 /* for gengrid as of now */
5717 void
5718 _elm_genlist_page_show(const Evas_Object *obj,
5719                        int                h_pagenumber,
5720                        int                v_pagenumber)
5721 {
5722    ELM_CHECK_WIDTYPE(obj, widtype);
5723    Widget_Data *wd = elm_widget_data_get(obj);
5724    if (!wd) return;
5725    elm_smart_scroller_page_show(wd->scr, h_pagenumber, v_pagenumber);
5726 }
5727
5728 /* for gengrid as of now */
5729 void
5730 _elm_genlist_page_bring_in(const Evas_Object *obj,
5731                            int                h_pagenumber,
5732                            int                v_pagenumber)
5733 {
5734    ELM_CHECK_WIDTYPE(obj, widtype);
5735    Widget_Data *wd = elm_widget_data_get(obj);
5736    if (!wd) return;
5737    elm_smart_scroller_page_bring_in(wd->scr, h_pagenumber, v_pagenumber);
5738 }
5739
5740 void
5741 _elm_genlist_item_unrealize(Elm_Gen_Item *it,
5742                             Eina_Bool     calc)
5743 {
5744    Evas_Object *content;
5745
5746    if (!it->realized) return;
5747    if (it->wd->reorder_it == it) return;
5748
5749    evas_event_freeze(evas_object_evas_get(WIDGET(it)));
5750    if (!calc)
5751      evas_object_smart_callback_call(WIDGET(it), SIG_UNREALIZED, it);
5752    if (it->long_timer)
5753      {
5754         ecore_timer_del(it->long_timer);
5755         it->long_timer = NULL;
5756      }
5757
5758    elm_widget_stringlist_free(it->texts);
5759    it->texts = NULL;
5760    elm_widget_stringlist_free(it->contents);
5761    it->contents = NULL;
5762    elm_widget_stringlist_free(it->states);
5763    it->states = NULL;
5764
5765    EINA_LIST_FREE(it->content_objs, content)
5766      evas_object_del(content);
5767
5768    it->unrealize_cb(it);
5769
5770    it->realized = EINA_FALSE;
5771    it->want_unrealize = EINA_FALSE;
5772    evas_event_thaw(evas_object_evas_get(WIDGET(it)));
5773    evas_event_thaw_eval(evas_object_evas_get(WIDGET(it)));
5774 }
5775
5776 void
5777 _elm_genlist_item_del_notserious(Elm_Gen_Item *it)
5778 {
5779    elm_widget_item_pre_notify_del(it);
5780    it->generation = it->wd->generation - 1; /* This means that the item is deleted */
5781    if (it->selected) it->wd->selected = eina_list_remove(it->wd->selected, it);
5782
5783    if (it->itc->func.del)
5784      it->itc->func.del((void *)it->base.data, WIDGET(it));
5785 }
5786
5787 void
5788 _elm_genlist_item_del_serious(Elm_Gen_Item *it)
5789 {
5790    _elm_genlist_item_del_notserious(it);
5791    it->wd->items = eina_inlist_remove(it->wd->items, EINA_INLIST_GET(it));
5792    if (it->tooltip.del_cb)
5793      it->tooltip.del_cb((void *)it->tooltip.data, WIDGET(it), it);
5794    it->wd->walking -= it->walking;
5795    if (it->long_timer) ecore_timer_del(it->long_timer);
5796    if (it->group)
5797      it->wd->group_items = eina_list_remove(it->wd->group_items, it);
5798
5799    if (it->wd->state)
5800      {
5801         eina_inlist_sorted_state_free(it->wd->state);
5802         it->wd->state = NULL;
5803      }
5804    if (it->wd->calc_job) ecore_job_del(it->wd->calc_job);
5805    it->wd->calc_job = ecore_job_add(it->wd->calc_cb, it->wd);
5806    free(it->item);
5807
5808    it->item = NULL;
5809    if (it->wd->last_selected_item == (Elm_Object_Item *) it)
5810      it->wd->last_selected_item = NULL;
5811    it->wd->item_count--;
5812 }