src/lib/elm_genlist.c

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