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