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