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, reorder_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;
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) || ((itb->must_recalc) && (!did_must_recalc)))
2377           {
2378              if (itb->must_recalc)
2379                {
2380                   Eina_List *l;
2381                   Elm_Genlist_Item *it;
2382                   EINA_LIST_FOREACH(itb->items, l, it)
2383                     if (it->mincalcd) it->mincalcd = EINA_FALSE;
2384                   itb->changed = EINA_TRUE;
2385                   if (itb->must_recalc) did_must_recalc = EINA_TRUE;
2386                   itb->must_recalc = EINA_FALSE;
2387                }
2388              if (itb->realized) _item_block_unrealize(itb);
2389              showme = _item_block_recalc(itb, in, EINA_FALSE);
2390              chb = itb;
2391           }
2392         itb->y = y;
2393         itb->x = 0;
2394         minh += itb->minh;
2395         if (minw == -1) minw = itb->minw;
2396         else if ((!itb->must_recalc) && (minw < itb->minw))
2397           {
2398              minw = itb->minw;
2399              minw_change = EINA_TRUE;
2400           }
2401         itb->w = minw;
2402         itb->h = itb->minh;
2403         y += itb->h;
2404         in += itb->count;
2405         if ((showme) && (wd->show_item) && (!wd->show_item->queued))
2406           {
2407              wd->show_item->showme = EINA_FALSE;
2408              if (wd->bring_in)
2409                elm_smart_scroller_region_bring_in(wd->scr,
2410                                                   wd->show_item->x +
2411                                                   wd->show_item->block->x,
2412                                                   wd->show_item->y +
2413                                                   wd->show_item->block->y,
2414                                                   wd->show_item->block->w,
2415                                                   wd->show_item->h);
2416              else
2417                elm_smart_scroller_child_region_show(wd->scr,
2418                                                     wd->show_item->x +
2419                                                     wd->show_item->block->x,
2420                                                     wd->show_item->y +
2421                                                     wd->show_item->block->y,
2422                                                     wd->show_item->block->w,
2423                                                     wd->show_item->h);
2424              wd->show_item = NULL;
2425           }
2426      }
2427    if (minw_change)
2428      {
2429         EINA_INLIST_FOREACH(wd->blocks, itb)
2430           {
2431              itb->minw = minw;
2432              itb->w = itb->minw;
2433           }
2434      }
2435    if ((chb) && (EINA_INLIST_GET(chb)->next))
2436      {
2437         EINA_INLIST_FOREACH(EINA_INLIST_GET(chb)->next, itb)
2438           {
2439              if (itb->realized) _item_block_unrealize(itb);
2440           }
2441      }
2442    wd->realminw = minw;
2443    if (minw < wd->w) minw = wd->w;
2444    if ((minw != wd->minw) || (minh != wd->minh))
2445      {
2446         wd->minw = minw;
2447         wd->minh = minh;
2448         evas_object_smart_callback_call(wd->pan_smart, "changed", NULL);
2449         _sizing_eval(wd->obj);
2450         if ((wd->anchor_item) && (wd->anchor_item->block) && (!wd->auto_scroll_enabled))
2451           {
2452              Elm_Genlist_Item *it;
2453              Evas_Coord it_y;
2454
2455              it = wd->anchor_item;
2456              it_y = wd->anchor_y;
2457              elm_smart_scroller_child_pos_set(wd->scr, wd->pan_x,
2458                                               it->block->y + it->y + it_y);
2459              wd->anchor_item = it;
2460              wd->anchor_y = it_y;
2461           }
2462      }
2463    t = ecore_time_get();
2464    if (did_must_recalc)
2465      {
2466         if (!wd->must_recalc_idler)
2467           wd->must_recalc_idler = ecore_idler_add(_must_recalc_idler, wd);
2468      }
2469    wd->calc_job = NULL;
2470    evas_object_smart_changed(wd->pan_smart);
2471    evas_event_thaw(evas_object_evas_get(wd->obj));
2472    evas_event_thaw_eval(evas_object_evas_get(wd->obj));
2473 }
2474
2475 static void
2476 _update_job(void *data)
2477 {
2478    Widget_Data *wd = data;
2479    Eina_List *l2;
2480    Item_Block *itb;
2481    int num, num0;
2482    Eina_Bool position = EINA_FALSE, recalc = EINA_FALSE;
2483    if (!wd) return;
2484    wd->update_job = NULL;
2485    num = 0;
2486
2487    evas_event_freeze(evas_object_evas_get(wd->obj));
2488    EINA_INLIST_FOREACH(wd->blocks, itb)
2489      {
2490         Evas_Coord itminw, itminh;
2491         Elm_Genlist_Item *it;
2492
2493         if (!itb->updateme)
2494           {
2495              num += itb->count;
2496              if (position)
2497                _item_block_position(itb, num);
2498              continue;
2499           }
2500         num0 = num;
2501         recalc = EINA_FALSE;
2502         EINA_LIST_FOREACH(itb->items, l2, it)
2503           {
2504              if (it->updateme)
2505                {
2506                   itminw = it->minw;
2507                   itminh = it->minh;
2508
2509                   it->updateme = EINA_FALSE;
2510                   if (it->realized)
2511                     {
2512                        _item_unrealize(it, EINA_FALSE);
2513                        _item_realize(it, num, EINA_FALSE);
2514                        position = EINA_TRUE;
2515                     }
2516                   else
2517                     {
2518                        _item_realize(it, num, EINA_TRUE);
2519                        _item_unrealize(it, EINA_TRUE);
2520                     }
2521                   if ((it->minw != itminw) || (it->minh != itminh))
2522                     recalc = EINA_TRUE;
2523                }
2524              num++;
2525           }
2526         itb->updateme = EINA_FALSE;
2527         if (recalc)
2528           {
2529              position = EINA_TRUE;
2530              itb->changed = EINA_TRUE;
2531              _item_block_recalc(itb, num0, EINA_FALSE);
2532              _item_block_position(itb, num0);
2533           }
2534      }
2535    if (position)
2536      {
2537         if (wd->calc_job) ecore_job_del(wd->calc_job);
2538         wd->calc_job = ecore_job_add(_calc_job, wd);
2539      }
2540    evas_event_thaw(evas_object_evas_get(wd->obj));
2541    evas_event_thaw_eval(evas_object_evas_get(wd->obj));
2542 }
2543
2544 static void
2545 _pan_set(Evas_Object *obj,
2546          Evas_Coord   x,
2547          Evas_Coord   y)
2548 {
2549    Pan *sd = evas_object_smart_data_get(obj);
2550    Item_Block *itb;
2551
2552    if (!sd) return;
2553    //   Evas_Coord ow, oh;
2554    //   evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
2555    //   ow = sd->wd->minw - ow;
2556    //   if (ow < 0) ow = 0;
2557    //   oh = sd->wd->minh - oh;
2558    //   if (oh < 0) oh = 0;
2559    //   if (x < 0) x = 0;
2560    //   if (y < 0) y = 0;
2561    //   if (x > ow) x = ow;
2562    //   if (y > oh) y = oh;
2563    if ((x == sd->wd->pan_x) && (y == sd->wd->pan_y)) return;
2564    sd->wd->pan_x = x;
2565    sd->wd->pan_y = y;
2566
2567    EINA_INLIST_FOREACH(sd->wd->blocks, itb)
2568      {
2569         if ((itb->y + itb->h) > y)
2570           {
2571              Elm_Genlist_Item *it;
2572              Eina_List *l2;
2573
2574              EINA_LIST_FOREACH(itb->items, l2, it)
2575                {
2576                   if ((itb->y + it->y) >= y)
2577                     {
2578                        sd->wd->anchor_item = it;
2579                        sd->wd->anchor_y = -(itb->y + it->y - y);
2580                        goto done;
2581                     }
2582                }
2583           }
2584      }
2585 done:
2586    if (!sd->wd->reorder_move_animator) evas_object_smart_changed(obj);
2587 }
2588
2589 static void
2590 _pan_get(Evas_Object *obj,
2591          Evas_Coord  *x,
2592          Evas_Coord  *y)
2593 {
2594    Pan *sd = evas_object_smart_data_get(obj);
2595
2596    if (!sd) return;
2597    if (x) *x = sd->wd->pan_x;
2598    if (y) *y = sd->wd->pan_y;
2599 }
2600
2601 static void
2602 _pan_max_get(Evas_Object *obj,
2603              Evas_Coord  *x,
2604              Evas_Coord  *y)
2605 {
2606    Pan *sd = evas_object_smart_data_get(obj);
2607    Evas_Coord ow, oh;
2608
2609    if (!sd) return;
2610    evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
2611    ow = sd->wd->minw - ow;
2612    if (ow < 0) ow = 0;
2613    oh = sd->wd->minh - oh;
2614    if (oh < 0) oh = 0;
2615    if (x) *x = ow;
2616    if (y) *y = oh;
2617 }
2618
2619 static void
2620 _pan_min_get(Evas_Object *obj __UNUSED__,
2621              Evas_Coord  *x,
2622              Evas_Coord  *y)
2623 {
2624    if (x) *x = 0;
2625    if (y) *y = 0;
2626 }
2627
2628 static void
2629 _pan_child_size_get(Evas_Object *obj,
2630                     Evas_Coord  *w,
2631                     Evas_Coord  *h)
2632 {
2633    Pan *sd = evas_object_smart_data_get(obj);
2634
2635    if (!sd) return;
2636    if (w) *w = sd->wd->minw;
2637    if (h) *h = sd->wd->minh;
2638 }
2639
2640 static void
2641 _pan_add(Evas_Object *obj)
2642 {
2643    Pan *sd;
2644    Evas_Object_Smart_Clipped_Data *cd;
2645
2646    _pan_sc.add(obj);
2647    cd = evas_object_smart_data_get(obj);
2648    sd = ELM_NEW(Pan);
2649    if (!sd) return;
2650    sd->__clipped_data = *cd;
2651    free(cd);
2652    evas_object_smart_data_set(obj, sd);
2653 }
2654
2655 static void
2656 _pan_del(Evas_Object *obj)
2657 {
2658    Pan *sd = evas_object_smart_data_get(obj);
2659
2660    if (!sd) return;
2661    if (sd->resize_job)
2662      {
2663         ecore_job_del(sd->resize_job);
2664         sd->resize_job = NULL;
2665      }
2666    _pan_sc.del(obj);
2667 }
2668
2669 static void
2670 _pan_resize_job(void *data)
2671 {
2672    Pan *sd = data;
2673    if (!sd) return;
2674    _sizing_eval(sd->wd->obj);
2675    sd->resize_job = NULL;
2676 }
2677
2678 static void
2679 _pan_resize(Evas_Object *obj,
2680             Evas_Coord   w,
2681             Evas_Coord   h)
2682 {
2683    Pan *sd = evas_object_smart_data_get(obj);
2684    Evas_Coord ow, oh;
2685
2686    if (!sd) return;
2687    evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
2688    if ((ow == w) && (oh == h)) return;
2689    if ((sd->wd->height_for_width) && (ow != w))
2690      {
2691         if (sd->resize_job) ecore_job_del(sd->resize_job);
2692         sd->resize_job = ecore_job_add(_pan_resize_job, sd);
2693      }
2694    if (sd->wd->calc_job) ecore_job_del(sd->wd->calc_job);
2695    sd->wd->calc_job = ecore_job_add(_calc_job, sd->wd);
2696 }
2697
2698 static void
2699 _pan_calculate(Evas_Object *obj)
2700 {
2701    Pan *sd = evas_object_smart_data_get(obj);
2702    Item_Block *itb;
2703    Evas_Coord ox, oy, ow, oh, cvx, cvy, cvw, cvh;
2704    int in = 0;
2705    Elm_Genlist_Item *git;
2706    Eina_List *l;
2707
2708    if (!sd) return;
2709    evas_event_freeze(evas_object_evas_get(obj));
2710    evas_object_geometry_get(obj, &ox, &oy, &ow, &oh);
2711    evas_output_viewport_get(evas_object_evas_get(obj), &cvx, &cvy, &cvw, &cvh);
2712    EINA_LIST_FOREACH(sd->wd->group_items, l, git)
2713      {
2714         git->want_realize = EINA_FALSE;
2715      }
2716    EINA_INLIST_FOREACH(sd->wd->blocks, itb)
2717      {
2718         itb->w = sd->wd->minw;
2719         if (ELM_RECTS_INTERSECT(itb->x - sd->wd->pan_x + ox,
2720                                 itb->y - sd->wd->pan_y + oy,
2721                                 itb->w, itb->h,
2722                                 cvx, cvy, cvw, cvh))
2723           {
2724              if ((!itb->realized) || (itb->changed))
2725                _item_block_realize(itb);
2726              _item_block_position(itb, in);
2727           }
2728         else
2729           {
2730              if (itb->realized) _item_block_unrealize(itb);
2731           }
2732         in += itb->count;
2733      }
2734    if ((!sd->wd->reorder_it) || (sd->wd->reorder_pan_move))
2735       _group_items_recalc(sd->wd);
2736    if ((sd->wd->reorder_mode) && (sd->wd->reorder_it))
2737      {
2738         if (sd->wd->pan_y != sd->wd->reorder_old_pan_y)
2739            sd->wd->reorder_pan_move = EINA_TRUE;
2740         else sd->wd->reorder_pan_move = EINA_FALSE;
2741         evas_object_raise(sd->wd->reorder_it->base.view);
2742         sd->wd->reorder_old_pan_y = sd->wd->pan_y;
2743         sd->wd->start_time = ecore_loop_time_get();
2744      }
2745    _item_auto_scroll(sd->wd);
2746    evas_event_thaw(evas_object_evas_get(obj));
2747    evas_event_thaw_eval(evas_object_evas_get(obj));
2748 }
2749
2750 static void
2751 _pan_move(Evas_Object *obj,
2752           Evas_Coord   x __UNUSED__,
2753           Evas_Coord   y __UNUSED__)
2754 {
2755    Pan *sd = evas_object_smart_data_get(obj);
2756
2757    if (!sd) return;
2758    if (sd->wd->calc_job) ecore_job_del(sd->wd->calc_job);
2759    sd->wd->calc_job = ecore_job_add(_calc_job, sd->wd);
2760 }
2761
2762 static void
2763 _hold_on(void        *data __UNUSED__,
2764          Evas_Object *obj,
2765          void        *event_info __UNUSED__)
2766 {
2767    Widget_Data *wd = elm_widget_data_get(obj);
2768    if (!wd) return;
2769    elm_smart_scroller_hold_set(wd->scr, 1);
2770 }
2771
2772 static void
2773 _hold_off(void        *data __UNUSED__,
2774           Evas_Object *obj,
2775           void        *event_info __UNUSED__)
2776 {
2777    Widget_Data *wd = elm_widget_data_get(obj);
2778    if (!wd) return;
2779    elm_smart_scroller_hold_set(wd->scr, 0);
2780 }
2781
2782 static void
2783 _freeze_on(void        *data __UNUSED__,
2784            Evas_Object *obj,
2785            void        *event_info __UNUSED__)
2786 {
2787    Widget_Data *wd = elm_widget_data_get(obj);
2788    if (!wd) return;
2789    elm_smart_scroller_freeze_set(wd->scr, 1);
2790 }
2791
2792 static void
2793 _freeze_off(void        *data __UNUSED__,
2794             Evas_Object *obj,
2795             void        *event_info __UNUSED__)
2796 {
2797    Widget_Data *wd = elm_widget_data_get(obj);
2798    if (!wd) return;
2799    elm_smart_scroller_freeze_set(wd->scr, 0);
2800 }
2801
2802 static void
2803 _scr_anim_start(void        *data,
2804                 Evas_Object *obj __UNUSED__,
2805                 void        *event_info __UNUSED__)
2806 {
2807    evas_object_smart_callback_call(data, SIG_SCROLL_ANIM_START, NULL);
2808 }
2809
2810 static void
2811 _scr_anim_stop(void        *data,
2812                Evas_Object *obj __UNUSED__,
2813                void        *event_info __UNUSED__)
2814 {
2815    evas_object_smart_callback_call(data, SIG_SCROLL_ANIM_STOP, NULL);
2816 }
2817
2818 static void
2819 _scr_drag_start(void            *data,
2820                 Evas_Object     *obj __UNUSED__,
2821                 void            *event_info __UNUSED__)
2822 {
2823    evas_object_smart_callback_call(data, SIG_SCROLL_DRAG_START, NULL);
2824 }
2825
2826 static void
2827 _scr_drag_stop(void            *data,
2828                Evas_Object     *obj __UNUSED__,
2829                void            *event_info __UNUSED__)
2830 {
2831    evas_object_smart_callback_call(data, SIG_SCROLL_DRAG_STOP, NULL);
2832 }
2833
2834 static void
2835 _scroll_edge_left(void        *data,
2836                   Evas_Object *scr __UNUSED__,
2837                   void        *event_info __UNUSED__)
2838 {
2839    Evas_Object *obj = data;
2840    evas_object_smart_callback_call(obj, SIG_SCROLL_EDGE_LEFT, NULL);
2841 }
2842
2843 static void
2844 _scroll_edge_right(void        *data,
2845                    Evas_Object *scr __UNUSED__,
2846                    void        *event_info __UNUSED__)
2847 {
2848    Evas_Object *obj = data;
2849    evas_object_smart_callback_call(obj, SIG_SCROLL_EDGE_RIGHT, NULL);
2850 }
2851
2852 static void
2853 _scroll_edge_top(void        *data,
2854                  Evas_Object *scr __UNUSED__,
2855                  void        *event_info __UNUSED__)
2856 {
2857    Evas_Object *obj = data;
2858    evas_object_smart_callback_call(obj, SIG_SCROLL_EDGE_TOP, NULL);
2859 }
2860
2861 static void
2862 _scroll_edge_bottom(void        *data,
2863                     Evas_Object *scr __UNUSED__,
2864                     void        *event_info __UNUSED__)
2865 {
2866    Evas_Object *obj = data;
2867    evas_object_smart_callback_call(obj, SIG_SCROLL_EDGE_BOTTOM, NULL);
2868 }
2869
2870 static void
2871 _mode_item_realize(Elm_Genlist_Item *it)
2872 {
2873    char buf[1024];
2874
2875    if ((it->mode_view) || (it->delete_me)) return;
2876
2877    evas_event_freeze(evas_object_evas_get(it->wd->obj));
2878    it->mode_view = edje_object_add(evas_object_evas_get(it->base.widget));
2879    edje_object_scale_set(it->mode_view,
2880                          elm_widget_scale_get(it->base.widget) *
2881                          _elm_config->scale);
2882    evas_object_smart_member_add(it->mode_view, it->wd->pan_smart);
2883    elm_widget_sub_object_add(it->base.widget, it->mode_view);
2884
2885    strncpy(buf, "item", sizeof(buf));
2886    if (it->wd->compress)
2887      strncat(buf, "_compress", sizeof(buf) - strlen(buf));
2888
2889    if (it->order_num_in & 0x1) strncat(buf, "_odd", sizeof(buf) - strlen(buf));
2890    strncat(buf, "/", sizeof(buf) - strlen(buf));
2891    strncat(buf, it->itc->mode_item_style, sizeof(buf) - strlen(buf));
2892
2893    _elm_theme_object_set(it->base.widget, it->mode_view, "genlist", buf,
2894                          elm_widget_style_get(it->base.widget));
2895    edje_object_mirrored_set(it->mode_view,
2896                             elm_widget_mirrored_get(it->base.widget));
2897
2898    /* signal callback add */
2899    evas_object_event_callback_add(it->mode_view, EVAS_CALLBACK_MOUSE_DOWN,
2900                                   _mouse_down, it);
2901    evas_object_event_callback_add(it->mode_view, EVAS_CALLBACK_MOUSE_UP,
2902                                   _mouse_up, it);
2903    evas_object_event_callback_add(it->mode_view, EVAS_CALLBACK_MOUSE_MOVE,
2904                                   _mouse_move, it);
2905
2906    /* label_get, icon_get, state_get */
2907    /* FIXME: If you see that assert, please notify us and we
2908       will clean our mess */
2909    assert(eina_list_count(it->mode_icon_objs) == 0);
2910
2911    _item_label_realize(it, it->mode_view, &it->mode_labels);
2912    it->mode_icon_objs = _item_icon_realize(it,
2913                                            it->mode_view,
2914                                            &it->mode_icons);
2915    _item_state_realize(it, it->mode_view, &it->mode_states);
2916
2917    edje_object_part_swallow(it->mode_view,
2918                             edje_object_data_get(it->mode_view, "mode_part"),
2919                             it->base.view);
2920
2921    it->want_unrealize = EINA_FALSE;
2922    evas_event_thaw(evas_object_evas_get(it->wd->obj));
2923    evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
2924 }
2925
2926 static void
2927 _mode_item_unrealize(Elm_Genlist_Item *it)
2928 {
2929    Widget_Data *wd = it->wd;
2930    Evas_Object *icon;
2931    if (!it->mode_view) return;
2932
2933    evas_event_freeze(evas_object_evas_get(it->wd->obj));
2934    elm_widget_stringlist_free(it->mode_labels);
2935    it->mode_labels = NULL;
2936    elm_widget_stringlist_free(it->mode_icons);
2937    it->mode_icons = NULL;
2938    elm_widget_stringlist_free(it->mode_states);
2939
2940    EINA_LIST_FREE(it->mode_icon_objs, icon)
2941      evas_object_del(icon);
2942
2943    edje_object_part_unswallow(it->mode_view, it->base.view);
2944    evas_object_smart_member_add(it->base.view, wd->pan_smart);
2945    evas_object_del(it->mode_view);
2946    it->mode_view = NULL;
2947
2948    if (wd->mode_item == it)
2949      wd->mode_item = NULL;
2950    evas_event_thaw(evas_object_evas_get(it->wd->obj));
2951    evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
2952 }
2953
2954 static void
2955 _item_mode_set(Elm_Genlist_Item *it)
2956 {
2957    if (!it) return;
2958    Widget_Data *wd = it->wd;
2959    if (!wd) return;
2960    char buf[1024];
2961
2962    wd->mode_item = it;
2963    it->nocache = EINA_TRUE;
2964
2965    if (wd->scr_hold_timer)
2966      {
2967         ecore_timer_del(wd->scr_hold_timer);
2968         wd->scr_hold_timer = NULL;
2969      }
2970    elm_smart_scroller_hold_set(wd->scr, EINA_TRUE);
2971    wd->scr_hold_timer = ecore_timer_add(0.1, _scr_hold_timer_cb, wd);
2972
2973    evas_event_freeze(evas_object_evas_get(it->wd->obj));
2974    _mode_item_realize(it);
2975    _item_position(it, it->mode_view, it->scrl_x, it->scrl_y);
2976    evas_event_thaw(evas_object_evas_get(it->wd->obj));
2977    evas_event_thaw_eval(evas_object_evas_get(it->wd->obj));
2978
2979    snprintf(buf, sizeof(buf), "elm,state,%s,active", wd->mode_type);
2980    edje_object_signal_emit(it->mode_view, buf, "elm");
2981 }
2982
2983 static void
2984 _item_mode_unset(Widget_Data *wd)
2985 {
2986    if (!wd) return;
2987    if (!wd->mode_item) return;
2988    char buf[1024], buf2[1024];
2989    Elm_Genlist_Item *it;
2990
2991    it = wd->mode_item;
2992    it->nocache = EINA_TRUE;
2993
2994    snprintf(buf, sizeof(buf), "elm,state,%s,passive", wd->mode_type);
2995    snprintf(buf2, sizeof(buf2), "elm,state,%s,passive,finished", wd->mode_type);
2996
2997    edje_object_signal_emit(it->mode_view, buf, "elm");
2998    edje_object_signal_callback_add(it->mode_view, buf2, "elm", _mode_finished_signal_cb, it);
2999
3000    wd->mode_item = NULL;
3001 }
3002
3003 static void
3004 _item_auto_scroll(Widget_Data *wd)
3005 {
3006    if (!wd) return;
3007    Elm_Genlist_Item  *it;
3008    Eina_List *l;
3009    Evas_Coord ox, oy, ow, oh;
3010
3011    if ((wd->expanded_item) && (wd->auto_scroll_enabled))
3012      {
3013         evas_object_geometry_get(wd->obj, &ox, &oy, &ow, &oh);
3014         if (wd->expanded_item->scrl_y > (oh + oy) / 2)
3015           {
3016              EINA_LIST_FOREACH(wd->expanded_item->items, l, it)
3017                 elm_genlist_item_bring_in(it);
3018           }
3019         wd->auto_scroll_enabled = EINA_FALSE;
3020      }
3021 }
3022
3023 EAPI Evas_Object *
3024 elm_genlist_add(Evas_Object *parent)
3025 {
3026    Evas_Object *obj;
3027    Evas *e;
3028    Widget_Data *wd;
3029    Evas_Coord minw, minh;
3030    static Evas_Smart *smart = NULL;
3031
3032    if (!smart)
3033      {
3034         static Evas_Smart_Class sc;
3035
3036         evas_object_smart_clipped_smart_set(&_pan_sc);
3037         sc = _pan_sc;
3038         sc.name = "elm_genlist_pan";
3039         sc.version = EVAS_SMART_CLASS_VERSION;
3040         sc.add = _pan_add;
3041         sc.del = _pan_del;
3042         sc.resize = _pan_resize;
3043         sc.move = _pan_move;
3044         sc.calculate = _pan_calculate;
3045         if (!(smart = evas_smart_class_new(&sc))) return NULL;
3046      }
3047
3048    ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
3049
3050    ELM_SET_WIDTYPE(widtype, "genlist");
3051    elm_widget_type_set(obj, "genlist");
3052    elm_widget_sub_object_add(parent, obj);
3053    elm_widget_on_focus_hook_set(obj, _on_focus_hook, NULL);
3054    elm_widget_signal_emit_hook_set(obj, _signal_emit_hook);
3055    elm_widget_data_set(obj, wd);
3056    elm_widget_del_hook_set(obj, _del_hook);
3057    elm_widget_del_pre_hook_set(obj, _del_pre_hook);
3058    elm_widget_theme_hook_set(obj, _theme_hook);
3059    elm_widget_can_focus_set(obj, EINA_TRUE);
3060    elm_widget_event_hook_set(obj, _event_hook);
3061    elm_widget_on_show_region_hook_set(obj, _show_region_hook, obj);
3062
3063    wd->scr = elm_smart_scroller_add(e);
3064    elm_smart_scroller_widget_set(wd->scr, obj);
3065    elm_smart_scroller_object_theme_set(obj, wd->scr, "genlist", "base",
3066                                        elm_widget_style_get(obj));
3067    elm_smart_scroller_bounce_allow_set(wd->scr, EINA_FALSE,
3068                                        _elm_config->thumbscroll_bounce_enable);
3069    elm_widget_resize_object_set(obj, wd->scr);
3070
3071    evas_object_smart_callback_add(wd->scr, "animate,start", _scr_anim_start, obj);
3072    evas_object_smart_callback_add(wd->scr, "animate,stop", _scr_anim_stop, obj);
3073    evas_object_smart_callback_add(wd->scr, "drag,start", _scr_drag_start, obj);
3074    evas_object_smart_callback_add(wd->scr, "drag,stop", _scr_drag_stop, obj);
3075    evas_object_smart_callback_add(wd->scr, "edge,left", _scroll_edge_left, obj);
3076    evas_object_smart_callback_add(wd->scr, "edge,right", _scroll_edge_right,
3077                                   obj);
3078    evas_object_smart_callback_add(wd->scr, "edge,top", _scroll_edge_top, obj);
3079    evas_object_smart_callback_add(wd->scr, "edge,bottom", _scroll_edge_bottom,
3080                                   obj);
3081
3082    wd->obj = obj;
3083    wd->mode = ELM_LIST_SCROLL;
3084    wd->max_items_per_block = MAX_ITEMS_PER_BLOCK;
3085    wd->item_cache_max = wd->max_items_per_block * 2;
3086    wd->longpress_timeout = _elm_config->longpress_timeout;
3087
3088    evas_object_smart_callback_add(obj, "scroll-hold-on", _hold_on, obj);
3089    evas_object_smart_callback_add(obj, "scroll-hold-off", _hold_off, obj);
3090    evas_object_smart_callback_add(obj, "scroll-freeze-on", _freeze_on, obj);
3091    evas_object_smart_callback_add(obj, "scroll-freeze-off", _freeze_off, obj);
3092
3093    wd->pan_smart = evas_object_smart_add(e, smart);
3094    wd->pan = evas_object_smart_data_get(wd->pan_smart);
3095    wd->pan->wd = wd;
3096
3097    elm_smart_scroller_extern_pan_set(wd->scr, wd->pan_smart,
3098                                      _pan_set, _pan_get, _pan_max_get,
3099                                      _pan_min_get, _pan_child_size_get);
3100
3101    edje_object_size_min_calc(elm_smart_scroller_edje_object_get(wd->scr),
3102                              &minw, &minh);
3103    evas_object_size_hint_min_set(obj, minw, minh);
3104
3105    evas_object_smart_callbacks_descriptions_set(obj, _signals);
3106
3107    _mirrored_set(obj, elm_widget_mirrored_get(obj));
3108    _sizing_eval(obj);
3109    return obj;
3110 }
3111
3112 static Elm_Genlist_Item *
3113 _item_new(Widget_Data                  *wd,
3114           const Elm_Genlist_Item_Class *itc,
3115           const void                   *data,
3116           Elm_Genlist_Item             *parent,
3117           Elm_Genlist_Item_Flags        flags,
3118           Evas_Smart_Cb                 func,
3119           const void                   *func_data)
3120 {
3121    Elm_Genlist_Item *it;
3122
3123    it = elm_widget_item_new(wd->obj, Elm_Genlist_Item);
3124    if (!it) return NULL;
3125    it->wd = wd;
3126    it->itc = itc;
3127    it->base.data = data;
3128    it->parent = parent;
3129    it->flags = flags;
3130    it->func.func = func;
3131    it->func.data = func_data;
3132    it->mouse_cursor = NULL;
3133    it->expanded_depth = 0;
3134    elm_widget_item_text_get_hook_set(it, _item_label_hook);
3135
3136    if (it->parent)
3137      {
3138         if (it->parent->flags & ELM_GENLIST_ITEM_GROUP)
3139           it->group_item = parent;
3140         else if (it->parent->group_item)
3141           it->group_item = it->parent->group_item;
3142      }
3143    return it;
3144 }
3145
3146 static void
3147 _item_block_add(Widget_Data      *wd,
3148                 Elm_Genlist_Item *it)
3149 {
3150    Item_Block *itb = NULL;
3151
3152    if (!it->rel)
3153      {
3154 newblock:
3155         if (it->rel)
3156           {
3157              itb = calloc(1, sizeof(Item_Block));
3158              if (!itb) return;
3159              itb->wd = wd;
3160              if (!it->rel->block)
3161                {
3162                   wd->blocks =
3163                     eina_inlist_append(wd->blocks, EINA_INLIST_GET(itb));
3164                   itb->items = eina_list_append(itb->items, it);
3165                }
3166              else
3167                {
3168                   if (it->before)
3169                     {
3170                        wd->blocks = eina_inlist_prepend_relative
3171                            (wd->blocks, EINA_INLIST_GET(itb),
3172                            EINA_INLIST_GET(it->rel->block));
3173                        itb->items =
3174                          eina_list_prepend_relative(itb->items, it, it->rel);
3175                     }
3176                   else
3177                     {
3178                        wd->blocks = eina_inlist_append_relative
3179                            (wd->blocks, EINA_INLIST_GET(itb),
3180                            EINA_INLIST_GET(it->rel->block));
3181                        itb->items =
3182                          eina_list_append_relative(itb->items, it, it->rel);
3183                     }
3184                }
3185           }
3186         else
3187           {
3188              if (it->before)
3189                {
3190                   if (wd->blocks)
3191                     {
3192                        itb = (Item_Block *)(wd->blocks);
3193                        if (itb->count >= wd->max_items_per_block)
3194                          {
3195                             itb = calloc(1, sizeof(Item_Block));
3196                             if (!itb) return;
3197                             itb->wd = wd;
3198                             wd->blocks =
3199                               eina_inlist_prepend(wd->blocks,
3200                                                   EINA_INLIST_GET(itb));
3201                          }
3202                     }
3203                   else
3204                     {
3205                        itb = calloc(1, sizeof(Item_Block));
3206                        if (!itb) return;
3207                        itb->wd = wd;
3208                        wd->blocks =
3209                          eina_inlist_prepend(wd->blocks, EINA_INLIST_GET(itb));
3210                     }
3211                   itb->items = eina_list_prepend(itb->items, it);
3212                }
3213              else
3214                {
3215                   if (wd->blocks)
3216                     {
3217                        itb = (Item_Block *)(wd->blocks->last);
3218                        if (itb->count >= wd->max_items_per_block)
3219                          {
3220                             itb = calloc(1, sizeof(Item_Block));
3221                             if (!itb) return;
3222                             itb->wd = wd;
3223                             wd->blocks =
3224                               eina_inlist_append(wd->blocks,
3225                                                  EINA_INLIST_GET(itb));
3226                          }
3227                     }
3228                   else
3229                     {
3230                        itb = calloc(1, sizeof(Item_Block));
3231                        if (!itb) return;
3232                        itb->wd = wd;
3233                        wd->blocks =
3234                          eina_inlist_append(wd->blocks, EINA_INLIST_GET(itb));
3235                     }
3236                   itb->items = eina_list_append(itb->items, it);
3237                }
3238           }
3239      }
3240    else
3241      {
3242         itb = it->rel->block;
3243         if (!itb) goto newblock;
3244         if (it->before)
3245           itb->items = eina_list_prepend_relative(itb->items, it, it->rel);
3246         else
3247           itb->items = eina_list_append_relative(itb->items, it, it->rel);
3248      }
3249    itb->count++;
3250    itb->changed = EINA_TRUE;
3251    it->block = itb;
3252    if (itb->wd->calc_job) ecore_job_del(itb->wd->calc_job);
3253    itb->wd->calc_job = ecore_job_add(_calc_job, itb->wd);
3254    if (it->rel)
3255      {
3256         it->rel->relcount--;
3257         if ((it->rel->delete_me) && (!it->rel->relcount))
3258           _item_del(it->rel);
3259         it->rel = NULL;
3260      }
3261    if (itb->count > itb->wd->max_items_per_block)
3262      {
3263         int newc;
3264         Item_Block *itb2;
3265         Elm_Genlist_Item *it2;
3266
3267         newc = itb->count / 2;
3268         itb2 = calloc(1, sizeof(Item_Block));
3269         if (!itb2) return;
3270         itb2->wd = wd;
3271         wd->blocks =
3272           eina_inlist_append_relative(wd->blocks, EINA_INLIST_GET(itb2),
3273                                       EINA_INLIST_GET(itb));
3274         itb2->changed = EINA_TRUE;
3275         while ((itb->count > newc) && (itb->items))
3276           {
3277              Eina_List *l;
3278
3279              l = eina_list_last(itb->items);
3280              it2 = l->data;
3281              itb->items = eina_list_remove_list(itb->items, l);
3282              itb->count--;
3283
3284              itb2->items = eina_list_prepend(itb2->items, it2);
3285              it2->block = itb2;
3286              itb2->count++;
3287           }
3288      }
3289 }
3290
3291 static int
3292 _queue_process(Widget_Data *wd)
3293 {
3294    int n;
3295    Eina_Bool showme = EINA_FALSE;
3296    double t0, t;
3297
3298    t0 = ecore_time_get();
3299    //evas_event_freeze(evas_object_evas_get(wd->obj));
3300    for (n = 0; (wd->queue) && (n < 128); n++)
3301      {
3302         Elm_Genlist_Item *it;
3303
3304         it = wd->queue->data;
3305         wd->queue = eina_list_remove_list(wd->queue, wd->queue);
3306         it->queued = EINA_FALSE;
3307         _item_block_add(wd, it);
3308         t = ecore_time_get();
3309         if (it->block->changed)
3310           {
3311              showme = _item_block_recalc(it->block, it->block->num, EINA_TRUE);
3312              it->block->changed = 0;
3313           }
3314         if (showme) it->block->showme = EINA_TRUE;
3315         if (eina_inlist_count(wd->blocks) > 1)
3316           {
3317              if ((t - t0) > (ecore_animator_frametime_get())) break;
3318           }
3319      }
3320    //evas_event_thaw(evas_object_evas_get(wd->obj));
3321    //evas_event_thaw_eval(evas_object_evas_get(wd->obj));
3322    return n;
3323 }
3324
3325 static Eina_Bool
3326 _idle_process(void *data, Eina_Bool *wakeup)
3327 {
3328    Widget_Data *wd = data;
3329
3330    //xxx
3331    //static double q_start = 0.0;
3332    //if (q_start == 0.0) q_start = ecore_time_get();
3333    //xxx
3334    if (_queue_process(wd) > 0) *wakeup = EINA_TRUE;
3335    if (!wd->queue)
3336      {
3337         //xxx
3338         //printf("PROCESS TIME: %3.3f\n", ecore_time_get() - q_start);
3339         //xxx
3340         return ECORE_CALLBACK_CANCEL;
3341      }
3342    return ECORE_CALLBACK_RENEW;
3343 }
3344
3345 static Eina_Bool
3346 _item_idle_enterer(void *data)
3347 {
3348    Widget_Data *wd = data;
3349    Eina_Bool wakeup = EINA_FALSE;
3350    Eina_Bool ok = _idle_process(data, &wakeup);
3351
3352    if (wakeup)
3353      {
3354         // wake up mainloop
3355         if (wd->calc_job) ecore_job_del(wd->calc_job);
3356         wd->calc_job = ecore_job_add(_calc_job, wd);
3357      }
3358    if (ok == ECORE_CALLBACK_CANCEL) wd->queue_idle_enterer = NULL;
3359    return ok;
3360 }
3361
3362 static void
3363 _item_queue(Widget_Data      *wd,
3364             Elm_Genlist_Item *it)
3365 {
3366    if (it->queued) return;
3367    it->queued = EINA_TRUE;
3368    wd->queue = eina_list_append(wd->queue, it);
3369 // FIXME: why does a freeze then thaw here cause some genlist
3370 // elm_genlist_item_append() to be much much slower?
3371 //   evas_event_freeze(evas_object_evas_get(wd->obj));
3372    while ((wd->queue) && ((!wd->blocks) || (!wd->blocks->next)))
3373      {
3374         if (wd->queue_idle_enterer)
3375           {
3376              ecore_idle_enterer_del(wd->queue_idle_enterer);
3377              wd->queue_idle_enterer = NULL;
3378           }
3379         _queue_process(wd);
3380      }
3381 //   evas_event_thaw(evas_object_evas_get(wd->obj));
3382 //   evas_event_thaw_eval(evas_object_evas_get(wd->obj));
3383    if (!wd->queue_idle_enterer)
3384      wd->queue_idle_enterer = ecore_idle_enterer_add(_item_idle_enterer, wd);
3385 }
3386
3387 static int
3388 _elm_genlist_item_compare_data(const void *data, const void *data1)
3389 {
3390    const Elm_Genlist_Item *item = data;
3391    const Elm_Genlist_Item *item1 = data1;
3392
3393    return _elm_genlist_item_compare_data_cb(item->base.data, item1->base.data);
3394 }
3395
3396 static int
3397 _elm_genlist_item_compare(const void *data, const void *data1)
3398 {
3399    const Elm_Genlist_Item *item, *item1;
3400    item = ELM_GENLIST_ITEM_FROM_INLIST(data);
3401    item1 = ELM_GENLIST_ITEM_FROM_INLIST(data1);
3402    return _elm_genlist_item_compare_cb(item, item1);
3403 }
3404
3405 static int
3406 _elm_genlist_item_list_compare(const void *data, const void *data1)
3407 {
3408    const Elm_Genlist_Item *item = data;
3409    const Elm_Genlist_Item *item1 = data1;
3410    return _elm_genlist_item_compare_cb(item, item1);
3411 }
3412
3413 static void
3414 _item_move_after(Elm_Genlist_Item *it, Elm_Genlist_Item *after)
3415 {
3416    if (!it) return;
3417    if (!after) return;
3418
3419    it->wd->items = eina_inlist_remove(it->wd->items, EINA_INLIST_GET(it));
3420    _item_block_del(it);
3421
3422    it->wd->items = eina_inlist_append_relative(it->wd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(after));
3423    it->rel = after;
3424    it->rel->relcount++;
3425    it->before = EINA_FALSE;
3426    if (after->group_item) it->group_item = after->group_item;
3427    _item_queue(it->wd, it);
3428
3429    // TODO: change this to smart callback
3430    if (it->itc->func.moved)
3431      it->itc->func.moved(it->base.widget, it, after, EINA_TRUE);
3432 }
3433
3434 static void
3435 _item_move_before(Elm_Genlist_Item *it, Elm_Genlist_Item *before)
3436 {
3437    if (!it) return;
3438    if (!before) return;
3439
3440    it->wd->items = eina_inlist_remove(it->wd->items, EINA_INLIST_GET(it));
3441    _item_block_del(it);
3442    it->wd->items = eina_inlist_prepend_relative(it->wd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(before));
3443    it->rel = before;
3444    it->rel->relcount++;
3445    it->before = EINA_TRUE;
3446    if (before->group_item) it->group_item = before->group_item;
3447    _item_queue(it->wd, it);
3448
3449    // TODO: change this to smart callback
3450    if (it->itc->func.moved)
3451      it->itc->func.moved(it->base.widget, it, before, EINA_FALSE);
3452 }
3453
3454 EAPI Elm_Genlist_Item *
3455 elm_genlist_item_append(Evas_Object                  *obj,
3456                         const Elm_Genlist_Item_Class *itc,
3457                         const void                   *data,
3458                         Elm_Genlist_Item             *parent,
3459                         Elm_Genlist_Item_Flags        flags,
3460                         Evas_Smart_Cb                 func,
3461                         const void                   *func_data)
3462 {
3463    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3464    Widget_Data *wd = elm_widget_data_get(obj);
3465    if (!wd) return NULL;
3466    Elm_Genlist_Item *it = _item_new(wd, itc, data, parent, flags, func,
3467                                     func_data);
3468    if (!it) return NULL;
3469    if (!it->parent)
3470      {
3471         if (flags & ELM_GENLIST_ITEM_GROUP)
3472           wd->group_items = eina_list_append(wd->group_items, it);
3473         wd->items = eina_inlist_append(wd->items, EINA_INLIST_GET(it));
3474         it->rel = NULL;
3475      }
3476    else
3477      {
3478         Elm_Genlist_Item *it2 = NULL;
3479         Eina_List *ll = eina_list_last(it->parent->items);
3480         if (ll) it2 = ll->data;
3481         it->parent->items = eina_list_append(it->parent->items, it);
3482         if (!it2) it2 = it->parent;
3483         wd->items =
3484           eina_inlist_append_relative(wd->items, EINA_INLIST_GET(it),
3485                                       EINA_INLIST_GET(it2));
3486         it->rel = it2;
3487         it->rel->relcount++;
3488      }
3489    it->before = EINA_FALSE;
3490    _item_queue(wd, it);
3491    return it;
3492 }
3493
3494 EAPI Elm_Genlist_Item *
3495 elm_genlist_item_prepend(Evas_Object                  *obj,
3496                          const Elm_Genlist_Item_Class *itc,
3497                          const void                   *data,
3498                          Elm_Genlist_Item             *parent,
3499                          Elm_Genlist_Item_Flags        flags,
3500                          Evas_Smart_Cb                 func,
3501                          const void                   *func_data)
3502 {
3503    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3504    Widget_Data *wd = elm_widget_data_get(obj);
3505    if (!wd) return NULL;
3506    Elm_Genlist_Item *it = _item_new(wd, itc, data, parent, flags, func,
3507                                     func_data);
3508    if (!it) return NULL;
3509    if (!it->parent)
3510      {
3511         if (flags & ELM_GENLIST_ITEM_GROUP)
3512           wd->group_items = eina_list_prepend(wd->group_items, it);
3513         wd->items = eina_inlist_prepend(wd->items, EINA_INLIST_GET(it));
3514         it->rel = NULL;
3515      }
3516    else
3517      {
3518         Elm_Genlist_Item *it2 = NULL;
3519         Eina_List *ll = it->parent->items;
3520         if (ll) it2 = ll->data;
3521         it->parent->items = eina_list_prepend(it->parent->items, it);
3522         if (!it2) it2 = it->parent;
3523         wd->items =
3524           eina_inlist_prepend_relative(wd->items, EINA_INLIST_GET(it),
3525                                        EINA_INLIST_GET(it2));
3526         it->rel = it2;
3527         it->rel->relcount++;
3528      }
3529    it->before = EINA_TRUE;
3530    _item_queue(wd, it);
3531    return it;
3532 }
3533
3534 EAPI Elm_Genlist_Item *
3535 elm_genlist_item_insert_after(Evas_Object                  *obj,
3536                               const Elm_Genlist_Item_Class *itc,
3537                               const void                   *data,
3538                               Elm_Genlist_Item             *parent,
3539                               Elm_Genlist_Item             *after,
3540                               Elm_Genlist_Item_Flags        flags,
3541                               Evas_Smart_Cb                 func,
3542                               const void                   *func_data)
3543 {
3544    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3545    EINA_SAFETY_ON_NULL_RETURN_VAL(after, NULL);
3546    Widget_Data *wd = elm_widget_data_get(obj);
3547    if (!wd) return NULL;
3548    Elm_Genlist_Item *it = _item_new(wd, itc, data, parent, flags, func,
3549                                     func_data);
3550    if (!it) return NULL;
3551    /* It makes no sense to insert after in an empty list with after != NULL, something really bad is happening in your app. */
3552    EINA_SAFETY_ON_NULL_RETURN_VAL(wd->items, NULL);
3553
3554    if (!it->parent)
3555      {
3556         if ((flags & ELM_GENLIST_ITEM_GROUP) &&
3557             (after->flags & ELM_GENLIST_ITEM_GROUP))
3558           wd->group_items = eina_list_append_relative(wd->group_items, it,
3559                                                       after);
3560      }
3561    else
3562      {
3563         it->parent->items = eina_list_append_relative(it->parent->items, it,
3564                                                       after);
3565      }
3566    wd->items = eina_inlist_append_relative(wd->items, EINA_INLIST_GET(it),
3567                                            EINA_INLIST_GET(after));
3568    it->rel = after;
3569    it->rel->relcount++;
3570    it->before = EINA_FALSE;
3571    _item_queue(wd, it);
3572    return it;
3573 }
3574
3575 EAPI Elm_Genlist_Item *
3576 elm_genlist_item_insert_before(Evas_Object                  *obj,
3577                                const Elm_Genlist_Item_Class *itc,
3578                                const void                   *data,
3579                                Elm_Genlist_Item             *parent,
3580                                Elm_Genlist_Item             *before,
3581                                Elm_Genlist_Item_Flags        flags,
3582                                Evas_Smart_Cb                 func,
3583                                const void                   *func_data)
3584 {
3585    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3586    EINA_SAFETY_ON_NULL_RETURN_VAL(before, NULL);
3587    Widget_Data *wd = elm_widget_data_get(obj);
3588    if (!wd) return NULL;
3589    Elm_Genlist_Item *it = _item_new(wd, itc, data, parent, flags, func,
3590                                     func_data);
3591    if (!it) return NULL;
3592    /* It makes no sense to insert before in an empty list with before != NULL, something really bad is happening in your app. */
3593    EINA_SAFETY_ON_NULL_RETURN_VAL(wd->items, NULL);
3594
3595    if (!it->parent)
3596      {
3597         if ((flags & ELM_GENLIST_ITEM_GROUP) &&
3598             (before->flags & ELM_GENLIST_ITEM_GROUP))
3599           wd->group_items = eina_list_prepend_relative(wd->group_items, it,
3600                                                        before);
3601      }
3602    else
3603      {
3604         it->parent->items = eina_list_prepend_relative(it->parent->items, it,
3605                                                        before);
3606      }
3607    wd->items = eina_inlist_prepend_relative(wd->items, EINA_INLIST_GET(it),
3608                                             EINA_INLIST_GET(before));
3609    it->rel = before;
3610    it->rel->relcount++;
3611    it->before = EINA_TRUE;
3612    _item_queue(wd, it);
3613    return it;
3614 }
3615
3616 EAPI Elm_Genlist_Item *
3617 elm_genlist_item_direct_sorted_insert(Evas_Object                  *obj,
3618                                       const Elm_Genlist_Item_Class *itc,
3619                                       const void                   *data,
3620                                       Elm_Genlist_Item             *parent,
3621                                       Elm_Genlist_Item_Flags        flags,
3622                                       Eina_Compare_Cb               comp,
3623                                       Evas_Smart_Cb                 func,
3624                                       const void                   *func_data)
3625 {
3626    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3627    Widget_Data *wd = elm_widget_data_get(obj);
3628    if (!wd) return NULL;
3629    Elm_Genlist_Item *rel = NULL;
3630    Elm_Genlist_Item *it = _item_new(wd, itc, data, parent, flags, func,
3631                                     func_data);
3632    if (!it) return NULL;
3633
3634    _elm_genlist_item_compare_cb = comp;
3635
3636    if (it->parent)
3637      {
3638         Eina_List *l;
3639         int cmp_result;
3640
3641         l = eina_list_search_sorted_near_list(it->parent->items,
3642                                               _elm_genlist_item_list_compare, it,
3643                                               &cmp_result);
3644         if (l)
3645           rel = eina_list_data_get(l);
3646         else
3647           rel = it->parent;
3648
3649         if (cmp_result >= 0)
3650           {
3651              it->parent->items = eina_list_prepend_relative_list(it->parent->items, it, l);
3652              wd->items = eina_inlist_prepend_relative(wd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(rel));
3653              it->before = EINA_FALSE;
3654           }
3655         else if (cmp_result < 0)
3656           {
3657              it->parent->items = eina_list_append_relative_list(it->parent->items, it, l);
3658              wd->items = eina_inlist_append_relative(wd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(rel));
3659              it->before = EINA_TRUE;
3660           }
3661      }
3662    else
3663      {
3664         if (!wd->state)
3665           {
3666              wd->state = eina_inlist_sorted_state_new();
3667           }
3668
3669         if (flags & ELM_GENLIST_ITEM_GROUP)
3670           wd->group_items = eina_list_append(wd->group_items, it);
3671
3672         wd->items = eina_inlist_sorted_state_insert(wd->items, EINA_INLIST_GET(it),
3673                                                     _elm_genlist_item_compare, wd->state);
3674
3675         if (EINA_INLIST_GET(it)->next)
3676           {
3677              rel = ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->next);
3678              it->before = EINA_TRUE;
3679           }
3680         else if (EINA_INLIST_GET(it)->prev)
3681           {
3682              rel = ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->prev);
3683              it->before = EINA_FALSE;
3684           }
3685      }
3686
3687    if (rel)
3688      {
3689         it->rel = rel;
3690         it->rel->relcount++;
3691      }
3692
3693    _item_queue(wd, it);
3694
3695    return it;
3696 }
3697
3698 EAPI Elm_Genlist_Item *
3699 elm_genlist_item_sorted_insert(Evas_Object                  *obj,
3700                                const Elm_Genlist_Item_Class *itc,
3701                                const void                   *data,
3702                                Elm_Genlist_Item             *parent,
3703                                Elm_Genlist_Item_Flags        flags,
3704                                Eina_Compare_Cb               comp,
3705                                Evas_Smart_Cb                 func,
3706                                const void                   *func_data)
3707 {
3708    _elm_genlist_item_compare_data_cb = comp;
3709
3710    return elm_genlist_item_direct_sorted_insert(obj, itc, data, parent, flags,
3711                                                 _elm_genlist_item_compare_data, func, func_data);
3712 }
3713
3714 EAPI void
3715 elm_genlist_clear(Evas_Object *obj)
3716 {
3717    ELM_CHECK_WIDTYPE(obj, widtype);
3718    Widget_Data *wd = elm_widget_data_get(obj);
3719    if (!wd) return;
3720    if (wd->state)
3721      {
3722         eina_inlist_sorted_state_free(wd->state);
3723         wd->state = NULL;
3724      }
3725    if (wd->walking > 0)
3726      {
3727         Elm_Genlist_Item *it;
3728
3729         wd->clear_me = EINA_TRUE;
3730         EINA_INLIST_FOREACH(wd->items, it)
3731           {
3732              it->delete_me = EINA_TRUE;
3733           }
3734         return;
3735      }
3736    evas_event_freeze(evas_object_evas_get(wd->obj));
3737    while (wd->items)
3738      {
3739         Elm_Genlist_Item *it = ELM_GENLIST_ITEM_FROM_INLIST(wd->items);
3740
3741         if (wd->anchor_item == it)
3742           {
3743              wd->anchor_item = ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->next);
3744              if (!wd->anchor_item)
3745                wd->anchor_item =
3746                  ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->prev);
3747           }
3748         wd->items = eina_inlist_remove(wd->items, wd->items);
3749         if (it->flags & ELM_GENLIST_ITEM_GROUP)
3750           it->wd->group_items = eina_list_remove(it->wd->group_items, it);
3751         elm_widget_item_pre_notify_del(it);
3752         if (it->realized) _item_unrealize(it, EINA_FALSE);
3753         if (((wd->clear_me) || (!it->delete_me)) && (it->itc->func.del))
3754           it->itc->func.del((void *)it->base.data, it->base.widget);
3755         if (it->long_timer) ecore_timer_del(it->long_timer);
3756         if (it->swipe_timer) ecore_timer_del(it->swipe_timer);
3757         elm_widget_item_del(it);
3758      }
3759    wd->clear_me = EINA_FALSE;
3760    wd->anchor_item = NULL;
3761    while (wd->blocks)
3762      {
3763         Item_Block *itb = (Item_Block *)(wd->blocks);
3764
3765         wd->blocks = eina_inlist_remove(wd->blocks, wd->blocks);
3766         if (itb->items) eina_list_free(itb->items);
3767         free(itb);
3768      }
3769    if (wd->calc_job)
3770      {
3771         ecore_job_del(wd->calc_job);
3772         wd->calc_job = NULL;
3773      }
3774    if (wd->queue_idle_enterer)
3775      {
3776         ecore_idle_enterer_del(wd->queue_idle_enterer);
3777         wd->queue_idle_enterer = NULL;
3778      }
3779    if (wd->must_recalc_idler)
3780      {
3781         ecore_idler_del(wd->must_recalc_idler);
3782         wd->must_recalc_idler = NULL;
3783      }
3784    if (wd->queue)
3785      {
3786         eina_list_free(wd->queue);
3787         wd->queue = NULL;
3788      }
3789    if (wd->selected)
3790      {
3791         eina_list_free(wd->selected);
3792         wd->selected = NULL;
3793      }
3794    if (wd->reorder_move_animator)
3795      {
3796         ecore_animator_del(wd->reorder_move_animator);
3797         wd->reorder_move_animator = NULL;
3798      }
3799    wd->show_item = NULL;
3800    wd->pan_x = 0;
3801    wd->pan_y = 0;
3802    wd->reorder_old_pan_y = 0;
3803    wd->minw = 0;
3804    wd->minh = 0;
3805    if (wd->pan_smart)
3806      {
3807         evas_object_size_hint_min_set(wd->pan_smart, wd->minw, wd->minh);
3808         evas_object_smart_callback_call(wd->pan_smart, "changed", NULL);
3809      }
3810    _sizing_eval(obj);
3811    elm_smart_scroller_child_region_show(wd->scr, 0, 0, 0, 0);
3812    evas_event_thaw(evas_object_evas_get(wd->obj));
3813    evas_event_thaw_eval(evas_object_evas_get(wd->obj));
3814 }
3815
3816 EAPI void
3817 elm_genlist_multi_select_set(Evas_Object *obj,
3818                              Eina_Bool    multi)
3819 {
3820    ELM_CHECK_WIDTYPE(obj, widtype);
3821    Widget_Data *wd = elm_widget_data_get(obj);
3822    if (!wd) return;
3823    wd->multi = multi;
3824 }
3825
3826 EAPI Eina_Bool
3827 elm_genlist_multi_select_get(const Evas_Object *obj)
3828 {
3829    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
3830    Widget_Data *wd = elm_widget_data_get(obj);
3831    if (!wd) return EINA_FALSE;
3832    return wd->multi;
3833 }
3834
3835 EAPI Elm_Genlist_Item *
3836 elm_genlist_selected_item_get(const Evas_Object *obj)
3837 {
3838    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3839    Widget_Data *wd = elm_widget_data_get(obj);
3840    if (!wd) return NULL;
3841    if (wd->selected) return wd->selected->data;
3842    return NULL;
3843 }
3844
3845 EAPI const Eina_List *
3846 elm_genlist_selected_items_get(const Evas_Object *obj)
3847 {
3848    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3849    Widget_Data *wd = elm_widget_data_get(obj);
3850    if (!wd) return NULL;
3851    return wd->selected;
3852 }
3853
3854 EAPI Eina_List *
3855 elm_genlist_realized_items_get(const Evas_Object *obj)
3856 {
3857    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3858    Widget_Data *wd = elm_widget_data_get(obj);
3859    Eina_List *list = NULL;
3860    Item_Block *itb;
3861    Eina_Bool done = EINA_FALSE;
3862    if (!wd) return NULL;
3863    EINA_INLIST_FOREACH(wd->blocks, itb)
3864      {
3865         if (itb->realized)
3866           {
3867              Eina_List *l;
3868              Elm_Genlist_Item *it;
3869
3870              done = 1;
3871              EINA_LIST_FOREACH(itb->items, l, it)
3872                {
3873                   if (it->realized) list = eina_list_append(list, it);
3874                }
3875           }
3876         else
3877           {
3878              if (done) break;
3879           }
3880      }
3881    return list;
3882 }
3883
3884 EAPI Elm_Genlist_Item *
3885 elm_genlist_at_xy_item_get(const Evas_Object *obj,
3886                            Evas_Coord         x,
3887                            Evas_Coord         y,
3888                            int               *posret)
3889 {
3890    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3891    Widget_Data *wd = elm_widget_data_get(obj);
3892    Evas_Coord ox, oy, ow, oh;
3893    Item_Block *itb;
3894    Evas_Coord lasty;
3895    if (!wd) return NULL;
3896    evas_object_geometry_get(wd->pan_smart, &ox, &oy, &ow, &oh);
3897    lasty = oy;
3898    EINA_INLIST_FOREACH(wd->blocks, itb)
3899      {
3900         Eina_List *l;
3901         Elm_Genlist_Item *it;
3902
3903         if (!ELM_RECTS_INTERSECT(ox + itb->x - itb->wd->pan_x,
3904                                  oy + itb->y - itb->wd->pan_y,
3905                                  itb->w, itb->h, x, y, 1, 1))
3906           continue;
3907         EINA_LIST_FOREACH(itb->items, l, it)
3908           {
3909              Evas_Coord itx, ity;
3910
3911              itx = ox + itb->x + it->x - itb->wd->pan_x;
3912              ity = oy + itb->y + it->y - itb->wd->pan_y;
3913              if (ELM_RECTS_INTERSECT(itx, ity, it->w, it->h, x, y, 1, 1))
3914                {
3915                   if (posret)
3916                     {
3917                        if (y <= (ity + (it->h / 4))) *posret = -1;
3918                        else if (y >= (ity + it->h - (it->h / 4)))
3919                          *posret = 1;
3920                        else *posret = 0;
3921                     }
3922                   return it;
3923                }
3924              lasty = ity + it->h;
3925           }
3926      }
3927    if (posret)
3928      {
3929         if (y > lasty) *posret = 1;
3930         else *posret = -1;
3931      }
3932    return NULL;
3933 }
3934
3935 EAPI Elm_Genlist_Item *
3936 elm_genlist_first_item_get(const Evas_Object *obj)
3937 {
3938    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3939    Widget_Data *wd = elm_widget_data_get(obj);
3940    if (!wd) return NULL;
3941    if (!wd->items) return NULL;
3942    Elm_Genlist_Item *it = ELM_GENLIST_ITEM_FROM_INLIST(wd->items);
3943    while ((it) && (it->delete_me))
3944      it = ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->next);
3945    return it;
3946 }
3947
3948 EAPI Elm_Genlist_Item *
3949 elm_genlist_last_item_get(const Evas_Object *obj)
3950 {
3951    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
3952    Widget_Data *wd = elm_widget_data_get(obj);
3953    if (!wd) return NULL;
3954    if (!wd->items) return NULL;
3955    Elm_Genlist_Item *it = ELM_GENLIST_ITEM_FROM_INLIST(wd->items->last);
3956    while ((it) && (it->delete_me))
3957      it = ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->prev);
3958    return it;
3959 }
3960
3961 EAPI Elm_Genlist_Item *
3962 elm_genlist_item_next_get(const Elm_Genlist_Item *it)
3963 {
3964    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
3965    while (it)
3966      {
3967         it = ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->next);
3968         if ((it) && (!it->delete_me)) break;
3969      }
3970    return (Elm_Genlist_Item *)it;
3971 }
3972
3973 EAPI Elm_Genlist_Item *
3974 elm_genlist_item_prev_get(const Elm_Genlist_Item *it)
3975 {
3976    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
3977    while (it)
3978      {
3979         it = ELM_GENLIST_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->prev);
3980         if ((it) && (!it->delete_me)) break;
3981      }
3982    return (Elm_Genlist_Item *)it;
3983 }
3984
3985 EAPI Evas_Object *
3986 elm_genlist_item_genlist_get(const Elm_Genlist_Item *it)
3987 {
3988    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
3989    return it->base.widget;
3990 }
3991
3992 EAPI Elm_Genlist_Item *
3993 elm_genlist_item_parent_get(const Elm_Genlist_Item *it)
3994 {
3995    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
3996    return it->parent;
3997 }
3998
3999 EAPI void
4000 elm_genlist_item_subitems_clear(Elm_Genlist_Item *it)
4001 {
4002    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
4003    Eina_List *tl = NULL, *l;
4004    Elm_Genlist_Item *it2;
4005
4006    EINA_LIST_FOREACH(it->items, l, it2)
4007      tl = eina_list_append(tl, it2);
4008    EINA_LIST_FREE(tl, it2)
4009      elm_genlist_item_del(it2);
4010 }
4011
4012 EAPI void
4013 elm_genlist_item_selected_set(Elm_Genlist_Item *it,
4014                               Eina_Bool         selected)
4015 {
4016    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
4017    Widget_Data *wd = elm_widget_data_get(it->base.widget);
4018    if (!wd) return;
4019    if ((it->delete_me) || (it->disabled)) return;
4020    selected = !!selected;
4021    if (it->selected == selected) return;
4022
4023    if (selected)
4024      {
4025         if (!wd->multi)
4026           {
4027              while (wd->selected)
4028                {
4029                   _item_unhighlight(wd->selected->data);
4030                   _item_unselect(wd->selected->data);
4031                }
4032           }
4033         _item_highlight(it);
4034         _item_select(it);
4035      }
4036    else
4037      {
4038         _item_unhighlight(it);
4039         _item_unselect(it);
4040      }
4041 }
4042
4043 EAPI Eina_Bool
4044 elm_genlist_item_selected_get(const Elm_Genlist_Item *it)
4045 {
4046    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, EINA_FALSE);
4047    return it->selected;
4048 }
4049
4050 EAPI void
4051 elm_genlist_item_expanded_set(Elm_Genlist_Item *it,
4052                               Eina_Bool         expanded)
4053 {
4054    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
4055    if (it->expanded == expanded) return;
4056    it->expanded = expanded;
4057    it->wd->expanded_item = it;
4058    if (it->expanded)
4059      {
4060         if (it->realized)
4061           edje_object_signal_emit(it->base.view, "elm,state,expanded", "elm");
4062         evas_object_smart_callback_call(it->base.widget, SIG_EXPANDED, it);
4063         it->wd->auto_scroll_enabled = EINA_TRUE;
4064      }
4065    else
4066      {
4067         if (it->realized)
4068           edje_object_signal_emit(it->base.view, "elm,state,contracted", "elm");
4069         evas_object_smart_callback_call(it->base.widget, SIG_CONTRACTED, it);
4070         it->wd->auto_scroll_enabled = EINA_FALSE;
4071      }
4072 }
4073
4074 EAPI Eina_Bool
4075 elm_genlist_item_expanded_get(const Elm_Genlist_Item *it)
4076 {
4077    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, EINA_FALSE);
4078    return it->expanded;
4079 }
4080
4081 EAPI int
4082 elm_genlist_item_expanded_depth_get(const Elm_Genlist_Item *it)
4083 {
4084    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, 0);
4085    return it->expanded_depth;
4086 }
4087
4088 EAPI void
4089 elm_genlist_item_disabled_set(Elm_Genlist_Item *it,
4090                               Eina_Bool         disabled)
4091 {
4092    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
4093    Eina_List *l;
4094    Evas_Object *obj;
4095    if (it->disabled == disabled) return;
4096    if (it->delete_me) return;
4097    it->disabled = !!disabled;
4098    if (it->selected)
4099      elm_genlist_item_selected_set(it, EINA_FALSE);
4100    if (it->realized)
4101      {
4102         if (it->disabled)
4103           edje_object_signal_emit(it->base.view, "elm,state,disabled", "elm");
4104         else
4105           edje_object_signal_emit(it->base.view, "elm,state,enabled", "elm");
4106         EINA_LIST_FOREACH(it->icon_objs, l, obj)
4107           elm_widget_disabled_set(obj, disabled);
4108      }
4109 }
4110
4111 EAPI Eina_Bool
4112 elm_genlist_item_disabled_get(const Elm_Genlist_Item *it)
4113 {
4114    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, EINA_FALSE);
4115    if (it->delete_me) return EINA_FALSE;
4116    return it->disabled;
4117 }
4118
4119 EAPI void
4120 elm_genlist_item_display_only_set(Elm_Genlist_Item *it,
4121                                   Eina_Bool         display_only)
4122 {
4123    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
4124    if (it->display_only == display_only) return;
4125    if (it->delete_me) return;
4126    it->display_only = display_only;
4127    it->mincalcd = EINA_FALSE;
4128    it->updateme = EINA_TRUE;
4129    if (it->block) it->block->updateme = EINA_TRUE;
4130    if (it->wd->update_job) ecore_job_del(it->wd->update_job);
4131    it->wd->update_job = ecore_job_add(_update_job, it->wd);
4132 }
4133
4134 EAPI Eina_Bool
4135 elm_genlist_item_display_only_get(const Elm_Genlist_Item *it)
4136 {
4137    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, EINA_FALSE);
4138    if (it->delete_me) return EINA_FALSE;
4139    return it->display_only;
4140 }
4141
4142 EAPI void
4143 elm_genlist_item_show(Elm_Genlist_Item *it)
4144 {
4145    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
4146    Evas_Coord gith = 0;
4147    if (it->delete_me) return;
4148    if ((it->queued) || (!it->mincalcd))
4149      {
4150         it->wd->show_item = it;
4151         it->wd->bring_in = EINA_TRUE;
4152         it->showme = EINA_TRUE;
4153         return;
4154      }
4155    if (it->wd->show_item)
4156      {
4157         it->wd->show_item->showme = EINA_FALSE;
4158         it->wd->show_item = NULL;
4159      }
4160    if ((it->group_item) && (it->wd->pan_y > (it->y + it->block->y)))
4161      gith = it->group_item->h;
4162    elm_smart_scroller_child_region_show(it->wd->scr,
4163                                         it->x + it->block->x,
4164                                         it->y + it->block->y - gith,
4165                                         it->block->w, it->h);
4166 }
4167
4168 EAPI void
4169 elm_genlist_item_bring_in(Elm_Genlist_Item *it)
4170 {
4171    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
4172    Evas_Coord gith = 0;
4173    if (it->delete_me) return;
4174    if ((it->queued) || (!it->mincalcd))
4175      {
4176         it->wd->show_item = it;
4177         it->wd->bring_in = EINA_TRUE;
4178         it->showme = EINA_TRUE;
4179         return;
4180      }
4181    if (it->wd->show_item)
4182      {
4183         it->wd->show_item->showme = EINA_FALSE;
4184         it->wd->show_item = NULL;
4185      }
4186    if ((it->group_item) && (it->wd->pan_y > (it->y + it->block->y)))
4187      gith = it->group_item->h;
4188    elm_smart_scroller_region_bring_in(it->wd->scr,
4189                                       it->x + it->block->x,
4190                                       it->y + it->block->y - gith,
4191                                       it->block->w, it->h);
4192 }
4193
4194 EAPI void
4195 elm_genlist_item_top_show(Elm_Genlist_Item *it)
4196 {
4197    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
4198    Evas_Coord ow, oh;
4199    Evas_Coord gith = 0;
4200
4201    if (it->delete_me) return;
4202    if ((it->queued) || (!it->mincalcd))
4203      {
4204         it->wd->show_item = it;
4205         it->wd->bring_in = EINA_TRUE;
4206         it->showme = EINA_TRUE;
4207         return;
4208      }
4209    if (it->wd->show_item)
4210      {
4211         it->wd->show_item->showme = EINA_FALSE;
4212         it->wd->show_item = NULL;
4213      }
4214    evas_object_geometry_get(it->wd->pan_smart, NULL, NULL, &ow, &oh);
4215    if (it->group_item) gith = it->group_item->h;
4216    elm_smart_scroller_child_region_show(it->wd->scr,
4217                                         it->x + it->block->x,
4218                                         it->y + it->block->y - gith,
4219                                         it->block->w, oh);
4220 }
4221
4222 EAPI void
4223 elm_genlist_item_top_bring_in(Elm_Genlist_Item *it)
4224 {
4225    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
4226    Evas_Coord ow, oh;
4227    Evas_Coord gith = 0;
4228
4229    if (it->delete_me) return;
4230    if ((it->queued) || (!it->mincalcd))
4231      {
4232         it->wd->show_item = it;
4233         it->wd->bring_in = EINA_TRUE;
4234         it->showme = EINA_TRUE;
4235         return;
4236      }
4237    if (it->wd->show_item)
4238      {
4239         it->wd->show_item->showme = EINA_FALSE;
4240         it->wd->show_item = NULL;
4241      }
4242    evas_object_geometry_get(it->wd->pan_smart, NULL, NULL, &ow, &oh);
4243    if (it->group_item) gith = it->group_item->h;
4244    elm_smart_scroller_region_bring_in(it->wd->scr,
4245                                       it->x + it->block->x,
4246                                       it->y + it->block->y - gith,
4247                                       it->block->w, oh);
4248 }
4249
4250 EAPI void
4251 elm_genlist_item_middle_show(Elm_Genlist_Item *it)
4252 {
4253    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
4254    Evas_Coord ow, oh;
4255
4256    if (it->delete_me) return;
4257    if ((it->queued) || (!it->mincalcd))
4258      {
4259         it->wd->show_item = it;
4260         it->wd->bring_in = EINA_TRUE;
4261         it->showme = EINA_TRUE;
4262         return;
4263      }
4264    if (it->wd->show_item)
4265      {
4266         it->wd->show_item->showme = EINA_FALSE;
4267         it->wd->show_item = NULL;
4268      }
4269    evas_object_geometry_get(it->wd->pan_smart, NULL, NULL, &ow, &oh);
4270    elm_smart_scroller_child_region_show(it->wd->scr,
4271                                         it->x + it->block->x,
4272                                         it->y + it->block->y - oh / 2 +
4273                                         it->h / 2, it->block->w, oh);
4274 }
4275
4276 EAPI void
4277 elm_genlist_item_middle_bring_in(Elm_Genlist_Item *it)
4278 {
4279    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
4280    Evas_Coord ow, oh;
4281
4282    if (it->delete_me) return;
4283    if ((it->queued) || (!it->mincalcd))
4284      {
4285         it->wd->show_item = it;
4286         it->wd->bring_in = EINA_TRUE;
4287         it->showme = EINA_TRUE;
4288         return;
4289      }
4290    if (it->wd->show_item)
4291      {
4292         it->wd->show_item->showme = EINA_FALSE;
4293         it->wd->show_item = NULL;
4294      }
4295    evas_object_geometry_get(it->wd->pan_smart, NULL, NULL, &ow, &oh);
4296    elm_smart_scroller_region_bring_in(it->wd->scr,
4297                                       it->x + it->block->x,
4298                                       it->y + it->block->y - oh / 2 + it->h / 2,
4299                                       it->block->w, oh);
4300 }
4301
4302 EAPI void
4303 elm_genlist_item_del(Elm_Genlist_Item *it)
4304 {
4305    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
4306    if ((it->relcount > 0) || (it->walking > 0))
4307      {
4308         elm_widget_item_pre_notify_del(it);
4309         elm_genlist_item_subitems_clear(it);
4310         it->delete_me = EINA_TRUE;
4311         if (it->wd->show_item == it) it->wd->show_item = NULL;
4312         if (it->selected)
4313           it->wd->selected = eina_list_remove(it->wd->selected,
4314                                               it);
4315         if (it->block)
4316           {
4317              if (it->realized) _item_unrealize(it, EINA_FALSE);
4318              it->block->changed = EINA_TRUE;
4319              if (it->wd->calc_job) ecore_job_del(it->wd->calc_job);
4320              it->wd->calc_job = ecore_job_add(_calc_job, it->wd);
4321           }
4322         if (it->itc->func.del)
4323           it->itc->func.del((void *)it->base.data, it->base.widget);
4324         return;
4325      }
4326    _item_del(it);
4327 }
4328
4329 EAPI void
4330 elm_genlist_item_data_set(Elm_Genlist_Item *it,
4331                           const void       *data)
4332 {
4333    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
4334    elm_widget_item_data_set(it, data);
4335 }
4336
4337 EAPI void *
4338 elm_genlist_item_data_get(const Elm_Genlist_Item *it)
4339 {
4340    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
4341    return elm_widget_item_data_get(it);
4342 }
4343
4344 EAPI void
4345 elm_genlist_item_icons_orphan(Elm_Genlist_Item *it)
4346 {
4347    Evas_Object *icon;
4348    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
4349    EINA_LIST_FREE(it->icon_objs, icon)
4350      {
4351         elm_widget_sub_object_del(it->base.widget, icon);
4352         evas_object_smart_member_del(icon);
4353         evas_object_hide(icon);
4354      }
4355 }
4356
4357 EAPI const Evas_Object *
4358 elm_genlist_item_object_get(const Elm_Genlist_Item *it)
4359 {
4360    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
4361    return it->base.view;
4362 }
4363
4364 EAPI void
4365 elm_genlist_item_update(Elm_Genlist_Item *it)
4366 {
4367    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
4368    if (!it->block) return;
4369    if (it->delete_me) return;
4370    it->mincalcd = EINA_FALSE;
4371    it->updateme = EINA_TRUE;
4372    it->block->updateme = EINA_TRUE;
4373    if (it->wd->update_job) ecore_job_del(it->wd->update_job);
4374    it->wd->update_job = ecore_job_add(_update_job, it->wd);
4375 }
4376
4377 EAPI void
4378 elm_genlist_item_item_class_update(Elm_Genlist_Item             *it,
4379                                    const Elm_Genlist_Item_Class *itc)
4380 {
4381    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
4382    if (!it->block) return;
4383    EINA_SAFETY_ON_NULL_RETURN(itc);
4384    if (it->delete_me) return;
4385    it->itc = itc;
4386    it->nocache = EINA_TRUE;
4387    elm_genlist_item_update(it);
4388 }
4389
4390 EAPI const Elm_Genlist_Item_Class *
4391 elm_genlist_item_item_class_get(const Elm_Genlist_Item *it)
4392 {
4393    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
4394    if (it->delete_me) return NULL;
4395    return it->itc;
4396 }
4397
4398 static Evas_Object *
4399 _elm_genlist_item_label_create(void        *data,
4400                                Evas_Object *obj __UNUSED__,
4401                                Evas_Object *tooltip,
4402                                void        *item __UNUSED__)
4403 {
4404    Evas_Object *label = elm_label_add(tooltip);
4405    if (!label)
4406      return NULL;
4407    elm_object_style_set(label, "tooltip");
4408    elm_object_text_set(label, data);
4409    return label;
4410 }
4411
4412 static void
4413 _elm_genlist_item_label_del_cb(void        *data,
4414                                Evas_Object *obj __UNUSED__,
4415                                void        *event_info __UNUSED__)
4416 {
4417    eina_stringshare_del(data);
4418 }
4419
4420 EAPI void
4421 elm_genlist_item_tooltip_text_set(Elm_Genlist_Item *item,
4422                                   const char       *text)
4423 {
4424    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item);
4425    text = eina_stringshare_add(text);
4426    elm_genlist_item_tooltip_content_cb_set(item, _elm_genlist_item_label_create,
4427                                            text,
4428                                            _elm_genlist_item_label_del_cb);
4429 }
4430
4431 EAPI void
4432 elm_genlist_item_tooltip_content_cb_set(Elm_Genlist_Item           *item,
4433                                         Elm_Tooltip_Item_Content_Cb func,
4434                                         const void                 *data,
4435                                         Evas_Smart_Cb               del_cb)
4436 {
4437    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_GOTO(item, error);
4438
4439    if ((item->tooltip.content_cb == func) && (item->tooltip.data == data))
4440      return;
4441
4442    if (item->tooltip.del_cb)
4443      item->tooltip.del_cb((void *)item->tooltip.data,
4444                           item->base.widget, item);
4445
4446    item->tooltip.content_cb = func;
4447    item->tooltip.data = data;
4448    item->tooltip.del_cb = del_cb;
4449
4450    if (item->base.view)
4451      {
4452         elm_widget_item_tooltip_content_cb_set(item,
4453                                                item->tooltip.content_cb,
4454                                                item->tooltip.data, NULL);
4455         elm_widget_item_tooltip_style_set(item, item->tooltip.style);
4456         elm_widget_item_tooltip_size_restrict_disable(item, item->tooltip.free_size);
4457      }
4458
4459    return;
4460
4461 error:
4462    if (del_cb) del_cb((void *)data, NULL, NULL);
4463 }
4464
4465 EAPI void
4466 elm_genlist_item_tooltip_unset(Elm_Genlist_Item *item)
4467 {
4468    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item);
4469    if ((item->base.view) && (item->tooltip.content_cb))
4470      elm_widget_item_tooltip_unset(item);
4471
4472    if (item->tooltip.del_cb)
4473      item->tooltip.del_cb((void *)item->tooltip.data, item->base.widget, item);
4474    item->tooltip.del_cb = NULL;
4475    item->tooltip.content_cb = NULL;
4476    item->tooltip.data = NULL;
4477    item->tooltip.free_size = EINA_FALSE;
4478    if (item->tooltip.style)
4479      elm_genlist_item_tooltip_style_set(item, NULL);
4480 }
4481
4482 EAPI void
4483 elm_genlist_item_tooltip_style_set(Elm_Genlist_Item *item,
4484                                    const char       *style)
4485 {
4486    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item);
4487    eina_stringshare_replace(&item->tooltip.style, style);
4488    if (item->base.view) elm_widget_item_tooltip_style_set(item, style);
4489 }
4490
4491 EAPI const char *
4492 elm_genlist_item_tooltip_style_get(const Elm_Genlist_Item *item)
4493 {
4494    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item, NULL);
4495    return item->tooltip.style;
4496 }
4497
4498 EAPI Eina_Bool
4499 elm_genlist_item_tooltip_size_restrict_disable(Elm_Genlist_Item *item, Eina_Bool disable)
4500 {
4501    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item, EINA_FALSE);
4502    item->tooltip.free_size = disable;
4503    if (item->base.view) return elm_widget_item_tooltip_size_restrict_disable(item, disable);
4504    return EINA_TRUE;
4505 }
4506
4507 EAPI Eina_Bool
4508 elm_genlist_item_tooltip_size_restrict_disabled_get(const Elm_Genlist_Item *item)
4509 {
4510    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item, EINA_FALSE);
4511    return item->tooltip.free_size;
4512 }
4513
4514 EAPI void
4515 elm_genlist_item_cursor_set(Elm_Genlist_Item *item,
4516                             const char       *cursor)
4517 {
4518    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item);
4519    eina_stringshare_replace(&item->mouse_cursor, cursor);
4520    if (item->base.view) elm_widget_item_cursor_set(item, cursor);
4521 }
4522
4523 EAPI const char *
4524 elm_genlist_item_cursor_get(const Elm_Genlist_Item *item)
4525 {
4526    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item, NULL);
4527    return elm_widget_item_cursor_get(item);
4528 }
4529
4530 EAPI void
4531 elm_genlist_item_cursor_unset(Elm_Genlist_Item *item)
4532 {
4533    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item);
4534    if (!item->mouse_cursor)
4535      return;
4536
4537    if (item->base.view)
4538      elm_widget_item_cursor_unset(item);
4539
4540    eina_stringshare_del(item->mouse_cursor);
4541    item->mouse_cursor = NULL;
4542 }
4543
4544 EAPI void
4545 elm_genlist_item_cursor_style_set(Elm_Genlist_Item *item,
4546                                   const char       *style)
4547 {
4548    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item);
4549    elm_widget_item_cursor_style_set(item, style);
4550 }
4551
4552 EAPI const char *
4553 elm_genlist_item_cursor_style_get(const Elm_Genlist_Item *item)
4554 {
4555    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item, NULL);
4556    return elm_widget_item_cursor_style_get(item);
4557 }
4558
4559 EAPI void
4560 elm_genlist_item_cursor_engine_only_set(Elm_Genlist_Item *item,
4561                                         Eina_Bool         engine_only)
4562 {
4563    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item);
4564    elm_widget_item_cursor_engine_only_set(item, engine_only);
4565 }
4566
4567 EAPI Eina_Bool
4568 elm_genlist_item_cursor_engine_only_get(const Elm_Genlist_Item *item)
4569 {
4570    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(item, EINA_FALSE);
4571    return elm_widget_item_cursor_engine_only_get(item);
4572 }
4573
4574 EAPI void
4575 elm_genlist_horizontal_set(Evas_Object  *obj,
4576                                 Elm_List_Mode mode)
4577 {
4578    ELM_CHECK_WIDTYPE(obj, widtype);
4579    Widget_Data *wd = elm_widget_data_get(obj);
4580    if (!wd) return;
4581    if (wd->mode == mode) return;
4582    wd->mode = mode;
4583    _sizing_eval(obj);
4584 }
4585
4586 EAPI void
4587 elm_genlist_horizontal_mode_set(Evas_Object  *obj,
4588                                 Elm_List_Mode mode)
4589 {
4590    elm_genlist_horizontal_set(obj, mode);
4591 }
4592
4593 EAPI Elm_List_Mode
4594 elm_genlist_horizontal_get(const Evas_Object *obj)
4595 {
4596    ELM_CHECK_WIDTYPE(obj, widtype) ELM_LIST_LAST;
4597    Widget_Data *wd = elm_widget_data_get(obj);
4598    if (!wd) return ELM_LIST_LAST;
4599    return wd->mode;
4600 }
4601
4602 EAPI Elm_List_Mode
4603 elm_genlist_horizontal_mode_get(const Evas_Object *obj)
4604 {
4605    return elm_genlist_horizontal_get(obj);
4606 }
4607
4608 EAPI void
4609 elm_genlist_always_select_mode_set(Evas_Object *obj,
4610                                    Eina_Bool    always_select)
4611 {
4612    ELM_CHECK_WIDTYPE(obj, widtype);
4613    Widget_Data *wd = elm_widget_data_get(obj);
4614    if (!wd) return;
4615    wd->always_select = always_select;
4616 }
4617
4618 EAPI Eina_Bool
4619 elm_genlist_always_select_mode_get(const Evas_Object *obj)
4620 {
4621    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
4622    Widget_Data *wd = elm_widget_data_get(obj);
4623    if (!wd) return EINA_FALSE;
4624    return wd->always_select;
4625 }
4626
4627 EAPI void
4628 elm_genlist_no_select_mode_set(Evas_Object *obj,
4629                                Eina_Bool    no_select)
4630 {
4631    ELM_CHECK_WIDTYPE(obj, widtype);
4632    Widget_Data *wd = elm_widget_data_get(obj);
4633    if (!wd) return;
4634    wd->no_select = no_select;
4635 }
4636
4637 EAPI Eina_Bool
4638 elm_genlist_no_select_mode_get(const Evas_Object *obj)
4639 {
4640    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
4641    Widget_Data *wd = elm_widget_data_get(obj);
4642    if (!wd) return EINA_FALSE;
4643    return wd->no_select;
4644 }
4645
4646 EAPI void
4647 elm_genlist_compress_mode_set(Evas_Object *obj,
4648                               Eina_Bool    compress)
4649 {
4650    ELM_CHECK_WIDTYPE(obj, widtype);
4651    Widget_Data *wd = elm_widget_data_get(obj);
4652    if (!wd) return;
4653    wd->compress = compress;
4654    if (!compress) elm_genlist_homogeneous_set(obj, EINA_FALSE);
4655 }
4656
4657 EAPI Eina_Bool
4658 elm_genlist_compress_mode_get(const Evas_Object *obj)
4659 {
4660    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
4661    Widget_Data *wd = elm_widget_data_get(obj);
4662    if (!wd) return EINA_FALSE;
4663    return wd->compress;
4664 }
4665
4666 EAPI void
4667 elm_genlist_height_for_width_mode_set(Evas_Object *obj,
4668                                       Eina_Bool    height_for_width)
4669 {
4670    ELM_CHECK_WIDTYPE(obj, widtype);
4671    Widget_Data *wd = elm_widget_data_get(obj);
4672    if (!wd) return;
4673    wd->height_for_width = !!height_for_width;
4674    if (wd->height_for_width)
4675      {
4676         elm_genlist_homogeneous_set(obj, EINA_FALSE);
4677         elm_genlist_compress_mode_set(obj, EINA_TRUE);
4678      }
4679 }
4680
4681 EAPI Eina_Bool
4682 elm_genlist_height_for_width_mode_get(const Evas_Object *obj)
4683 {
4684    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
4685    Widget_Data *wd = elm_widget_data_get(obj);
4686    if (!wd) return EINA_FALSE;
4687    return wd->height_for_width;
4688 }
4689
4690 EAPI void
4691 elm_genlist_bounce_set(Evas_Object *obj,
4692                        Eina_Bool    h_bounce,
4693                        Eina_Bool    v_bounce)
4694 {
4695    ELM_CHECK_WIDTYPE(obj, widtype);
4696    Widget_Data *wd = elm_widget_data_get(obj);
4697    if (!wd) return;
4698    elm_smart_scroller_bounce_allow_set(wd->scr, h_bounce, v_bounce);
4699 }
4700
4701 EAPI void
4702 elm_genlist_bounce_get(const Evas_Object *obj,
4703                        Eina_Bool         *h_bounce,
4704                        Eina_Bool         *v_bounce)
4705 {
4706    ELM_CHECK_WIDTYPE(obj, widtype);
4707    Widget_Data *wd = elm_widget_data_get(obj);
4708    if (!wd) return;
4709    elm_smart_scroller_bounce_allow_get(wd->scr, h_bounce, v_bounce);
4710 }
4711
4712 EAPI void
4713 elm_genlist_homogeneous_set(Evas_Object *obj,
4714                             Eina_Bool    homogeneous)
4715 {
4716    ELM_CHECK_WIDTYPE(obj, widtype);
4717    Widget_Data *wd = elm_widget_data_get(obj);
4718    if (!wd) return;
4719    if (homogeneous) elm_genlist_compress_mode_set(obj, EINA_TRUE);
4720    wd->homogeneous = homogeneous;
4721 }
4722
4723 EAPI Eina_Bool
4724 elm_genlist_homogeneous_get(const Evas_Object *obj)
4725 {
4726    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
4727    Widget_Data *wd = elm_widget_data_get(obj);
4728    if (!wd) return EINA_FALSE;
4729    return wd->homogeneous;
4730 }
4731
4732 EAPI void
4733 elm_genlist_block_count_set(Evas_Object *obj,
4734                             int          n)
4735 {
4736    ELM_CHECK_WIDTYPE(obj, widtype);
4737    Widget_Data *wd = elm_widget_data_get(obj);
4738    if (!wd) return;
4739    wd->max_items_per_block = n;
4740    wd->item_cache_max = wd->max_items_per_block * 2;
4741    _item_cache_clean(wd);
4742 }
4743
4744 EAPI int
4745 elm_genlist_block_count_get(const Evas_Object *obj)
4746 {
4747    ELM_CHECK_WIDTYPE(obj, widtype) 0;
4748    Widget_Data *wd = elm_widget_data_get(obj);
4749    if (!wd) return 0;
4750    return wd->max_items_per_block;
4751 }
4752
4753 EAPI void
4754 elm_genlist_longpress_timeout_set(Evas_Object *obj,
4755                                   double       timeout)
4756 {
4757    ELM_CHECK_WIDTYPE(obj, widtype);
4758    Widget_Data *wd = elm_widget_data_get(obj);
4759    if (!wd) return;
4760    wd->longpress_timeout = timeout;
4761 }
4762
4763 EAPI double
4764 elm_genlist_longpress_timeout_get(const Evas_Object *obj)
4765 {
4766    ELM_CHECK_WIDTYPE(obj, widtype) 0;
4767    Widget_Data *wd = elm_widget_data_get(obj);
4768    if (!wd) return 0;
4769    return wd->longpress_timeout;
4770 }
4771
4772 EAPI void
4773 elm_genlist_scroller_policy_set(Evas_Object        *obj,
4774                                 Elm_Scroller_Policy policy_h,
4775                                 Elm_Scroller_Policy policy_v)
4776 {
4777    ELM_CHECK_WIDTYPE(obj, widtype);
4778    Widget_Data *wd = elm_widget_data_get(obj);
4779    if ((!wd) || (!wd->scr)) return;
4780    if ((policy_h >= ELM_SCROLLER_POLICY_LAST) ||
4781        (policy_v >= ELM_SCROLLER_POLICY_LAST))
4782      return;
4783    elm_smart_scroller_policy_set(wd->scr, policy_h, policy_v);
4784 }
4785
4786 EAPI void
4787 elm_genlist_scroller_policy_get(const Evas_Object   *obj,
4788                                 Elm_Scroller_Policy *policy_h,
4789                                 Elm_Scroller_Policy *policy_v)
4790 {
4791    ELM_CHECK_WIDTYPE(obj, widtype);
4792    Widget_Data *wd = elm_widget_data_get(obj);
4793    Elm_Smart_Scroller_Policy s_policy_h, s_policy_v;
4794    if ((!wd) || (!wd->scr)) return;
4795    elm_smart_scroller_policy_get(wd->scr, &s_policy_h, &s_policy_v);
4796    if (policy_h) *policy_h = (Elm_Scroller_Policy)s_policy_h;
4797    if (policy_v) *policy_v = (Elm_Scroller_Policy)s_policy_v;
4798 }
4799
4800 EAPI void
4801 elm_genlist_realized_items_update(Evas_Object *obj)
4802 {
4803    ELM_CHECK_WIDTYPE(obj, widtype);
4804
4805    Eina_List *list, *l;
4806    Elm_Genlist_Item *it;
4807
4808    list = elm_genlist_realized_items_get(obj);
4809    EINA_LIST_FOREACH(list, l, it)
4810      elm_genlist_item_update(it);
4811 }
4812
4813 EAPI void
4814 elm_genlist_item_mode_set(Elm_Genlist_Item *it,
4815                           const char       *mode_type,
4816                           Eina_Bool         mode_set)
4817 {
4818    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
4819    Widget_Data *wd = it->wd;
4820    Eina_List *l;
4821    Elm_Genlist_Item *it2;
4822
4823    if (!wd) return;
4824    if (!mode_type) return;
4825    if ((it->delete_me) || (it->disabled)) return;
4826
4827    if ((wd->mode_item == it) &&
4828        (!strcmp(mode_type, wd->mode_type)) &&
4829        (mode_set))
4830       return;
4831    if (!it->itc->mode_item_style) return;
4832
4833    if (wd->multi)
4834      {
4835         EINA_LIST_FOREACH(wd->selected, l, it2)
4836           if (it2->realized)
4837             elm_genlist_item_selected_set(it2, EINA_FALSE);
4838      }
4839    else
4840      {
4841         it2 = elm_genlist_selected_item_get(wd->obj);
4842         if ((it2) && (it2->realized))
4843           elm_genlist_item_selected_set(it2, EINA_FALSE);
4844      }
4845
4846    if (((wd->mode_type) && (strcmp(mode_type, wd->mode_type))) ||
4847        (mode_set) ||
4848        ((it == wd->mode_item) && (!mode_set)))
4849      _item_mode_unset(wd);
4850
4851    eina_stringshare_replace(&wd->mode_type, mode_type);
4852    if (mode_set) _item_mode_set(it);
4853 }
4854
4855 EAPI const char *
4856 elm_genlist_mode_get(const Evas_Object *obj)
4857 {
4858    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
4859    Widget_Data *wd = elm_widget_data_get(obj);
4860    if (!wd) return NULL;
4861    return wd->mode_type;
4862 }
4863
4864 EAPI const Elm_Genlist_Item *
4865 elm_genlist_mode_item_get(const Evas_Object *obj)
4866 {
4867    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
4868    Widget_Data *wd = elm_widget_data_get(obj);
4869    if (!wd) return NULL;
4870    return wd->mode_item;
4871 }
4872
4873 EAPI void
4874 elm_genlist_reorder_mode_set(Evas_Object *obj,
4875                              Eina_Bool    reorder_mode)
4876 {
4877    ELM_CHECK_WIDTYPE(obj, widtype);
4878    Widget_Data *wd = elm_widget_data_get(obj);
4879    if (!wd) return;
4880    wd->reorder_mode = reorder_mode;
4881 }
4882
4883 EAPI Eina_Bool
4884 elm_genlist_reorder_mode_get(const Evas_Object *obj)
4885 {
4886    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
4887    Widget_Data *wd = elm_widget_data_get(obj);
4888    if (!wd) return EINA_FALSE;
4889    return wd->reorder_mode;
4890 }