summaryrefslogtreecommitdiff
path: root/efl/elementary/scroller.pxi
blob: e15d8aaf1b7f47dc1dff6e2ce78bfb7372c360fa (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
# Copyright (C) 2007-2015 various contributors (see AUTHORS)
#
# This file is part of Python-EFL.
#
# Python-EFL is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 3 of the License, or (at your option) any later version.
#
# Python-EFL is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this Python-EFL.  If not, see <http://www.gnu.org/licenses/>.
#

include "scroller_cdef.pxi"

cdef class Scrollable(Object):
    """Scrollable(..)

    An Elementary scrollable interface will handle an internal **panning**
    object. It has the function of clipping and moving the actual scrollable
    content around, by the command of the scrollable interface calls.

    If a widget supports the scrollable interface, you can inherit from the
    widget class and this class to allow access to the scroller of that widget.

    """

    def __init__(self, *args, **kwargs):
        if type(self) is Scrollable:
            raise TypeError("Must not instantiate Scrollable, but subclasses")

    @DEPRECATED("1.8", "Use :py:attr:`theme<efl.elementary.object.Object.theme>` instead.")
    def custom_widget_base_theme_set(self, widget, base):
        """custom_widget_base_theme_set(widget, base)

        """
        if isinstance(widget, unicode): widget = PyUnicode_AsUTF8String(widget)
        if isinstance(base, unicode): base = PyUnicode_AsUTF8String(base)
        elm_scroller_custom_widget_base_theme_set(self.obj,
            <const char *>widget if widget is not None else NULL,
            <const char *>base if base is not None else NULL)

    def content_min_limit(self, w, h):
        """Make the scroller minimum size limited to the minimum size of the
        content

        By default the scroller will be as small as its design allows,
        irrespective of its content. This will make the scroller minimum
        size the right size horizontally and/or vertically to perfectly fit
        its content in that direction.

        :param w: Enable limiting minimum size horizontally
        :type w: bool
        :param h: Enable limiting minimum size vertically
        :type h: bool

        """
        elm_scroller_content_min_limit(self.obj, w, h)

    def region_show(self, x, y, w, h):
        """Show a specific virtual region within the scroller content object

        This will ensure all (or part if it does not fit) of the designated
        region in the virtual content object (0, 0 starting at the top-left
        of the virtual content object) is shown within the scroller.

        :param x: X coordinate of the region
        :type x: Evas_Coord (int)
        :param y: Y coordinate of the region
        :type y: Evas_Coord (int)
        :param w: Width of the region
        :type w: Evas_Coord (int)
        :param h: Height of the region
        :type h: Evas_Coord (int)

        """
        elm_scroller_region_show(self.obj, x, y, w, h)

    property policy:
        """The scrollbar visibility policy

        This property reflects the scrollbar visibility policy for the given
        scroller. :attr:`ELM_SCROLLER_POLICY_AUTO` means the scrollbar is made
        visible if it is needed, and otherwise kept hidden.
        :attr:`ELM_SCROLLER_POLICY_ON` turns it on all the time, and
        :attr:`ELM_SCROLLER_POLICY_OFF` always keeps it off. This applies
        respectively for the horizontal and vertical scrollbars.

        :type: (:ref:`Elm_Scroller_Policy` **policy_h**, :ref:`Elm_Scroller_Policy` **policy_v**)

        """
        def __get__(self):
            cdef Elm_Scroller_Policy policy_h, policy_v
            elm_scroller_policy_get(self.obj, &policy_h, &policy_v)
            return (policy_h, policy_v)

        def __set__(self, value):
            cdef Elm_Scroller_Policy policy_h, policy_v
            policy_h, policy_v = value
            elm_scroller_policy_set(self.obj, policy_h, policy_v)

    def policy_set(self, policy_h, policy_v):
        elm_scroller_policy_set(self.obj, policy_h, policy_v)
    def policy_get(self):
        cdef Elm_Scroller_Policy policy_h, policy_v
        elm_scroller_policy_get(self.obj, &policy_h, &policy_v)
        return (policy_h, policy_v)

    property single_direction:
        """The type of single direction scroll

        :type: :ref:`Elm_Scroller_Single_Direction`

        .. versionadded:: 1.8

        """
        def __set__(self, Elm_Scroller_Single_Direction single_dir):
            elm_scroller_single_direction_set(self.obj, single_dir)

        def __get__(self):
            return elm_scroller_single_direction_get(self.obj)

    def single_direction_set(self, Elm_Scroller_Single_Direction single_dir):
        elm_scroller_single_direction_set(self.obj, single_dir)

    def single_direction_get(self):
        return elm_scroller_single_direction_get(self.obj)

    property region:
        """Get the currently visible content region

        This gets the current region in the content object that is visible
        through the scroller. The region co-ordinates are returned in the
        *x*, *y*, *w*, ``h`` values pointed to.

        .. note:: All coordinates are relative to the content.

        .. seealso:: :py:func:`region_show()`

        :type: tuple of Evas_Coord (int)

        """
        def __get__(self):
            cdef Evas_Coord x, y, w, h
            elm_scroller_region_get(self.obj, &x, &y, &w, &h)
            return (x, y, w, h)

    def region_get(self):
        cdef Evas_Coord x, y, w, h
        elm_scroller_region_get(self.obj, &x, &y, &w, &h)
        return (x, y, w, h)

    property child_size:
        """Get the size of the content object

        This gets the size of the content object of the scroller.

        :type: (int **w**, int **h**)

        """
        def __get__(self):
            cdef Evas_Coord w, h
            elm_scroller_child_size_get(self.obj, &w, &h)
            return (w, h)

    def child_size_get(self):
        cdef Evas_Coord w, h
        elm_scroller_child_size_get(self.obj, &w, &h)
        return (w, h)

    property page_snap:
        """

        Page snapping behavior of a scroller

        When scrolling, if a scroller is paged (see
        :attr:`page_size` and :attr:`page_relative`),
        the scroller may snap to pages when being scrolled, i.e., even if
        it had momentum to scroll further, it will stop at the next page
        boundaries. This is **disabled**, by default, for both axis. This
        function will set if it that is enabled or not, for each axis.

        .. note::

            If the object is not set to have pages, nothing will happen after
            this call.

        :type: (bool **page_h_snap**, bool **page_v_snap**)

        .. versionadded:: 1.8


        """
        def __set__(self, value):
            page_h_snap, page_v_snap = value
            elm_scroller_page_snap_set(self.obj, page_h_snap, page_v_snap)

        def __get__(self):
            cdef Eina_Bool page_h_snap, page_v_snap
            elm_scroller_page_snap_get(self.obj, &page_h_snap, &page_v_snap)
            return page_h_snap, page_v_snap

    property bounce:
        """The bouncing behavior

        When scrolling, the scroller may "bounce" when reaching an edge of
        the content object. This is a visual way to indicate the end has
        been reached. This is enabled by default for both axis. This API
        will set if it is enabled for the given axis with the boolean
        parameters for each axis.

        :type: (bool **h**, bool **v**)

        """
        def __get__(self):
            cdef Eina_Bool h, v
            elm_scroller_bounce_get(self.obj, &h, &v)
            return (h, v)

        def __set__(self, value):
            cdef Eina_Bool h, v
            h, v = value
            elm_scroller_bounce_set(self.obj, h, v)

    def bounce_set(self, h, v):
        elm_scroller_bounce_set(self.obj, h, v)
    def bounce_get(self):
        cdef Eina_Bool h, v
        elm_scroller_bounce_get(self.obj, &h, &v)
        return (h, v)

    property page_relative:
        """Set scroll page size relative to viewport size.

        The scroller is capable of limiting scrolling by the user to
        "pages". That is to jump by and only show a "whole page" at a time
        as if the continuous area of the scroller content is split into page
        sized pieces. This sets the size of a page relative to the viewport
        of the scroller. 1.0 is "one viewport" in size (horizontally or
        vertically). 0.0 turns it off in that axis. This is mutually
        exclusive with page size (see :py:attr:`page_size` for more
        information). Likewise 0.5 is "half a viewport". Sane usable values
        are normally between 0.0 and 1.0 including 1.0. If you only want a
        single axis to be page "limited", use 0.0 for the other axis.

        :type: (float **h_pagerel**, float **v_pagerel**)

        """
        def __set__(self, value):
            h_pagerel, v_pagerel = value
            elm_scroller_page_relative_set(self.obj, h_pagerel, v_pagerel)

        def __get__(self):
            cdef double h_pagerel, v_pagerel
            elm_scroller_page_relative_get(self.obj, &h_pagerel, &v_pagerel)
            return (h_pagerel, v_pagerel)

    def page_relative_set(self, h_pagerel, v_pagerel):
        elm_scroller_page_relative_set(self.obj, h_pagerel, v_pagerel)

    def page_relative_get(self):
        cdef double h_pagerel, v_pagerel
        elm_scroller_page_relative_get(self.obj, &h_pagerel, &v_pagerel)
        return (h_pagerel, v_pagerel)

    property page_size:
        """Scroller widget's current page size.

        An absolute fixed value, with 0 turning it off for that axis.

        .. seealso:: :attr:`page_relative`

        :type: (int **h_pagesize**, int **v_pagesize**)

        .. versionadded:: 1.8
            Getter for this property

        """
        def __set__(self, value):
            h_pagesize, v_pagesize = value
            elm_scroller_page_size_set(self.obj, h_pagesize, v_pagesize)

        def __get__(self):
            cdef int h_pagesize, v_pagesize
            elm_scroller_page_size_get(self.obj, &h_pagesize,  &v_pagesize)
            return (h_pagesize, v_pagesize)

    def page_size_set(self, h_pagesize, v_pagesize):
        elm_scroller_page_size_set(self.obj, h_pagesize, v_pagesize)

    def page_size_get(self):
        cdef int h_pagesize, v_pagesize
        elm_scroller_page_size_get(self.obj, &h_pagesize,  &v_pagesize)
        return (h_pagesize, v_pagesize)

    property step_size:
        """The step size to move scroller by key event.

        :type: (int **x**, int **y**)

        .. versionadded:: 1.13

        """
        def __set__(self, value):
            x, y = value
            elm_scroller_step_size_set(self.obj, x, y)

        def __get__(self):
            cdef int x, y
            elm_scroller_step_size_get(self.obj, &x,  &y)
            return (x, y)

    def step_size_set(self, x, y):
        elm_scroller_step_size_set(self.obj, x, y)

    def step_size_get(self):
        cdef int x, y
        elm_scroller_step_size_get(self.obj, &x,  &y)
        return (x, y)

    property page_scroll_limit:
        """The maximum of the movable page at a flicking.

        The value of maximum movable page should be more than 1.

        :type: (int **page_limit_h**, int **page_limit_v**)

        .. versionadded:: 1.8

        """
        def __set__(self, value):
            page_limit_h, page_limit_v = value
            elm_scroller_page_scroll_limit_set(self.obj, page_limit_h, page_limit_v)

        def __get__(self):
            cdef int page_limit_h, page_limit_v
            elm_scroller_page_scroll_limit_get(self.obj, &page_limit_h, &page_limit_v)
            return (page_limit_h, page_limit_v)

    def page_scroll_limit_set(self, int page_limit_h, int page_limit_v):
        elm_scroller_page_scroll_limit_set(self.obj, page_limit_h, page_limit_v)

    def page_scroll_limit_get(self):
        cdef int page_limit_h, page_limit_v
        elm_scroller_page_scroll_limit_get(self.obj, &page_limit_h, &page_limit_v)
        return (page_limit_h, page_limit_v)

    property current_page:
        """Get scroll current page number.

        The page number starts from 0. 0 is the first page. Current page
        means the page which meets the top-left of the viewport. If there
        are two or more pages in the viewport, it returns the number of the
        page which meets the top-left of the viewport.

        .. seealso::
            :py:attr:`last_page`
            :py:func:`page_show()`
            :py:func:`page_bring_in()`

        :type: (int **h_pagenumber**, int **v_pagenumber**)

        """
        def __get__(self):
            cdef int h_pagenumber, v_pagenumber
            elm_scroller_current_page_get(self.obj, &h_pagenumber, &v_pagenumber)
            return (h_pagenumber, v_pagenumber)

    def current_page_get(self):
        cdef int h_pagenumber, v_pagenumber
        elm_scroller_current_page_get(self.obj, &h_pagenumber, &v_pagenumber)
        return (h_pagenumber, v_pagenumber)

    property last_page:
        """Get scroll last page number.

        The page number starts from 0. 0 is the first page.
        This returns the last page number among the pages.

        .. seealso::
            :py:attr:`current_page`
            :py:func:`page_show()`
            :py:func:`page_bring_in()`

        :type: (int **h_pagenumber**, int **v_pagenumber**)

        """
        def __get__(self):
            cdef int h_pagenumber, v_pagenumber
            elm_scroller_last_page_get(self.obj, &h_pagenumber, &v_pagenumber)
            return (h_pagenumber, v_pagenumber)

    def last_page_get(self):
        cdef int h_pagenumber, v_pagenumber
        elm_scroller_last_page_get(self.obj, &h_pagenumber, &v_pagenumber)
        return (h_pagenumber, v_pagenumber)

    def page_show(self, h_pagenumber, v_pagenumber):
        """Show a specific virtual region within the scroller content object
        by page number.

        0, 0 of the indicated page is located at the top-left of the viewport.
        This will jump to the page directly without animation.

        Example of usage::

            sc = Scroller(win)
            sc.content = content
            sc.page_relative = (1, 0)
            h_page, v_page = sc.current_page
            sc.page_show(h_page + 1, v_page)

        .. seealso:: :py:func:`page_bring_in()`

        :param h_pagenumber: The horizontal page number
        :type h_pagenumber: int
        :param v_pagenumber: The vertical page number
        :type v_pagenumber: int

        """
        elm_scroller_page_show(self.obj, h_pagenumber, v_pagenumber)

    def page_bring_in(self, h_pagenumber, v_pagenumber):
        """Show a specific virtual region within the scroller content object by page number.

        0, 0 of the indicated page is located at the top-left of the viewport.
        This will slide to the page with animation.

        Example of usage::

            sc = Scroller(win)
            sc.content = content
            sc.page_relative = (1, 0)
            h_page, v_page = sc.last_page
            sc.page_bring_in(h_page, v_page)

        .. seealso:: :py:func:`page_show()`

        :param h_pagenumber: The horizontal page number
        :type h_pagenumber: int
        :param v_pagenumber: The vertical page number
        :type v_pagenumber: int

        """
        elm_scroller_page_bring_in(self.obj, h_pagenumber, v_pagenumber)

    def region_bring_in(self, x, y, w, h):
        """Show a specific virtual region within the scroller content object.

        This will ensure all (or part if it does not fit) of the designated
        region in the virtual content object (0, 0 starting at the top-left of the
        virtual content object) is shown within the scroller. Unlike
        elm_scroller_region_show(), this allow the scroller to "smoothly slide"
        to this location (if configuration in general calls for transitions). It
        may not jump immediately to the new location and make take a while and
        show other content along the way.

        .. seealso:: :py:func:`region_show()`

        :param x: X coordinate of the region
        :type x: Evas_Coord (int)
        :param y: Y coordinate of the region
        :type y: Evas_Coord (int)
        :param w: Width of the region
        :type w: Evas_Coord (int)
        :param h: Height of the region
        :type h: Evas_Coord (int)

        """
        elm_scroller_region_bring_in(self.obj, x, y, w, h)

    property propagate_events:
        """Event propagation for a scroller

        This enables or disables event propagation from the scroller content
        to the scroller and its parent. By default event propagation is
        disabled.

        :type: bool

        """
        def __get__(self):
            return bool(elm_scroller_propagate_events_get(self.obj))

        def __set__(self, propagation):
            elm_scroller_propagate_events_set(self.obj, propagation)

    def propagate_events_set(self, propagation):
        elm_scroller_propagate_events_set(self.obj, propagation)
    def propagate_events_get(self):
        return bool(elm_scroller_propagate_events_get(self.obj))

    property wheel_disabled:
        """Enable or disable mouse wheel to be used to scroll the scroller.
        
        Mouse wheel can be used to scroll up and down the scroller.
        Wheel is enabled by default.

        :type: bool
        
        .. versionadded:: 1.15

        """
        def __get__(self):
            return bool(elm_scroller_wheel_disabled_get(self.obj))

        def __set__(self, disabled):
            elm_scroller_wheel_disabled_set(self.obj, disabled)

    def wheel_disabled_set(self, disabled):
        elm_scroller_wheel_disabled_set(self.obj, disabled)
    def wheel_disabled_get(self):
        return bool(elm_scroller_wheel_disabled_get(self.obj))

    property gravity:
        """Scrolling gravity on a scroller

        The gravity, defines how the scroller will adjust its view when the
        size of the scroller contents increase.

        The scroller will adjust the view to glue itself as follows:

        ``x=0.0``, for showing the left most region of the content.
        ``x=1.0``, for showing the right most region of the content.
        ``y=0.0``, for showing the bottom most region of the content.
        ``y=1.0``, for showing the top most region of the content.

        Default values for x and y are 0.0

        :type: (float **x**, float **y**)

        """
        def __get__(self):
            cdef double x, y
            elm_scroller_gravity_get(self.obj, &x, &y)
            return (x, y)

        def __set__(self, value):
            x, y = value
            elm_scroller_gravity_set(self.obj, x, y)

    def gravity_set(self, x, y):
        elm_scroller_gravity_set(self.obj, x, y)
    def gravity_get(self):
        cdef double x, y
        elm_scroller_gravity_get(self.obj, &x, &y)
        return (x, y)

    property movement_block:
        """

        Blocking of scrolling (per axis) on a given scroller

        This function will block scrolling movement (by input of a user) in
        a given direction. One can disable movements in the X axis, the Y
        axis or both. The default value is :attr:`ELM_SCROLLER_MOVEMENT_NO_BLOCK`,
        where movements are allowed in both directions.

        What makes this function different from
        :meth:`~efl.elementary.object.Object.scroll_freeze_push`,
        :meth:`~efl.elementary.object.Object.scroll_hold_push` and
        :meth:`~efl.elementary.object.Object.scroll_lock_x_set`
        (or :meth:`~efl.elementary.object.Object.scroll_lock_x_set`)
        is that it **doesn't** propagate its effects to any parent or child
        widget of the object. Only the target scrollable widget will be locked
        with regard to scrolling.

        :type: :ref:`Elm_Scroller_Movement_Block`

        .. versionadded:: 1.8

        """
        def __set__(self, Elm_Scroller_Movement_Block block):
            elm_scroller_movement_block_set(self.obj, block)

        def __get__(self):
            return elm_scroller_movement_block_get(self.obj)

    property loop:
        """

        Set an infinite loop for the scroller

        :type: (bool **h**, bool **v**)

        .. versionadded:: 1.14

        """
        def __set__(self, value):
            h, v = value
            elm_scroller_loop_set(self.obj, h, v)

        def __get__(self):
            cdef Eina_Bool h, v
            elm_scroller_loop_get(self.obj, &h, &v)
            return (h, v)

    def loop_set(self, h, v):
        elm_scroller_loop_set(self.obj, h, v)
    def loop_get(self):
        cdef Eina_Bool h, v
        elm_scroller_loop_get(self.obj, &h, &v)
        return (h, v)

    def callback_edge_left_add(self, func, *args, **kwargs):
        """The left edge of the content has been reached."""
        self._callback_add("edge,left", func, args, kwargs)

    def callback_edge_left_del(self, func):
        self._callback_del("edge,left", func)

    def callback_edge_right_add(self, func, *args, **kwargs):
        """The right edge of the content has been reached."""
        self._callback_add("edge,right", func, args, kwargs)

    def callback_edge_right_del(self, func):
        self._callback_del("edge,right", func)

    def callback_edge_top_add(self, func, *args, **kwargs):
        """The top edge of the content has been reached."""
        self._callback_add("edge,top", func, args, kwargs)

    def callback_edge_top_del(self, func):
        self._callback_del("edge,top", func)

    def callback_edge_bottom_add(self, func, *args, **kwargs):
        """The bottom edge of the content has been reached."""
        self._callback_add("edge,bottom", func, args, kwargs)

    def callback_edge_bottom_del(self, func):
        self._callback_del("edge,bottom", func)

    def callback_scroll_add(self, func, *args, **kwargs):
        """The content has been scrolled (moved)."""
        self._callback_add("scroll", func, args, kwargs)

    def callback_scroll_del(self, func):
        self._callback_del("scroll", func)

    def callback_scroll_left_add(self, func, *args, **kwargs):
        """the content has been scrolled (moved) leftwards"""
        self._callback_add("scroll,left", func, args, kwargs)

    def callback_scroll_left_del(self, func):
        self._callback_del("scroll,left", func)

    def callback_scroll_right_add(self, func, *args, **kwargs):
        """the content has been scrolled (moved) rightwards"""
        self._callback_add("scroll,right", func, args, kwargs)

    def callback_scroll_right_del(self, func):
        self._callback_del("scroll,right", func)

    def callback_scroll_up_add(self, func, *args, **kwargs):
        """the content has been scrolled (moved) upwards"""
        self._callback_add("scroll,up", func, args, kwargs)

    def callback_scroll_up_del(self, func):
        self._callback_del("scroll,up", func)

    def callback_scroll_down_add(self, func, *args, **kwargs):
        """the content has been scrolled (moved) downwards"""
        self._callback_add("scroll,down", func, args, kwargs)

    def callback_scroll_down_del(self, func):
        self._callback_del("scroll,down", func)


    def callback_scroll_anim_start_add(self, func, *args, **kwargs):
        """Scrolling animation has started."""
        self._callback_add("scroll,anim,start", func, args, kwargs)

    def callback_scroll_anim_start_del(self, func):
        self._callback_del("scroll,anim,start", func)

    def callback_scroll_anim_stop_add(self, func, *args, **kwargs):
        """Scrolling animation has stopped."""
        self._callback_add("scroll,anim,stop", func, args, kwargs)

    def callback_scroll_anim_stop_del(self, func):
        self._callback_del("scroll,anim,stop", func)

    def callback_scroll_drag_start_add(self, func, *args, **kwargs):
        """Dragging the contents around has started."""
        self._callback_add("scroll,drag,start", func, args, kwargs)

    def callback_scroll_drag_start_del(self, func):
        self._callback_del("scroll,drag,start", func)

    def callback_scroll_drag_stop_add(self, func, *args, **kwargs):
        """Dragging the contents around has stopped."""
        self._callback_add("scroll,drag,stop", func, args, kwargs)

    def callback_scroll_drag_stop_del(self, func):
        self._callback_del("scroll,drag,stop", func)

    def callback_vbar_drag_add(self, func, *args, **kwargs):
        """the vertical scroll bar has been dragged"""
        self._callback_add("vbar,drag", func, args, kwargs)

    def callback_vbar_drag_del(self, func):
        self._callback_del("vbar,drag", func)

    def callback_vbar_press_add(self, func, *args, **kwargs):
        """the vertical scroll bar has been pressed"""
        self._callback_add("vbar,press", func, args, kwargs)

    def callback_vbar_press_del(self, func):
        self._callback_del("vbar,press", func)

    def callback_vbar_unpress_add(self, func, *args, **kwargs):
        """the vertical scroll bar has been unpressed"""
        self._callback_add("vbar,unpress", func, args, kwargs)

    def callback_vbar_unpress_del(self, func):
        self._callback_del("vbar,unpress", func)

    def callback_hbar_drag_add(self, func, *args, **kwargs):
        """the horizontal scroll bar has been dragged"""
        self._callback_add("hbar,drag", func, args, kwargs)

    def callback_hbar_drag_del(self, func):
        self._callback_del("hbar,drag", func)

    def callback_hbar_press_add(self, func, *args, **kwargs):
        """the horizontal scroll bar has been pressed"""
        self._callback_add("hbar,press", func, args, kwargs)

    def callback_hbar_press_del(self, func):
        self._callback_del("hbar,press", func)

    def callback_hbar_unpress_add(self, func, *args, **kwargs):
        """the horizontal scroll bar has been unpressed"""
        self._callback_add("hbar,unpress", func, args, kwargs)

    def callback_hbar_unpress_del(self, func):
        self._callback_del("hbar,unpress", func)

    def callback_scroll_page_changed_add(self, func, *args, **kwargs):
        """the visible page has changed"""
        self._callback_add("scroll,page,changed", func, args, kwargs)

    def callback_scroll_page_changed_del(self, func):
        self._callback_del("scroll,page,changed", func)

    def callback_focused_add(self, func, *args, **kwargs):
        """When the scroller has received focus.

        .. versionadded:: 1.8
        """
        self._callback_add("focused", func, args, kwargs)

    def callback_focused_del(self, func):
        self._callback_del("focused", func)

    def callback_unfocused_add(self, func, *args, **kwargs):
        """When the scroller has lost focus.

        .. versionadded:: 1.8
        """
        self._callback_add("unfocused", func, args, kwargs)

    def callback_unfocused_del(self, func):
        self._callback_del("unfocused", func)


cdef class _ScrollerWidget(LayoutClass):
    def __init__(self, evasObject parent, *args, **kwargs):
        self._set_obj(elm_scroller_add(parent.obj))
        self._set_properties_from_keyword_args(kwargs)


class Scroller(Scrollable, _ScrollerWidget):
    """Scroller(..)

    This is the class that actually implement the widget.

    """
    def __init__(self, evasObject parent, *args, **kwargs):
        _ScrollerWidget.__init__(self, parent, *args, **kwargs)


_object_mapping_register("Elm_Scroller", Scroller)