src/lib/elm_genlist.c

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