src/lib/elm_genlist.c

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