767 lines
27 KiB
Cython
767 lines
27 KiB
Cython
# Copyright (C) 2007-2022 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):
|
|
"""
|
|
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)
|
|
|
|
|
|
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)
|