src/lib/elm_genlist.c

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