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