src/lib/elm_genlist.c

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