src/lib/elm_genlist.c

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