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