src/lib/els_scroller.c

   1 #include <Elementary.h>
   2 #include "elm_priv.h"
   3 #include "els_scroller.h"
   4 #include "els_pan.h"
   5
   6 #define SMART_NAME "els_scroller"
   7 #define API_ENTRY Smart_Data *sd; sd = evas_object_smart_data_get(obj); if ((!obj) || (!sd) || (evas_object_type_get(obj) && strcmp(evas_object_type_get(obj), SMART_NAME)))
   8 #define INTERNAL_ENTRY Smart_Data *sd; sd = evas_object_smart_data_get(obj); if (!sd) return;
   9 typedef struct _Smart_Data Smart_Data;
  10
  11 #define EVTIME 1
  12 //#define SCROLLDBG 1
  13
  14 struct _Smart_Data
  15 {
  16    Evas_Coord   x, y, w, h;
  17    Evas_Coord   wx, wy, ww, wh; /* Last "wanted" geometry */
  18
  19    Evas_Object *smart_obj;
  20    Evas_Object *child_obj;
  21    Evas_Object *pan_obj;
  22    Evas_Object *edje_obj;
  23    Evas_Object *event_obj;
  24
  25    Evas_Object *widget;
  26
  27    Elm_Smart_Scroller_Policy hbar_flags, vbar_flags;
  28
  29    struct {
  30         Evas_Coord x, y;
  31         Evas_Coord sx, sy;
  32         Evas_Coord dx, dy;
  33         Evas_Coord pdx, pdy;
  34         Evas_Coord bx, by;
  35         Evas_Coord ax, ay;
  36         Evas_Coord bx0, by0;
  37         Evas_Coord b0x, b0y;
  38         Evas_Coord b2x, b2y;
  39         struct {
  40              Evas_Coord    x, y;
  41              double        timestamp, localtimestamp;
  42         } history[60];
  43         struct {
  44            double tadd, dxsum, dysum;
  45            double est_timestamp_diff;
  46         } hist;
  47       double anim_start;
  48       double anim_start2;
  49       double anim_start3;
  50       double onhold_vx, onhold_vy, onhold_tlast, onhold_vxe, onhold_vye;
  51       double extra_time;
  52       Evas_Coord hold_x, hold_y;
  53       Ecore_Animator *hold_animator;
  54       Ecore_Animator *onhold_animator;
  55       Ecore_Animator *momentum_animator;
  56       Ecore_Animator *bounce_x_animator;
  57       Ecore_Animator *bounce_y_animator;
  58       Evas_Coord locked_x, locked_y;
  59       int hdir, vdir;
  60       Eina_Bool now : 1;
  61       Eina_Bool cancelled : 1;
  62       Eina_Bool hold : 1;
  63       Eina_Bool hold_parent : 1;
  64       Eina_Bool want_dragged : 1;
  65       Eina_Bool dragged : 1;
  66       Eina_Bool dragged_began : 1;
  67       Eina_Bool dir_x : 1;
  68       Eina_Bool dir_y : 1;
  69       Eina_Bool locked : 1;
  70       Eina_Bool bounce_x_hold : 1;
  71       Eina_Bool bounce_y_hold : 1;
  72       Eina_Bool scroll : 1;
  73    } down;
  74
  75    struct {
  76       Evas_Coord w, h;
  77       Eina_Bool resized : 1;
  78    } child;
  79    struct {
  80       Evas_Coord x, y;
  81    } step, page;
  82
  83    struct {
  84       void (*set) (Evas_Object *obj, Evas_Coord x, Evas_Coord y);
  85       void (*get) (Evas_Object *obj, Evas_Coord *x, Evas_Coord *y);
  86       void (*max_get) (Evas_Object *obj, Evas_Coord *x, Evas_Coord *y);
  87       void (*min_get) (Evas_Object *obj, Evas_Coord *x, Evas_Coord *y);
  88       void (*child_size_get) (Evas_Object *obj, Evas_Coord *x, Evas_Coord *y);
  89       void (*gravity_set) (Evas_Object *obj, double x, double y);
  90       void (*gravity_get) (Evas_Object *obj, double *x, double *y);
  91    } pan_func;
  92
  93    struct {
  94       struct {
  95          Evas_Coord start, end;
  96          double t_start, t_end;
  97          Ecore_Animator *animator;
  98       } x, y;
  99    } scrollto;
 100
 101    double pagerel_h, pagerel_v;
 102    Evas_Coord pagesize_h, pagesize_v;
 103
 104    Eina_Bool hbar_visible : 1;
 105    Eina_Bool vbar_visible : 1;
 106    Eina_Bool extern_pan : 1;
 107    Eina_Bool one_dir_at_a_time : 1;
 108    Eina_Bool hold : 1;
 109    Eina_Bool freeze : 1;
 110    Eina_Bool bouncemex : 1;
 111    Eina_Bool bouncemey : 1;
 112    Eina_Bool bounce_horiz : 1;
 113    Eina_Bool bounce_vert : 1;
 114    Eina_Bool momentum_animator_disabled :1;
 115    Eina_Bool bounce_animator_disabled :1;
 116    Eina_Bool is_mirrored : 1;
 117    Eina_Bool wheel_disabled : 1;
 118 };
 119
 120 /* local subsystem functions */
 121 static void _smart_child_del_hook(void *data, Evas *e, Evas_Object *obj, void *event_info);
 122 static void _smart_pan_changed_hook(void *data, Evas_Object *obj, void *event_info);
 123 static void _smart_event_wheel(void *data, Evas *e, Evas_Object *obj, void *event_info);
 124 static void _smart_event_mouse_down(void *data, Evas *e, Evas_Object *obj, void *event_info);
 125 static Eina_Bool  _smart_hold_animator(void *data);
 126 static Eina_Bool  _smart_momentum_animator(void *data);
 127 static void _smart_event_mouse_up(void *data, Evas *e, Evas_Object *obj, void *event_info);
 128 static Eina_Bool  _smart_onhold_animator(void *data);
 129 static void _smart_event_mouse_move(void *data, Evas *e, Evas_Object *obj, void *event_info);
 130 static void _smart_edje_drag_v_start(void *data, Evas_Object *obj, const char *emission, const char *source);
 131 static void _smart_edje_drag_v_stop(void *data, Evas_Object *obj, const char *emission, const char *source);
 132 static void _smart_edje_drag_v(void *data, Evas_Object *obj, const char *emission, const char *source);
 133 static void _smart_edje_drag_h_start(void *data, Evas_Object *obj, const char *emission, const char *source);
 134 static void _smart_edje_drag_h_stop(void *data, Evas_Object *obj, const char *emission, const char *source);
 135 static void _smart_edje_drag_h(void *data, Evas_Object *obj, const char *emission, const char *source);
 136 static void _smart_scrollbar_read(Smart_Data *sd);
 137 static void _smart_scrollbar_reset(Smart_Data *sd);
 138 static int  _smart_scrollbar_bar_h_visibility_adjust(Smart_Data *sd);
 139 static int  _smart_scrollbar_bar_v_visibility_adjust(Smart_Data *sd);
 140 static void _smart_scrollbar_bar_visibility_adjust(Smart_Data *sd);
 141 static void _smart_scrollbar_size_adjust(Smart_Data *sd);
 142 static void _smart_reconfigure(Smart_Data *sd);
 143 static void _smart_add(Evas_Object *obj);
 144 static void _smart_del(Evas_Object *obj);
 145 static void _smart_move(Evas_Object *obj, Evas_Coord x, Evas_Coord y);
 146 static void _smart_resize(Evas_Object *obj, Evas_Coord w, Evas_Coord h);
 147 static void _smart_show(Evas_Object *obj);
 148 static void _smart_hide(Evas_Object *obj);
 149 static void _smart_color_set(Evas_Object *obj, int r, int g, int b, int a);
 150 static void _smart_clip_set(Evas_Object *obj, Evas_Object *clip);
 151 static void _smart_clip_unset(Evas_Object *obj);
 152 static void _smart_init(void);
 153
 154 static void _elm_smart_scroller_wanted_region_set(Evas_Object *obj);
 155
 156 /* local subsystem globals */
 157 static Evas_Smart *_smart = NULL;
 158
 159 /* externally accessible functions */
 160 Evas_Object *
 161 elm_smart_scroller_add(Evas *evas)
 162 {
 163    _smart_init();
 164    return evas_object_smart_add(evas, _smart);
 165 }
 166
 167 static Evas_Coord
 168 _elm_smart_scroller_x_mirrored_get(Evas_Object *obj, Evas_Coord x)
 169 {
 170    API_ENTRY return x;
 171
 172    Evas_Coord cw, ch, w, ret;
 173    elm_smart_scroller_child_viewport_size_get(obj, &w, NULL);
 174    sd->pan_func.child_size_get(sd->pan_obj, &cw, &ch);
 175    ret = (cw - (x + w));
 176    return (ret >= 0) ? ret : 0;
 177 }
 178
 179 void
 180 elm_smart_scroller_mirrored_set(Evas_Object *obj, Eina_Bool mirrored)
 181 {
 182    API_ENTRY return;
 183    Evas_Coord wx;
 184    if (sd->is_mirrored == mirrored)
 185      return;
 186
 187    sd->is_mirrored = mirrored;
 188    edje_object_mirrored_set(sd->edje_obj, mirrored);
 189
 190    if (sd->is_mirrored)
 191      wx = _elm_smart_scroller_x_mirrored_get(sd->smart_obj, sd->wx);
 192    else
 193      wx = sd->wx;
 194
 195    elm_smart_scroller_child_pos_set(sd->smart_obj, wx, sd->wy);
 196 }
 197
 198 void
 199 elm_smart_scroller_child_set(Evas_Object *obj, Evas_Object *child)
 200 {
 201    Evas_Coord w, h;
 202    Evas_Object *o;
 203
 204    API_ENTRY return;
 205    if (sd->child_obj)
 206      {
 207         _elm_smart_pan_child_set(sd->pan_obj, NULL);
 208         evas_object_event_callback_del_full(sd->child_obj, EVAS_CALLBACK_DEL, _smart_child_del_hook, sd);
 209      }
 210
 211    sd->child_obj = child;
 212    sd->wx = sd->wy = 0;
 213    /* (-1) means want viewports size */
 214    sd->ww = sd->wh = -1;
 215    if (!child) return;
 216
 217    if (!sd->pan_obj)
 218      {
 219         o = _elm_smart_pan_add(evas_object_evas_get(obj));
 220         sd->pan_obj = o;
 221         evas_object_smart_callback_add(o, "changed", _smart_pan_changed_hook, sd);
 222         edje_object_part_swallow(sd->edje_obj, "elm.swallow.content", o);
 223      }
 224
 225    sd->pan_func.set = _elm_smart_pan_set;
 226    sd->pan_func.get = _elm_smart_pan_get;
 227    sd->pan_func.max_get = _elm_smart_pan_max_get;
 228    sd->pan_func.min_get = _elm_smart_pan_min_get;
 229    sd->pan_func.child_size_get = _elm_smart_pan_child_size_get;
 230    sd->pan_func.gravity_set = _elm_smart_pan_gravity_set;
 231    sd->pan_func.gravity_get = _elm_smart_pan_gravity_get;
 232
 233    evas_object_event_callback_add(child, EVAS_CALLBACK_DEL, _smart_child_del_hook, sd);
 234    _elm_smart_pan_child_set(sd->pan_obj, child);
 235    sd->pan_func.child_size_get(sd->pan_obj, &w, &h);
 236    sd->child.w = w;
 237    sd->child.h = h;
 238    _smart_scrollbar_size_adjust(sd);
 239    _smart_scrollbar_reset(sd);
 240 }
 241
 242 void
 243 elm_smart_scroller_extern_pan_set(Evas_Object *obj, Evas_Object *pan,
 244                                   void (*pan_set) (Evas_Object *obj, Evas_Coord x, Evas_Coord y),
 245                                   void (*pan_get) (Evas_Object *obj, Evas_Coord *x, Evas_Coord *y),
 246                                   void (*pan_max_get) (Evas_Object *obj, Evas_Coord *x, Evas_Coord *y),
 247                                   void (*pan_min_get) (Evas_Object *obj, Evas_Coord *x, Evas_Coord *y),
 248                                   void (*pan_child_size_get) (Evas_Object *obj, Evas_Coord *x, Evas_Coord *y))
 249 {
 250    API_ENTRY return;
 251
 252    elm_smart_scroller_child_set(obj, NULL);
 253
 254    if (sd->pan_obj)
 255      {
 256         evas_object_smart_callback_del(sd->pan_obj, "changed", _smart_pan_changed_hook);
 257      }
 258
 259    if (sd->extern_pan)
 260      {
 261         if (sd->pan_obj)
 262           {
 263              edje_object_part_unswallow(sd->edje_obj, sd->pan_obj);
 264              sd->pan_obj = NULL;
 265           }
 266      }
 267    else
 268      {
 269         if (sd->pan_obj)
 270           {
 271              evas_object_del(sd->pan_obj);
 272              sd->pan_obj = NULL;
 273           }
 274      }
 275    if (!pan)
 276      {
 277         sd->extern_pan = EINA_FALSE;
 278         return;
 279      }
 280
 281    sd->pan_obj = pan;
 282    sd->pan_func.set = pan_set;
 283    sd->pan_func.get = pan_get;
 284    sd->pan_func.max_get = pan_max_get;
 285    sd->pan_func.min_get = pan_min_get;
 286    sd->pan_func.child_size_get = pan_child_size_get;
 287    sd->pan_func.gravity_set = _elm_smart_pan_gravity_set;
 288    sd->pan_func.gravity_get = _elm_smart_pan_gravity_get;
 289    sd->extern_pan = EINA_TRUE;
 290    evas_object_smart_callback_add(sd->pan_obj, "changed", _smart_pan_changed_hook, sd);
 291    edje_object_part_swallow(sd->edje_obj, "elm.swallow.content", sd->pan_obj);
 292    evas_object_show(sd->pan_obj);
 293 }
 294
 295 void
 296 elm_smart_scroller_custom_edje_file_set(Evas_Object *obj, char *file, char *group)
 297 {
 298    API_ENTRY return;
 299
 300    edje_object_file_set(sd->edje_obj, file, group);
 301    if (sd->pan_obj)
 302      edje_object_part_swallow(sd->edje_obj, "elm.swallow.content", sd->pan_obj);
 303    sd->vbar_visible = !sd->vbar_visible;
 304    sd->hbar_visible = !sd->hbar_visible;
 305    _smart_scrollbar_bar_visibility_adjust(sd);
 306    if (sd->hbar_flags == ELM_SMART_SCROLLER_POLICY_ON)
 307      edje_object_signal_emit(sd->edje_obj, "elm,action,show_always,hbar", "elm");
 308    else if (sd->hbar_flags == ELM_SMART_SCROLLER_POLICY_OFF)
 309      edje_object_signal_emit(sd->edje_obj, "elm,action,hide,hbar", "elm");
 310    else
 311      edje_object_signal_emit(sd->edje_obj, "elm,action,show_notalways,hbar", "elm");
 312    if (sd->vbar_flags == ELM_SMART_SCROLLER_POLICY_ON)
 313      edje_object_signal_emit(sd->edje_obj, "elm,action,show_always,vbar", "elm");
 314    else if (sd->vbar_flags == ELM_SMART_SCROLLER_POLICY_OFF)
 315      edje_object_signal_emit(sd->edje_obj, "elm,action,hide,vbar", "elm");
 316    else
 317      edje_object_signal_emit(sd->edje_obj, "elm,action,show_notalways,vbar", "elm");
 318 }
 319
 320 Eina_Bool
 321 elm_smart_scroller_momentum_animator_disabled_get(Evas_Object *obj)
 322 {
 323    API_ENTRY return EINA_FALSE;
 324    return sd->momentum_animator_disabled;
 325 }
 326
 327 void
 328 elm_smart_scroller_momentum_animator_disabled_set(Evas_Object *obj, Eina_Bool disabled)
 329 {
 330    API_ENTRY return;
 331    sd->momentum_animator_disabled = disabled;
 332    if (sd->momentum_animator_disabled)
 333      {
 334         if (sd->down.momentum_animator)
 335           {
 336              ecore_animator_del(sd->down.momentum_animator);
 337              sd->down.momentum_animator = NULL;
 338              if (sd->child.resized)
 339                _elm_smart_scroller_wanted_region_set(sd->smart_obj);
 340           }
 341      }
 342 }
 343
 344 Eina_Bool
 345 elm_smart_scroller_bounce_animator_disabled_get(Evas_Object *obj)
 346 {
 347    API_ENTRY return EINA_FALSE;
 348    return sd->bounce_animator_disabled;
 349 }
 350
 351 void
 352 elm_smart_scroller_bounce_animator_disabled_set(Evas_Object *obj, Eina_Bool disabled)
 353 {
 354    API_ENTRY return;
 355    sd->bounce_animator_disabled = disabled;
 356    if (sd->bounce_animator_disabled)
 357      {
 358         if (sd->scrollto.x.animator)
 359           {
 360              ecore_animator_del(sd->scrollto.x.animator);
 361              sd->scrollto.x.animator = NULL;
 362           }
 363
 364         if (sd->scrollto.y.animator)
 365           {
 366              ecore_animator_del(sd->scrollto.y.animator);
 367              sd->scrollto.y.animator = NULL;
 368           }
 369      }
 370 }
 371
 372 Eina_Bool
 373 elm_smart_scroller_wheel_disabled_get(Evas_Object *obj)
 374 {
 375    API_ENTRY return EINA_FALSE;
 376    return sd->wheel_disabled;
 377 }
 378
 379 void
 380 elm_smart_scroller_wheel_disabled_set(Evas_Object *obj, Eina_Bool disabled)
 381 {
 382    API_ENTRY return;
 383    if ((!sd->wheel_disabled) && (disabled))
 384      evas_object_event_callback_del_full(sd->event_obj, EVAS_CALLBACK_MOUSE_WHEEL, _smart_event_wheel, sd);
 385    else if ((sd->wheel_disabled) && (!disabled))
 386      evas_object_event_callback_add(sd->event_obj, EVAS_CALLBACK_MOUSE_WHEEL, _smart_event_wheel, sd);
 387    sd->wheel_disabled = disabled;
 388 }
 389
 390 /* Update the wanted coordinates according to the x, y passed
 391  * widget directionality, child size and etc. */
 392 static void
 393 _update_wanted_coordinates(Smart_Data *sd, Evas_Coord x, Evas_Coord y)
 394 {
 395    Evas_Coord cw, ch;
 396
 397    sd->pan_func.child_size_get(sd->pan_obj, &cw, &ch);
 398
 399    /* Update wx/y/w/h - and if the requested positions aren't legal
 400     * adjust a bit. */
 401    elm_smart_scroller_child_viewport_size_get(sd->smart_obj, &sd->ww, &sd->wh);
 402    if (x < 0)
 403      sd->wx = 0;
 404    else if ((x + sd->ww) > cw)
 405      sd->wx = cw - sd->ww;
 406    else if (sd->is_mirrored)
 407      sd->wx = _elm_smart_scroller_x_mirrored_get(sd->smart_obj, x);
 408    else
 409      sd->wx = x;
 410    if (y < 0) sd->wy = 0;
 411    else if ((y + sd->wh) > ch) sd->wy = ch - sd->wh;
 412    else sd->wy = y;
 413 }
 414
 415 static void
 416 _smart_anim_start(Evas_Object *obj)
 417 {
 418    evas_object_smart_callback_call(obj, "animate,start", NULL);
 419 }
 420
 421 static void
 422 _smart_anim_stop(Evas_Object *obj)
 423 {
 424    evas_object_smart_callback_call(obj, "animate,stop", NULL);
 425 }
 426
 427 static void
 428 _smart_drag_start(Evas_Object *obj)
 429 {
 430    evas_object_smart_callback_call(obj, "drag,start", NULL);
 431 }
 432
 433 static void
 434 _smart_drag_stop(Evas_Object *obj)
 435 {
 436    evas_object_smart_callback_call(obj, "drag,stop", NULL);
 437 }
 438
 439 static Eina_Bool
 440 _smart_scrollto_x_animator(void *data)
 441 {
 442    Smart_Data *sd = data;
 443    Evas_Coord px, py;
 444    double t, tt;
 445
 446    t = ecore_loop_time_get();
 447    tt = (t - sd->scrollto.x.t_start) / (sd->scrollto.x.t_end - sd->scrollto.x.t_start);
 448    tt = 1.0 - tt;
 449    tt = 1.0 - (tt * tt);
 450    sd->pan_func.get(sd->pan_obj, &px, &py);
 451    px = (sd->scrollto.x.start * (1.0 - tt)) +
 452       (sd->scrollto.x.end * tt);
 453    if (t >= sd->scrollto.x.t_end)
 454      {
 455         px = sd->scrollto.x.end;
 456         elm_smart_scroller_child_pos_set(sd->smart_obj, px, py);
 457         sd->down.sx = px;
 458         sd->down.x = sd->down.history[0].x;
 459         _update_wanted_coordinates(sd, px, py);
 460         sd->scrollto.x.animator = NULL;
 461         if ((!sd->scrollto.y.animator) && (!sd->down.bounce_y_animator))
 462           _smart_anim_stop(sd->smart_obj);
 463         return ECORE_CALLBACK_CANCEL;
 464      }
 465    elm_smart_scroller_child_pos_set(sd->smart_obj, px, py);
 466    _update_wanted_coordinates(sd, px, py);
 467    return ECORE_CALLBACK_RENEW;
 468 }
 469
 470 static void
 471 _smart_momentum_end(Smart_Data *sd)
 472 {
 473    if ((sd->down.bounce_x_animator) || (sd->down.bounce_y_animator)) return;
 474    if (sd->down.momentum_animator)
 475      {
 476         Evas_Coord px, py;
 477         elm_smart_scroller_child_pos_get(sd->smart_obj, &px, &py);
 478         _update_wanted_coordinates(sd, px, py);
 479
 480         ecore_animator_del(sd->down.momentum_animator);
 481         sd->down.momentum_animator = NULL;
 482         sd->down.bounce_x_hold = EINA_FALSE;
 483         sd->down.bounce_y_hold = EINA_FALSE;
 484         sd->down.ax = 0;
 485         sd->down.ay = 0;
 486         sd->down.dx = 0;
 487         sd->down.dy = 0;
 488         sd->down.pdx = 0;
 489         sd->down.pdy = 0;
 490         if (sd->child.resized)
 491           _elm_smart_scroller_wanted_region_set(sd->smart_obj);
 492      }
 493 }
 494
 495 static void
 496 _smart_scrollto_x(Smart_Data *sd, double t_in, Evas_Coord pos_x)
 497 {
 498    Evas_Coord px, py, x, y, w, h;
 499    double t;
 500
 501    if (sd->freeze) return;
 502    if (t_in <= 0.0)
 503      {
 504         elm_smart_scroller_child_pos_get(sd->smart_obj, &x, &y);
 505         elm_smart_scroller_child_viewport_size_get(sd->smart_obj, &w, &h);
 506         x = pos_x;
 507         elm_smart_scroller_child_region_set(sd->smart_obj, x, y, w, h);
 508         return;
 509      }
 510    t = ecore_loop_time_get();
 511    sd->pan_func.get(sd->pan_obj, &px, &py);
 512    sd->scrollto.x.start = px;
 513    sd->scrollto.x.end = pos_x;
 514    sd->scrollto.x.t_start = t;
 515    sd->scrollto.x.t_end = t + t_in;
 516    if (!sd->scrollto.x.animator)
 517      {
 518         sd->scrollto.x.animator = ecore_animator_add(_smart_scrollto_x_animator, sd);
 519         if (!sd->scrollto.y.animator)
 520           _smart_anim_start(sd->smart_obj);
 521      }
 522    if (sd->down.bounce_x_animator)
 523      {
 524         ecore_animator_del(sd->down.bounce_x_animator);
 525         sd->down.bounce_x_animator = NULL;
 526         _smart_momentum_end(sd);
 527         if (sd->child.resized)
 528           _elm_smart_scroller_wanted_region_set(sd->smart_obj);
 529      }
 530    sd->bouncemex = EINA_FALSE;
 531 }
 532
 533 static Eina_Bool
 534 _smart_scrollto_y_animator(void *data)
 535 {
 536    Smart_Data *sd = data;
 537    Evas_Coord px, py;
 538    double t, tt;
 539
 540    t = ecore_loop_time_get();
 541    tt = (t - sd->scrollto.y.t_start) / (sd->scrollto.y.t_end - sd->scrollto.y.t_start);
 542    tt = 1.0 - tt;
 543    tt = 1.0 - (tt * tt);
 544    sd->pan_func.get(sd->pan_obj, &px, &py);
 545    py = (sd->scrollto.y.start * (1.0 - tt)) +
 546       (sd->scrollto.y.end * tt);
 547    if (t >= sd->scrollto.y.t_end)
 548      {
 549         py = sd->scrollto.y.end;
 550         elm_smart_scroller_child_pos_set(sd->smart_obj, px, py);
 551         sd->down.sy = py;
 552         sd->down.y = sd->down.history[0].y;
 553         _update_wanted_coordinates(sd, px, py);
 554         sd->scrollto.y.animator = NULL;
 555         if ((!sd->scrollto.x.animator) && (!sd->down.bounce_x_animator))
 556           _smart_anim_stop(sd->smart_obj);
 557         return ECORE_CALLBACK_CANCEL;
 558      }
 559    elm_smart_scroller_child_pos_set(sd->smart_obj, px, py);
 560    _update_wanted_coordinates(sd, px, py);
 561
 562    return ECORE_CALLBACK_RENEW;
 563 }
 564
 565 static void
 566 _smart_scrollto_y(Smart_Data *sd, double t_in, Evas_Coord pos_y)
 567 {
 568    Evas_Coord px, py, x, y, w, h;
 569    double t;
 570
 571    if (sd->freeze) return;
 572    if (t_in <= 0.0)
 573      {
 574         elm_smart_scroller_child_pos_get(sd->smart_obj, &x, &y);
 575         elm_smart_scroller_child_viewport_size_get(sd->smart_obj, &w, &h);
 576         y = pos_y;
 577         elm_smart_scroller_child_region_set(sd->smart_obj, x, y, w, h);
 578         return;
 579      }
 580    t = ecore_loop_time_get();
 581    sd->pan_func.get(sd->pan_obj, &px, &py);
 582    sd->scrollto.y.start = py;
 583    sd->scrollto.y.end = pos_y;
 584    sd->scrollto.y.t_start = t;
 585    sd->scrollto.y.t_end = t + t_in;
 586    if (!sd->scrollto.y.animator)
 587      {
 588         sd->scrollto.y.animator = ecore_animator_add(_smart_scrollto_y_animator, sd);
 589         if (!sd->scrollto.x.animator)
 590           _smart_anim_start(sd->smart_obj);
 591      }
 592    if (sd->down.bounce_y_animator)
 593      {
 594         ecore_animator_del(sd->down.bounce_y_animator);
 595         sd->down.bounce_y_animator = NULL;
 596         _smart_momentum_end(sd);
 597         if (sd->child.resized)
 598           _elm_smart_scroller_wanted_region_set(sd->smart_obj);
 599      }
 600    sd->bouncemey = EINA_FALSE;
 601 }
 602
 603 static Eina_Bool
 604 _smart_do_page(Smart_Data *sd)
 605 {
 606    if ((sd->pagerel_h == 0.0) && (!sd->pagesize_h) &&
 607        (sd->pagerel_v == 0.0) && (!sd->pagesize_v))
 608      return EINA_FALSE;
 609    return EINA_TRUE;
 610 }
 611
 612 static Evas_Coord
 613 _smart_page_x_get(Smart_Data *sd, int offset)
 614 {
 615    Evas_Coord x, y, w, h, cw, ch, minx = 0;
 616
 617    elm_smart_scroller_child_pos_get(sd->smart_obj, &x, &y);
 618    elm_smart_scroller_child_viewport_size_get(sd->smart_obj, &w, &h);
 619    sd->pan_func.child_size_get(sd->pan_obj, &cw, &ch);
 620    sd->pan_func.min_get(sd->pan_obj, &minx, NULL);
 621
 622    x += offset;
 623
 624    if (sd->pagerel_h > 0.0)
 625      sd->pagesize_h = w * sd->pagerel_h;
 626    if (sd->pagesize_h > 0)
 627      {
 628         x = x + (sd->pagesize_h * 0.5);
 629         x = x / (sd->pagesize_h);
 630         x = x * (sd->pagesize_h);
 631      }
 632    if ((x + w) > cw) x = cw - w;
 633    if (x < minx) x = minx;
 634    return x;
 635 }
 636
 637 static Evas_Coord
 638 _smart_page_y_get(Smart_Data *sd, int offset)
 639 {
 640    Evas_Coord x, y, w, h, cw, ch, miny = 0;
 641
 642    elm_smart_scroller_child_pos_get(sd->smart_obj, &x, &y);
 643    elm_smart_scroller_child_viewport_size_get(sd->smart_obj, &w, &h);
 644    sd->pan_func.child_size_get(sd->pan_obj, &cw, &ch);
 645    sd->pan_func.min_get(sd->pan_obj, NULL, &miny);
 646
 647    y += offset;
 648
 649    if (sd->pagerel_v > 0.0)
 650      sd->pagesize_v = h * sd->pagerel_v;
 651    if (sd->pagesize_v > 0)
 652      {
 653         y = y + (sd->pagesize_v * 0.5);
 654         y = y / (sd->pagesize_v);
 655         y = y * (sd->pagesize_v);
 656      }
 657    if ((y + h) > ch) y = ch - h;
 658    if (y < miny) y = miny;
 659    return y;
 660 }
 661
 662 static void
 663 _smart_page_adjust(Smart_Data *sd)
 664 {
 665    Evas_Coord x, y, w, h;
 666
 667    if (!_smart_do_page(sd)) return;
 668
 669    elm_smart_scroller_child_viewport_size_get(sd->smart_obj, &w, &h);
 670
 671    x = _smart_page_x_get(sd, 0);
 672    y = _smart_page_y_get(sd, 0);
 673
 674    elm_smart_scroller_child_region_set(sd->smart_obj, x, y, w, h);
 675 }
 676
 677 static Eina_Bool
 678 _smart_bounce_x_animator(void *data)
 679 {
 680    Smart_Data *sd;
 681    Evas_Coord x, y, dx, w, odx, ed, md;
 682    double t, p, dt, pd, r;
 683
 684    sd = data;
 685    t = ecore_loop_time_get();
 686    dt = t - sd->down.anim_start2;
 687    if (dt >= 0.0)
 688      {
 689         dt = dt / _elm_config->thumbscroll_bounce_friction;
 690         odx = sd->down.b2x - sd->down.bx;
 691         elm_smart_scroller_child_viewport_size_get(sd->smart_obj, &w, NULL);
 692         if (!sd->down.momentum_animator && (w > abs(odx)))
 693           {
 694              pd = (double)odx / (double)w;
 695              pd = (pd > 0) ? pd : -pd;
 696              pd = 1.0 - ((1.0 - pd) * (1.0 - pd));
 697              dt = dt / pd;
 698           }
 699         if (dt > 1.0) dt = 1.0;
 700         p = 1.0 - ((1.0 - dt) * (1.0 - dt));
 701         elm_smart_scroller_child_pos_get(sd->smart_obj, &x, &y);
 702         dx = (odx * p);
 703         r = 1.0;
 704         if (sd->down.momentum_animator)
 705           {
 706              ed = abs(sd->down.dx * (_elm_config->thumbscroll_friction + sd->down.extra_time) - sd->down.b0x);
 707              md = abs(_elm_config->thumbscroll_friction * 5 * w);
 708              if (ed > md) r = (double)(md)/(double)ed;
 709           }
 710         x = sd->down.b2x + (int)((double)(dx - odx) * r);
 711         if (!sd->down.cancelled)
 712           elm_smart_scroller_child_pos_set(sd->smart_obj, x, y);
 713         if (dt >= 1.0)
 714           {
 715              if (sd->down.momentum_animator)
 716                sd->down.bounce_x_hold = EINA_TRUE;
 717              if ((!sd->down.bounce_y_animator) &&
 718                  (!sd->scrollto.y.animator))
 719                _smart_anim_stop(sd->smart_obj);
 720              sd->down.bounce_x_animator = NULL;
 721              sd->down.pdx = 0;
 722              sd->bouncemex = EINA_FALSE;
 723              _smart_momentum_end(sd);
 724              if (sd->child.resized)
 725                _elm_smart_scroller_wanted_region_set(sd->smart_obj);
 726              return ECORE_CALLBACK_CANCEL;
 727           }
 728      }
 729    return ECORE_CALLBACK_RENEW;
 730 }
 731
 732 static Eina_Bool
 733 _smart_bounce_y_animator(void *data)
 734 {
 735    Smart_Data *sd;
 736    Evas_Coord x, y, dy, h, ody, ed, md;
 737    double t, p, dt, pd, r;
 738
 739    sd = data;
 740    t = ecore_loop_time_get();
 741    dt = t - sd->down.anim_start3;
 742    if (dt >= 0.0)
 743      {
 744         dt = dt / _elm_config->thumbscroll_bounce_friction;
 745         ody = sd->down.b2y - sd->down.by;
 746         elm_smart_scroller_child_viewport_size_get(sd->smart_obj, NULL, &h);
 747         if (!sd->down.momentum_animator && (h > abs(ody)))
 748           {
 749              pd = (double)ody / (double)h;
 750              pd = (pd > 0) ? pd : -pd;
 751              pd = 1.0 - ((1.0 - pd) * (1.0 - pd));
 752              dt = dt / pd;
 753           }
 754         if (dt > 1.0) dt = 1.0;
 755         p = 1.0 - ((1.0 - dt) * (1.0 - dt));
 756         elm_smart_scroller_child_pos_get(sd->smart_obj, &x, &y);
 757         dy = (ody * p);
 758         r = 1.0;
 759         if (sd->down.momentum_animator)
 760           {
 761              ed = abs(sd->down.dy * (_elm_config->thumbscroll_friction + sd->down.extra_time) - sd->down.b0y);
 762              md = abs(_elm_config->thumbscroll_friction * 5 * h);
 763              if (ed > md) r = (double)(md)/(double)ed;
 764           }
 765         y = sd->down.b2y + (int)((double)(dy - ody) * r);
 766         if (!sd->down.cancelled)
 767           elm_smart_scroller_child_pos_set(sd->smart_obj, x, y);
 768         if (dt >= 1.0)
 769           {
 770              if (sd->down.momentum_animator)
 771                sd->down.bounce_y_hold = EINA_TRUE;
 772              if ((!sd->down.bounce_x_animator) &&
 773                  (!sd->scrollto.y.animator))
 774                _smart_anim_stop(sd->smart_obj);
 775              sd->down.bounce_y_animator = NULL;
 776              sd->down.pdy = 0;
 777              sd->bouncemey = EINA_FALSE;
 778              _smart_momentum_end(sd);
 779              if (sd->child.resized)
 780                _elm_smart_scroller_wanted_region_set(sd->smart_obj);
 781              return ECORE_CALLBACK_CANCEL;
 782           }
 783      }
 784    return ECORE_CALLBACK_RENEW;
 785 }
 786
 787 #define LEFT 0
 788 #define RIGHT 1
 789 #define UP 2
 790 #define DOWN 3
 791 static Eina_Bool
 792 can_scroll(Smart_Data *sd, int dir)
 793 {
 794    Evas_Coord mx = 0, my = 0, px = 0, py = 0, minx = 0, miny = 0;
 795
 796    sd->pan_func.max_get(sd->pan_obj, &mx, &my);
 797    sd->pan_func.min_get(sd->pan_obj, &minx, &miny);
 798    sd->pan_func.get(sd->pan_obj, &px, &py);
 799    switch (dir)
 800      {
 801       case LEFT:
 802         if (px > minx) return EINA_TRUE;
 803         break;
 804       case RIGHT:
 805         if ((px - minx) < mx) return EINA_TRUE;
 806         break;
 807       case UP:
 808         if (py > miny) return EINA_TRUE;
 809         break;
 810       case DOWN:
 811         if ((py - miny) < my) return EINA_TRUE;
 812         break;
 813       default:
 814         break;
 815      }
 816    return EINA_FALSE;
 817 }
 818
 819 static Eina_Bool
 820 _smart_momentum_animator(void *data)
 821 {
 822    Smart_Data *sd;
 823    double t, dt, p;
 824    Evas_Coord x, y, dx, dy, px, py, maxx, maxy, minx, miny;
 825    Eina_Bool no_bounce_x_end = EINA_FALSE, no_bounce_y_end = EINA_FALSE;
 826
 827    sd = data;
 828    t = ecore_loop_time_get();
 829    dt = t - sd->down.anim_start;
 830    if (dt >= 0.0)
 831      {
 832         /*
 833         if (sd->down.hold_parent)
 834           {
 835              if ((sd->down.dir_x) && !can_scroll(sd, sd->down.hdir))
 836                {
 837                   sd->down.dir_x = 0;
 838                }
 839              if ((sd->down.dir_y) && !can_scroll(sd, sd->down.vdir))
 840                {
 841                   sd->down.dir_y = 0;
 842                }
 843            }
 844         if ((!sd->down.dir_x) && (!sd->down.dir_y))
 845           {
 846              sd->down.cancelled = 1;
 847           }
 848         */
 849         dt = dt / (_elm_config->thumbscroll_friction + sd->down.extra_time);
 850         if (dt > 1.0) dt = 1.0;
 851         p = 1.0 - ((1.0 - dt) * (1.0 - dt));
 852         dx = (sd->down.dx * (_elm_config->thumbscroll_friction + sd->down.extra_time) * p);
 853         dy = (sd->down.dy * (_elm_config->thumbscroll_friction + sd->down.extra_time) * p);
 854         sd->down.ax = dx;
 855         sd->down.ay = dy;
 856         x = sd->down.sx - dx;
 857         y = sd->down.sy - dy;
 858         elm_smart_scroller_child_pos_get(sd->smart_obj, &px, &py);
 859         if ((sd->down.bounce_x_animator) ||
 860             (sd->down.bounce_x_hold))
 861           {
 862              sd->down.bx = sd->down.bx0 - dx + sd->down.b0x;
 863              x = px;
 864           }
 865         if ((sd->down.bounce_y_animator) ||
 866             (sd->down.bounce_y_hold))
 867           {
 868              sd->down.by = sd->down.by0 - dy + sd->down.b0y;
 869              y = py;
 870           }
 871         elm_smart_scroller_child_pos_set(sd->smart_obj, x, y);
 872         _update_wanted_coordinates(sd, x, y);
 873         sd->pan_func.max_get(sd->pan_obj, &maxx, &maxy);
 874         sd->pan_func.min_get(sd->pan_obj, &minx, &miny);
 875         if (!sd->bounce_horiz)
 876           {
 877              if (x <= minx) no_bounce_x_end = EINA_TRUE;
 878              if ((x - minx) >= maxx) no_bounce_x_end = EINA_TRUE;
 879           }
 880         if (!sd->bounce_vert)
 881           {
 882              if (y <= miny) no_bounce_y_end = EINA_TRUE;
 883              if ((y - miny) >= maxy) no_bounce_y_end = EINA_TRUE;
 884           }
 885         if ((dt >= 1.0) ||
 886             ((sd->down.bounce_x_hold) && (sd->down.bounce_y_hold)) ||
 887             (no_bounce_x_end && no_bounce_y_end))
 888           {
 889              _smart_anim_stop(sd->smart_obj);
 890
 891              sd->down.momentum_animator = NULL;
 892              sd->down.bounce_x_hold = EINA_FALSE;
 893              sd->down.bounce_y_hold = EINA_FALSE;
 894              sd->down.ax = 0;
 895              sd->down.ay = 0;
 896              sd->down.pdx = 0;
 897              sd->down.pdy = 0;
 898              if (sd->child.resized)
 899                _elm_smart_scroller_wanted_region_set(sd->smart_obj);
 900              return ECORE_CALLBACK_CANCEL;
 901           }
 902      }
 903    return ECORE_CALLBACK_RENEW;
 904 }
 905
 906 static void
 907 bounce_eval(Smart_Data *sd)
 908 {
 909    Evas_Coord mx, my, px, py, bx, by, b2x, b2y, minx = 0, miny = 0;
 910
 911    if (sd->freeze) return;
 912    if ((!sd->bouncemex) && (!sd->bouncemey)) return;
 913    if (sd->down.now) return; // down bounce while still held down
 914    if (sd->down.onhold_animator)
 915      {
 916         ecore_animator_del(sd->down.onhold_animator);
 917         sd->down.onhold_animator = NULL;
 918         if (sd->child.resized)
 919           _elm_smart_scroller_wanted_region_set(sd->smart_obj);
 920      }
 921    if (sd->down.hold_animator)
 922      {
 923         ecore_animator_del(sd->down.hold_animator);
 924         sd->down.hold_animator = NULL;
 925         if (sd->child.resized)
 926           _elm_smart_scroller_wanted_region_set(sd->smart_obj);
 927      }
 928    sd->pan_func.max_get(sd->pan_obj, &mx, &my);
 929    sd->pan_func.min_get(sd->pan_obj, &minx, &miny);
 930    sd->pan_func.get(sd->pan_obj, &px, &py);
 931    bx = px;
 932    by = py;
 933    if (px < minx) px = minx;
 934    if ((px - minx) > mx) px = mx + minx;
 935    if (py < miny) py = miny;
 936    if ((py - miny) > my) py = my + miny;
 937    b2x = px;
 938    b2y = py;
 939    if ((!sd->widget) ||
 940        (!elm_widget_drag_child_locked_x_get(sd->widget)))
 941      {
 942         if ((!sd->down.bounce_x_animator) && (!sd->bounce_animator_disabled))
 943           {
 944              if (sd->bouncemex)
 945                {
 946                   if (sd->scrollto.x.animator)
 947                     {
 948                        ecore_animator_del(sd->scrollto.x.animator);
 949                        sd->scrollto.x.animator = NULL;
 950                     }
 951                   sd->down.bounce_x_animator = ecore_animator_add(_smart_bounce_x_animator, sd);
 952                   sd->down.anim_start2 = ecore_loop_time_get();
 953                   sd->down.bx = bx;
 954                   sd->down.bx0 = bx;
 955                   sd->down.b2x = b2x;
 956                   if (sd->down.momentum_animator) sd->down.b0x = sd->down.ax;
 957                   else sd->down.b0x = 0;
 958                }
 959           }
 960      }
 961    if ((!sd->widget) ||
 962        (!elm_widget_drag_child_locked_y_get(sd->widget)))
 963      {
 964         if ((!sd->down.bounce_y_animator) && (!sd->bounce_animator_disabled))
 965           {
 966              if (sd->bouncemey)
 967                {
 968                   if (sd->scrollto.y.animator)
 969                     {
 970                        ecore_animator_del(sd->scrollto.y.animator);
 971                        sd->scrollto.y.animator = NULL;
 972                     }
 973                   sd->down.bounce_y_animator = ecore_animator_add(_smart_bounce_y_animator, sd);
 974                   sd->down.anim_start3 = ecore_loop_time_get();
 975                   sd->down.by = by;
 976                   sd->down.by0 = by;
 977                   sd->down.b2y = b2y;
 978                   if (sd->down.momentum_animator) sd->down.b0y = sd->down.ay;
 979                   else sd->down.b0y = 0;
 980                }
 981           }
 982      }
 983 }
 984
 985 void
 986 elm_smart_scroller_child_pos_set(Evas_Object *obj, Evas_Coord x, Evas_Coord y)
 987 {
 988    Evas_Coord mx = 0, my = 0, px = 0, py = 0, minx = 0, miny = 0;
 989    double vx, vy;
 990
 991    API_ENTRY return;
 992    // FIXME: allow for bounce outside of range
 993    sd->pan_func.max_get(sd->pan_obj, &mx, &my);
 994    sd->pan_func.min_get(sd->pan_obj, &minx, &miny);
 995    if (mx > 0) vx = (double)(x - minx) / (double)mx;
 996    else vx = 0.0;
 997    if (vx < 0.0) vx = 0.0;
 998    else if (vx > 1.0) vx = 1.0;
 999    if (my > 0) vy = (double)(y - miny) / (double)my;
1000    else vy = 0.0;
1001    if (vy < 0.0) vy = 0.0;
1002    else if (vy > 1.0) vy = 1.0;
1003    edje_object_part_drag_value_set(sd->edje_obj, "elm.dragable.vbar", 0.0, vy);
1004    edje_object_part_drag_value_set(sd->edje_obj, "elm.dragable.hbar", vx, 0.0);
1005    sd->pan_func.get(sd->pan_obj, &px, &py);
1006    if (!_elm_config->thumbscroll_bounce_enable)
1007      {
1008         if (x < minx) x = minx;
1009         if ((x - minx) > mx) x = mx + minx;
1010         if (y < miny) y = miny;
1011         if ((y - miny) > my) y = my + miny;
1012      }
1013
1014    if (!sd->bounce_horiz)
1015      {
1016         if (x < minx) x = minx;
1017         if ((x - minx) > mx) x = mx + minx;
1018      }
1019    if (!sd->bounce_vert)
1020      {
1021         if (y < miny) y = miny;
1022         if (y - miny > my) y = my + miny;
1023      }
1024
1025    sd->pan_func.set(sd->pan_obj, x, y);
1026    if ((px != x) || (py != y))
1027      edje_object_signal_emit(sd->edje_obj, "elm,action,scroll", "elm");
1028    if (!sd->down.bounce_x_animator)
1029      {
1030         if (((x < minx) && (0 <= sd->down.dx)) ||
1031             ((x > (mx + minx)) && (0 >= sd->down.dx)))
1032           {
1033              sd->bouncemex = EINA_TRUE;
1034              bounce_eval(sd);
1035           }
1036         else
1037           sd->bouncemex = EINA_FALSE;
1038      }
1039    if (!sd->down.bounce_y_animator)
1040      {
1041         if (((y < miny) && (0 <= sd->down.dy)) ||
1042             ((y > (my + miny)) && (0 >= sd->down.dy)))
1043           {
1044              sd->bouncemey = EINA_TRUE;
1045              bounce_eval(sd);
1046           }
1047         else
1048           sd->bouncemey = EINA_FALSE;
1049      }
1050    if ((x != px) || (y != py))
1051      {
1052         evas_object_smart_callback_call(obj, "scroll", NULL);
1053      }
1054    if ((x != px)/* && (!sd->bouncemex)*/)
1055      {
1056         if (x == minx)
1057           evas_object_smart_callback_call(obj, "edge,left", NULL);
1058         if (x == (mx + minx))
1059           evas_object_smart_callback_call(obj, "edge,right", NULL);
1060      }
1061    if ((y != py)/* && (!sd->bouncemey)*/)
1062      {
1063         if (y == miny)
1064           evas_object_smart_callback_call(obj, "edge,top", NULL);
1065         if (y == my + miny)
1066           evas_object_smart_callback_call(obj, "edge,bottom", NULL);
1067      }
1068 }
1069
1070 void
1071 elm_smart_scroller_child_pos_get(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y)
1072 {
1073    API_ENTRY return;
1074    sd->pan_func.get(sd->pan_obj, x, y);
1075 }
1076
1077 /* returns TRUE when we need to move the scroller, FALSE otherwise.
1078  * Updates w and h either way, so save them if you need them. */
1079 static Eina_Bool
1080 _elm_smart_scroller_child_region_show_internal(Evas_Object *obj, Evas_Coord *_x, Evas_Coord *_y, Evas_Coord w, Evas_Coord h)
1081 {
1082    Evas_Coord mx = 0, my = 0, cw = 0, ch = 0, px = 0, py = 0, nx, ny, minx = 0, miny = 0, pw = 0, ph = 0, x = *_x, y = *_y;
1083
1084    API_ENTRY return EINA_FALSE;
1085    sd->pan_func.max_get(sd->pan_obj, &mx, &my);
1086    sd->pan_func.min_get(sd->pan_obj, &minx, &miny);
1087    sd->pan_func.child_size_get(sd->pan_obj, &cw, &ch);
1088    sd->pan_func.get(sd->pan_obj, &px, &py);
1089    evas_object_geometry_get(sd->pan_obj, NULL, NULL, &pw, &ph);
1090
1091    nx = px;
1092    if ((x < px) && ((x + w) < (px + (cw - mx)))) nx = x;
1093    else if ((x > px) && ((x + w) > (px + (cw - mx)))) nx = x + w - (cw - mx);
1094    ny = py;
1095    if ((y < py) && ((y + h) < (py + (ch - my)))) ny = y;
1096    else if ((y > py) && ((y + h) > (py + (ch - my)))) ny = y + h - (ch - my);
1097
1098    if ((sd->down.bounce_x_animator) || (sd->down.bounce_y_animator) ||
1099        (sd->scrollto.x.animator) || (sd->scrollto.y.animator))
1100      {
1101         _smart_anim_stop(sd->smart_obj);
1102      }
1103    if (sd->scrollto.x.animator)
1104      {
1105         ecore_animator_del(sd->scrollto.x.animator);
1106         sd->scrollto.x.animator = NULL;
1107      }
1108    if (sd->scrollto.y.animator)
1109      {
1110         ecore_animator_del(sd->scrollto.y.animator);
1111         sd->scrollto.y.animator = NULL;
1112      }
1113    if (sd->down.bounce_x_animator)
1114      {
1115         ecore_animator_del(sd->down.bounce_x_animator);
1116         sd->down.bounce_x_animator = NULL;
1117         sd->bouncemex = EINA_FALSE;
1118         if (sd->child.resized)
1119           _elm_smart_scroller_wanted_region_set(sd->smart_obj);
1120      }
1121    if (sd->down.bounce_y_animator)
1122      {
1123         ecore_animator_del(sd->down.bounce_y_animator);
1124         sd->down.bounce_y_animator = NULL;
1125         sd->bouncemey = EINA_FALSE;
1126         if (sd->child.resized)
1127           _elm_smart_scroller_wanted_region_set(sd->smart_obj);
1128      }
1129    if (sd->down.hold_animator)
1130      {
1131         ecore_animator_del(sd->down.hold_animator);
1132         sd->down.hold_animator = NULL;
1133         _smart_drag_stop(sd->smart_obj);
1134         if (sd->child.resized)
1135           _elm_smart_scroller_wanted_region_set(sd->smart_obj);
1136      }
1137    if (sd->down.momentum_animator)
1138      {
1139         ecore_animator_del(sd->down.momentum_animator);
1140         sd->down.momentum_animator = NULL;
1141         sd->down.bounce_x_hold = EINA_FALSE;
1142         sd->down.bounce_y_hold = EINA_FALSE;
1143         sd->down.ax = 0;
1144         sd->down.ay = 0;
1145         sd->down.pdx = 0;
1146         sd->down.pdy = 0;
1147         if (sd->child.resized)
1148           _elm_smart_scroller_wanted_region_set(sd->smart_obj);
1149      }
1150
1151    x = nx;
1152    if ((x + pw) > cw) x = cw - pw;
1153    if (x < minx) x = minx;
1154    y = ny;
1155    if ((y + ph) > ch) y = ch - ph;
1156    if (y < miny) y = miny;
1157
1158    if ((x == px) && (y == py)) return EINA_FALSE;
1159    *_x = x;
1160    *_y = y;
1161    return EINA_TRUE;
1162 }
1163
1164 /* Set should be used for calculated positions, for example, when we move
1165  * because of an animation or because this is the correct position after
1166  * constraints. */
1167 void
1168 elm_smart_scroller_child_region_set(Evas_Object *obj, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h)
1169 {
1170    API_ENTRY return;
1171    if (_elm_smart_scroller_child_region_show_internal(obj, &x, &y, w, h))
1172      {
1173         elm_smart_scroller_child_pos_set(obj, x, y);
1174         sd->down.sx = x;
1175         sd->down.sy = y;
1176         sd->down.x = sd->down.history[0].x;
1177         sd->down.y = sd->down.history[0].y;
1178      }
1179 }
1180
1181 /* Set should be used for setting the wanted position, for example a user scroll
1182  * or moving the cursor in an entry. */
1183 void
1184 elm_smart_scroller_child_region_show(Evas_Object *obj, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h)
1185 {
1186    API_ENTRY return;
1187    sd->wx = x;
1188    sd->wy = y;
1189    sd->ww = w;
1190    sd->wh = h;
1191    if (_elm_smart_scroller_child_region_show_internal(obj, &x, &y, w, h))
1192      {
1193         elm_smart_scroller_child_pos_set(obj, x, y);
1194         sd->down.sx = x;
1195         sd->down.sy = y;
1196         sd->down.x = sd->down.history[0].x;
1197         sd->down.y = sd->down.history[0].y;
1198      }
1199 }
1200
1201 void
1202 elm_smart_scroller_child_viewport_size_get(Evas_Object *obj, Evas_Coord *w, Evas_Coord *h)
1203 {
1204    API_ENTRY return;
1205    if (!sd->pan_obj) return;
1206    edje_object_calc_force(sd->edje_obj);
1207    evas_object_geometry_get(sd->pan_obj, NULL, NULL, w, h);
1208 }
1209
1210 void
1211 elm_smart_scroller_step_size_set(Evas_Object *obj, Evas_Coord x, Evas_Coord y)
1212 {
1213    API_ENTRY return;
1214    if (x < 1) x = 1;
1215    if (y < 1) y = 1;
1216    sd->step.x = x;
1217    sd->step.y = y;
1218    _smart_scrollbar_size_adjust(sd);
1219 }
1220
1221 void
1222 elm_smart_scroller_step_size_get(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y)
1223 {
1224    API_ENTRY return;
1225    if (x) *x = sd->step.x;
1226    if (y) *y = sd->step.y;
1227 }
1228
1229 void
1230 elm_smart_scroller_page_size_set(Evas_Object *obj, Evas_Coord x, Evas_Coord y)
1231 {
1232    API_ENTRY return;
1233    sd->page.x = x;
1234    sd->page.y = y;
1235    _smart_scrollbar_size_adjust(sd);
1236 }
1237
1238 void
1239 elm_smart_scroller_page_size_get(Evas_Object *obj, Evas_Coord *x, Evas_Coord *y)
1240 {
1241    API_ENTRY return;
1242    if (x) *x = sd->page.x;
1243    if (y) *y = sd->page.y;
1244 }
1245
1246 void
1247 elm_smart_scroller_policy_set(Evas_Object *obj, Elm_Smart_Scroller_Policy hbar, Elm_Smart_Scroller_Policy vbar)
1248 {
1249    API_ENTRY return;
1250    if ((sd->hbar_flags == hbar) && (sd->vbar_flags == vbar)) return;
1251    sd->hbar_flags = hbar;
1252    sd->vbar_flags = vbar;
1253    if (sd->hbar_flags == ELM_SMART_SCROLLER_POLICY_ON)
1254      edje_object_signal_emit(sd->edje_obj, "elm,action,show_always,hbar", "elm");
1255    else if (sd->hbar_flags == ELM_SMART_SCROLLER_POLICY_OFF)
1256      edje_object_signal_emit(sd->edje_obj, "elm,action,hide,hbar", "elm");
1257    else
1258      edje_object_signal_emit(sd->edje_obj, "elm,action,show_notalways,hbar", "elm");
1259    if (sd->vbar_flags == ELM_SMART_SCROLLER_POLICY_ON)
1260      edje_object_signal_emit(sd->edje_obj, "elm,action,show_always,vbar", "elm");
1261    else if (sd->vbar_flags == ELM_SMART_SCROLLER_POLICY_OFF)
1262      edje_object_signal_emit(sd->edje_obj, "elm,action,hide,vbar", "elm");
1263    else
1264      edje_object_signal_emit(sd->edje_obj, "elm,action,show_notalways,vbar", "elm");
1265    _smart_scrollbar_size_adjust(sd);
1266 }
1267
1268 void
1269 elm_smart_scroller_policy_get(Evas_Object *obj, Elm_Smart_Scroller_Policy *hbar, Elm_Smart_Scroller_Policy *vbar)
1270 {
1271    API_ENTRY return;
1272    if (hbar) *hbar = sd->hbar_flags;
1273    if (vbar) *vbar = sd->vbar_flags;
1274 }
1275
1276 Evas_Object *
1277 elm_smart_scroller_edje_object_get(Evas_Object *obj)
1278 {
1279    API_ENTRY return NULL;
1280    return sd->edje_obj;
1281 }
1282
1283 void
1284 elm_smart_scroller_single_dir_set(Evas_Object *obj, Eina_Bool single_dir)
1285 {
1286    API_ENTRY return;
1287    sd->one_dir_at_a_time = single_dir;
1288 }
1289
1290 Eina_Bool
1291 elm_smart_scroller_single_dir_get(Evas_Object *obj)
1292 {
1293    API_ENTRY return EINA_FALSE;
1294    return sd->one_dir_at_a_time;
1295 }
1296
1297 void
1298 elm_smart_scroller_object_theme_set(Evas_Object *parent, Evas_Object *obj, const char *clas, const char *group, const char *style)
1299 {
1300    API_ENTRY return;
1301    Evas_Coord mw, mh;
1302    //Does this API require parent object absolutely? if then remove this exception.
1303    double parent_scale = parent ? elm_widget_scale_get(parent) : 1;
1304    _elm_theme_object_set(parent, sd->edje_obj, clas, group, style);
1305    edje_object_scale_set(sd->edje_obj, parent_scale * _elm_config->scale);
1306    if (sd->pan_obj)
1307      edje_object_part_swallow(sd->edje_obj, "elm.swallow.content", sd->pan_obj);
1308    mw = mh = -1;
1309    elm_coords_finger_size_adjust(1, &mw, 1, &mh);
1310    if (edje_object_part_exists(sd->edje_obj, "elm.scrollbar.base"))
1311      {
1312         Evas_Object *base;
1313         base = edje_object_part_swallow_get(sd->edje_obj, "elm.scrollbar.base");
1314         if (!base)
1315           {
1316              base = evas_object_rectangle_add(evas_object_evas_get(sd->edje_obj));
1317              evas_object_color_set(base, 0, 0, 0, 0);
1318              edje_object_part_swallow(sd->edje_obj, "elm.scrollbar.base", base);
1319           }
1320         if (!_elm_config->thumbscroll_enable)
1321           evas_object_size_hint_min_set(base, mw, mh);
1322      }
1323    sd->vbar_visible = !sd->vbar_visible;
1324    sd->hbar_visible = !sd->hbar_visible;
1325    _smart_scrollbar_bar_visibility_adjust(sd);
1326 }
1327
1328 void
1329 elm_smart_scroller_hold_set(Evas_Object *obj, Eina_Bool hold)
1330 {
1331    API_ENTRY return;
1332    sd->hold = hold;
1333 }
1334
1335 void
1336 elm_smart_scroller_freeze_set(Evas_Object *obj, Eina_Bool freeze)
1337 {
1338    API_ENTRY return;
1339    sd->freeze = freeze;
1340    if (sd->freeze)
1341      {
1342         if (sd->down.onhold_animator)
1343           {
1344              ecore_animator_del(sd->down.onhold_animator);
1345              sd->down.onhold_animator = NULL;
1346              if (sd->child.resized)
1347                _elm_smart_scroller_wanted_region_set(sd->smart_obj);
1348           }
1349      }
1350    else
1351      bounce_eval(sd);
1352 }
1353
1354 void
1355 elm_smart_scroller_bounce_allow_set(Evas_Object *obj, Eina_Bool horiz, Eina_Bool vert)
1356 {
1357    API_ENTRY return;
1358    sd->bounce_horiz = !!horiz;
1359    sd->bounce_vert = !!vert;
1360 }
1361
1362 void
1363 elm_smart_scroller_bounce_allow_get(const Evas_Object *obj, Eina_Bool *horiz, Eina_Bool *vert)
1364 {
1365    API_ENTRY return;
1366    if (horiz) *horiz = sd->bounce_horiz;
1367    if (vert) *vert = sd->bounce_vert;
1368 }
1369
1370 void
1371 elm_smart_scroller_paging_set(Evas_Object *obj, double pagerel_h, double pagerel_v, Evas_Coord pagesize_h, Evas_Coord pagesize_v)
1372 {
1373    API_ENTRY return;
1374    sd->pagerel_h = pagerel_h;
1375    sd->pagerel_v = pagerel_v;
1376    sd->pagesize_h = pagesize_h;
1377    sd->pagesize_v = pagesize_v;
1378    _smart_page_adjust(sd);
1379 }
1380
1381 void
1382 elm_smart_scroller_paging_get(Evas_Object *obj, double *pagerel_h, double *pagerel_v, Evas_Coord *pagesize_h, Evas_Coord *pagesize_v)
1383 {
1384    API_ENTRY return;
1385    if (pagerel_h) *pagerel_h = sd->pagerel_h;
1386    if (pagerel_v) *pagerel_v = sd->pagerel_v;
1387    if (pagesize_h) *pagesize_h = sd->pagesize_h;
1388    if (pagesize_v) *pagesize_v = sd->pagesize_v;
1389 }
1390
1391 void
1392 elm_smart_scroller_current_page_get(Evas_Object *obj, int *pagenumber_h, int *pagenumber_v)
1393 {
1394    API_ENTRY return;
1395    Evas_Coord x, y;
1396    elm_smart_scroller_child_pos_get(sd->smart_obj, &x, &y);
1397    if (pagenumber_h)
1398      {
1399         if (sd->pagesize_h > 0)
1400           *pagenumber_h = (x + sd->pagesize_h - 1) / sd->pagesize_h;
1401         else
1402           *pagenumber_h = 0;
1403      }
1404    if (pagenumber_v)
1405      {
1406         if (sd->pagesize_v > 0)
1407           *pagenumber_v = (y + sd->pagesize_v - 1) / sd->pagesize_v;
1408         else
1409           *pagenumber_v = 0;
1410      }
1411 }
1412
1413 void
1414 elm_smart_scroller_last_page_get(Evas_Object *obj, int *pagenumber_h, int *pagenumber_v)
1415 {
1416    API_ENTRY return;
1417    Evas_Coord cw, ch;
1418    sd->pan_func.child_size_get(sd->pan_obj, &cw, &ch);
1419    if (pagenumber_h)
1420      {
1421         if (sd->pagesize_h > 0)
1422           *pagenumber_h = cw / sd->pagesize_h + 1;
1423         else
1424           *pagenumber_h = 0;
1425      }
1426    if (pagenumber_v)
1427      {
1428         if (sd->pagesize_v > 0)
1429           *pagenumber_v = ch / sd->pagesize_v + 1;
1430         else
1431           *pagenumber_v = 0;
1432      }
1433 }
1434
1435 void
1436 elm_smart_scroller_page_show(Evas_Object *obj, int pagenumber_h, int pagenumber_v)
1437 {
1438    API_ENTRY return;
1439    Evas_Coord x, y, w, h;
1440    elm_smart_scroller_child_viewport_size_get(sd->smart_obj, &w, &h);
1441    if (pagenumber_h >= 0) x = sd->pagesize_h * pagenumber_h;
1442    if (pagenumber_v >= 0) y = sd->pagesize_v * pagenumber_v;
1443    if (_elm_smart_scroller_child_region_show_internal(obj, &x, &y, w, h))
1444      elm_smart_scroller_child_pos_set(obj, x, y);
1445 }
1446
1447 void
1448 elm_smart_scroller_page_bring_in(Evas_Object *obj, int pagenumber_h, int pagenumber_v)
1449 {
1450    API_ENTRY return;
1451    Evas_Coord x, y, w, h;
1452    elm_smart_scroller_child_viewport_size_get(sd->smart_obj, &w, &h);
1453    if (pagenumber_h >= 0) x = sd->pagesize_h * pagenumber_h;
1454    if (pagenumber_v >= 0) y = sd->pagesize_v * pagenumber_v;
1455    if (_elm_smart_scroller_child_region_show_internal(obj, &x, &y, w, h))
1456      {
1457         _smart_scrollto_x(sd, _elm_config->bring_in_scroll_friction, x);
1458         _smart_scrollto_y(sd, _elm_config->bring_in_scroll_friction, y);
1459      }
1460 }
1461
1462 void
1463 elm_smart_scroller_region_bring_in(Evas_Object *obj, Evas_Coord x, Evas_Coord y, Evas_Coord w, Evas_Coord h)
1464 {
1465    API_ENTRY return;
1466    if (_elm_smart_scroller_child_region_show_internal(obj, &x, &y, w, h))
1467      {
1468         _smart_scrollto_x(sd, _elm_config->bring_in_scroll_friction, x);
1469         _smart_scrollto_y(sd, _elm_config->bring_in_scroll_friction, y);
1470      }
1471 }
1472
1473 void
1474 elm_smart_scroller_widget_set(Evas_Object *obj, Evas_Object *wid)
1475 {
1476    API_ENTRY return;
1477    sd->widget = wid;
1478 }
1479
1480 static void
1481 _elm_smart_scroller_wanted_region_set(Evas_Object *obj)
1482 {
1483    INTERNAL_ENTRY;
1484    Evas_Coord ww, wh, wx = sd->wx;
1485
1486    if (sd->down.now || sd->down.momentum_animator ||
1487        sd->down.bounce_x_animator || sd->down.bounce_y_animator ||
1488        sd->down.hold_animator || sd->down.onhold_animator ||
1489        sd->scrollto.x.animator || sd->scrollto.y.animator) return;
1490
1491    sd->child.resized = EINA_FALSE;
1492
1493    /* Flip to RTL cords only if init in RTL mode */
1494    if (sd->is_mirrored)
1495      wx = _elm_smart_scroller_x_mirrored_get(obj, sd->wx);
1496
1497    if (sd->ww == -1)
1498      {
1499         elm_smart_scroller_child_viewport_size_get(obj, &ww, &wh);
1500      }
1501    else
1502      {
1503         ww = sd->ww;
1504         wh = sd->wh;
1505      }
1506
1507    elm_smart_scroller_child_region_set(obj, wx, sd->wy, ww, wh);
1508 }
1509
1510 /* local subsystem functions */
1511 static void
1512 _smart_edje_drag_v_start(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1513 {
1514    Smart_Data *sd;
1515
1516    sd = data;
1517    _smart_scrollbar_read(sd);
1518    _smart_drag_start(sd->smart_obj);
1519    sd->freeze = EINA_TRUE;
1520 }
1521
1522 static void
1523 _smart_edje_drag_v_stop(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1524 {
1525    Smart_Data *sd;
1526
1527    sd = data;
1528    _smart_scrollbar_read(sd);
1529    _smart_drag_stop(sd->smart_obj);
1530    sd->freeze = EINA_FALSE;
1531 }
1532
1533 static void
1534 _smart_edje_drag_v(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1535 {
1536    Smart_Data *sd;
1537
1538    sd = data;
1539    _smart_scrollbar_read(sd);
1540 }
1541
1542 static void
1543 _smart_edje_drag_h_start(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1544 {
1545    Smart_Data *sd;
1546
1547    sd = data;
1548    _smart_scrollbar_read(sd);
1549    _smart_drag_start(sd->smart_obj);
1550    sd->freeze = EINA_TRUE;
1551 }
1552
1553 static void
1554 _smart_edje_drag_h_stop(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1555 {
1556    Smart_Data *sd;
1557
1558    sd = data;
1559    _smart_scrollbar_read(sd);
1560    _smart_drag_stop(sd->smart_obj);
1561    sd->freeze = EINA_FALSE;
1562 }
1563
1564 static void
1565 _smart_edje_drag_h(void *data, Evas_Object *obj __UNUSED__, const char *emission __UNUSED__, const char *source __UNUSED__)
1566 {
1567    Smart_Data *sd;
1568
1569    sd = data;
1570    _smart_scrollbar_read(sd);
1571 }
1572
1573 static void
1574 _smart_child_del_hook(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1575 {
1576    Smart_Data *sd;
1577
1578    sd = data;
1579    sd->child_obj = NULL;
1580    _smart_scrollbar_size_adjust(sd);
1581    _smart_scrollbar_reset(sd);
1582 }
1583
1584 static void
1585 _smart_pan_changed_hook(void *data, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
1586 {
1587    Evas_Coord w, h;
1588    Smart_Data *sd;
1589
1590    sd = data;
1591    sd->pan_func.child_size_get(sd->pan_obj, &w, &h);
1592    if ((w != sd->child.w) || (h != sd->child.h))
1593      {
1594         sd->child.w = w;
1595         sd->child.h = h;
1596         _smart_scrollbar_size_adjust(sd);
1597         evas_object_size_hint_min_set(sd->smart_obj, sd->child.w, sd->child.h);
1598         sd->child.resized = EINA_TRUE;
1599         _elm_smart_scroller_wanted_region_set(sd->smart_obj);
1600      }
1601 }
1602
1603 void
1604 elm_smart_scroller_gravity_set(Evas_Object *obj, double x, double y)
1605 {
1606    API_ENTRY return;
1607
1608    sd->pan_func.gravity_set(sd->pan_obj, x, y);
1609 }
1610
1611 void
1612 elm_smart_scroller_gravity_get(Evas_Object *obj, double *x, double *y)
1613 {
1614    API_ENTRY return;
1615
1616    sd->pan_func.gravity_get(sd->pan_obj, x, y);
1617 }
1618
1619 static void
1620 _smart_event_wheel(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
1621 {
1622    Evas_Event_Mouse_Wheel *ev;
1623    Smart_Data *sd;
1624    Evas_Coord x = 0, y = 0;
1625
1626    sd = data;
1627    ev = event_info;
1628    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return ;
1629    if ((evas_key_modifier_is_set(ev->modifiers, "Control")) ||
1630        (evas_key_modifier_is_set(ev->modifiers, "Alt")) ||
1631        (evas_key_modifier_is_set(ev->modifiers, "Shift")) ||
1632        (evas_key_modifier_is_set(ev->modifiers, "Meta")) ||
1633        (evas_key_modifier_is_set(ev->modifiers, "Hyper")) ||
1634        (evas_key_modifier_is_set(ev->modifiers, "Super")))
1635      return;
1636    elm_smart_scroller_child_pos_get(sd->smart_obj, &x, &y);
1637    if ((sd->down.bounce_x_animator) || (sd->down.bounce_y_animator) ||
1638        (sd->scrollto.x.animator) || (sd->scrollto.y.animator))
1639      {
1640         _smart_anim_stop(sd->smart_obj);
1641      }
1642    if (sd->scrollto.x.animator)
1643      {
1644         ecore_animator_del(sd->scrollto.x.animator);
1645         sd->scrollto.x.animator = NULL;
1646      }
1647    if (sd->scrollto.y.animator)
1648      {
1649         ecore_animator_del(sd->scrollto.y.animator);
1650         sd->scrollto.y.animator = NULL;
1651      }
1652    if (sd->down.bounce_x_animator)
1653      {
1654         ecore_animator_del(sd->down.bounce_x_animator);
1655         sd->down.bounce_x_animator = NULL;
1656         sd->bouncemex = EINA_FALSE;
1657         if (sd->child.resized)
1658           _elm_smart_scroller_wanted_region_set(sd->smart_obj);
1659      }
1660    if (sd->down.bounce_y_animator)
1661      {
1662         ecore_animator_del(sd->down.bounce_y_animator);
1663         sd->down.bounce_y_animator = NULL;
1664         sd->bouncemey = EINA_FALSE;
1665         if (sd->child.resized)
1666           _elm_smart_scroller_wanted_region_set(sd->smart_obj);
1667      }
1668    if (!ev->direction)
1669      y += ev->z * sd->step.y;
1670    else if (ev->direction == 1)
1671      x += ev->z * sd->step.x;
1672
1673    if ((!sd->hold) && (!sd->freeze))
1674      {
1675         _update_wanted_coordinates(sd, x, y);
1676         elm_smart_scroller_child_pos_set(sd->smart_obj, x, y);
1677      }
1678 }
1679
1680 static void
1681 _smart_event_mouse_down(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
1682 {
1683    Evas_Event_Mouse_Down *ev;
1684    Smart_Data *sd;
1685    Evas_Coord x = 0, y = 0;
1686
1687    sd = data;
1688    ev = event_info;
1689    //   if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return ;
1690    if (_elm_config->thumbscroll_enable)
1691      {
1692         sd->down.hold = EINA_FALSE;
1693         if ((sd->down.bounce_x_animator) || (sd->down.bounce_y_animator) ||
1694             (sd->down.momentum_animator) || (sd->scrollto.x.animator) ||
1695             (sd->scrollto.y.animator))
1696           {
1697              ev->event_flags |= EVAS_EVENT_FLAG_ON_SCROLL | EVAS_EVENT_FLAG_ON_HOLD;
1698              sd->down.scroll = EINA_TRUE;
1699              sd->down.hold = EINA_TRUE;
1700              _smart_anim_stop(sd->smart_obj);
1701           }
1702         if (sd->scrollto.x.animator)
1703           {
1704              ecore_animator_del(sd->scrollto.x.animator);
1705              sd->scrollto.x.animator = NULL;
1706           }
1707         if (sd->scrollto.y.animator)
1708           {
1709              ecore_animator_del(sd->scrollto.y.animator);
1710              sd->scrollto.y.animator = NULL;
1711           }
1712         if (sd->down.bounce_x_animator)
1713           {
1714              ecore_animator_del(sd->down.bounce_x_animator);
1715              sd->down.bounce_x_animator = NULL;
1716              sd->bouncemex = EINA_FALSE;
1717              if (sd->child.resized)
1718                _elm_smart_scroller_wanted_region_set(sd->smart_obj);
1719           }
1720         if (sd->down.bounce_y_animator)
1721           {
1722              ecore_animator_del(sd->down.bounce_y_animator);
1723              sd->down.bounce_y_animator = NULL;
1724              sd->bouncemey = EINA_FALSE;
1725              if (sd->child.resized)
1726                _elm_smart_scroller_wanted_region_set(sd->smart_obj);
1727           }
1728         if (sd->down.hold_animator)
1729           {
1730              ecore_animator_del(sd->down.hold_animator);
1731              sd->down.hold_animator = NULL;
1732              _smart_drag_stop(sd->smart_obj);
1733              if (sd->child.resized)
1734                _elm_smart_scroller_wanted_region_set(sd->smart_obj);
1735           }
1736         if (sd->down.momentum_animator)
1737           {
1738              ecore_animator_del(sd->down.momentum_animator);
1739              sd->down.momentum_animator = NULL;
1740              sd->down.bounce_x_hold = EINA_FALSE;
1741              sd->down.bounce_y_hold = EINA_FALSE;
1742              sd->down.ax = 0;
1743              sd->down.ay = 0;
1744              if (sd->child.resized)
1745                _elm_smart_scroller_wanted_region_set(sd->smart_obj);
1746           }
1747         if (ev->button == 1)
1748           {
1749              sd->down.hist.est_timestamp_diff =
1750                 ecore_loop_time_get() - ((double)ev->timestamp / 1000.0);
1751              sd->down.hist.tadd = 0.0;
1752              sd->down.hist.dxsum = 0.0;
1753              sd->down.hist.dysum = 0.0;
1754              sd->down.now = EINA_TRUE;
1755              sd->down.dragged = EINA_FALSE;
1756              sd->down.dir_x = EINA_FALSE;
1757              sd->down.dir_y = EINA_FALSE;
1758              sd->down.x = ev->canvas.x;
1759              sd->down.y = ev->canvas.y;
1760              elm_smart_scroller_child_pos_get(sd->smart_obj, &x, &y);
1761              sd->down.sx = x;
1762              sd->down.sy = y;
1763              sd->down.locked = EINA_FALSE;
1764              memset(&(sd->down.history[0]), 0, sizeof(sd->down.history[0]) * 60);
1765 #ifdef EVTIME
1766              sd->down.history[0].timestamp = ev->timestamp / 1000.0;
1767              sd->down.history[0].localtimestamp = ecore_loop_time_get();
1768 #else
1769              sd->down.history[0].timestamp = ecore_loop_time_get();
1770 #endif
1771              sd->down.history[0].x = ev->canvas.x;
1772              sd->down.history[0].y = ev->canvas.y;
1773           }
1774         sd->down.dragged_began = EINA_FALSE;
1775         sd->down.hold_parent = EINA_FALSE;
1776         sd->down.cancelled = EINA_FALSE;
1777      }
1778 }
1779
1780 static void
1781 _down_coord_eval(Smart_Data *sd, Evas_Coord *x, Evas_Coord *y)
1782 {
1783    Evas_Coord minx, miny;
1784
1785    if (sd->down.dir_x) *x = sd->down.sx - (*x - sd->down.x);
1786    else *x = sd->down.sx;
1787    if (sd->down.dir_y) *y = sd->down.sy - (*y - sd->down.y);
1788    else *y = sd->down.sy;
1789
1790    if ((sd->down.dir_x) || (sd->down.dir_y))
1791      {
1792         if (!((sd->down.dir_x) && (sd->down.dir_y)))
1793           {
1794              if (sd->down.dir_x) *y = sd->down.locked_y;
1795              else *x = sd->down.locked_x;
1796           }
1797      }
1798
1799    sd->pan_func.min_get(sd->pan_obj, &minx, &miny);
1800
1801    if (*x < minx)
1802      *x += (minx - *x) * _elm_config->thumbscroll_border_friction;
1803    else if (sd->child.w <= sd->w)
1804      *x += (sd->down.sx - *x) * _elm_config->thumbscroll_border_friction;
1805    else if ((sd->child.w - sd->w + minx) < *x)
1806      *x += (sd->child.w - sd->w + minx - *x) *
1807         _elm_config->thumbscroll_border_friction;
1808
1809    if (*y < miny)
1810      *y += (miny - *y) * _elm_config->thumbscroll_border_friction;
1811    else if (sd->child.h <= sd->h)
1812      *y += (sd->down.sy - *y) * _elm_config->thumbscroll_border_friction;
1813    else if ((sd->child.h - sd->h + miny) < *y)
1814      *y += (sd->child.h - sd->h + miny - *y) *
1815         _elm_config->thumbscroll_border_friction;
1816 }
1817
1818 static Eina_Bool
1819 _smart_hold_animator(void *data)
1820 {
1821    Smart_Data *sd = data;
1822    Evas_Coord ox = 0, oy = 0, fx = 0, fy= 0;
1823
1824    fx = sd->down.hold_x;
1825    fy = sd->down.hold_y;
1826
1827    if ((!sd->hold) && (!sd->freeze) && (_elm_config->scroll_smooth_time_interval > 0.0))
1828      {
1829         int i, count = 0; //count for the real event number we have to deal with
1830         int queue_size = 10; //for event queue size
1831         int src_index = 0, dst_index = 0;
1832         int xsum = 0, ysum=0;
1833         Evas_Coord  x=0, y=0;
1834
1835         struct {
1836              Evas_Coord x, y;
1837              double t;
1838         } pos[queue_size];
1839
1840         double tdiff, tnow;
1841         double time_interval=_elm_config->scroll_smooth_time_interval;
1842         // FIXME: assume server and client have the same "timezone"
1843         // (0 timepoint) for now. this needs to be figured out in advance
1844         // though.
1845         tdiff = sd->down.hist.est_timestamp_diff;
1846         tnow = ecore_time_get() - tdiff;
1847
1848         for(i = 0; i < queue_size; i++)
1849           {
1850              x = sd->down.history[i].x;
1851              y = sd->down.history[i].y;
1852
1853              //if there is no history value , we don't deal with it
1854              //if there is better wat to know existance of history value , I will modify this code to it
1855              if ( (x == 0) && (y == 0) )
1856                {
1857                   break;
1858                }
1859              _down_coord_eval(sd, &x, &y);
1860
1861              pos[i].x = x;
1862              pos[i].y = y;
1863              pos[i].t = tnow - sd->down.history[i].timestamp;
1864           }
1865         count = --i;
1866
1867         // we only deal with smooth scroll there is enough history
1868         for(i = 0; i < queue_size; i++)
1869           {
1870              if (src_index > count) break;
1871              if (i == 0)
1872                {
1873                   xsum = pos[i].x;
1874                   ysum = pos[i].y;
1875                   dst_index++;
1876                   continue;
1877                }
1878              while ((pos[src_index].t < time_interval *i) &&
1879                      (src_index <= count))
1880                {
1881                   src_index++;
1882                }
1883              if (src_index <= count)
1884                {
1885                   xsum += pos[src_index].x;
1886                   ysum += pos[src_index].y;
1887                   dst_index++;
1888                }
1889           }
1890         fx = xsum / dst_index;
1891         fy = ysum / dst_index;
1892      }
1893
1894    elm_smart_scroller_child_pos_get(sd->smart_obj, &ox, &oy);
1895    if (sd->down.dir_x)
1896      {
1897         if ((!sd->widget) ||
1898             (!elm_widget_drag_child_locked_x_get(sd->widget)))
1899           ox = fx;
1900      }
1901    if (sd->down.dir_y)
1902      {
1903         if ((!sd->widget) ||
1904             (!elm_widget_drag_child_locked_y_get(sd->widget)))
1905           oy = fy;
1906      }
1907
1908    elm_smart_scroller_child_pos_set(sd->smart_obj, ox, oy);
1909    return ECORE_CALLBACK_RENEW;
1910 }
1911
1912 static Eina_Bool
1913 _smart_event_post_up(void *data, Evas *e __UNUSED__)
1914 {
1915    Smart_Data *sd = data;
1916    if (sd->widget)
1917      {
1918         if (sd->down.dragged)
1919           {
1920              elm_widget_drag_lock_x_set(sd->widget, 0);
1921              elm_widget_drag_lock_y_set(sd->widget, 0);
1922           }
1923      }
1924    return EINA_TRUE;
1925 }
1926
1927 static void
1928 _smart_event_mouse_up(void *data, Evas *e, Evas_Object *obj __UNUSED__, void *event_info)
1929 {
1930    Evas_Event_Mouse_Down *ev;
1931    Smart_Data *sd;
1932    Evas_Coord x = 0, y = 0, ox = 0, oy = 0;
1933    Evas_Coord vw, vh, aw, ah;
1934
1935    sd = data;
1936    ev = event_info;
1937    sd->down.hold_parent = EINA_FALSE;
1938    sd->down.dx = 0;
1939    sd->down.dy = 0;
1940    //   if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return ;
1941    evas_post_event_callback_push(e, _smart_event_post_up, sd);
1942    // FIXME: respect elm_widget_scroll_hold_get of parent container
1943    if (_elm_config->thumbscroll_enable)
1944      {
1945         if (ev->button == 1)
1946           {
1947              if (sd->down.onhold_animator)
1948                {
1949                   ecore_animator_del(sd->down.onhold_animator);
1950                   sd->down.onhold_animator = NULL;
1951                   if (sd->child.resized)
1952                     _elm_smart_scroller_wanted_region_set(sd->smart_obj);
1953                }
1954              x = ev->canvas.x - sd->down.x;
1955              y = ev->canvas.y - sd->down.y;
1956              if (sd->down.dragged)
1957                {
1958                   _smart_drag_stop(sd->smart_obj);
1959                   if ((!sd->hold) && (!sd->freeze))
1960                     {
1961                        double t, at, dt;
1962                        int i;
1963                        Evas_Coord ax, ay, dx, dy, vel;
1964
1965 #ifdef EVTIME
1966                        t = ev->timestamp / 1000.0;
1967 #else
1968                        t = ecore_loop_time_get();
1969 #endif
1970                        ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
1971                        ax = ev->canvas.x;
1972                        ay = ev->canvas.y;
1973                        at = 0.0;
1974 #ifdef SCROLLDBG
1975                        printf("------ %i %i\n", ev->canvas.x, ev->canvas.y);
1976 #endif
1977                        for (i = 0; i < 60; i++)
1978                          {
1979                             dt = t - sd->down.history[i].timestamp;
1980                             if (dt > 0.2) break;
1981 #ifdef SCROLLDBG
1982                             printf("H: %i %i @ %1.3f\n",
1983                                    sd->down.history[i].x,
1984                                    sd->down.history[i].y, dt);
1985 #endif
1986                             at += dt;
1987                             ax += sd->down.history[i].x;
1988                             ay += sd->down.history[i].y;
1989                          }
1990                        ax /= (i + 1);
1991                        ay /= (i + 1);
1992                        at /= (i + 1);
1993                        at /= _elm_config->thumbscroll_sensitivity_friction;
1994                        dx = ev->canvas.x - ax;
1995                        dy = ev->canvas.y - ay;
1996                        if (at > 0)
1997                          {
1998                             vel = sqrt((dx * dx) + (dy * dy)) / at;
1999                             if ((_elm_config->thumbscroll_friction > 0.0) &&
2000                                 (vel > _elm_config->thumbscroll_momentum_threshold))
2001                               {
2002                                  int minx, miny, mx, my, px, py;
2003                                  sd->pan_func.min_get(sd->pan_obj, &minx, &miny);
2004                                  sd->pan_func.max_get(sd->pan_obj, &mx, &my);
2005                                  sd->pan_func.get(sd->pan_obj, &px, &py);
2006                                  sd->down.dx = ((double)dx / at);
2007                                  sd->down.dy = ((double)dy / at);
2008                                  if (((sd->down.dx > 0) && (sd->down.pdx > 0)) ||
2009                                      ((sd->down.dx < 0) && (sd->down.pdx < 0)))
2010                                    if (px > minx && px < mx)
2011                                      sd->down.dx += (double)sd->down.pdx * 1.5; // FIXME: * 1.5 - probably should be config
2012                                  if (((sd->down.dy > 0) && (sd->down.pdy > 0)) ||
2013                                      ((sd->down.dy < 0) && (sd->down.pdy < 0)))
2014                                    if (py > miny && py < my)
2015                                      sd->down.dy += (double)sd->down.pdy * 1.5; // FIXME: * 1.5 - probably should be config
2016                                  if (((sd->down.dx > 0) && (sd->down.pdx > 0)) ||
2017                                      ((sd->down.dx < 0) && (sd->down.pdx < 0)) ||
2018                                      ((sd->down.dy > 0) && (sd->down.pdy > 0)) ||
2019                                      ((sd->down.dy < 0) && (sd->down.pdy < 0)))
2020                                    {
2021                                       double t = ecore_loop_time_get();
2022                                       double dt = t - sd->down.anim_start;
2023
2024                                       if (dt < 0.0) dt = 0.0;
2025                                       else if (dt > _elm_config->thumbscroll_friction)
2026                                         dt = _elm_config->thumbscroll_friction;
2027                                       sd->down.extra_time = _elm_config->thumbscroll_friction - dt;
2028                                    }
2029                                  else
2030                                    sd->down.extra_time = 0.0;
2031                                  elm_smart_scroller_child_viewport_size_get(sd->smart_obj, &vw, &vh);
2032                                  aw = abs(sd->down.dx);
2033                                  if (aw  > vw*3)
2034                                    {
2035                                       if (sd->down.dx > 0) sd->down.dx = vw*3;
2036                                       else sd->down.dx = -(vw*3);
2037                                    }
2038                                  ah = abs(sd->down.dy);
2039                                  if (ah  > vh*3)
2040                                    {
2041                                       if (sd->down.dy > 0) sd->down.dy = vh*3;
2042                                       else sd->down.dy = -(vh*3);
2043                                    }
2044                                  sd->down.pdx = sd->down.dx;
2045                                  sd->down.pdy = sd->down.dy;
2046                                  ox = -sd->down.dx;
2047                                  oy = -sd->down.dy;
2048                                  if (!_smart_do_page(sd))
2049                                    {
2050                                       if ((!sd->down.momentum_animator) && (!sd->momentum_animator_disabled))
2051                                         {
2052                                            sd->down.momentum_animator = ecore_animator_add(_smart_momentum_animator, sd);
2053                                            ev->event_flags |= EVAS_EVENT_FLAG_ON_SCROLL;
2054                                            _smart_anim_start(sd->smart_obj);
2055                                         }
2056                                       sd->down.anim_start = ecore_loop_time_get();
2057                                       elm_smart_scroller_child_pos_get(sd->smart_obj, &x, &y);
2058                                       sd->down.sx = x;
2059                                       sd->down.sy = y;
2060                                       sd->down.b0x = 0;
2061                                       sd->down.b0y = 0;
2062                                    }
2063                               }
2064                          }
2065                     }
2066                   else
2067                     {
2068                        sd->down.pdx = 0;
2069                        sd->down.pdy = 0;
2070                     }
2071                   evas_event_feed_hold(e, 0, ev->timestamp, ev->data);
2072                   if (_smart_do_page(sd))
2073                     {
2074                        Evas_Coord pgx, pgy;
2075
2076                        elm_smart_scroller_child_pos_get(sd->smart_obj, &x, &y);
2077                        if ((!sd->widget) ||
2078                            (!elm_widget_drag_child_locked_x_get(sd->widget)))
2079                          {
2080                             pgx = _smart_page_x_get(sd, ox);
2081                             if (pgx != x)
2082                               {
2083                                  ev->event_flags |= EVAS_EVENT_FLAG_ON_SCROLL;
2084                                  _smart_scrollto_x(sd, _elm_config->page_scroll_friction, pgx);
2085                               }
2086                          }
2087                        if ((!sd->widget) ||
2088                            (!elm_widget_drag_child_locked_y_get(sd->widget)))
2089                          {
2090                             pgy = _smart_page_y_get(sd, oy);
2091                             if (pgy != y)
2092                               {
2093                                  ev->event_flags |= EVAS_EVENT_FLAG_ON_SCROLL;
2094                                  _smart_scrollto_y(sd, _elm_config->page_scroll_friction, pgy);
2095                               }
2096                          }
2097                     }
2098                }
2099              else
2100                {
2101                   sd->down.pdx = 0;
2102                   sd->down.pdy = 0;
2103                   if (_smart_do_page(sd))
2104                     {
2105                        Evas_Coord pgx, pgy;
2106
2107                        elm_smart_scroller_child_pos_get(sd->smart_obj, &x, &y);
2108                        if ((!sd->widget) ||
2109                            (!elm_widget_drag_child_locked_x_get(sd->widget)))
2110                          {
2111                             pgx = _smart_page_x_get(sd, ox);
2112                             if (pgx != x) _smart_scrollto_x(sd, _elm_config->page_scroll_friction, pgx);
2113                          }
2114                        if ((!sd->widget) ||
2115                            (!elm_widget_drag_child_locked_y_get(sd->widget)))
2116                          {
2117                             pgy = _smart_page_y_get(sd, oy);
2118                             if (pgy != y) _smart_scrollto_y(sd, _elm_config->page_scroll_friction, pgy);
2119                          }
2120                     }
2121                }
2122              if (sd->down.hold_animator)
2123                {
2124                   ecore_animator_del(sd->down.hold_animator);
2125                   sd->down.hold_animator = NULL;
2126                   if (sd->child.resized)
2127                     _elm_smart_scroller_wanted_region_set(sd->smart_obj);
2128                }
2129              if (sd->down.scroll)
2130                {
2131                   ev->event_flags |= EVAS_EVENT_FLAG_ON_SCROLL;
2132                   sd->down.scroll = EINA_FALSE;
2133                }
2134              if (sd->down.hold)
2135                {
2136                   ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
2137                   sd->down.hold = EINA_FALSE;
2138                }
2139              sd->down.dragged_began = EINA_FALSE;
2140              sd->down.dir_x = EINA_FALSE;
2141              sd->down.dir_y = EINA_FALSE;
2142              sd->down.want_dragged = EINA_FALSE;
2143              sd->down.dragged = EINA_FALSE;
2144              sd->down.now = EINA_FALSE;
2145              elm_smart_scroller_child_pos_get(sd->smart_obj, &x, &y);
2146              elm_smart_scroller_child_pos_set(sd->smart_obj, x, y);
2147              _update_wanted_coordinates(sd, x, y);
2148
2149              if (sd->child.resized)
2150                _elm_smart_scroller_wanted_region_set(sd->smart_obj);
2151
2152              if (!_smart_do_page(sd))
2153                bounce_eval(sd);
2154           }
2155      }
2156 }
2157
2158 static Eina_Bool
2159 _smart_onhold_animator(void *data)
2160 {
2161    Smart_Data *sd;
2162    double t, td;
2163    double vx, vy;
2164    Evas_Coord x, y, ox, oy;
2165
2166    sd = data;
2167    t = ecore_loop_time_get();
2168    if (sd->down.onhold_tlast > 0.0)
2169      {
2170         td = t - sd->down.onhold_tlast;
2171         vx = sd->down.onhold_vx * td * (double)_elm_config->thumbscroll_threshold * 2.0;
2172         vy = sd->down.onhold_vy * td * (double)_elm_config->thumbscroll_threshold * 2.0;
2173         elm_smart_scroller_child_pos_get(sd->smart_obj, &ox, &oy);
2174         x = ox;
2175         y = oy;
2176
2177         if (sd->down.dir_x)
2178           {
2179              if ((!sd->widget) ||
2180                  (!elm_widget_drag_child_locked_x_get(sd->widget)))
2181                {
2182                   sd->down.onhold_vxe += vx;
2183                   x = ox + (int)sd->down.onhold_vxe;
2184                   sd->down.onhold_vxe -= (int)sd->down.onhold_vxe;
2185                }
2186           }
2187
2188         if (sd->down.dir_y)
2189           {
2190              if ((!sd->widget) ||
2191                  (!elm_widget_drag_child_locked_y_get(sd->widget)))
2192                {
2193                   sd->down.onhold_vye += vy;
2194                   y = oy + (int)sd->down.onhold_vye;
2195                   sd->down.onhold_vye -= (int)sd->down.onhold_vye;
2196                }
2197           }
2198
2199         elm_smart_scroller_child_pos_set(sd->smart_obj, x, y);
2200      }
2201    sd->down.onhold_tlast = t;
2202    return ECORE_CALLBACK_RENEW;
2203 }
2204
2205 static Eina_Bool
2206 _smart_event_post_move(void *data, Evas *e __UNUSED__)
2207 {
2208    Smart_Data *sd = data;
2209
2210    if (sd->down.want_dragged)
2211      {
2212         int start = 0;
2213
2214         if (sd->down.hold_parent)
2215           {
2216              if ((sd->down.dir_x) && !can_scroll(sd, sd->down.hdir))
2217                {
2218                   sd->down.dir_x = EINA_FALSE;
2219                }
2220              if ((sd->down.dir_y) && !can_scroll(sd, sd->down.vdir))
2221                {
2222                   sd->down.dir_y = EINA_FALSE;
2223                }
2224           }
2225         if (sd->down.dir_x)
2226           {
2227              if ((!sd->widget) ||
2228                  (!elm_widget_drag_child_locked_x_get(sd->widget)))
2229                {
2230                   sd->down.want_dragged = EINA_FALSE;
2231                   sd->down.dragged = EINA_TRUE;
2232                   if (sd->widget)
2233                     {
2234                        elm_widget_drag_lock_x_set(sd->widget, 1);
2235                     }
2236                   start = 1;
2237                }
2238              else
2239                sd->down.dir_x = EINA_FALSE;
2240           }
2241         if (sd->down.dir_y)
2242           {
2243              if ((!sd->widget) ||
2244                  (!elm_widget_drag_child_locked_y_get(sd->widget)))
2245                {
2246                   sd->down.want_dragged = EINA_FALSE;
2247                   sd->down.dragged = EINA_TRUE;
2248                   if (sd->widget)
2249                     {
2250                        elm_widget_drag_lock_y_set(sd->widget, 1);
2251                     }
2252                   start = 1;
2253                }
2254              else
2255                sd->down.dir_y = EINA_FALSE;
2256           }
2257         if ((!sd->down.dir_x) && (!sd->down.dir_y))
2258           {
2259              sd->down.cancelled = EINA_TRUE;
2260           }
2261         if (start) _smart_drag_start(sd->smart_obj);
2262      }
2263    return EINA_TRUE;
2264 }
2265
2266 static void
2267 _smart_event_mouse_move(void *data, Evas *e, Evas_Object *obj __UNUSED__, void *event_info)
2268 {
2269    Evas_Event_Mouse_Move *ev;
2270    Smart_Data *sd;
2271    Evas_Coord x = 0, y = 0;
2272
2273    sd = data;
2274    ev = event_info;
2275    //   if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD) return ;
2276    if (ev->event_flags & EVAS_EVENT_FLAG_ON_HOLD)
2277      sd->down.hold_parent = EINA_TRUE;
2278    evas_post_event_callback_push(e, _smart_event_post_move, sd);
2279
2280    // FIXME: respect elm_widget_scroll_hold_get of parent container
2281    if (_elm_config->thumbscroll_enable)
2282      {
2283         if (sd->down.now)
2284           {
2285              int dodir = 0;
2286
2287              if (sd->scrollto.x.animator)
2288                {
2289                   Evas_Coord px;
2290                   ecore_animator_del(sd->scrollto.x.animator);
2291                   sd->scrollto.x.animator = NULL;
2292                   sd->pan_func.get(sd->pan_obj, &px, NULL);
2293                   sd->down.sx = px;
2294                   sd->down.x = sd->down.history[0].x;
2295                }
2296
2297              if (sd->scrollto.y.animator)
2298                {
2299                   Evas_Coord py;
2300                   ecore_animator_del(sd->scrollto.y.animator);
2301                   sd->scrollto.y.animator = NULL;
2302                   sd->pan_func.get(sd->pan_obj, NULL, &py);
2303                   sd->down.sy = py;
2304                   sd->down.y = sd->down.history[0].y;
2305                }
2306
2307 #ifdef SCROLLDBG
2308              printf("::: %i %i\n", ev->cur.canvas.x, ev->cur.canvas.y);
2309 #endif
2310              memmove(&(sd->down.history[1]), &(sd->down.history[0]),
2311                      sizeof(sd->down.history[0]) * (60 - 1));
2312 #ifdef EVTIME
2313              sd->down.history[0].timestamp = ev->timestamp / 1000.0;
2314              sd->down.history[0].localtimestamp = ecore_loop_time_get();
2315 #else
2316              sd->down.history[0].timestamp = ecore_loop_time_get();
2317 #endif
2318              sd->down.history[0].x = ev->cur.canvas.x;
2319              sd->down.history[0].y = ev->cur.canvas.y;
2320
2321              if (!sd->down.dragged_began)
2322                {
2323                   x = ev->cur.canvas.x - sd->down.x;
2324                   y = ev->cur.canvas.y - sd->down.y;
2325
2326                   sd->down.hdir = -1;
2327                   sd->down.vdir = -1;
2328
2329                   if      (x > 0) sd->down.hdir = LEFT;
2330                   else if (x < 0) sd->down.hdir = RIGHT;
2331                   if      (y > 0) sd->down.vdir = UP;
2332                   else if (y < 0) sd->down.vdir = DOWN;
2333
2334                   if (x < 0) x = -x;
2335                   if (y < 0) y = -y;
2336
2337                   if ((sd->one_dir_at_a_time) &&
2338                       (!((sd->down.dir_x) || (sd->down.dir_y))))
2339                     {
2340                        if (x > _elm_config->thumbscroll_threshold)
2341                          {
2342                             if (x > (y * 2))
2343                               {
2344                                  sd->down.dir_x = EINA_TRUE;
2345                                  sd->down.dir_y = EINA_FALSE;
2346                                  dodir++;
2347                               }
2348                          }
2349                        if (y > _elm_config->thumbscroll_threshold)
2350                          {
2351                             if (y > (x * 2))
2352                               {
2353                                  sd->down.dir_x = EINA_FALSE;
2354                                  sd->down.dir_y = EINA_TRUE;
2355                                  dodir++;
2356                               }
2357                          }
2358                        if (!dodir)
2359                          {
2360                             sd->down.dir_x = EINA_TRUE;
2361                             sd->down.dir_y = EINA_TRUE;
2362                          }
2363                     }
2364                   else
2365                     {
2366                        sd->down.dir_x = EINA_TRUE;
2367                        sd->down.dir_y = EINA_TRUE;
2368                     }
2369                }
2370              if ((!sd->hold) && (!sd->freeze))
2371                {
2372                   if ((sd->down.dragged) ||
2373                       (((x * x) + (y * y)) >
2374                        (_elm_config->thumbscroll_threshold *
2375                         _elm_config->thumbscroll_threshold)))
2376                     {
2377                        sd->down.dragged_began = EINA_TRUE;
2378                        if (!sd->down.dragged)
2379                          {
2380                             sd->down.want_dragged = EINA_TRUE;
2381                             ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
2382                             //                            evas_event_feed_hold(e, 1, ev->timestamp, ev->data);
2383                             //                            _smart_drag_start(sd->smart_obj);
2384                          }
2385                        if (sd->down.dragged)
2386                          {
2387                             ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
2388                          }
2389                        //                       ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
2390                        //                       sd->down.dragged = 1;
2391                        if (sd->down.dir_x)
2392                          x = sd->down.sx - (ev->cur.canvas.x - sd->down.x);
2393                        else
2394                          x = sd->down.sx;
2395                        if (sd->down.dir_y)
2396                          y = sd->down.sy - (ev->cur.canvas.y - sd->down.y);
2397                        else
2398                          y = sd->down.sy;
2399                        if ((sd->down.dir_x) || (sd->down.dir_y))
2400                          {
2401                             if (!sd->down.locked)
2402                               {
2403                                  sd->down.locked_x = x;
2404                                  sd->down.locked_y = y;
2405                                  sd->down.locked = EINA_TRUE;
2406                               }
2407                             if (!((sd->down.dir_x) && (sd->down.dir_y)))
2408                               {
2409                                  if (sd->down.dir_x) y = sd->down.locked_y;
2410                                  else x = sd->down.locked_x;
2411                               }
2412                          }
2413                          {
2414                             Evas_Coord minx, miny;
2415                             sd->pan_func.min_get(sd->pan_obj, &minx, &miny);
2416                             if (y < miny)
2417                               y += (miny - y) *
2418                                  _elm_config->thumbscroll_border_friction;
2419                             else if (sd->child.h <= sd->h)
2420                               y += (sd->down.sy - y) *
2421                                  _elm_config->thumbscroll_border_friction;
2422                             else if ((sd->child.h - sd->h + miny) < y)
2423                               y += (sd->child.h - sd->h + miny - y) *
2424                                  _elm_config->thumbscroll_border_friction;
2425                             if (x < minx)
2426                               x += (minx - x) *
2427                                  _elm_config->thumbscroll_border_friction;
2428                             else if (sd->child.w <= sd->w)
2429                               x += (sd->down.sx - x) *
2430                                  _elm_config->thumbscroll_border_friction;
2431                             else if ((sd->child.w - sd->w + minx) < x)
2432                               x += (sd->child.w - sd->w + minx - x) *
2433                                  _elm_config->thumbscroll_border_friction;
2434                          }
2435
2436                        sd->down.hold_x = x;
2437                        sd->down.hold_y = y;
2438                        if (!sd->down.hold_animator)
2439                          sd->down.hold_animator =
2440                             ecore_animator_add(_smart_hold_animator, sd);
2441                        //                       printf("a %i %i\n", sd->down.hold_x, sd->down.hold_y);
2442                        //                       _smart_onhold_animator(sd);
2443                        //                       elm_smart_scroller_child_pos_set(sd->smart_obj, x, y);
2444                     }
2445                   else
2446                     {
2447                        if (sd->down.dragged_began)
2448                          {
2449                             ev->event_flags |= EVAS_EVENT_FLAG_ON_HOLD;
2450                             if (!sd->down.hold)
2451                               {
2452                                  sd->down.hold = EINA_TRUE;
2453                                  evas_event_feed_hold(e, 1, ev->timestamp, ev->data);
2454                               }
2455                          }
2456                     }
2457                }
2458              else if (!sd->freeze)
2459                {
2460                   Evas_Coord ex, ey, ew, eh;
2461                   double vx = 0.0, vy = 0.0;
2462
2463                   evas_object_geometry_get(sd->event_obj, &ex, &ey, &ew, &eh);
2464                   x = ev->cur.canvas.x - ex;
2465                   y = ev->cur.canvas.y - ey;
2466                   if (x < _elm_config->thumbscroll_threshold)
2467                     {
2468                        if (_elm_config->thumbscroll_threshold > 0.0)
2469                          vx = -(double)(_elm_config->thumbscroll_threshold - x) /
2470                             _elm_config->thumbscroll_threshold;
2471                        else
2472                          vx = -1.0;
2473                     }
2474                   else if (x > (ew - _elm_config->thumbscroll_threshold))
2475                     {
2476                        if (_elm_config->thumbscroll_threshold > 0.0)
2477                          vx = (double)(_elm_config->thumbscroll_threshold - (ew - x)) /
2478                             _elm_config->thumbscroll_threshold;
2479                        else
2480                          vx = 1.0;
2481                     }
2482                   if (y < _elm_config->thumbscroll_threshold)
2483                     {
2484                        if (_elm_config->thumbscroll_threshold > 0.0)
2485                          vy = -(double)(_elm_config->thumbscroll_threshold - y) /
2486                             _elm_config->thumbscroll_threshold;
2487                        else
2488                          vy = -1.0;
2489                     }
2490                   else if (y > (eh - _elm_config->thumbscroll_threshold))
2491                     {
2492                        if (_elm_config->thumbscroll_threshold > 0.0)
2493                          vy = (double)(_elm_config->thumbscroll_threshold - (eh - y)) /
2494                             _elm_config->thumbscroll_threshold;
2495                        else
2496                          vy = 1.0;
2497                     }
2498                   if ((vx != 0.0) || (vy != 0.0))
2499                     {
2500                        sd->down.onhold_vx = vx;
2501                        sd->down.onhold_vy = vy;
2502                        if (!sd->down.onhold_animator)
2503                          {
2504                             sd->down.onhold_vxe = 0.0;
2505                             sd->down.onhold_vye = 0.0;
2506                             sd->down.onhold_tlast = 0.0;
2507                             sd->down.onhold_animator = ecore_animator_add(_smart_onhold_animator, sd);
2508                          }
2509                        //                       printf("b %i %i\n", sd->down.hold_x, sd->down.hold_y);
2510                     }
2511                   else
2512                     {
2513                        if (sd->down.onhold_animator)
2514                          {
2515                             ecore_animator_del(sd->down.onhold_animator);
2516                             sd->down.onhold_animator = NULL;
2517                             if (sd->child.resized)
2518                               _elm_smart_scroller_wanted_region_set(sd->smart_obj);
2519                          }
2520                     }
2521                }
2522           }
2523      }
2524 }
2525
2526 static void
2527 _smart_scrollbar_read(Smart_Data *sd)
2528 {
2529    Evas_Coord x, y, mx = 0, my = 0, px, py, minx = 0, miny = 0;
2530    double vx, vy;
2531
2532    if ((sd->down.dragged) || (sd->down.bounce_x_animator)
2533        || (sd->down.bounce_y_animator) || (sd->down.momentum_animator)
2534        || (sd->scrollto.x.animator) || (sd->scrollto.y.animator))
2535      return;
2536    edje_object_part_drag_value_get(sd->edje_obj, "elm.dragable.vbar", NULL, &vy);
2537    edje_object_part_drag_value_get(sd->edje_obj, "elm.dragable.hbar", &vx, NULL);
2538    sd->pan_func.max_get(sd->pan_obj, &mx, &my);
2539    sd->pan_func.min_get(sd->pan_obj, &minx, &miny);
2540    x = vx * (double)mx + minx;
2541    y = vy * (double)my + miny;
2542    sd->pan_func.get(sd->pan_obj, &px, &py);
2543    sd->pan_func.set(sd->pan_obj, x, y);
2544    if ((px != x) || (py != y))
2545      edje_object_signal_emit(sd->edje_obj, "elm,action,scroll", "elm");
2546 }
2547
2548 static void
2549 _smart_scrollbar_reset(Smart_Data *sd)
2550 {
2551    Evas_Coord px = 0, py = 0, minx = 0, miny = 0;
2552
2553    edje_object_part_drag_value_set(sd->edje_obj, "elm.dragable.vbar", 0.0, 0.0);
2554    edje_object_part_drag_value_set(sd->edje_obj, "elm.dragable.hbar", 0.0, 0.0);
2555    if ((!sd->child_obj) && (!sd->extern_pan))
2556      {
2557         edje_object_part_drag_size_set(sd->edje_obj, "elm.dragable.vbar", 1.0, 1.0);
2558         edje_object_part_drag_size_set(sd->edje_obj, "elm.dragable.hbar", 1.0, 1.0);
2559      }
2560    if (sd->pan_obj)
2561      {
2562         sd->pan_func.min_get(sd->pan_obj, &minx, &miny);
2563         sd->pan_func.get(sd->pan_obj, &px, &py);
2564         sd->pan_func.set(sd->pan_obj, minx, miny);
2565      }
2566    if ((px != minx) || (py != miny))
2567      edje_object_signal_emit(sd->edje_obj, "elm,action,scroll", "elm");
2568 }
2569
2570 static int
2571 _smart_scrollbar_bar_v_visibility_adjust(Smart_Data *sd)
2572 {
2573    int scroll_v_vis_change = 0;
2574    Evas_Coord h, vw = 0, vh = 0;
2575
2576    h = sd->child.h;
2577    if (sd->pan_obj)
2578      evas_object_geometry_get(sd->pan_obj, NULL, NULL, &vw, &vh);
2579    if (sd->vbar_visible)
2580      {
2581         if (sd->vbar_flags == ELM_SMART_SCROLLER_POLICY_AUTO)
2582           {
2583              if ((sd->child_obj) || (sd->extern_pan))
2584                {
2585                   if (h <= vh)
2586                     {
2587                        scroll_v_vis_change = 1;
2588                        sd->vbar_visible = EINA_FALSE;
2589                     }
2590                }
2591              else
2592                {
2593                   scroll_v_vis_change = 1;
2594                   sd->vbar_visible = EINA_FALSE;
2595                }
2596           }
2597         else if (sd->vbar_flags == ELM_SMART_SCROLLER_POLICY_OFF)
2598           {
2599              scroll_v_vis_change = 1;
2600              sd->vbar_visible = EINA_FALSE;
2601           }
2602      }
2603    else
2604      {
2605         if (sd->vbar_flags == ELM_SMART_SCROLLER_POLICY_AUTO)
2606           {
2607              if ((sd->child_obj) || (sd->extern_pan))
2608                {
2609                   if (h > vh)
2610                     {
2611                        scroll_v_vis_change = 1;
2612                        sd->vbar_visible = EINA_TRUE;
2613                     }
2614                }
2615           }
2616         else if (sd->vbar_flags == ELM_SMART_SCROLLER_POLICY_ON)
2617           {
2618              scroll_v_vis_change = 1;
2619              sd->vbar_visible = EINA_TRUE;
2620           }
2621      }
2622    if (scroll_v_vis_change)
2623      {
2624         if (sd->vbar_flags != ELM_SMART_SCROLLER_POLICY_OFF)
2625           {
2626              if (sd->vbar_visible)
2627                edje_object_signal_emit(sd->edje_obj, "elm,action,show,vbar", "elm");
2628              else
2629                edje_object_signal_emit(sd->edje_obj, "elm,action,hide,vbar", "elm");
2630              edje_object_message_signal_process(sd->edje_obj);
2631              _smart_scrollbar_size_adjust(sd);
2632           }
2633         else
2634           edje_object_signal_emit(sd->edje_obj, "elm,action,hide,vbar", "elm");
2635      }
2636    return scroll_v_vis_change;
2637 }
2638
2639 static int
2640 _smart_scrollbar_bar_h_visibility_adjust(Smart_Data *sd)
2641 {
2642    int scroll_h_vis_change = 0;
2643    Evas_Coord w, vw = 0, vh = 0;
2644
2645    w = sd->child.w;
2646    if (sd->pan_obj)
2647      evas_object_geometry_get(sd->pan_obj, NULL, NULL, &vw, &vh);
2648    if (sd->hbar_visible)
2649      {
2650         if (sd->hbar_flags == ELM_SMART_SCROLLER_POLICY_AUTO)
2651           {
2652              if ((sd->child_obj) || (sd->extern_pan))
2653                {
2654                   if (w <= vw)
2655                     {
2656                        scroll_h_vis_change = 1;
2657                        sd->hbar_visible = EINA_FALSE;
2658                     }
2659                }
2660              else
2661                {
2662                   scroll_h_vis_change = 1;
2663                   sd->hbar_visible = EINA_FALSE;
2664                }
2665           }
2666         else if (sd->hbar_flags == ELM_SMART_SCROLLER_POLICY_OFF)
2667           {
2668              scroll_h_vis_change = 1;
2669              sd->hbar_visible = EINA_FALSE;
2670           }
2671      }
2672    else
2673      {
2674         if (sd->hbar_flags == ELM_SMART_SCROLLER_POLICY_AUTO)
2675           {
2676              if ((sd->child_obj) || (sd->extern_pan))
2677                {
2678                   if (w > vw)
2679                     {
2680                        scroll_h_vis_change = 1;
2681                        sd->hbar_visible = EINA_TRUE;
2682                     }
2683                }
2684           }
2685         else if (sd->hbar_flags == ELM_SMART_SCROLLER_POLICY_ON)
2686           {
2687              scroll_h_vis_change = 1;
2688              sd->hbar_visible = EINA_TRUE;
2689           }
2690      }
2691    if (scroll_h_vis_change)
2692      {
2693         if (sd->hbar_flags != ELM_SMART_SCROLLER_POLICY_OFF)
2694           {
2695              if (sd->hbar_visible)
2696                edje_object_signal_emit(sd->edje_obj, "elm,action,show,hbar", "elm");
2697              else
2698                edje_object_signal_emit(sd->edje_obj, "elm,action,hide,hbar", "elm");
2699              edje_object_message_signal_process(sd->edje_obj);
2700              _smart_scrollbar_size_adjust(sd);
2701           }
2702         else
2703           edje_object_signal_emit(sd->edje_obj, "elm,action,hide,hbar", "elm");
2704         _smart_scrollbar_size_adjust(sd);
2705      }
2706    return scroll_h_vis_change;
2707 }
2708
2709 static void
2710 _smart_scrollbar_bar_visibility_adjust(Smart_Data *sd)
2711 {
2712    int changed = 0;
2713
2714    changed |= _smart_scrollbar_bar_h_visibility_adjust(sd);
2715    changed |= _smart_scrollbar_bar_v_visibility_adjust(sd);
2716    if (changed)
2717      {
2718         _smart_scrollbar_bar_h_visibility_adjust(sd);
2719         _smart_scrollbar_bar_v_visibility_adjust(sd);
2720      }
2721 }
2722
2723 static void
2724 _smart_scrollbar_size_adjust(Smart_Data *sd)
2725 {
2726    if ((sd->child_obj) || (sd->extern_pan))
2727      {
2728         Evas_Coord x, y, w, h, mx = 0, my = 0, vw = 0, vh = 0, px, py, minx = 0, miny = 0;
2729         double vx, vy, size;
2730
2731         edje_object_part_geometry_get(sd->edje_obj, "elm.swallow.content",
2732                                       NULL, NULL, &vw, &vh);
2733         w = sd->child.w;
2734         if (w < 1) w = 1;
2735         size = (double)vw / (double)w;
2736         if (size > 1.0)
2737           {
2738              size = 1.0;
2739              edje_object_part_drag_value_set(sd->edje_obj, "elm.dragable.hbar", 0.0, 0.0);
2740           }
2741         edje_object_part_drag_size_set(sd->edje_obj, "elm.dragable.hbar", size, 1.0);
2742
2743         h = sd->child.h;
2744         if (h < 1) h = 1;
2745         size = (double)vh / (double)h;
2746         if (size > 1.0)
2747           {
2748              size = 1.0;
2749              edje_object_part_drag_value_set(sd->edje_obj, "elm.dragable.vbar", 0.0, 0.0);
2750           }
2751         edje_object_part_drag_size_set(sd->edje_obj, "elm.dragable.vbar", 1.0, size);
2752
2753         edje_object_part_drag_value_get(sd->edje_obj, "elm.dragable.hbar", &vx, NULL);
2754         edje_object_part_drag_value_get(sd->edje_obj, "elm.dragable.vbar", NULL, &vy);
2755         sd->pan_func.max_get(sd->pan_obj, &mx, &my);
2756         sd->pan_func.min_get(sd->pan_obj, &minx, &miny);
2757         x = vx * mx + minx;
2758         y = vy * my + miny;
2759
2760         edje_object_part_drag_step_set(sd->edje_obj, "elm.dragable.hbar", (double)sd->step.x / (double)w, 0.0);
2761         edje_object_part_drag_step_set(sd->edje_obj, "elm.dragable.vbar", 0.0, (double)sd->step.y / (double)h);
2762         if (sd->page.x > 0)
2763           edje_object_part_drag_page_set(sd->edje_obj, "elm.dragable.hbar", (double)sd->page.x / (double)w, 0.0);
2764         else
2765           edje_object_part_drag_page_set(sd->edje_obj, "elm.dragable.hbar", -((double)sd->page.x * ((double)vw / (double)w)) / 100.0, 0.0);
2766         if (sd->page.y > 0)
2767           edje_object_part_drag_page_set(sd->edje_obj, "elm.dragable.vbar", 0.0, (double)sd->page.y / (double)h);
2768         else
2769           edje_object_part_drag_page_set(sd->edje_obj, "elm.dragable.vbar", 0.0, -((double)sd->page.y * ((double)vh / (double)h)) / 100.0);
2770
2771         sd->pan_func.get(sd->pan_obj, &px, &py);
2772         if (vx != mx) x = px;
2773         if (vy != my) y = py;
2774         sd->pan_func.set(sd->pan_obj, x, y);
2775         //      if ((px != 0) || (py != 0))
2776         //        edje_object_signal_emit(sd->edje_obj, "elm,action,scroll", "elm");
2777      }
2778    else
2779      {
2780         Evas_Coord px = 0, py = 0, minx = 0, miny = 0;
2781
2782         edje_object_part_drag_size_set(sd->edje_obj, "elm.dragable.vbar", 1.0, 1.0);
2783         edje_object_part_drag_size_set(sd->edje_obj, "elm.dragable.hbar", 1.0, 1.0);
2784         sd->pan_func.min_get(sd->pan_obj, &minx, &miny);
2785         sd->pan_func.get(sd->pan_obj, &px, &py);
2786         sd->pan_func.set(sd->pan_obj, minx, miny);
2787         if ((px != minx) || (py != miny))
2788           edje_object_signal_emit(sd->edje_obj, "elm,action,scroll", "elm");
2789      }
2790    _smart_scrollbar_bar_visibility_adjust(sd);
2791 }
2792
2793 static void
2794 _smart_reconfigure(Smart_Data *sd)
2795 {
2796    evas_object_move(sd->edje_obj, sd->x, sd->y);
2797    evas_object_resize(sd->edje_obj, sd->w, sd->h);
2798    evas_object_move(sd->event_obj, sd->x, sd->y);
2799    evas_object_resize(sd->event_obj, sd->w, sd->h);
2800    _smart_scrollbar_size_adjust(sd);
2801    _smart_page_adjust(sd);
2802 }
2803
2804 static void
2805 _smart_add(Evas_Object *obj)
2806 {
2807    Smart_Data *sd;
2808    Evas_Object *o;
2809
2810    sd = calloc(1, sizeof(Smart_Data));
2811    if (!sd) return;
2812    evas_object_smart_data_set(obj, sd);
2813
2814    sd->smart_obj = obj;
2815    sd->x = 0;
2816    sd->y = 0;
2817    sd->w = 0;
2818    sd->h = 0;
2819    sd->step.x = 32;
2820    sd->step.y = 32;
2821    sd->page.x = -50;
2822    sd->page.y = -50;
2823    sd->hbar_flags = ELM_SMART_SCROLLER_POLICY_AUTO;
2824    sd->vbar_flags = ELM_SMART_SCROLLER_POLICY_AUTO;
2825    sd->hbar_visible = EINA_TRUE;
2826    sd->vbar_visible = EINA_TRUE;
2827
2828    sd->bounce_horiz = EINA_TRUE;
2829    sd->bounce_vert = EINA_TRUE;
2830
2831    sd->one_dir_at_a_time = EINA_TRUE;
2832    sd->momentum_animator_disabled = EINA_FALSE;
2833    sd->bounce_animator_disabled = EINA_FALSE;
2834
2835    o = edje_object_add(evas_object_evas_get(obj));
2836    evas_object_propagate_events_set(o, 0);
2837    sd->edje_obj = o;
2838    elm_smart_scroller_object_theme_set(NULL, obj, "scroller", "base", "default");
2839    edje_object_signal_callback_add(o, "drag", "elm.dragable.vbar", _smart_edje_drag_v, sd);
2840    edje_object_signal_callback_add(o, "drag,set", "elm.dragable.vbar", _smart_edje_drag_v, sd);
2841    edje_object_signal_callback_add(o, "drag,start", "elm.dragable.vbar", _smart_edje_drag_v_start, sd);
2842    edje_object_signal_callback_add(o, "drag,stop", "elm.dragable.vbar", _smart_edje_drag_v_stop, sd);
2843    edje_object_signal_callback_add(o, "drag,step", "elm.dragable.vbar", _smart_edje_drag_v, sd);
2844    edje_object_signal_callback_add(o, "drag,page", "elm.dragable.vbar", _smart_edje_drag_v, sd);
2845    edje_object_signal_callback_add(o, "drag", "elm.dragable.hbar", _smart_edje_drag_h, sd);
2846    edje_object_signal_callback_add(o, "drag,set", "elm.dragable.hbar", _smart_edje_drag_h, sd);
2847    edje_object_signal_callback_add(o, "drag,start", "elm.dragable.hbar", _smart_edje_drag_h_start, sd);
2848    edje_object_signal_callback_add(o, "drag,stop", "elm.dragable.hbar", _smart_edje_drag_h_stop, sd);
2849    edje_object_signal_callback_add(o, "drag,step", "elm.dragable.hbar", _smart_edje_drag_h, sd);
2850    edje_object_signal_callback_add(o, "drag,page", "elm.dragable.hbar", _smart_edje_drag_h, sd);
2851    evas_object_smart_member_add(o, obj);
2852
2853    o = evas_object_rectangle_add(evas_object_evas_get(obj));
2854    sd->event_obj = o;
2855    evas_object_color_set(o, 0, 0, 0, 0);
2856    evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_WHEEL, _smart_event_wheel, sd);
2857    evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_DOWN, _smart_event_mouse_down, sd);
2858    evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_UP, _smart_event_mouse_up, sd);
2859    evas_object_event_callback_add(o, EVAS_CALLBACK_MOUSE_MOVE, _smart_event_mouse_move, sd);
2860    evas_object_smart_member_add(o, obj);
2861    evas_object_repeat_events_set(o, 1);
2862
2863    sd->pan_func.set = _elm_smart_pan_set;
2864    sd->pan_func.get = _elm_smart_pan_get;
2865    sd->pan_func.max_get = _elm_smart_pan_max_get;
2866    sd->pan_func.min_get = _elm_smart_pan_min_get;
2867    sd->pan_func.child_size_get = _elm_smart_pan_child_size_get;
2868
2869    _smart_scrollbar_reset(sd);
2870 }
2871
2872 static void
2873 _smart_del(Evas_Object *obj)
2874 {
2875    INTERNAL_ENTRY;
2876    elm_smart_scroller_child_set(obj, NULL);
2877    if (!sd->extern_pan) evas_object_del(sd->pan_obj);
2878    evas_object_del(sd->edje_obj);
2879    evas_object_del(sd->event_obj);
2880    if (sd->down.hold_animator) ecore_animator_del(sd->down.hold_animator);
2881    if (sd->down.onhold_animator) ecore_animator_del(sd->down.onhold_animator);
2882    if (sd->down.momentum_animator) ecore_animator_del(sd->down.momentum_animator);
2883    if (sd->down.bounce_x_animator) ecore_animator_del(sd->down.bounce_x_animator);
2884    if (sd->down.bounce_y_animator) ecore_animator_del(sd->down.bounce_y_animator);
2885    if (sd->scrollto.x.animator) ecore_animator_del(sd->scrollto.x.animator);
2886    if (sd->scrollto.y.animator) ecore_animator_del(sd->scrollto.y.animator);
2887    free(sd);
2888    evas_object_smart_data_set(obj, NULL);
2889 }
2890
2891 static void
2892 _smart_move(Evas_Object *obj, Evas_Coord x, Evas_Coord y)
2893 {
2894    INTERNAL_ENTRY;
2895    sd->x = x;
2896    sd->y = y;
2897    _smart_reconfigure(sd);
2898 }
2899
2900 static void
2901 _smart_resize(Evas_Object *obj, Evas_Coord w, Evas_Coord h)
2902 {
2903    INTERNAL_ENTRY;
2904    sd->w = w;
2905    sd->h = h;
2906    _smart_reconfigure(sd);
2907    _elm_smart_scroller_wanted_region_set(obj);
2908 }
2909
2910 static void
2911 _smart_show(Evas_Object *obj)
2912 {
2913    INTERNAL_ENTRY;
2914    evas_object_show(sd->edje_obj);
2915    evas_object_show(sd->event_obj);
2916 }
2917
2918 static void
2919 _smart_hide(Evas_Object *obj)
2920 {
2921    INTERNAL_ENTRY;
2922    evas_object_hide(sd->edje_obj);
2923    evas_object_hide(sd->event_obj);
2924 }
2925
2926 static void
2927 _smart_color_set(Evas_Object *obj, int r, int g, int b, int a)
2928 {
2929    INTERNAL_ENTRY;
2930    evas_object_color_set(sd->edje_obj, r, g, b, a);
2931 }
2932
2933 static void
2934 _smart_clip_set(Evas_Object *obj, Evas_Object *clip)
2935 {
2936    INTERNAL_ENTRY;
2937    evas_object_clip_set(sd->edje_obj, clip);
2938    evas_object_clip_set(sd->event_obj, clip);
2939 }
2940
2941 static void
2942 _smart_clip_unset(Evas_Object *obj)
2943 {
2944    INTERNAL_ENTRY;
2945    evas_object_clip_unset(sd->edje_obj);
2946    evas_object_clip_unset(sd->event_obj);
2947 }
2948
2949 /* never need to touch this */
2950
2951 static void
2952 _smart_init(void)
2953 {
2954    if (_smart) return;
2955      {
2956         static const Evas_Smart_Class sc =
2957           {
2958              SMART_NAME,
2959              EVAS_SMART_CLASS_VERSION,
2960              _smart_add,
2961              _smart_del,
2962              _smart_move,
2963              _smart_resize,
2964              _smart_show,
2965              _smart_hide,
2966              _smart_color_set,
2967              _smart_clip_set,
2968              _smart_clip_unset,
2969              NULL,
2970              NULL,
2971              NULL,
2972              NULL,
2973              NULL,
2974              NULL,
2975              NULL
2976           };
2977         _smart = evas_smart_class_new(&sc);
2978      }
2979 }