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