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