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