src/lib/elm_gengrid.c

   1 #include <Elementary.h>
   2 #include <Elementary_Cursor.h>
   3 #include "elm_priv.h"
   4 #include "els_scroller.h"
   5 #include "elm_gen.h"
   6
   7 /* --
   8  * TODO:
   9  * Handle non-homogeneous objects too.
  10  */
  11
  12 #define PRELOAD 1
  13 #define REORDER_EFFECT_TIME 0.5
  14
  15 #define ELM_GEN_SETUP(wd) \
  16    (wd)->calc_cb = (Ecore_Cb)_calc_job
  17
  18 #define ELM_GEN_ITEM_SETUP(it) \
  19    (it)->del_cb = (Ecore_Cb)_item_del; \
  20    (it)->highlight_cb = (Ecore_Cb)_item_highlight; \
  21    (it)->unsel_cb = (Ecore_Cb)_item_unselect; \
  22    (it)->unrealize_cb = (Ecore_Cb)_item_unrealize_cb
  23
  24 struct Elm_Gen_Item_Type
  25 {
  26    Elm_Gen_Item   *it;
  27    Ecore_Animator *item_moving_effect_timer;
  28    Evas_Coord   gx, gy, ox, oy, tx, ty, rx, ry;
  29    unsigned int moving_effect_start_time;
  30    int          prev_group;
  31
  32    Eina_Bool   group_realized : 1;
  33    Eina_Bool   moving : 1;
  34 };
  35
  36 struct _Widget_Data
  37 {
  38    Eina_Inlist_Sorted_State *state;
  39    Evas_Object      *obj; /* the gengrid object */
  40    Evas_Object      *scr; /* a smart scroller object which is used internally in genlist */
  41    Evas_Object      *pan_smart; /* "elm_genlist_pan" evas smart object. this is an extern pan of smart scroller(scr). */
  42    Eina_List        *selected;
  43    Eina_List        *group_items; /* list of groups index items */
  44    Eina_Inlist      *items; /* inlist of all items */
  45    Elm_Gen_Item     *reorder_it; /* item currently being repositioned */
  46    Elm_Gen_Item     *last_selected_item;
  47    Pan              *pan; /* pan_smart object's smart data */
  48    Ecore_Job        *calc_job;
  49    int               walking;
  50    int               item_width, item_height;
  51    int               group_item_width, group_item_height;
  52    int               minw, minh;
  53    long              count;
  54    Evas_Coord        pan_x, pan_y;
  55    Eina_Bool         reorder_mode : 1;
  56    Eina_Bool         on_hold : 1;
  57    Eina_Bool         multi : 1;
  58    Eina_Bool         no_select : 1;
  59    Eina_Bool         wasselected : 1;
  60    Eina_Bool         always_select : 1;
  61    Eina_Bool         clear_me : 1;
  62    Eina_Bool         h_bounce : 1;
  63    Eina_Bool         v_bounce : 1;
  64    Ecore_Cb          del_cb, calc_cb, sizing_cb;
  65    Ecore_Cb          clear_cb;
  66    ////////////////////////////////////
  67    double            align_x, align_y;
  68
  69    Evas_Coord        old_pan_x, old_pan_y;
  70    Evas_Coord        reorder_item_x, reorder_item_y;
  71    unsigned int      nmax;
  72    long              items_lost;
  73
  74    Eina_Bool         horizontal : 1;
  75    Eina_Bool         longpressed : 1;
  76    Eina_Bool         reorder_item_changed : 1;
  77    Eina_Bool         move_effect_enabled : 1;
  78 };
  79
  80 static const char *widtype = NULL;
  81 static void      _item_highlight(Elm_Gen_Item *it);
  82 static void      _item_unrealize_cb(Elm_Gen_Item *it);
  83 static void      _item_unselect(Elm_Gen_Item *it);
  84 static void      _calc_job(void *data);
  85 static void      _on_focus_hook(void        *data,
  86                                 Evas_Object *obj);
  87 static Eina_Bool _item_multi_select_up(Widget_Data *wd);
  88 static Eina_Bool _item_multi_select_down(Widget_Data *wd);
  89 static Eina_Bool _item_multi_select_left(Widget_Data *wd);
  90 static Eina_Bool _item_multi_select_right(Widget_Data *wd);
  91 static Eina_Bool _item_single_select_up(Widget_Data *wd);
  92 static Eina_Bool _item_single_select_down(Widget_Data *wd);
  93 static Eina_Bool _item_single_select_left(Widget_Data *wd);
  94 static Eina_Bool _item_single_select_right(Widget_Data *wd);
  95 static Eina_Bool _event_hook(Evas_Object       *obj,
  96                              Evas_Object       *src,
  97                              Evas_Callback_Type type,
  98                              void              *event_info);
  99 static Eina_Bool _deselect_all_items(Widget_Data *wd);
 100
 101 static Evas_Smart_Class _pan_sc = EVAS_SMART_CLASS_INIT_VERSION;
 102 static void _mirrored_set(Evas_Object *obj, Eina_Bool rtl);
 103
 104 static const char SIG_ACTIVATED[] = "activated";
 105 static const char SIG_CLICKED_DOUBLE[] = "clicked,double";
 106 static const char SIG_LONGPRESSED[] = "longpressed";
 107 static const char SIG_SELECTED[] = "selected";
 108 static const char SIG_UNSELECTED[] = "unselected";
 109 static const char SIG_REALIZED[] = "realized";
 110 static const char SIG_UNREALIZED[] = "unrealized";
 111 static const char SIG_CHANGED[] = "changed";
 112 static const char SIG_DRAG_START_UP[] = "drag,start,up";
 113 static const char SIG_DRAG_START_DOWN[] = "drag,start,down";
 114 static const char SIG_DRAG_START_LEFT[] = "drag,start,left";
 115 static const char SIG_DRAG_START_RIGHT[] = "drag,start,right";
 116 static const char SIG_DRAG_STOP[] = "drag,stop";
 117 static const char SIG_DRAG[] = "drag";
 118 static const char SIG_SCROLL[] = "scroll";
 119 static const char SIG_SCROLL_ANIM_START[] = "scroll,anim,start";
 120 static const char SIG_SCROLL_ANIM_STOP[] = "scroll,anim,stop";
 121 static const char SIG_SCROLL_DRAG_START[] = "scroll,drag,start";
 122 static const char SIG_SCROLL_DRAG_STOP[] = "scroll,drag,stop";
 123 static const char SIG_SCROLL_EDGE_TOP[] = "scroll,edge,top"; // TODO : remove this
 124 static const char SIG_SCROLL_EDGE_BOTTOM[] = "scroll,edge,bottom"; // TODO : remove this
 125 static const char SIG_SCROLL_EDGE_LEFT[] = "scroll,edge,left"; // TODO : remove this
 126 static const char SIG_SCROLL_EDGE_RIGHT[] = "scroll,edge,right"; // TODO : remove this
 127 static const char SIG_EDGE_TOP[] = "edge,top";
 128 static const char SIG_EDGE_BOTTOM[] = "edge,bottom";
 129 static const char SIG_EDGE_LEFT[] = "edge,left";
 130 static const char SIG_EDGE_RIGHT[] = "edge,right";
 131 static const char SIG_MOVED[] = "moved";
 132
 133 static const Evas_Smart_Cb_Description _signals[] = {
 134    {SIG_ACTIVATED, ""},
 135    {SIG_CLICKED_DOUBLE, ""},
 136    {SIG_LONGPRESSED, ""},
 137    {SIG_SELECTED, ""},
 138    {SIG_UNSELECTED, ""},
 139    {SIG_REALIZED, ""},
 140    {SIG_UNREALIZED, ""},
 141    {SIG_CHANGED, ""},
 142    {SIG_DRAG_START_UP, ""},
 143    {SIG_DRAG_START_DOWN, ""},
 144    {SIG_DRAG_START_LEFT, ""},
 145    {SIG_DRAG_START_RIGHT, ""},
 146    {SIG_DRAG_STOP, ""},
 147    {SIG_DRAG, ""},
 148    {SIG_SCROLL, ""},
 149    {SIG_SCROLL_ANIM_START, ""},
 150    {SIG_SCROLL_ANIM_STOP, ""},
 151    {SIG_SCROLL_DRAG_START, ""},
 152    {SIG_SCROLL_DRAG_STOP, ""},
 153    {SIG_EDGE_TOP, ""},
 154    {SIG_EDGE_BOTTOM, ""},
 155    {SIG_EDGE_LEFT, ""},
 156    {SIG_EDGE_RIGHT, ""},
 157    {SIG_MOVED, ""},
 158    {NULL, NULL}
 159 };
 160
 161 static Eina_Compare_Cb _elm_gengrid_item_compare_cb;
 162 static Eina_Compare_Cb _elm_gengrid_item_compare_data_cb;
 163
 164 static Eina_Bool
 165 _event_hook(Evas_Object       *obj,
 166             Evas_Object *src   __UNUSED__,
 167             Evas_Callback_Type type,
 168             void              *event_info)
 169 {
 170    if (type != EVAS_CALLBACK_KEY_DOWN) return EINA_FALSE;
 171    Evas_Event_Key_Down *ev = event_info;
 172    Widget_Data *wd = elm_widget_data_get(obj);
 173    if (!wd) return EINA_FALSE;
 174    if (!wd->items) return EINA_FALSE;
 175    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return EINA_FALSE;
 176    if (elm_widget_disabled_get(obj)) return EINA_FALSE;
 177
 178    Elm_Gen_Item *it = NULL;
 179    Evas_Coord x = 0;
 180    Evas_Coord y = 0;
 181    Evas_Coord step_x = 0;
 182    Evas_Coord step_y = 0;
 183    Evas_Coord v_w = 0;
 184    Evas_Coord v_h = 0;
 185    Evas_Coord page_x = 0;
 186    Evas_Coord page_y = 0;
 187
 188    elm_smart_scroller_child_pos_get(wd->scr, &x, &y);
 189    elm_smart_scroller_step_size_get(wd->scr, &step_x, &step_y);
 190    elm_smart_scroller_page_size_get(wd->scr, &page_x, &page_y);
 191    elm_smart_scroller_child_viewport_size_get(wd->scr, &v_w, &v_h);
 192
 193    if ((!strcmp(ev->keyname, "Left")) || (!strcmp(ev->keyname, "KP_Left")))
 194      {
 195         if ((wd->horizontal) &&
 196             (((evas_key_modifier_is_set(ev->modifiers, "Shift")) &&
 197               (_item_multi_select_up(wd)))
 198              || (_item_single_select_up(wd))))
 199           {
 200              ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 201              return EINA_TRUE;
 202           }
 203         else if ((!wd->horizontal) &&
 204                  (((evas_key_modifier_is_set(ev->modifiers, "Shift")) &&
 205                    (_item_multi_select_left(wd)))
 206                   || (_item_single_select_left(wd))))
 207           {
 208              ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 209              return EINA_TRUE;
 210           }
 211         else
 212           x -= step_x;
 213      }
 214    else if ((!strcmp(ev->keyname, "Right")) || (!strcmp(ev->keyname, "KP_Right")))
 215      {
 216         if ((wd->horizontal) &&
 217             (((evas_key_modifier_is_set(ev->modifiers, "Shift")) &&
 218               (_item_multi_select_down(wd)))
 219              || (_item_single_select_down(wd))))
 220           {
 221              ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 222              return EINA_TRUE;
 223           }
 224         else if ((!wd->horizontal) &&
 225                  (((evas_key_modifier_is_set(ev->modifiers, "Shift")) &&
 226                    (_item_multi_select_right(wd)))
 227                   || (_item_single_select_right(wd))))
 228           {
 229              ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 230              return EINA_TRUE;
 231           }
 232         else
 233           x += step_x;
 234      }
 235    else if ((!strcmp(ev->keyname, "Up")) || (!strcmp(ev->keyname, "KP_Up")))
 236      {
 237         if ((wd->horizontal) &&
 238             (((evas_key_modifier_is_set(ev->modifiers, "Shift")) &&
 239               (_item_multi_select_left(wd)))
 240              || (_item_single_select_left(wd))))
 241           {
 242              ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 243              return EINA_TRUE;
 244           }
 245         else if ((!wd->horizontal) &&
 246                  (((evas_key_modifier_is_set(ev->modifiers, "Shift")) &&
 247                    (_item_multi_select_up(wd)))
 248                   || (_item_single_select_up(wd))))
 249           {
 250              ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 251              return EINA_TRUE;
 252           }
 253         else
 254           y -= step_y;
 255      }
 256    else if ((!strcmp(ev->keyname, "Down")) || (!strcmp(ev->keyname, "KP_Down")))
 257      {
 258         if ((wd->horizontal) &&
 259             (((evas_key_modifier_is_set(ev->modifiers, "Shift")) &&
 260               (_item_multi_select_right(wd)))
 261              || (_item_single_select_right(wd))))
 262           {
 263              ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 264              return EINA_TRUE;
 265           }
 266         else if ((!wd->horizontal) &&
 267                  (((evas_key_modifier_is_set(ev->modifiers, "Shift")) &&
 268                    (_item_multi_select_down(wd)))
 269                   || (_item_single_select_down(wd))))
 270           {
 271              ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 272              return EINA_TRUE;
 273           }
 274         else
 275           y += step_y;
 276      }
 277    else if ((!strcmp(ev->keyname, "Home")) || (!strcmp(ev->keyname, "KP_Home")))
 278      {
 279         it = elm_gen_first_item_get(obj);
 280         elm_gengrid_item_bring_in(it);
 281         ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 282         return EINA_TRUE;
 283      }
 284    else if ((!strcmp(ev->keyname, "End")) || (!strcmp(ev->keyname, "KP_End")))
 285      {
 286         it = elm_gen_last_item_get(obj);
 287         elm_gengrid_item_bring_in(it);
 288         ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 289         return EINA_TRUE;
 290      }
 291    else if ((!strcmp(ev->keyname, "Prior")) || (!strcmp(ev->keyname, "KP_Prior")))
 292      {
 293         if (wd->horizontal)
 294           {
 295              if (page_x < 0)
 296                x -= -(page_x * v_w) / 100;
 297              else
 298                x -= page_x;
 299           }
 300         else
 301           {
 302              if (page_y < 0)
 303                y -= -(page_y * v_h) / 100;
 304              else
 305                y -= page_y;
 306           }
 307      }
 308    else if ((!strcmp(ev->keyname, "Next")) || (!strcmp(ev->keyname, "KP_Next")))
 309      {
 310         if (wd->horizontal)
 311           {
 312              if (page_x < 0)
 313                x += -(page_x * v_w) / 100;
 314              else
 315                x += page_x;
 316           }
 317         else
 318           {
 319              if (page_y < 0)
 320                y += -(page_y * v_h) / 100;
 321              else
 322                y += page_y;
 323           }
 324      }
 325    else if (!strcmp(ev->keyname, "Escape"))
 326      {
 327         if (!_deselect_all_items(wd)) return EINA_FALSE;
 328         ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 329         return EINA_TRUE;
 330      }
 331    else if ((!strcmp(ev->keyname, "Return")) ||
 332             (!strcmp(ev->keyname, "KP_Enter")) ||
 333             (!strcmp(ev->keyname, "space")))
 334      {
 335         it = elm_gengrid_selected_item_get(obj);
 336         evas_object_smart_callback_call(WIDGET(it), SIG_ACTIVATED, it);
 337      }
 338    else return EINA_FALSE;
 339
 340    ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
 341    elm_smart_scroller_child_pos_set(wd->scr, x, y);
 342    return EINA_TRUE;
 343 }
 344
 345 static Eina_Bool
 346 _deselect_all_items(Widget_Data *wd)
 347 {
 348    if (!wd->selected) return EINA_FALSE;
 349    while (wd->selected)
 350      elm_gen_item_selected_set(wd->selected->data, EINA_FALSE);
 351
 352    return EINA_TRUE;
 353 }
 354
 355 static Eina_Bool
 356 _item_multi_select_left(Widget_Data *wd)
 357 {
 358    if (!wd->selected) return EINA_FALSE;
 359
 360    Elm_Gen_Item *prev = elm_gen_item_prev_get(wd->last_selected_item);
 361    if (!prev) return EINA_TRUE;
 362    if (elm_gen_item_selected_get(prev))
 363      {
 364         elm_gen_item_selected_set(wd->last_selected_item, EINA_FALSE);
 365         wd->last_selected_item = prev;
 366         elm_gengrid_item_show(wd->last_selected_item);
 367      }
 368    else
 369      {
 370         elm_gen_item_selected_set(prev, EINA_TRUE);
 371         elm_gengrid_item_show(prev);
 372      }
 373
 374    return EINA_TRUE;
 375 }
 376
 377 static Eina_Bool
 378 _item_multi_select_right(Widget_Data *wd)
 379 {
 380    if (!wd->selected) return EINA_FALSE;
 381
 382    Elm_Gen_Item *next = elm_gen_item_next_get(wd->last_selected_item);
 383    if (!next) return EINA_TRUE;
 384    if (elm_gen_item_selected_get(next))
 385      {
 386         elm_gen_item_selected_set(wd->last_selected_item, EINA_FALSE);
 387         wd->last_selected_item = next;
 388         elm_gengrid_item_show(wd->last_selected_item);
 389      }
 390    else
 391      {
 392         elm_gen_item_selected_set(next, EINA_TRUE);
 393         elm_gengrid_item_show(next);
 394      }
 395
 396    return EINA_TRUE;
 397 }
 398
 399 static Eina_Bool
 400 _item_multi_select_up(Widget_Data *wd)
 401 {
 402    unsigned int i;
 403    Eina_Bool r = EINA_TRUE;
 404
 405    if (!wd->selected) return EINA_FALSE;
 406
 407    for (i = 0; (r) && (i < wd->nmax); i++)
 408      r &= _item_multi_select_left(wd);
 409
 410    return r;
 411 }
 412
 413 static Eina_Bool
 414 _item_multi_select_down(Widget_Data *wd)
 415 {
 416    unsigned int i;
 417    Eina_Bool r = EINA_TRUE;
 418
 419    if (!wd->selected) return EINA_FALSE;
 420
 421    for (i = 0; (r) && (i < wd->nmax); i++)
 422      r &= _item_multi_select_right(wd);
 423
 424    return r;
 425 }
 426
 427 static Eina_Bool
 428 _item_single_select_up(Widget_Data *wd)
 429 {
 430    unsigned int i;
 431
 432    Elm_Gen_Item *prev;
 433
 434    if (!wd->selected)
 435      {
 436         prev = ELM_GEN_ITEM_FROM_INLIST(wd->items->last);
 437         while ((prev) && (prev->delete_me))
 438           prev = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(prev)->prev);
 439         elm_gen_item_selected_set(prev, EINA_TRUE);
 440         elm_gengrid_item_show(prev);
 441         return EINA_TRUE;
 442      }
 443    else prev = elm_gen_item_prev_get(wd->last_selected_item);
 444
 445    if (!prev) return EINA_FALSE;
 446
 447    for (i = 1; i < wd->nmax; i++)
 448      {
 449         Elm_Gen_Item *tmp = elm_gen_item_prev_get(prev);
 450         if (!tmp) return EINA_FALSE;
 451         prev = tmp;
 452      }
 453
 454    _deselect_all_items(wd);
 455
 456    elm_gen_item_selected_set(prev, EINA_TRUE);
 457    elm_gengrid_item_show(prev);
 458    return EINA_TRUE;
 459 }
 460
 461 static Eina_Bool
 462 _item_single_select_down(Widget_Data *wd)
 463 {
 464    unsigned int i;
 465
 466    Elm_Gen_Item *next;
 467
 468    if (!wd->selected)
 469      {
 470         next = ELM_GEN_ITEM_FROM_INLIST(wd->items);
 471         while ((next) && (next->delete_me))
 472           next = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(next)->next);
 473         elm_gen_item_selected_set(next, EINA_TRUE);
 474         elm_gengrid_item_show(next);
 475         return EINA_TRUE;
 476      }
 477    else next = elm_gen_item_next_get(wd->last_selected_item);
 478
 479    if (!next) return EINA_FALSE;
 480
 481    for (i = 1; i < wd->nmax; i++)
 482      {
 483         Elm_Gen_Item *tmp = elm_gen_item_next_get(next);
 484         if (!tmp) return EINA_FALSE;
 485         next = tmp;
 486      }
 487
 488    _deselect_all_items(wd);
 489
 490    elm_gen_item_selected_set(next, EINA_TRUE);
 491    elm_gengrid_item_show(next);
 492    return EINA_TRUE;
 493 }
 494
 495 static Eina_Bool
 496 _item_single_select_left(Widget_Data *wd)
 497 {
 498    Elm_Gen_Item *prev;
 499    if (!wd->selected)
 500      {
 501         prev = ELM_GEN_ITEM_FROM_INLIST(wd->items->last);
 502         while ((prev) && (prev->delete_me))
 503           prev = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(prev)->prev);
 504      }
 505    else prev = elm_gen_item_prev_get(wd->last_selected_item);
 506
 507    if (!prev) return EINA_FALSE;
 508
 509    _deselect_all_items(wd);
 510
 511    elm_gen_item_selected_set(prev, EINA_TRUE);
 512    elm_gengrid_item_show(prev);
 513    return EINA_TRUE;
 514 }
 515
 516 static Eina_Bool
 517 _item_single_select_right(Widget_Data *wd)
 518 {
 519    Elm_Gen_Item *next;
 520    if (!wd->selected)
 521      {
 522         next = ELM_GEN_ITEM_FROM_INLIST(wd->items);
 523         while ((next) && (next->delete_me))
 524           next = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(next)->next);
 525      }
 526    else next = elm_gen_item_next_get(wd->last_selected_item);
 527
 528    if (!next) return EINA_FALSE;
 529
 530    _deselect_all_items(wd);
 531
 532    elm_gen_item_selected_set(next, EINA_TRUE);
 533    elm_gengrid_item_show(next);
 534    return EINA_TRUE;
 535 }
 536
 537 static void
 538 _on_focus_hook(void *data   __UNUSED__,
 539                Evas_Object *obj)
 540 {
 541    Widget_Data *wd = elm_widget_data_get(obj);
 542    if (!wd) return;
 543    if (elm_widget_focus_get(obj))
 544      {
 545         edje_object_signal_emit(wd->obj, "elm,action,focus", "elm");
 546         evas_object_focus_set(wd->obj, EINA_TRUE);
 547         if ((wd->selected) && (!wd->last_selected_item))
 548           wd->last_selected_item = eina_list_data_get(wd->selected);
 549      }
 550    else
 551      {
 552         edje_object_signal_emit(wd->obj, "elm,action,unfocus", "elm");
 553         evas_object_focus_set(wd->obj, EINA_FALSE);
 554      }
 555 }
 556
 557 static void
 558 _mirrored_set(Evas_Object *obj, Eina_Bool rtl)
 559 {
 560    Widget_Data *wd = elm_widget_data_get(obj);
 561    Elm_Gen_Item *it;
 562    if (!wd) return;
 563    elm_smart_scroller_mirrored_set(wd->scr, rtl);
 564    if (!wd->items) return;
 565    it = ELM_GEN_ITEM_FROM_INLIST(wd->items);
 566
 567    while (it)
 568      {
 569         edje_object_mirrored_set(VIEW(it), rtl);
 570         elm_gengrid_item_update(it);
 571         it = ELM_GEN_ITEM_FROM_INLIST(EINA_INLIST_GET(it)->next);
 572      }
 573 }
 574
 575 static void
 576 _theme_hook(Evas_Object *obj)
 577 {
 578    Widget_Data *wd = elm_widget_data_get(obj);
 579    if (!wd) return;
 580    _elm_widget_mirrored_reload(obj);
 581    _mirrored_set(obj, elm_widget_mirrored_get(obj));
 582    elm_smart_scroller_object_theme_set(obj, wd->scr, "gengrid", "base",
 583                                        elm_widget_style_get(obj));
 584 }
 585
 586 static void
 587 _del_pre_hook(Evas_Object *obj)
 588 {
 589    Widget_Data *wd = elm_widget_data_get(obj);
 590    if (!wd) return;
 591    elm_gen_clear(obj);
 592    evas_object_del(wd->pan_smart);
 593    wd->pan_smart = NULL;
 594 }
 595
 596 static void
 597 _del_hook(Evas_Object *obj)
 598 {
 599    Widget_Data *wd = elm_widget_data_get(obj);
 600    if (wd->calc_job) ecore_job_del(wd->calc_job);
 601    free(wd);
 602 }
 603
 604 static void
 605 _signal_emit_hook(Evas_Object *obj,
 606                   const char  *emission,
 607                   const char  *source)
 608 {
 609    Widget_Data *wd = elm_widget_data_get(obj);
 610    if (!wd) return;
 611    edje_object_signal_emit(elm_smart_scroller_edje_object_get(wd->scr),
 612                            emission, source);
 613 }
 614
 615 static void
 616 _signal_callback_add_hook(Evas_Object *obj,
 617                           const char  *emission,
 618                           const char  *source,
 619                           Edje_Signal_Cb func_cb,
 620                           void *data)
 621 {
 622    Widget_Data *wd = elm_widget_data_get(obj);
 623    if (!wd) return;
 624    edje_object_signal_callback_add(elm_smart_scroller_edje_object_get(wd->scr),
 625                                    emission, source, func_cb, data);
 626 }
 627
 628 static void
 629 _signal_callback_del_hook(Evas_Object *obj,
 630                           const char  *emission,
 631                           const char  *source,
 632                           Edje_Signal_Cb func_cb,
 633                           void *data)
 634 {
 635    Widget_Data *wd = elm_widget_data_get(obj);
 636    if (!wd) return;
 637    edje_object_signal_callback_del_full(elm_smart_scroller_edje_object_get(wd->scr),
 638                                         emission, source, func_cb, data);
 639 }
 640
 641 static void
 642 _mouse_move(void        *data,
 643             Evas *evas   __UNUSED__,
 644             Evas_Object *obj,
 645             void        *event_info)
 646 {
 647    Elm_Gen_Item *it = data;
 648    Evas_Event_Mouse_Move *ev = event_info;
 649    Evas_Coord minw = 0, minh = 0, x, y, dx, dy, adx, ady;
 650    Evas_Coord ox, oy, ow, oh, it_scrl_x, it_scrl_y;
 651
 652    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
 653      {
 654         if (!it->wd->on_hold)
 655           {
 656              it->wd->on_hold = EINA_TRUE;
 657              if (!it->wd->wasselected)
 658                _item_unselect(it);
 659           }
 660      }
 661    if ((it->dragging) && (it->down))
 662      {
 663         if (it->long_timer)
 664           {
 665              ecore_timer_del(it->long_timer);
 666              it->long_timer = NULL;
 667           }
 668         evas_object_smart_callback_call(WIDGET(it), SIG_DRAG, it);
 669         return;
 670      }
 671    if ((!it->down) || (it->wd->longpressed))
 672      {
 673         if (it->long_timer)
 674           {
 675              ecore_timer_del(it->long_timer);
 676              it->long_timer = NULL;
 677           }
 678         if ((it->wd->reorder_mode) && (it->wd->reorder_it))
 679           {
 680              evas_object_geometry_get(it->wd->pan_smart, &ox, &oy, &ow, &oh);
 681
 682              it_scrl_x = ev->cur.canvas.x - it->wd->reorder_it->dx;
 683              it_scrl_y = ev->cur.canvas.y - it->wd->reorder_it->dy;
 684
 685              if (it_scrl_x < ox) it->wd->reorder_item_x = ox;
 686              else if (it_scrl_x + it->wd->item_width > ox + ow)
 687                it->wd->reorder_item_x = ox + ow - it->wd->item_width;
 688              else it->wd->reorder_item_x = it_scrl_x;
 689
 690              if (it_scrl_y < oy) it->wd->reorder_item_y = oy;
 691              else if (it_scrl_y + it->wd->item_height > oy + oh)
 692                it->wd->reorder_item_y = oy + oh - it->wd->item_height;
 693              else it->wd->reorder_item_y = it_scrl_y;
 694
 695              if (it->wd->calc_job) ecore_job_del(it->wd->calc_job);
 696              it->wd->calc_job = ecore_job_add(_calc_job, it->wd);
 697           }
 698         return;
 699      }
 700    if (!it->display_only)
 701      elm_coords_finger_size_adjust(1, &minw, 1, &minh);
 702    evas_object_geometry_get(obj, &x, &y, NULL, NULL);
 703    x = ev->cur.canvas.x - x;
 704    y = ev->cur.canvas.y - y;
 705    dx = x - it->dx;
 706    adx = dx;
 707    if (adx < 0) adx = -dx;
 708    dy = y - it->dy;
 709    ady = dy;
 710    if (ady < 0) ady = -dy;
 711    minw /= 2;
 712    minh /= 2;
 713    if ((adx > minw) || (ady > minh))
 714      {
 715         const char *left_drag, *right_drag;
 716         if (!elm_widget_mirrored_get(WIDGET(it)))
 717           {
 718              left_drag = SIG_DRAG_START_LEFT;
 719              right_drag = SIG_DRAG_START_RIGHT;
 720           }
 721         else
 722           {
 723              left_drag = SIG_DRAG_START_RIGHT;
 724              right_drag = SIG_DRAG_START_LEFT;
 725           }
 726
 727         it->dragging = 1;
 728         if (it->long_timer)
 729           {
 730              ecore_timer_del(it->long_timer);
 731              it->long_timer = NULL;
 732           }
 733         if (!it->wd->wasselected)
 734           _item_unselect(it);
 735         if (dy < 0)
 736           {
 737              if (ady > adx)
 738                evas_object_smart_callback_call(WIDGET(it), SIG_DRAG_START_UP,
 739                                                it);
 740              else
 741                {
 742                   if (dx < 0)
 743                     evas_object_smart_callback_call(WIDGET(it),
 744                                                     left_drag, it);
 745                }
 746           }
 747         else
 748           {
 749              if (ady > adx)
 750                evas_object_smart_callback_call(WIDGET(it),
 751                                                SIG_DRAG_START_DOWN, it);
 752              else
 753                {
 754                   if (dx < 0)
 755                     evas_object_smart_callback_call(WIDGET(it),
 756                                                     left_drag, it);
 757                   else
 758                     evas_object_smart_callback_call(WIDGET(it),
 759                                                     right_drag, it);
 760                }
 761           }
 762      }
 763 }
 764
 765 static Eina_Bool
 766 _long_press(void *data)
 767 {
 768    Elm_Gen_Item *it = data;
 769
 770    it->long_timer = NULL;
 771    if ((it->disabled) || (it->dragging)) return ECORE_CALLBACK_CANCEL;
 772    it->wd->longpressed = EINA_TRUE;
 773    evas_object_smart_callback_call(WIDGET(it), SIG_LONGPRESSED, it);
 774    if (it->wd->reorder_mode)
 775      {
 776         it->wd->reorder_it = it;
 777         evas_object_raise(VIEW(it));
 778         elm_smart_scroller_hold_set(it->wd->scr, EINA_TRUE);
 779         elm_smart_scroller_bounce_allow_set(it->wd->scr, EINA_FALSE, EINA_FALSE);
 780         edje_object_signal_emit(VIEW(it), "elm,state,reorder,enabled", "elm");
 781      }
 782    return ECORE_CALLBACK_CANCEL;
 783 }
 784
 785 static void
 786 _mouse_down(void        *data,
 787             Evas *evas   __UNUSED__,
 788             Evas_Object *obj,
 789             void        *event_info)
 790 {
 791    Elm_Gen_Item *it = data;
 792    Evas_Event_Mouse_Down *ev = event_info;
 793    Evas_Coord x, y;
 794
 795    if (ev->button != 1) return;
 796    it->down = 1;
 797    it->dragging = 0;
 798    evas_object_geometry_get(obj, &x, &y, NULL, NULL);
 799    it->dx = ev->canvas.x - x;
 800    it->dy = ev->canvas.y - y;
 801    it->wd->longpressed = EINA_FALSE;
 802    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) it->wd->on_hold = EINA_TRUE;
 803    else it->wd->on_hold = EINA_FALSE;
 804    it->wd->wasselected = it->selected;
 805    _item_highlight(it);
 806    if (ev->flags & EVAS_BUTTON_DOUBLE_CLICK)
 807      {
 808         evas_object_smart_callback_call(WIDGET(it), SIG_CLICKED_DOUBLE, it);
 809         evas_object_smart_callback_call(WIDGET(it), SIG_ACTIVATED, it);
 810      }
 811    if (it->long_timer) ecore_timer_del(it->long_timer);
 812    if (it->realized)
 813      it->long_timer = ecore_timer_add(_elm_config->longpress_timeout,
 814                                         _long_press, it);
 815    else
 816      it->long_timer = NULL;
 817 }
 818
 819 static void
 820 _mouse_up(void            *data,
 821           Evas *evas       __UNUSED__,
 822           Evas_Object *obj __UNUSED__,
 823           void            *event_info)
 824 {
 825    Elm_Gen_Item *it = data;
 826    Evas_Event_Mouse_Up *ev = event_info;
 827    Eina_Bool dragged = EINA_FALSE;
 828
 829    if (ev->button != 1) return;
 830    it->down = EINA_FALSE;
 831    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) it->wd->on_hold = EINA_TRUE;
 832    else it->wd->on_hold = EINA_FALSE;
 833    if (it->long_timer)
 834      {
 835         ecore_timer_del(it->long_timer);
 836         it->long_timer = NULL;
 837      }
 838    if (it->dragging)
 839      {
 840         it->dragging = EINA_FALSE;
 841         evas_object_smart_callback_call(WIDGET(it), SIG_DRAG_STOP, it);
 842         dragged = EINA_TRUE;
 843      }
 844    if (it->wd->on_hold)
 845      {
 846         it->wd->longpressed = EINA_FALSE;
 847         it->wd->on_hold = EINA_FALSE;
 848         return;
 849      }
 850    if ((it->wd->reorder_mode) && (it->wd->reorder_it))
 851      {
 852         evas_object_smart_callback_call(WIDGET(it), SIG_MOVED, it->wd->reorder_it);
 853         it->wd->reorder_it = NULL;
 854         it->wd->move_effect_enabled = EINA_FALSE;
 855         if (it->wd->calc_job) ecore_job_del(it->wd->calc_job);
 856           it->wd->calc_job = ecore_job_add(_calc_job, it->wd);
 857
 858         elm_smart_scroller_hold_set(it->wd->scr, EINA_FALSE);
 859         elm_smart_scroller_bounce_allow_set(it->wd->scr, it->wd->h_bounce, it->wd->v_bounce);
 860         edje_object_signal_emit(VIEW(it), "elm,state,reorder,disabled", "elm");
 861      }
 862    if (it->wd->longpressed)
 863      {
 864         it->wd->longpressed = EINA_FALSE;
 865         if (!it->wd->wasselected) _item_unselect(it);
 866         it->wd->wasselected = EINA_FALSE;
 867         return;
 868      }
 869    if (dragged)
 870      {
 871         if (it->want_unrealize)
 872           elm_gen_item_unrealize(it, EINA_FALSE);
 873      }
 874    if ((it->disabled) || (dragged)) return;
 875    if (it->wd->multi)
 876      {
 877         if (!it->selected)
 878           {
 879              _item_highlight(it);
 880              it->sel_cb(it);
 881           }
 882         else _item_unselect(it);
 883      }
 884    else
 885      {
 886         if (!it->selected)
 887           {
 888              while (it->wd->selected)
 889                _item_unselect(it->wd->selected->data);
 890           }
 891         else
 892           {
 893              const Eina_List *l, *l_next;
 894              Elm_Gen_Item *item2;
 895
 896              EINA_LIST_FOREACH_SAFE(it->wd->selected, l, l_next, item2)
 897                 if (item2 != it) _item_unselect(item2);
 898           }
 899         _item_highlight(it);
 900         it->sel_cb(it);
 901      }
 902 }
 903
 904 static void
 905 _item_highlight(Elm_Gen_Item *it)
 906 {
 907    if ((it->wd->no_select) || (it->delete_me) || (it->highlighted)) return;
 908    edje_object_signal_emit(VIEW(it), "elm,state,selected", "elm");
 909    it->highlighted = EINA_TRUE;
 910 }
 911
 912 static void
 913 _item_realize(Elm_Gen_Item *it)
 914 {
 915    char buf[1024];
 916    char style[1024];
 917
 918    if ((it->realized) || (it->delete_me)) return;
 919    VIEW(it) = edje_object_add(evas_object_evas_get(WIDGET(it)));
 920    edje_object_scale_set(VIEW(it), elm_widget_scale_get(WIDGET(it)) *
 921                          _elm_config->scale);
 922    edje_object_mirrored_set(VIEW(it), elm_widget_mirrored_get(WIDGET(it)));
 923    evas_object_smart_member_add(VIEW(it), it->wd->pan_smart);
 924    elm_widget_sub_object_add(WIDGET(it), VIEW(it));
 925    snprintf(style, sizeof(style), "item/%s",
 926             it->itc->item_style ? it->itc->item_style : "default");
 927    _elm_theme_object_set(WIDGET(it), VIEW(it), "gengrid", style,
 928                          elm_widget_style_get(WIDGET(it)));
 929    it->spacer =
 930       evas_object_rectangle_add(evas_object_evas_get(WIDGET(it)));
 931    evas_object_color_set(it->spacer, 0, 0, 0, 0);
 932    elm_widget_sub_object_add(WIDGET(it), it->spacer);
 933    evas_object_size_hint_min_set(it->spacer, 2 * _elm_config->scale, 1);
 934    edje_object_part_swallow(VIEW(it), "elm.swallow.pad", it->spacer);
 935
 936    if (it->itc->func.label_get)
 937      {
 938         const Eina_List *l;
 939         const char *key;
 940
 941         it->labels =
 942            elm_widget_stringlist_get(edje_object_data_get(VIEW(it),
 943                                                           "labels"));
 944         EINA_LIST_FOREACH(it->labels, l, key)
 945           {
 946              char *s = it->itc->func.label_get
 947                 ((void *)it->base.data, WIDGET(it), key);
 948              if (s)
 949                {
 950                   edje_object_part_text_set(VIEW(it), key, s);
 951                   free(s);
 952                }
 953           }
 954      }
 955
 956    if (it->itc->func.content_get)
 957      {
 958         const Eina_List *l;
 959         const char *key;
 960         Evas_Object *ic = NULL;
 961
 962         it->contents =
 963            elm_widget_stringlist_get(edje_object_data_get(VIEW(it),
 964                                                           "contents"));
 965         EINA_LIST_FOREACH(it->contents, l, key)
 966           {
 967              if (it->itc->func.content_get)
 968                ic = it->itc->func.content_get
 969                   ((void *)it->base.data, WIDGET(it), key);
 970              if (ic)
 971                {
 972                   it->content_objs = eina_list_append(it->content_objs, ic);
 973                   edje_object_part_swallow(VIEW(it), key, ic);
 974                   evas_object_show(ic);
 975                   elm_widget_sub_object_add(WIDGET(it), ic);
 976                }
 977           }
 978      }
 979
 980    if (it->itc->func.state_get)
 981      {
 982         const Eina_List *l;
 983         const char *key;
 984
 985         it->states =
 986            elm_widget_stringlist_get(edje_object_data_get(VIEW(it),
 987                                                           "states"));
 988         EINA_LIST_FOREACH(it->states, l, key)
 989           {
 990              Eina_Bool on = it->itc->func.state_get
 991                 ((void *)it->base.data, WIDGET(it), l->data);
 992              if (on)
 993                {
 994                   snprintf(buf, sizeof(buf), "elm,state,%s,active", key);
 995                   edje_object_signal_emit(VIEW(it), buf, "elm");
 996                }
 997           }
 998      }
 999
1000    if (it->group)
1001      {
1002         if ((!it->wd->group_item_width) && (!it->wd->group_item_height))
1003           {
1004              edje_object_size_min_restricted_calc(VIEW(it),
1005                                                   &it->wd->group_item_width,
1006                                                   &it->wd->group_item_height,
1007                                                   it->wd->group_item_width,
1008                                                   it->wd->group_item_height);
1009           }
1010      }
1011    else
1012      {
1013         if ((!it->wd->item_width) && (!it->wd->item_height))
1014           {
1015              edje_object_size_min_restricted_calc(VIEW(it),
1016                                                   &it->wd->item_width,
1017                                                   &it->wd->item_height,
1018                                                   it->wd->item_width,
1019                                                   it->wd->item_height);
1020              elm_coords_finger_size_adjust(1, &it->wd->item_width,
1021                                            1, &it->wd->item_height);
1022           }
1023
1024         evas_object_event_callback_add(VIEW(it), EVAS_CALLBACK_MOUSE_DOWN,
1025                                        _mouse_down, it);
1026         evas_object_event_callback_add(VIEW(it), EVAS_CALLBACK_MOUSE_UP,
1027                                        _mouse_up, it);
1028         evas_object_event_callback_add(VIEW(it), EVAS_CALLBACK_MOUSE_MOVE,
1029                                        _mouse_move, it);
1030
1031         if (it->selected)
1032           edje_object_signal_emit(VIEW(it), "elm,state,selected", "elm");
1033         if (it->disabled)
1034           edje_object_signal_emit(VIEW(it), "elm,state,disabled", "elm");
1035      }
1036    evas_object_show(VIEW(it));
1037
1038    if (it->tooltip.content_cb)
1039      {
1040         elm_widget_item_tooltip_content_cb_set(it,
1041                                                it->tooltip.content_cb,
1042                                                it->tooltip.data, NULL);
1043         elm_widget_item_tooltip_style_set(it, it->tooltip.style);
1044         elm_widget_item_tooltip_size_restrict_disable(it, it->tooltip.free_size);
1045      }
1046
1047    if (it->mouse_cursor)
1048      elm_widget_item_cursor_set(it, it->mouse_cursor);
1049
1050    it->realized = EINA_TRUE;
1051    it->want_unrealize = EINA_FALSE;
1052 }
1053
1054 static void
1055 _item_unrealize_cb(Elm_Gen_Item *it)
1056 {
1057    evas_object_del(VIEW(it));
1058    VIEW(it) = NULL;
1059    evas_object_del(it->spacer);
1060    it->spacer = NULL;
1061 }
1062
1063 static Eina_Bool
1064 _reorder_item_moving_effect_timer_cb(void *data)
1065 {
1066    Elm_Gen_Item *it = data;
1067    double time, t;
1068    Evas_Coord dx, dy;
1069
1070    time = REORDER_EFFECT_TIME;
1071    t = ((0.0 > (t = ecore_loop_time_get()-it->item->moving_effect_start_time)) ? 0.0 : t);
1072    dx = ((it->item->tx - it->item->ox) / 10) * _elm_config->scale;
1073    dy = ((it->item->ty - it->item->oy) / 10) * _elm_config->scale;
1074
1075    if (t <= time)
1076      {
1077         it->item->rx += (1 * sin((t / time) * (M_PI / 2)) * dx);
1078         it->item->ry += (1 * sin((t / time) * (M_PI / 2)) * dy);
1079      }
1080    else
1081      {
1082         it->item->rx += dx;
1083         it->item->ry += dy;
1084      }
1085
1086    if ((((dx > 0) && (it->item->rx >= it->item->tx)) || ((dx <= 0) && (it->item->rx <= it->item->tx))) &&
1087        (((dy > 0) && (it->item->ry >= it->item->ty)) || ((dy <= 0) && (it->item->ry <= it->item->ty))))
1088      {
1089         evas_object_move(VIEW(it), it->item->tx, it->item->ty);
1090         if (it->group)
1091           {
1092              Evas_Coord vw, vh;
1093              evas_object_geometry_get(it->wd->pan_smart, NULL, NULL, &vw, &vh);
1094              if (it->wd->horizontal)
1095                evas_object_resize(VIEW(it), it->wd->group_item_width, vh);
1096              else
1097                evas_object_resize(VIEW(it), vw, it->wd->group_item_height);
1098           }
1099         else
1100           evas_object_resize(VIEW(it), it->wd->item_width, it->wd->item_height);
1101         it->item->moving = EINA_FALSE;
1102         it->item->item_moving_effect_timer = NULL;
1103         return ECORE_CALLBACK_CANCEL;
1104      }
1105
1106    evas_object_move(VIEW(it), it->item->rx, it->item->ry);
1107    if (it->group)
1108      {
1109         Evas_Coord vw, vh;
1110         evas_object_geometry_get(it->wd->pan_smart, NULL, NULL, &vw, &vh);
1111         if (it->wd->horizontal)
1112           evas_object_resize(VIEW(it), it->wd->group_item_width, vh);
1113         else
1114           evas_object_resize(VIEW(it), vw, it->wd->group_item_height);
1115      }
1116    else
1117      evas_object_resize(VIEW(it), it->wd->item_width, it->wd->item_height);
1118
1119    return ECORE_CALLBACK_RENEW;
1120 }
1121
1122 static void
1123 _group_item_place(Pan *sd)
1124 {
1125    Evas_Coord iw, ih, vw, vh;
1126    Eina_List *l;
1127    Eina_Bool was_realized;
1128    Elm_Gen_Item *it;
1129    evas_object_geometry_get(sd->wd->pan_smart, NULL, NULL, &vw, &vh);
1130    if (sd->wd->horizontal)
1131      {
1132         iw = sd->wd->group_item_width;
1133         ih = vh;
1134      }
1135    else
1136      {
1137         iw = vw;
1138         ih = sd->wd->group_item_height;
1139      }
1140    EINA_LIST_FOREACH(sd->wd->group_items, l, it)
1141      {
1142         was_realized = it->realized;
1143         if (it->item->group_realized)
1144           {
1145              _item_realize(it);
1146              if (!was_realized)
1147                evas_object_smart_callback_call(WIDGET(it), SIG_REALIZED, it);
1148              evas_object_move(VIEW(it), it->item->gx, it->item->gy);
1149              evas_object_resize(VIEW(it), iw, ih);
1150              evas_object_raise(VIEW(it));
1151           }
1152         else
1153           elm_gen_item_unrealize(it, EINA_FALSE);
1154      }
1155 }
1156
1157
1158 static void
1159 _item_place(Elm_Gen_Item *it,
1160             Evas_Coord        cx,
1161             Evas_Coord        cy)
1162 {
1163    Evas_Coord x, y, ox, oy, cvx, cvy, cvw, cvh, iw, ih, ww;
1164    Evas_Coord tch, tcw, alignw = 0, alignh = 0, vw, vh;
1165    Eina_Bool reorder_item_move_forward = EINA_FALSE;
1166    long items_count;
1167    it->x = cx;
1168    it->y = cy;
1169    evas_object_geometry_get(it->wd->pan_smart, &ox, &oy, &vw, &vh);
1170
1171    /* Preload rows/columns at each side of the Gengrid */
1172    cvx = ox - PRELOAD * it->wd->item_width;
1173    cvy = oy - PRELOAD * it->wd->item_height;
1174    cvw = vw + 2 * PRELOAD * it->wd->item_width;
1175    cvh = vh + 2 * PRELOAD * it->wd->item_height;
1176
1177    alignh = 0;
1178    alignw = 0;
1179
1180    items_count = it->wd->count - eina_list_count(it->wd->group_items) + it->wd->items_lost;
1181    if (it->wd->horizontal)
1182      {
1183         int columns, items_visible = 0, items_row;
1184
1185         if (it->wd->item_height > 0)
1186           items_visible = vh / it->wd->item_height;
1187         if (items_visible < 1)
1188           items_visible = 1;
1189
1190         columns = items_count / items_visible;
1191         if (items_count % items_visible)
1192           columns++;
1193
1194         tcw = (it->wd->item_width * columns) + (it->wd->group_item_width * eina_list_count(it->wd->group_items));
1195         alignw = (vw - tcw) * it->wd->align_x;
1196
1197         items_row = items_visible;
1198         if (items_row > it->wd->count)
1199           items_row = it->wd->count;
1200         tch = items_row * it->wd->item_height;
1201         alignh = (vh - tch) * it->wd->align_y;
1202      }
1203    else
1204      {
1205         int rows, items_visible = 0, items_col;
1206
1207         if (it->wd->item_width > 0)
1208           items_visible = vw / it->wd->item_width;
1209         if (items_visible < 1)
1210           items_visible = 1;
1211
1212         rows = items_count / items_visible;
1213         if (items_count % items_visible)
1214           rows++;
1215
1216         tch = (it->wd->item_height * rows) + (it->wd->group_item_height * eina_list_count(it->wd->group_items));
1217         alignh = (vh - tch) * it->wd->align_y;
1218
1219         items_col = items_visible;
1220         if (items_col > it->wd->count)
1221           items_col = it->wd->count;
1222         tcw = items_col * it->wd->item_width;
1223         alignw = (vw - tcw) * it->wd->align_x;
1224      }
1225
1226    if (it->group)
1227      {
1228         if (it->wd->horizontal)
1229           {
1230              x = (((cx - it->item->prev_group) * it->wd->item_width) + (it->item->prev_group * it->wd->group_item_width)) - it->wd->pan_x + ox + alignw;
1231              y = 0;
1232              iw = it->wd->group_item_width;
1233              ih = vh;
1234           }
1235         else
1236           {
1237              x = 0;
1238              y = (((cy - it->item->prev_group) * it->wd->item_height) + (it->item->prev_group * it->wd->group_item_height)) - it->wd->pan_y + oy + alignh;
1239              iw = vw;
1240              ih = it->wd->group_item_height;
1241           }
1242         it->item->gx = x;
1243         it->item->gy = y;
1244      }
1245    else
1246      {
1247         if (it->wd->horizontal)
1248           {
1249              x = (((cx - it->item->prev_group) * it->wd->item_width) + (it->item->prev_group * it->wd->group_item_width)) - it->wd->pan_x + ox + alignw;
1250              y = (cy * it->wd->item_height) - it->wd->pan_y + oy + alignh;
1251           }
1252         else
1253           {
1254              x = (cx * it->wd->item_width) - it->wd->pan_x + ox + alignw;
1255              y = (((cy - it->item->prev_group) * it->wd->item_height) + (it->item->prev_group * it->wd->group_item_height)) - it->wd->pan_y + oy + alignh;
1256           }
1257         if (elm_widget_mirrored_get(WIDGET(it)))
1258           {  /* Switch items side and componsate for pan_x when in RTL mode */
1259              evas_object_geometry_get(WIDGET(it), NULL, NULL, &ww, NULL);
1260              x = ww - x - it->wd->item_width - it->wd->pan_x - it->wd->pan_x;
1261           }
1262         iw = it->wd->item_width;
1263         ih = it->wd->item_height;
1264      }
1265
1266    Eina_Bool was_realized = it->realized;
1267    if (ELM_RECTS_INTERSECT(x, y, iw, ih, cvx, cvy, cvw, cvh))
1268      {
1269         _item_realize(it);
1270         if (!was_realized)
1271           evas_object_smart_callback_call(WIDGET(it), SIG_REALIZED, it);
1272         if (it->parent)
1273           {
1274              if (it->wd->horizontal)
1275                {
1276                   if (it->parent->item->gx < 0)
1277                     {
1278                        it->parent->item->gx = x + it->wd->item_width - it->wd->group_item_width;
1279                        if (it->parent->item->gx > 0)
1280                          it->parent->item->gx = 0;
1281                     }
1282                }
1283              else
1284                {
1285                   if (it->parent->item->gy < 0)
1286                     {
1287                        it->parent->item->gy = y + it->wd->item_height - it->wd->group_item_height;
1288                        if (it->parent->item->gy > 0)
1289                          it->parent->item->gy = 0;
1290                     }
1291                   it->parent->item->group_realized = EINA_TRUE;
1292                }
1293           }
1294         if (it->wd->reorder_mode)
1295           {
1296              if (it->wd->reorder_it)
1297                {
1298                   if (it->item->moving) return;
1299
1300                   if (!it->wd->move_effect_enabled)
1301                     {
1302                        it->item->ox = x;
1303                        it->item->oy = y;
1304                     }
1305                   if (it->wd->reorder_it == it)
1306                     {
1307                        evas_object_move(VIEW(it),
1308                                         it->wd->reorder_item_x, it->wd->reorder_item_y);
1309                        evas_object_resize(VIEW(it), iw, ih);
1310                        return;
1311                     }
1312                   else
1313                     {
1314                        if (it->wd->move_effect_enabled)
1315                          {
1316                             if ((it->item->ox != x) || (it->item->oy != y))
1317                               {
1318                                  if (((it->wd->old_pan_x == it->wd->pan_x) && (it->wd->old_pan_y == it->wd->pan_y)) ||
1319                                      ((it->wd->old_pan_x != it->wd->pan_x) && !(it->item->ox - it->wd->pan_x + it->wd->old_pan_x == x)) ||
1320                                      ((it->wd->old_pan_y != it->wd->pan_y) && !(it->item->oy - it->wd->pan_y + it->wd->old_pan_y == y)))
1321                                    {
1322                                       it->item->tx = x;
1323                                       it->item->ty = y;
1324                                       it->item->rx = it->item->ox;
1325                                       it->item->ry = it->item->oy;
1326                                       it->item->moving = EINA_TRUE;
1327                                       it->item->moving_effect_start_time = ecore_loop_time_get();
1328                                       it->item->item_moving_effect_timer = ecore_animator_add(_reorder_item_moving_effect_timer_cb, it);
1329                                       return;
1330                                    }
1331                               }
1332                          }
1333
1334                        /* need fix here */
1335                        Evas_Coord nx, ny, nw, nh;
1336                        if (it->group)
1337                          {
1338                             if (it->wd->horizontal)
1339                               {
1340                                  nx = x + (it->wd->group_item_width / 2);
1341                                  ny = y;
1342                                  nw = 1;
1343                                  nh = vh;
1344                               }
1345                             else
1346                               {
1347                                  nx = x;
1348                                  ny = y + (it->wd->group_item_height / 2);
1349                                  nw = vw;
1350                                  nh = 1;
1351                               }
1352                          }
1353                        else
1354                          {
1355                             nx = x + (it->wd->item_width / 2);
1356                             ny = y + (it->wd->item_height / 2);
1357                             nw = 1;
1358                             nh = 1;
1359                          }
1360
1361                        if ( ELM_RECTS_INTERSECT(it->wd->reorder_item_x, it->wd->reorder_item_y,
1362                                                 it->wd->item_width, it->wd->item_height,
1363                                                 nx, ny, nw, nh))
1364                          {
1365                             if (it->wd->horizontal)
1366                               {
1367                                  if ((it->wd->nmax * it->wd->reorder_it->x + it->wd->reorder_it->y) >
1368                                      (it->wd->nmax * it->x + it->y))
1369                                    reorder_item_move_forward = EINA_TRUE;
1370                               }
1371                             else
1372                               {
1373                                  if ((it->wd->nmax * it->wd->reorder_it->y + it->wd->reorder_it->x) >
1374                                      (it->wd->nmax * it->y + it->x))
1375                                    reorder_item_move_forward = EINA_TRUE;
1376                               }
1377
1378                             it->wd->items = eina_inlist_remove(it->wd->items,
1379                                                                  EINA_INLIST_GET(it->wd->reorder_it));
1380                             if (reorder_item_move_forward)
1381                               it->wd->items = eina_inlist_prepend_relative(it->wd->items,
1382                                                                              EINA_INLIST_GET(it->wd->reorder_it),
1383                                                                              EINA_INLIST_GET(it));
1384                             else
1385                               it->wd->items = eina_inlist_append_relative(it->wd->items,
1386                                                                             EINA_INLIST_GET(it->wd->reorder_it),
1387                                                                             EINA_INLIST_GET(it));
1388
1389                             it->wd->reorder_item_changed = EINA_TRUE;
1390                             it->wd->move_effect_enabled = EINA_TRUE;
1391                             if (it->wd->calc_job) ecore_job_del(it->wd->calc_job);
1392                               it->wd->calc_job = ecore_job_add(_calc_job, it->wd);
1393
1394                             return;
1395                          }
1396                     }
1397                }
1398              else if (it->item->item_moving_effect_timer)
1399                {
1400                   ecore_animator_del(it->item->item_moving_effect_timer);
1401                   it->item->item_moving_effect_timer = NULL;
1402                   it->item->moving = EINA_FALSE;
1403                }
1404           }
1405         if (!it->group)
1406           {
1407              evas_object_move(VIEW(it), x, y);
1408              evas_object_resize(VIEW(it), iw, ih);
1409           }
1410         else
1411           it->item->group_realized = EINA_TRUE;
1412      }
1413    else
1414      {
1415         if (!it->group)
1416           elm_gen_item_unrealize(it, EINA_FALSE);
1417         else
1418           it->item->group_realized = EINA_FALSE;
1419      }
1420 }
1421
1422 static void
1423 _item_del(Elm_Gen_Item *it)
1424 {
1425    Evas_Object *obj = WIDGET(it);
1426
1427    evas_event_freeze(evas_object_evas_get(obj));
1428    it->wd->selected = eina_list_remove(it->wd->selected, it);
1429    if (it->realized) elm_gen_item_unrealize(it, EINA_FALSE);
1430    it->wd->count--;
1431    elm_gen_item_del_serious(it);
1432    evas_event_thaw(evas_object_evas_get(obj));
1433    evas_event_thaw_eval(evas_object_evas_get(obj));
1434 }
1435
1436 static void
1437 _item_unselect(Elm_Gen_Item *it)
1438 {
1439    if ((it->delete_me) || (!it->highlighted)) return;
1440    edje_object_signal_emit(VIEW(it), "elm,state,unselected", "elm");
1441    it->highlighted = EINA_FALSE;
1442    if (it->selected)
1443      {
1444         it->selected = EINA_FALSE;
1445         it->wd->selected = eina_list_remove(it->wd->selected, it);
1446         evas_object_smart_callback_call(WIDGET(it), SIG_UNSELECTED, it);
1447      }
1448 }
1449
1450 static void
1451 _calc_job(void *data)
1452 {
1453    Widget_Data *wd = data;
1454    Evas_Coord minw = 0, minh = 0, nmax = 0, cvw, cvh;
1455    Elm_Gen_Item *it, *group_item = NULL;
1456    int count_group = 0;
1457    long count = 0;
1458    wd->items_lost = 0;
1459
1460    evas_object_geometry_get(wd->pan_smart, NULL, NULL, &cvw, &cvh);
1461    if ((cvw != 0) || (cvh != 0))
1462      {
1463         if ((wd->horizontal) && (wd->item_height > 0))
1464           nmax = cvh / wd->item_height;
1465         else if (wd->item_width > 0)
1466           nmax = cvw / wd->item_width;
1467
1468         if (nmax < 1)
1469           nmax = 1;
1470
1471         EINA_INLIST_FOREACH(wd->items, it)
1472           {
1473              if (it->item->prev_group != count_group)
1474                it->item->prev_group = count_group;
1475              if (it->group)
1476                {
1477                   count = count % nmax;
1478                   if (count)
1479                     wd->items_lost += nmax - count;
1480                   //printf("%d items and I lost %d\n", count, wd->items_lost);
1481                   count_group++;
1482                   if (count) count = 0;
1483                   group_item = it;
1484                }
1485              else
1486                {
1487                   if (it->parent != group_item)
1488                     it->parent = group_item;
1489                   count++;
1490                }
1491           }
1492         count = wd->count + wd->items_lost - count_group;
1493         if (wd->horizontal)
1494           {
1495              minw = (ceil(count / (float)nmax) * wd->item_width) + (count_group * wd->group_item_width);
1496              minh = nmax * wd->item_height;
1497           }
1498         else
1499           {
1500              minw = nmax * wd->item_width;
1501              minh = (ceil(count / (float)nmax) * wd->item_height) + (count_group * wd->group_item_height);
1502           }
1503
1504         if ((minw != wd->minw) || (minh != wd->minh))
1505           {
1506              wd->minh = minh;
1507              wd->minw = minw;
1508              evas_object_smart_callback_call(wd->pan_smart, "changed", NULL);
1509           }
1510
1511         wd->nmax = nmax;
1512         evas_object_smart_changed(wd->pan_smart);
1513      }
1514    wd->calc_job = NULL;
1515 }
1516
1517 static void
1518 _pan_add(Evas_Object *obj)
1519 {
1520    Pan *sd;
1521    Evas_Object_Smart_Clipped_Data *cd;
1522
1523    _pan_sc.add(obj);
1524    cd = evas_object_smart_data_get(obj);
1525    sd = ELM_NEW(Pan);
1526    if (!sd) return;
1527    sd->__clipped_data = *cd;
1528    free(cd);
1529    evas_object_smart_data_set(obj, sd);
1530 }
1531
1532 static void
1533 _pan_del(Evas_Object *obj)
1534 {
1535    Pan *sd = evas_object_smart_data_get(obj);
1536
1537    if (!sd) return;
1538    _pan_sc.del(obj);
1539 }
1540
1541 static void
1542 _pan_set(Evas_Object *obj,
1543          Evas_Coord   x,
1544          Evas_Coord   y)
1545 {
1546    Pan *sd = evas_object_smart_data_get(obj);
1547    if ((x == sd->wd->pan_x) && (y == sd->wd->pan_y)) return;
1548    sd->wd->pan_x = x;
1549    sd->wd->pan_y = y;
1550    evas_object_smart_changed(obj);
1551 }
1552
1553 static void
1554 _pan_get(Evas_Object *obj,
1555          Evas_Coord  *x,
1556          Evas_Coord  *y)
1557 {
1558    Pan *sd = evas_object_smart_data_get(obj);
1559    if (x) *x = sd->wd->pan_x;
1560    if (y) *y = sd->wd->pan_y;
1561 }
1562
1563 static void
1564 _pan_child_size_get(Evas_Object *obj,
1565                     Evas_Coord  *w,
1566                     Evas_Coord  *h)
1567 {
1568    Pan *sd = evas_object_smart_data_get(obj);
1569    if (w) *w = sd->wd->minw;
1570    if (h) *h = sd->wd->minh;
1571 }
1572
1573 static void
1574 _pan_max_get(Evas_Object *obj,
1575              Evas_Coord  *x,
1576              Evas_Coord  *y)
1577 {
1578    Pan *sd = evas_object_smart_data_get(obj);
1579    Evas_Coord ow, oh;
1580
1581    if (!sd) return;
1582    evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
1583    if (x)
1584      *x = (ow < sd->wd->minw) ? sd->wd->minw - ow : 0;
1585    if (y)
1586      *y = (oh < sd->wd->minh) ? sd->wd->minh - oh : 0;
1587 }
1588
1589 static void
1590 _pan_min_get(Evas_Object *obj,
1591              Evas_Coord  *x,
1592              Evas_Coord  *y)
1593 {
1594    Pan *sd = evas_object_smart_data_get(obj);
1595    Evas_Coord mx, my;
1596
1597    if (!sd) return;
1598    _pan_max_get(obj, &mx, &my);
1599    if (x)
1600      *x = -mx * sd->wd->align_x;
1601    if (y)
1602      *y = -my * sd->wd->align_y;
1603 }
1604
1605 static void
1606 _pan_resize(Evas_Object *obj,
1607             Evas_Coord   w,
1608             Evas_Coord   h)
1609 {
1610    Pan *sd = evas_object_smart_data_get(obj);
1611    Evas_Coord ow, oh;
1612
1613    evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
1614    if ((ow == w) && (oh == h)) return;
1615    if (sd->wd->calc_job) ecore_job_del(sd->wd->calc_job);
1616    sd->wd->calc_job = ecore_job_add(_calc_job, sd->wd);
1617 }
1618
1619 static void
1620 _pan_calculate(Evas_Object *obj)
1621 {
1622    Pan *sd = evas_object_smart_data_get(obj);
1623    Evas_Coord cx = 0, cy = 0;
1624    Elm_Gen_Item *it;
1625
1626    if (!sd) return;
1627    if (!sd->wd->nmax) return;
1628
1629    sd->wd->reorder_item_changed = EINA_FALSE;
1630
1631    EINA_INLIST_FOREACH(sd->wd->items, it)
1632      {
1633         if (it->group)
1634           {
1635              if (sd->wd->horizontal)
1636                {
1637                   if (cy)
1638                     {
1639                        cx++;
1640                        cy = 0;
1641                     }
1642                }
1643              else
1644                {
1645                   if (cx)
1646                     {
1647                        cx = 0;
1648                        cy++;
1649                     }
1650                }
1651           }
1652         _item_place(it, cx, cy);
1653         if (sd->wd->reorder_item_changed) return;
1654         if (it->group)
1655           {
1656              if (sd->wd->horizontal)
1657                {
1658                   cx++;
1659                   cy = 0;
1660                }
1661              else
1662                {
1663                   cx = 0;
1664                   cy++;
1665                }
1666           }
1667         else
1668           {
1669              if (sd->wd->horizontal)
1670                {
1671                   cy = (cy + 1) % sd->wd->nmax;
1672                   if (!cy) cx++;
1673                }
1674              else
1675                {
1676                   cx = (cx + 1) % sd->wd->nmax;
1677                   if (!cx) cy++;
1678                }
1679           }
1680      }
1681    _group_item_place(sd);
1682
1683
1684    if ((sd->wd->reorder_mode) && (sd->wd->reorder_it))
1685      {
1686         if (!sd->wd->reorder_item_changed)
1687           {
1688              sd->wd->old_pan_x = sd->wd->pan_x;
1689              sd->wd->old_pan_y = sd->wd->pan_y;
1690           }
1691         sd->wd->move_effect_enabled = EINA_FALSE;
1692      }
1693    evas_object_smart_callback_call(sd->wd->obj, SIG_CHANGED, NULL);
1694 }
1695
1696 static void
1697 _pan_move(Evas_Object *obj,
1698           Evas_Coord x __UNUSED__,
1699           Evas_Coord y __UNUSED__)
1700 {
1701    Pan *sd = evas_object_smart_data_get(obj);
1702    if (!sd) return;
1703    if (sd->wd->calc_job) ecore_job_del(sd->wd->calc_job);
1704    sd->wd->calc_job = ecore_job_add(_calc_job, sd->wd);
1705 }
1706
1707 static void
1708 _hold_on(void *data       __UNUSED__,
1709          Evas_Object     *obj,
1710          void *event_info __UNUSED__)
1711 {
1712    Widget_Data *wd = elm_widget_data_get(obj);
1713    if (!wd) return;
1714    elm_smart_scroller_hold_set(wd->scr, 1);
1715 }
1716
1717 static void
1718 _hold_off(void *data       __UNUSED__,
1719           Evas_Object     *obj,
1720           void *event_info __UNUSED__)
1721 {
1722    Widget_Data *wd = elm_widget_data_get(obj);
1723    if (!wd) return;
1724    elm_smart_scroller_hold_set(wd->scr, 0);
1725 }
1726
1727 static void
1728 _freeze_on(void *data       __UNUSED__,
1729            Evas_Object     *obj,
1730            void *event_info __UNUSED__)
1731 {
1732    Widget_Data *wd = elm_widget_data_get(obj);
1733    if (!wd) return;
1734    elm_smart_scroller_freeze_set(wd->scr, 1);
1735 }
1736
1737 static void
1738 _freeze_off(void *data       __UNUSED__,
1739             Evas_Object     *obj,
1740             void *event_info __UNUSED__)
1741 {
1742    Widget_Data *wd = elm_widget_data_get(obj);
1743    if (!wd) return;
1744    elm_smart_scroller_freeze_set(wd->scr, 0);
1745 }
1746
1747 static void
1748 _scr_anim_start(void        *data,
1749                 Evas_Object *obj __UNUSED__,
1750                 void        *event_info __UNUSED__)
1751 {
1752    evas_object_smart_callback_call(data, SIG_SCROLL_ANIM_START, NULL);
1753 }
1754
1755 static void
1756 _scr_anim_stop(void        *data,
1757                 Evas_Object *obj __UNUSED__,
1758                 void        *event_info __UNUSED__)
1759 {
1760    evas_object_smart_callback_call(data, SIG_SCROLL_ANIM_STOP, NULL);
1761 }
1762
1763 static void
1764 _scr_drag_start(void            *data,
1765                 Evas_Object *obj __UNUSED__,
1766                 void *event_info __UNUSED__)
1767 {
1768    evas_object_smart_callback_call(data, SIG_SCROLL_DRAG_START, NULL);
1769 }
1770
1771 static void
1772 _scr_drag_stop(void            *data,
1773                Evas_Object *obj __UNUSED__,
1774                void *event_info __UNUSED__)
1775 {
1776    evas_object_smart_callback_call(data, SIG_SCROLL_DRAG_STOP, NULL);
1777 }
1778
1779 static void
1780 _edge_left(void        *data,
1781            Evas_Object *scr __UNUSED__,
1782            void        *event_info __UNUSED__)
1783 {
1784    evas_object_smart_callback_call(data, SIG_EDGE_LEFT, NULL);
1785 }
1786
1787 static void
1788 _edge_right(void        *data,
1789             Evas_Object *scr __UNUSED__,
1790             void        *event_info __UNUSED__)
1791 {
1792    evas_object_smart_callback_call(data, SIG_EDGE_RIGHT, NULL);
1793 }
1794
1795 static void
1796 _edge_top(void        *data,
1797           Evas_Object *scr __UNUSED__,
1798           void        *event_info __UNUSED__)
1799 {
1800    evas_object_smart_callback_call(data, SIG_EDGE_TOP, NULL);
1801 }
1802
1803 static void
1804 _edge_bottom(void        *data,
1805              Evas_Object *scr __UNUSED__,
1806              void        *event_info __UNUSED__)
1807 {
1808    evas_object_smart_callback_call(data, SIG_EDGE_BOTTOM, NULL);
1809 }
1810
1811 static void
1812 _scr_scroll(void            *data,
1813             Evas_Object *obj __UNUSED__,
1814             void *event_info __UNUSED__)
1815 {
1816    evas_object_smart_callback_call(data, SIG_SCROLL, NULL);
1817 }
1818
1819 static int
1820 _elm_gengrid_item_compare_data(const void *data, const void *data1)
1821 {
1822    const Elm_Gen_Item *it = data;
1823    const Elm_Gen_Item *item1 = data1;
1824
1825    return _elm_gengrid_item_compare_data_cb(it->base.data, item1->base.data);
1826 }
1827
1828 static int
1829 _elm_gengrid_item_compare(const void *data, const void *data1)
1830 {
1831    Elm_Gen_Item *it, *item1;
1832    it = ELM_GEN_ITEM_FROM_INLIST(data);
1833    item1 = ELM_GEN_ITEM_FROM_INLIST(data1);
1834    return _elm_gengrid_item_compare_cb(it, item1);
1835 }
1836
1837 static Elm_Gen_Item *
1838 _item_new(Widget_Data                  *wd,
1839           const Elm_Gengrid_Item_Class *itc,
1840           const void                   *data,
1841           Evas_Smart_Cb                 func,
1842           const void                   *func_data)
1843 {
1844    Elm_Gen_Item *it;
1845
1846    it = elm_gen_item_new(wd, itc, data, NULL, func, func_data);
1847    if (!it) return NULL;
1848    it->item = ELM_NEW(Elm_Gen_Item_Type);
1849    wd->count++;
1850    it->group = it->itc->item_style && (!strcmp(it->itc->item_style, "group_index"));
1851    ELM_GEN_ITEM_SETUP(it);
1852
1853    return it;
1854 }
1855
1856 EAPI Evas_Object *
1857 elm_gengrid_add(Evas_Object *parent)
1858 {
1859    Evas_Object *obj;
1860    Evas *e;
1861    Widget_Data *wd;
1862    static Evas_Smart *smart = NULL;
1863    Eina_Bool bounce = _elm_config->thumbscroll_bounce_enable;
1864
1865    if (!smart)
1866      {
1867         static Evas_Smart_Class sc;
1868
1869         evas_object_smart_clipped_smart_set(&_pan_sc);
1870         sc = _pan_sc;
1871         sc.name = "elm_gengrid_pan";
1872         sc.version = EVAS_SMART_CLASS_VERSION;
1873         sc.add = _pan_add;
1874         sc.del = _pan_del;
1875         sc.resize = _pan_resize;
1876         sc.move = _pan_move;
1877         sc.calculate = _pan_calculate;
1878         if (!(smart = evas_smart_class_new(&sc))) return NULL;
1879      }
1880
1881    ELM_WIDGET_STANDARD_SETUP(wd, Widget_Data, parent, e, obj, NULL);
1882
1883    ELM_SET_WIDTYPE(widtype, "gengrid");
1884    ELM_GEN_SETUP(wd);
1885    elm_widget_type_set(obj, "gengrid");
1886    elm_widget_sub_object_add(parent, obj);
1887    elm_widget_on_focus_hook_set(obj, _on_focus_hook, NULL);
1888    elm_widget_data_set(obj, wd);
1889    elm_widget_del_hook_set(obj, _del_hook);
1890    elm_widget_del_pre_hook_set(obj, _del_pre_hook);
1891    elm_widget_theme_hook_set(obj, _theme_hook);
1892    elm_widget_signal_emit_hook_set(obj, _signal_emit_hook);
1893    elm_widget_can_focus_set(obj, EINA_TRUE);
1894    elm_widget_signal_callback_add_hook_set(obj, _signal_callback_add_hook);
1895    elm_widget_signal_callback_del_hook_set(obj, _signal_callback_del_hook);
1896    elm_widget_event_hook_set(obj, _event_hook);
1897
1898    wd->scr = elm_smart_scroller_add(e);
1899    elm_smart_scroller_widget_set(wd->scr, obj);
1900    elm_smart_scroller_object_theme_set(obj, wd->scr, "gengrid", "base",
1901                                        "default");
1902    elm_smart_scroller_bounce_allow_set(wd->scr, bounce,
1903                                        _elm_config->thumbscroll_bounce_enable);
1904    elm_widget_resize_object_set(obj, wd->scr);
1905
1906    evas_object_smart_callback_add(wd->scr, "animate,start", _scr_anim_start, obj);
1907    evas_object_smart_callback_add(wd->scr, "animate,stop", _scr_anim_stop, obj);
1908    evas_object_smart_callback_add(wd->scr, "drag,start", _scr_drag_start, obj);
1909    evas_object_smart_callback_add(wd->scr, "drag,stop", _scr_drag_stop, obj);
1910    evas_object_smart_callback_add(wd->scr, "edge,left", _edge_left, obj);
1911    evas_object_smart_callback_add(wd->scr, "edge,right", _edge_right, obj);
1912    evas_object_smart_callback_add(wd->scr, "edge,top", _edge_top, obj);
1913    evas_object_smart_callback_add(wd->scr, "edge,bottom", _edge_bottom,
1914                                   obj);
1915    evas_object_smart_callback_add(wd->scr, "scroll", _scr_scroll, obj);
1916
1917    wd->obj = obj;
1918    wd->align_x = 0.5;
1919    wd->align_y = 0.5;
1920    wd->h_bounce = bounce;
1921    wd->v_bounce = bounce;
1922
1923    evas_object_smart_callback_add(obj, "scroll-hold-on", _hold_on, obj);
1924    evas_object_smart_callback_add(obj, "scroll-hold-off", _hold_off, obj);
1925    evas_object_smart_callback_add(obj, "scroll-freeze-on", _freeze_on, obj);
1926    evas_object_smart_callback_add(obj, "scroll-freeze-off", _freeze_off, obj);
1927
1928    wd->pan_smart = evas_object_smart_add(e, smart);
1929    wd->pan = evas_object_smart_data_get(wd->pan_smart);
1930    wd->pan->wd = wd;
1931
1932    elm_smart_scroller_extern_pan_set(wd->scr, wd->pan_smart,
1933                                      _pan_set, _pan_get, _pan_max_get,
1934                                      _pan_min_get, _pan_child_size_get);
1935
1936    evas_object_smart_callbacks_descriptions_set(obj, _signals);
1937
1938    _mirrored_set(obj, elm_widget_mirrored_get(obj));
1939    return obj;
1940 }
1941
1942 EAPI void
1943 elm_gengrid_item_size_set(Evas_Object *obj,
1944                           Evas_Coord   w,
1945                           Evas_Coord   h)
1946 {
1947    ELM_CHECK_WIDTYPE(obj, widtype);
1948    Widget_Data *wd = elm_widget_data_get(obj);
1949    if (!wd) return;
1950    if ((wd->item_width == w) && (wd->item_height == h)) return;
1951    wd->item_width = w;
1952    wd->item_height = h;
1953    if (wd->calc_job) ecore_job_del(wd->calc_job);
1954    wd->calc_job = ecore_job_add(_calc_job, wd);
1955 }
1956
1957 EAPI void
1958 elm_gengrid_item_size_get(const Evas_Object *obj,
1959                           Evas_Coord        *w,
1960                           Evas_Coord        *h)
1961 {
1962    ELM_CHECK_WIDTYPE(obj, widtype);
1963    Widget_Data *wd = elm_widget_data_get(obj);
1964    if (!wd) return;
1965    if (w) *w = wd->item_width;
1966    if (h) *h = wd->item_height;
1967 }
1968
1969 EAPI void
1970 elm_gengrid_group_item_size_set(Evas_Object *obj,
1971                           Evas_Coord   w,
1972                           Evas_Coord   h)
1973 {
1974    ELM_CHECK_WIDTYPE(obj, widtype);
1975    Widget_Data *wd = elm_widget_data_get(obj);
1976    if (!wd) return;
1977    if ((wd->group_item_width == w) && (wd->group_item_height == h)) return;
1978    wd->group_item_width = w;
1979    wd->group_item_height = h;
1980    if (wd->calc_job) ecore_job_del(wd->calc_job);
1981    wd->calc_job = ecore_job_add(_calc_job, wd);
1982 }
1983
1984 EAPI void
1985 elm_gengrid_group_item_size_get(const Evas_Object *obj,
1986                           Evas_Coord        *w,
1987                           Evas_Coord        *h)
1988 {
1989    ELM_CHECK_WIDTYPE(obj, widtype);
1990    Widget_Data *wd = elm_widget_data_get(obj);
1991    if (!wd) return;
1992    if (w) *w = wd->group_item_width;
1993    if (h) *h = wd->group_item_height;
1994 }
1995
1996 EAPI void
1997 elm_gengrid_align_set(Evas_Object *obj,
1998                       double       align_x,
1999                       double       align_y)
2000 {
2001    ELM_CHECK_WIDTYPE(obj, widtype);
2002
2003    Widget_Data *wd = elm_widget_data_get(obj);
2004    double old_h = wd->align_x, old_y = wd->align_y;
2005
2006    if (align_x > 1.0)
2007      align_x = 1.0;
2008    else if (align_x < 0.0)
2009      align_x = 0.0;
2010    wd->align_x = align_x;
2011
2012    if (align_y > 1.0)
2013      align_y = 1.0;
2014    else if (align_y < 0.0)
2015      align_y = 0.0;
2016    wd->align_y = align_y;
2017
2018    if ((old_h != wd->align_x) || (old_y != wd->align_y))
2019      evas_object_smart_calculate(wd->pan_smart);
2020 }
2021
2022 EAPI void
2023 elm_gengrid_align_get(const Evas_Object *obj,
2024                       double            *align_x,
2025                       double            *align_y)
2026 {
2027    ELM_CHECK_WIDTYPE(obj, widtype);
2028    Widget_Data *wd = elm_widget_data_get(obj);
2029    if (align_x) *align_x = wd->align_x;
2030    if (align_y) *align_y = wd->align_y;
2031 }
2032
2033 EAPI Elm_Gen_Item *
2034 elm_gengrid_item_append(Evas_Object                  *obj,
2035                         const Elm_Gengrid_Item_Class *itc,
2036                         const void                   *data,
2037                         Evas_Smart_Cb                 func,
2038                         const void                   *func_data)
2039 {
2040    Elm_Gen_Item *it;
2041    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
2042    Widget_Data *wd = elm_widget_data_get(obj);
2043    if (!wd) return NULL;
2044
2045    it = _item_new(wd, itc, data, func, func_data);
2046    if (!it) return NULL;
2047    wd->items = eina_inlist_append(wd->items, EINA_INLIST_GET(it));
2048
2049    if (it->group)
2050      wd->group_items = eina_list_prepend(wd->group_items, it);
2051
2052    if (wd->calc_job) ecore_job_del(wd->calc_job);
2053    wd->calc_job = ecore_job_add(_calc_job, wd);
2054
2055    return it;
2056 }
2057
2058 EAPI Elm_Gen_Item *
2059 elm_gengrid_item_prepend(Evas_Object                  *obj,
2060                          const Elm_Gengrid_Item_Class *itc,
2061                          const void                   *data,
2062                          Evas_Smart_Cb                 func,
2063                          const void                   *func_data)
2064 {
2065    Elm_Gen_Item *it;
2066    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
2067    Widget_Data *wd = elm_widget_data_get(obj);
2068    if (!wd) return NULL;
2069
2070    it = _item_new(wd, itc, data, func, func_data);
2071    if (!it) return NULL;
2072    wd->items = eina_inlist_prepend(wd->items, EINA_INLIST_GET(it));
2073    if (it->group)
2074      wd->group_items = eina_list_append(wd->group_items, it);
2075
2076    if (wd->calc_job) ecore_job_del(wd->calc_job);
2077    wd->calc_job = ecore_job_add(_calc_job, wd);
2078
2079    return it;
2080 }
2081
2082 EAPI Elm_Gen_Item *
2083 elm_gengrid_item_insert_before(Evas_Object                  *obj,
2084                                const Elm_Gengrid_Item_Class *itc,
2085                                const void                   *data,
2086                                Elm_Gen_Item             *relative,
2087                                Evas_Smart_Cb                 func,
2088                                const void                   *func_data)
2089 {
2090    Elm_Gen_Item *it;
2091    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
2092    EINA_SAFETY_ON_NULL_RETURN_VAL(relative, NULL);
2093    Widget_Data *wd = elm_widget_data_get(obj);
2094    if (!wd) return NULL;
2095
2096    it = _item_new(wd, itc, data, func, func_data);
2097    if (!it) return NULL;
2098    wd->items = eina_inlist_prepend_relative
2099       (wd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(relative));
2100    if (it->group)
2101      wd->group_items = eina_list_append_relative(wd->group_items, it, relative->parent);
2102
2103    if (wd->calc_job) ecore_job_del(wd->calc_job);
2104    wd->calc_job = ecore_job_add(_calc_job, wd);
2105
2106    return it;
2107 }
2108
2109 EAPI Elm_Gen_Item *
2110 elm_gengrid_item_insert_after(Evas_Object                  *obj,
2111                               const Elm_Gengrid_Item_Class *itc,
2112                               const void                   *data,
2113                               Elm_Gen_Item             *relative,
2114                               Evas_Smart_Cb                 func,
2115                               const void                   *func_data)
2116 {
2117    Elm_Gen_Item *it;
2118    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
2119    EINA_SAFETY_ON_NULL_RETURN_VAL(relative, NULL);
2120    Widget_Data *wd = elm_widget_data_get(obj);
2121    if (!wd) return NULL;
2122
2123    it = _item_new(wd, itc, data, func, func_data);
2124    if (!it) return NULL;
2125    wd->items = eina_inlist_append_relative
2126       (wd->items, EINA_INLIST_GET(it), EINA_INLIST_GET(relative));
2127    if (it->group)
2128      wd->group_items = eina_list_prepend_relative(wd->group_items, it, relative->parent);
2129
2130    if (wd->calc_job) ecore_job_del(wd->calc_job);
2131    wd->calc_job = ecore_job_add(_calc_job, wd);
2132
2133    return it;
2134 }
2135
2136 EAPI Elm_Gen_Item *
2137 elm_gengrid_item_direct_sorted_insert(Evas_Object                  *obj,
2138                                       const Elm_Gengrid_Item_Class *itc,
2139                                       const void                   *data,
2140                                       Eina_Compare_Cb               comp,
2141                                       Evas_Smart_Cb                 func,
2142                                       const void                   *func_data)
2143 {
2144    Elm_Gen_Item *it;
2145    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
2146    Widget_Data *wd = elm_widget_data_get(obj);
2147    if (!wd) return NULL;
2148
2149    it = _item_new(wd, itc, data, func, func_data);
2150    if (!it) return NULL;
2151
2152    if (!wd->state)
2153      wd->state = eina_inlist_sorted_state_new();
2154
2155    _elm_gengrid_item_compare_cb = comp;
2156    wd->items = eina_inlist_sorted_state_insert(wd->items, EINA_INLIST_GET(it),
2157                                          _elm_gengrid_item_compare, wd->state);
2158    if (wd->calc_job) ecore_job_del(wd->calc_job);
2159    wd->calc_job = ecore_job_add(_calc_job, wd);
2160
2161    return it;
2162 }
2163
2164 EAPI Elm_Gen_Item *
2165 elm_gengrid_item_sorted_insert(Evas_Object                  *obj,
2166                                const Elm_Gengrid_Item_Class *itc,
2167                                const void                   *data,
2168                                Eina_Compare_Cb               comp,
2169                                Evas_Smart_Cb                 func,
2170                                const void                   *func_data)
2171 {
2172    _elm_gengrid_item_compare_data_cb = comp;
2173
2174    return elm_gengrid_item_direct_sorted_insert(obj, itc, data, _elm_gengrid_item_compare_data, func, func_data);
2175 }
2176
2177 EAPI void
2178 elm_gengrid_item_del(Elm_Gen_Item *it)
2179 {
2180    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
2181    if ((it->relcount > 0) || (it->walking > 0))
2182      {
2183         elm_gen_item_del_notserious(it);
2184         return;
2185      }
2186
2187    _item_del(it);
2188 }
2189
2190 EAPI void
2191 elm_gengrid_horizontal_set(Evas_Object *obj,
2192                            Eina_Bool    setting)
2193 {
2194    ELM_CHECK_WIDTYPE(obj, widtype);
2195    Widget_Data *wd = elm_widget_data_get(obj);
2196    if (!wd) return;
2197    if (setting == wd->horizontal) return;
2198    wd->horizontal = setting;
2199
2200    /* Update the items to conform to the new layout */
2201    if (wd->calc_job) ecore_job_del(wd->calc_job);
2202    wd->calc_job = ecore_job_add(_calc_job, wd);
2203 }
2204
2205 EAPI Eina_Bool
2206 elm_gengrid_horizontal_get(const Evas_Object *obj)
2207 {
2208    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
2209    Widget_Data *wd = elm_widget_data_get(obj);
2210    if (!wd) return EINA_FALSE;
2211    return wd->horizontal;
2212 }
2213
2214 EAPI void
2215 elm_gengrid_clear(Evas_Object *obj)
2216 {
2217    elm_gen_clear(obj);
2218 }
2219
2220 EAPI const Evas_Object *
2221 elm_gengrid_item_object_get(const Elm_Gen_Item *it)
2222 {
2223    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
2224    return VIEW(it);
2225 }
2226
2227 EAPI void
2228 elm_gengrid_item_update(Elm_Gen_Item *it)
2229 {
2230    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
2231    if (!it->realized) return;
2232    if (it->want_unrealize) return;
2233    elm_gen_item_unrealize(it, EINA_FALSE);
2234    _item_realize(it);
2235    _item_place(it, it->x, it->y);
2236 }
2237
2238 EAPI void *
2239 elm_gengrid_item_data_get(const Elm_Gen_Item *it)
2240 {
2241    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
2242    return elm_widget_item_data_get(it);
2243 }
2244
2245 EAPI void
2246 elm_gengrid_item_data_set(Elm_Gen_Item *it,
2247                           const void       *data)
2248 {
2249    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
2250    elm_widget_item_data_set(it, data);
2251 }
2252
2253 EAPI const Elm_Gengrid_Item_Class *
2254 elm_gengrid_item_item_class_get(const Elm_Gen_Item *it)
2255 {
2256    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
2257    if (it->delete_me) return NULL;
2258    return it->itc;
2259 }
2260
2261 EAPI void
2262 elm_gengrid_item_item_class_set(Elm_Gen_Item *it,
2263                                 const Elm_Gengrid_Item_Class *itc)
2264 {
2265    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
2266    EINA_SAFETY_ON_NULL_RETURN(itc);
2267    if (it->delete_me) return;
2268    it->itc = itc;
2269    elm_gengrid_item_update(it);
2270 }
2271
2272 EAPI void
2273 elm_gengrid_item_pos_get(const Elm_Gen_Item *it,
2274                          unsigned int           *x,
2275                          unsigned int           *y)
2276 {
2277    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
2278    if (x) *x = it->x;
2279    if (y) *y = it->y;
2280 }
2281
2282 EAPI void
2283 elm_gengrid_multi_select_set(Evas_Object *obj,
2284                              Eina_Bool    multi)
2285 {
2286    ELM_CHECK_WIDTYPE(obj, widtype);
2287    Widget_Data *wd = elm_widget_data_get(obj);
2288    if (!wd) return;
2289    wd->multi = multi;
2290 }
2291
2292 EAPI Eina_Bool
2293 elm_gengrid_multi_select_get(const Evas_Object *obj)
2294 {
2295    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
2296    Widget_Data *wd = elm_widget_data_get(obj);
2297    if (!wd) return EINA_FALSE;
2298    return wd->multi;
2299 }
2300
2301 EAPI Elm_Gen_Item *
2302 elm_gengrid_selected_item_get(const Evas_Object *obj)
2303 {
2304    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
2305    Widget_Data *wd = elm_widget_data_get(obj);
2306    if (!wd) return NULL;
2307    if (wd->selected) return wd->selected->data;
2308    return NULL;
2309 }
2310
2311 EAPI const Eina_List *
2312 elm_gengrid_selected_items_get(const Evas_Object *obj)
2313 {
2314    ELM_CHECK_WIDTYPE(obj, widtype) NULL;
2315    Widget_Data *wd = elm_widget_data_get(obj);
2316    if (!wd) return NULL;
2317    return wd->selected;
2318 }
2319
2320 EAPI void
2321 elm_gengrid_item_selected_set(Elm_Gen_Item *it,
2322                               Eina_Bool         selected)
2323 {
2324    elm_gen_item_selected_set(it, selected);
2325 }
2326
2327 EAPI Eina_Bool
2328 elm_gengrid_item_selected_get(const Elm_Gen_Item *it)
2329 {
2330    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, EINA_FALSE);
2331    return it->selected;
2332 }
2333
2334 EAPI void
2335 elm_gengrid_item_disabled_set(Elm_Gen_Item *it,
2336                               Eina_Bool         disabled)
2337 {
2338    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
2339    if (it->disabled == disabled) return;
2340    if (it->delete_me) return;
2341    it->disabled = !!disabled;
2342    if (it->realized)
2343      {
2344         if (it->disabled)
2345           edje_object_signal_emit(VIEW(it), "elm,state,disabled", "elm");
2346         else
2347           edje_object_signal_emit(VIEW(it), "elm,state,enabled", "elm");
2348      }
2349 }
2350
2351 EAPI Eina_Bool
2352 elm_gengrid_item_disabled_get(const Elm_Gen_Item *it)
2353 {
2354    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, EINA_FALSE);
2355    if (it->delete_me) return EINA_FALSE;
2356    return it->disabled;
2357 }
2358
2359 static Evas_Object *
2360 _elm_gengrid_item_label_create(void        *data,
2361                                Evas_Object *obj __UNUSED__,
2362                                Evas_Object *tooltip,
2363                                void *it   __UNUSED__)
2364 {
2365    Evas_Object *label = elm_label_add(tooltip);
2366    if (!label)
2367      return NULL;
2368    elm_object_style_set(label, "tooltip");
2369    elm_object_text_set(label, data);
2370    return label;
2371 }
2372
2373 static void
2374 _elm_gengrid_item_label_del_cb(void            *data,
2375                                Evas_Object *obj __UNUSED__,
2376                                void *event_info __UNUSED__)
2377 {
2378    eina_stringshare_del(data);
2379 }
2380
2381 EAPI void
2382 elm_gengrid_item_tooltip_text_set(Elm_Gen_Item *it,
2383                                   const char       *text)
2384 {
2385    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
2386    text = eina_stringshare_add(text);
2387    elm_gengrid_item_tooltip_content_cb_set(it, _elm_gengrid_item_label_create,
2388                                            text,
2389                                            _elm_gengrid_item_label_del_cb);
2390 }
2391
2392 EAPI void
2393 elm_gengrid_item_tooltip_content_cb_set(Elm_Gen_Item           *it,
2394                                         Elm_Tooltip_Item_Content_Cb func,
2395                                         const void                 *data,
2396                                         Evas_Smart_Cb               del_cb)
2397 {
2398    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_GOTO(it, error);
2399
2400    if ((it->tooltip.content_cb == func) && (it->tooltip.data == data))
2401      return;
2402
2403    if (it->tooltip.del_cb)
2404      it->tooltip.del_cb((void *)it->tooltip.data,
2405                           WIDGET(it), it);
2406    it->tooltip.content_cb = func;
2407    it->tooltip.data = data;
2408    it->tooltip.del_cb = del_cb;
2409    if (VIEW(it))
2410      {
2411         elm_widget_item_tooltip_content_cb_set(it,
2412                                                it->tooltip.content_cb,
2413                                                it->tooltip.data, NULL);
2414         elm_widget_item_tooltip_style_set(it, it->tooltip.style);
2415         elm_widget_item_tooltip_size_restrict_disable(it, it->tooltip.free_size);
2416      }
2417
2418    return;
2419
2420 error:
2421    if (del_cb) del_cb((void *)data, NULL, NULL);
2422 }
2423
2424 EAPI void
2425 elm_gengrid_item_tooltip_unset(Elm_Gen_Item *it)
2426 {
2427    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
2428    if ((VIEW(it)) && (it->tooltip.content_cb))
2429      elm_widget_item_tooltip_unset(it);
2430
2431    if (it->tooltip.del_cb)
2432      it->tooltip.del_cb((void *)it->tooltip.data, WIDGET(it), it);
2433    it->tooltip.del_cb = NULL;
2434    it->tooltip.content_cb = NULL;
2435    it->tooltip.data = NULL;
2436    it->tooltip.free_size = EINA_FALSE;
2437    if (it->tooltip.style)
2438      elm_gengrid_item_tooltip_style_set(it, NULL);
2439 }
2440
2441 EAPI void
2442 elm_gengrid_item_tooltip_style_set(Elm_Gen_Item *it,
2443                                    const char       *style)
2444 {
2445    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
2446    eina_stringshare_replace(&it->tooltip.style, style);
2447    if (VIEW(it)) elm_widget_item_tooltip_style_set(it, style);
2448 }
2449
2450 EAPI const char *
2451 elm_gengrid_item_tooltip_style_get(const Elm_Gen_Item *it)
2452 {
2453    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
2454    return it->tooltip.style;
2455 }
2456
2457 EAPI Eina_Bool
2458 elm_gengrid_item_tooltip_size_restrict_disable(Elm_Gen_Item *it, Eina_Bool disable)
2459 {
2460    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, EINA_FALSE);
2461    it->tooltip.free_size = disable;
2462    if (VIEW(it)) return elm_widget_item_tooltip_size_restrict_disable(it, disable);
2463    return EINA_TRUE;
2464 }
2465
2466 EAPI Eina_Bool
2467 elm_gengrid_item_tooltip_size_restrict_disabled_get(const Elm_Gen_Item *it)
2468 {
2469    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, EINA_FALSE);
2470    return it->tooltip.free_size;
2471 }
2472
2473 EAPI void
2474 elm_gengrid_item_cursor_set(Elm_Gen_Item *it,
2475                             const char       *cursor)
2476 {
2477    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
2478    eina_stringshare_replace(&it->mouse_cursor, cursor);
2479    if (VIEW(it)) elm_widget_item_cursor_set(it, cursor);
2480 }
2481
2482 EAPI const char *
2483 elm_gengrid_item_cursor_get(const Elm_Gen_Item *it)
2484 {
2485    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
2486    return elm_widget_item_cursor_get(it);
2487 }
2488
2489 EAPI void
2490 elm_gengrid_item_cursor_unset(Elm_Gen_Item *it)
2491 {
2492    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
2493    if (!it->mouse_cursor)
2494      return;
2495
2496    if (VIEW(it))
2497      elm_widget_item_cursor_unset(it);
2498
2499    eina_stringshare_del(it->mouse_cursor);
2500    it->mouse_cursor = NULL;
2501 }
2502
2503 EAPI void
2504 elm_gengrid_item_cursor_style_set(Elm_Gen_Item *it,
2505                                   const char       *style)
2506 {
2507    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
2508    elm_widget_item_cursor_style_set(it, style);
2509 }
2510
2511 EAPI const char *
2512 elm_gengrid_item_cursor_style_get(const Elm_Gen_Item *it)
2513 {
2514    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, NULL);
2515    return elm_widget_item_cursor_style_get(it);
2516 }
2517
2518 EAPI void
2519 elm_gengrid_item_cursor_engine_only_set(Elm_Gen_Item *it,
2520                                         Eina_Bool         engine_only)
2521 {
2522    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
2523    elm_widget_item_cursor_engine_only_set(it, engine_only);
2524 }
2525
2526 EAPI Eina_Bool
2527 elm_gengrid_item_cursor_engine_only_get(const Elm_Gen_Item *it)
2528 {
2529    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it, EINA_FALSE);
2530    return elm_widget_item_cursor_engine_only_get(it);
2531 }
2532
2533 EAPI void
2534 elm_gengrid_reorder_mode_set(Evas_Object *obj,
2535                              Eina_Bool    reorder_mode)
2536 {
2537    ELM_CHECK_WIDTYPE(obj, widtype);
2538    Widget_Data *wd = elm_widget_data_get(obj);
2539    if (!wd) return;
2540    wd->reorder_mode = reorder_mode;
2541 }
2542
2543 EAPI Eina_Bool
2544 elm_gengrid_reorder_mode_get(const Evas_Object *obj)
2545 {
2546    ELM_CHECK_WIDTYPE(obj, widtype) EINA_FALSE;
2547    Widget_Data *wd = elm_widget_data_get(obj);
2548    if (!wd) return EINA_FALSE;
2549    return wd->reorder_mode;
2550 }
2551
2552 EAPI void
2553 elm_gengrid_always_select_mode_set(Evas_Object *obj,
2554                                    Eina_Bool    always_select)
2555 {
2556    elm_gen_always_select_mode_set(obj, always_select);
2557 }
2558
2559 EAPI Eina_Bool
2560 elm_gengrid_always_select_mode_get(const Evas_Object *obj)
2561 {
2562    return elm_gen_always_select_mode_get(obj);
2563 }
2564
2565 EAPI void
2566 elm_gengrid_no_select_mode_set(Evas_Object *obj,
2567                                Eina_Bool    no_select)
2568 {
2569    elm_gen_no_select_mode_set(obj, no_select);
2570 }
2571
2572 EAPI Eina_Bool
2573 elm_gengrid_no_select_mode_get(const Evas_Object *obj)
2574 {
2575    return elm_gen_no_select_mode_get(obj);
2576 }
2577
2578 EAPI void
2579 elm_gengrid_bounce_set(Evas_Object *obj,
2580                        Eina_Bool    h_bounce,
2581                        Eina_Bool    v_bounce)
2582 {
2583    elm_gen_bounce_set(obj, h_bounce, v_bounce);
2584 }
2585
2586 EAPI void
2587 elm_gengrid_bounce_get(const Evas_Object *obj,
2588                        Eina_Bool         *h_bounce,
2589                        Eina_Bool         *v_bounce)
2590 {
2591    return elm_gen_bounce_get(obj, h_bounce, v_bounce);
2592 }
2593
2594 EAPI void
2595 elm_gengrid_page_relative_set(Evas_Object *obj,
2596                               double       h_pagerel,
2597                               double       v_pagerel)
2598 {
2599    elm_gen_page_relative_set(obj, h_pagerel, v_pagerel);
2600 }
2601
2602 EAPI void
2603 elm_gengrid_page_relative_get(const Evas_Object *obj, double *h_pagerel, double *v_pagerel)
2604 {
2605    elm_gen_page_relative_get(obj, h_pagerel, v_pagerel);
2606 }
2607
2608 EAPI void
2609 elm_gengrid_page_size_set(Evas_Object *obj,
2610                           Evas_Coord   h_pagesize,
2611                           Evas_Coord   v_pagesize)
2612 {
2613    elm_gen_page_size_set(obj, h_pagesize, v_pagesize);
2614 }
2615
2616 EAPI void
2617 elm_gengrid_current_page_get(const Evas_Object *obj, int *h_pagenumber, int *v_pagenumber)
2618 {
2619    elm_gen_current_page_get(obj, h_pagenumber, v_pagenumber);
2620 }
2621
2622 EAPI void
2623 elm_gengrid_last_page_get(const Evas_Object *obj, int *h_pagenumber, int *v_pagenumber)
2624 {
2625    elm_gen_last_page_get(obj, h_pagenumber, v_pagenumber);
2626 }
2627
2628 EAPI void
2629 elm_gengrid_page_show(const Evas_Object *obj, int h_pagenumber, int v_pagenumber)
2630 {
2631    elm_gen_page_show(obj, h_pagenumber, v_pagenumber);
2632 }
2633
2634 EAPI void
2635 elm_gengrid_page_bring_in(const Evas_Object *obj, int h_pagenumber, int v_pagenumber)
2636 {
2637    elm_gen_page_bring_in(obj, h_pagenumber, v_pagenumber);
2638 }
2639
2640 EAPI Elm_Gen_Item *
2641 elm_gengrid_first_item_get(const Evas_Object *obj)
2642 {
2643    return elm_gen_first_item_get(obj);
2644 }
2645
2646 EAPI Elm_Gen_Item *
2647 elm_gengrid_last_item_get(const Evas_Object *obj)
2648 {
2649    return elm_gen_last_item_get(obj);
2650 }
2651
2652 EAPI Elm_Gen_Item *
2653 elm_gengrid_item_next_get(const Elm_Gen_Item *it)
2654 {
2655    return elm_gen_item_next_get(it);
2656 }
2657
2658 EAPI Elm_Gen_Item *
2659 elm_gengrid_item_prev_get(const Elm_Gen_Item *it)
2660 {
2661    return elm_gen_item_prev_get(it);
2662 }
2663
2664 EAPI Evas_Object *
2665 elm_gengrid_item_gengrid_get(const Elm_Gen_Item *it)
2666 {
2667    return elm_gen_item_widget_get(it);
2668 }
2669
2670 EAPI void
2671 elm_gengrid_item_show(Elm_Gen_Item *it)
2672 {
2673    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
2674    Widget_Data *wd = it->wd;
2675    Evas_Coord minx = 0, miny = 0;
2676
2677    if (!wd) return;
2678    if ((!it) || (it->delete_me)) return;
2679    _pan_min_get(wd->pan_smart, &minx, &miny);
2680
2681    if (wd->horizontal)
2682      elm_smart_scroller_region_bring_in(it->wd->scr,
2683                                         ((it->x - it->item->prev_group) * wd->item_width) + (it->item->prev_group * it->wd->group_item_width) + minx,
2684                                         it->y * wd->item_height + miny,
2685                                         it->wd->item_width,
2686                                         it->wd->item_height);
2687    else
2688      elm_smart_scroller_region_bring_in(it->wd->scr,
2689                                         it->x * wd->item_width + minx,
2690                                         ((it->y - it->item->prev_group)* wd->item_height) + (it->item->prev_group * it->wd->group_item_height) + miny,
2691                                         it->wd->item_width,
2692                                         it->wd->item_height);
2693 }
2694
2695 EAPI void
2696 elm_gengrid_item_bring_in(Elm_Gen_Item *it)
2697 {
2698    ELM_WIDGET_ITEM_WIDTYPE_CHECK_OR_RETURN(it);
2699    if (it->delete_me) return;
2700
2701    Evas_Coord minx = 0, miny = 0;
2702    Widget_Data *wd = it->wd;
2703    if (!wd) return;
2704    _pan_min_get(wd->pan_smart, &minx, &miny);
2705
2706    if (wd->horizontal)
2707      elm_smart_scroller_region_bring_in(it->wd->scr,
2708                                         ((it->x - it->item->prev_group) * wd->item_width) + (it->item->prev_group * it->wd->group_item_width) + minx,
2709                                         it->y * wd->item_height + miny,
2710                                         it->wd->item_width,
2711                                         it->wd->item_height);
2712    else
2713      elm_smart_scroller_region_bring_in(it->wd->scr,
2714                                         it->x * wd->item_width + minx,
2715                                         ((it->y - it->item->prev_group)* wd->item_height) + (it->item->prev_group * it->wd->group_item_height) + miny,
2716                                         it->wd->item_width,
2717                                         it->wd->item_height);
2718 }