U Pe@sdZdZddlmZddlmZmZmZddlm Z ddl m Z m Z m Z mZmZmZmZmZddlmZmZmZmZmZmZddlmZdd lmZdd lmZdd l m!Z!dd l"m#Z#dd l$m%Z%ddl&m'Z'iZ(ddZ)Gddde*Z+Gddde,Z-e-defiZ.Gddde.Z/dS)ae! Widget class ============ The :class:`Widget` class is the base class required for creating Widgets. This widget class was designed with a couple of principles in mind: * *Event Driven* Widget interaction is built on top of events that occur. If a property changes, the widget can respond to the change in the 'on_' callback. If nothing changes, nothing will be done. That's the main goal of the :class:`~kivy.properties.Property` class. * *Separation Of Concerns (the widget and its graphical representation)* Widgets don't have a `draw()` method. This is done on purpose: The idea is to allow you to create your own graphical representation outside the widget class. Obviously you can still use all the available properties to do that, so that your representation properly reflects the widget's current state. Every widget has its own :class:`~kivy.graphics.Canvas` that you can use to draw. This separation allows Kivy to run your application in a very efficient manner. * *Bounding Box / Collision* Often you want to know if a certain point is within the bounds of your widget. An example would be a button widget where you only want to trigger an action when the button itself is actually touched. For this, you can use the :meth:`~Widget.collide_point` method, which will return True if the point you pass to it is inside the axis-aligned bounding box defined by the widget's position and size. If a simple AABB is not sufficient, you can override the method to perform the collision checks with more complex shapes, e.g. a polygon. You can also check if a widget collides with another widget with :meth:`~Widget.collide_widget`. We also have some default values and behaviors that you should be aware of: * A :class:`Widget` is not a :class:`~kivy.uix.layout.Layout`: it will not change the position or the size of its children. If you want control over positioning or sizing, use a :class:`~kivy.uix.layout.Layout`. * The default size of a widget is (100, 100). This is only changed if the parent is a :class:`~kivy.uix.layout.Layout`. For example, if you add a :class:`Label` inside a :class:`Button`, the label will not inherit the button's size or position because the button is not a *Layout*: it's just another *Widget*. * The default size_hint is (1, 1). If the parent is a :class:`Layout`, then the widget size will be the parent layout's size. * :meth:`~Widget.on_touch_down`, :meth:`~Widget.on_touch_move`, :meth:`~Widget.on_touch_up` don't do any sort of collisions. If you want to know if the touch is inside your widget, use :meth:`~Widget.collide_point`. Using Properties ---------------- When you read the documentation, all properties are described in the format:: is a and defaults to . e.g. :attr:`~kivy.uix.label.Label.text` is a :class:`~kivy.properties.StringProperty` and defaults to ''. If you want to be notified when the pos attribute changes, i.e. when the widget moves, you can bind your own callback function like this:: def callback_pos(instance, value): print('The widget', instance, 'moved to', value) wid = Widget() wid.bind(pos=callback_pos) Read more about :doc:`/api-kivy.properties`. Basic drawing ------------- Widgets support a range of drawing instructions that you can use to customize the look of your widgets and layouts. For example, to draw a background image for your widget, you can do the following: .. code-block:: python def redraw(self, args): self.bg_rect.size = self.size self.bg_rect.pos = self.pos widget = Widget() with widget.canvas: widget.bg_rect = Rectangle(source="cover.jpg", pos=self.pos, size=self.size) widget.bind(pos=redraw, size=redraw) To draw a background in kv: .. code-block:: kv Widget: canvas: Rectangle: source: "cover.jpg" size: self.size pos: self.pos These examples only scratch the surface. Please see the :mod:`kivy.graphics` documentation for more information. .. _widget-event-bubbling: Widget touch event bubbling --------------------------- When you catch touch events between multiple widgets, you often need to be aware of the order in which these events are propagated. In Kivy, events bubble up from the first child upwards through the other children. If a widget has children, the event is passed through its children before being passed on to the widget after it. As the :meth:`~kivy.uix.widget.Widget.add_widget` method inserts widgets at index 0 by default, this means the event goes from the most recently added widget back to the first one added. Consider the following: .. code-block:: python box = BoxLayout() box.add_widget(Label(text="a")) box.add_widget(Label(text="b")) box.add_widget(Label(text="c")) The label with text "c" gets the event first, "b" second and "a" last. You can reverse this order by manually specifying the index: .. code-block:: python box = BoxLayout() box.add_widget(Label(text="a"), index=0) box.add_widget(Label(text="b"), index=1) box.add_widget(Label(text="c"), index=2) Now the order would be "a", "b" then "c". One thing to keep in mind when using kv is that declaring a widget uses the :meth:`~kivy.uix.widget.Widget.add_widget` method for insertion. Hence, using .. code-block:: kv BoxLayout: MyLabel: text: "a" MyLabel: text: "b" MyLabel: text: "c" would result in the event order "c", "b" then "a" as "c" was actually the last added widget. It thus has index 0, "b" index 1 and "a" index 2. Effectively, the child order is the reverse of its listed order. This ordering is the same for the :meth:`~kivy.uix.widget.Widget.on_touch_move` and :meth:`~kivy.uix.widget.Widget.on_touch_up` events. In order to stop this event bubbling, a method can return `True`. This tells Kivy the event has been handled and the event propagation stops. For example: .. code-block:: python class MyWidget(Widget): def on_touch_down(self, touch): If : # Do stuff here and kill the event return True else: return super(MyWidget, self).on_touch_down(touch) This approach gives you good control over exactly how events are dispatched and managed. Sometimes, however, you may wish to let the event be completely propagated before taking action. You can use the :class:`~kivy.clock.Clock` to help you here: .. code-block:: python class MyWidget(Label): def on_touch_down(self, touch, after=False): if after: print "Fired after the event has been dispatched!" else: Clock.schedule_once(lambda dt: self.on_touch_down(touch, True)) return super(MyWidget, self).on_touch_down(touch) Usage of :attr:`Widget.center`, :attr:`Widget.right`, and :attr:`Widget.top` ---------------------------------------------------------------------------- A common mistake when using one of the computed properties such as :attr:`Widget.right` is to use it to make a widget follow its parent with a KV rule such as `right: self.parent.right`. Consider, for example: .. code-block:: kv FloatLayout: id: layout width: 100 Widget: id: wid right: layout.right The (mistaken) expectation is that this rule ensures that wid's right will always be whatever layout's right is - that is wid.right and layout.right will always be identical. In actual fact, this rule only says that "whenever layout's `right` changes, wid's right will be set to that value". The difference being that as long as `layout.right` doesn't change, `wid.right` could be anything, even a value that will make them different. Specifically, for the KV code above, consider the following example:: >>> print(layout.right, wid.right) (100, 100) >>> wid.x = 200 >>> print(layout.right, wid.right) (100, 300) As can be seen, initially they are in sync, however, when we change `wid.x` they go out of sync because `layout.right` is not changed and the rule is not triggered. The proper way to make the widget follow its parent's right is to use :attr:`Widget.pos_hint`. If instead of `right: layout.right` we did `pos_hint: {'right': 1}`, then the widgets right will always be set to be at the parent's right at each layout update. )WidgetWidgetException)EventDispatcher)MODE_DONT_DISPATCHMODE_FILTERED_DISPATCHMODE_DEFAULT_DISPATCH)Factory)NumericPropertyStringProperty AliasPropertyReferenceListPropertyObjectProperty ListProperty DictPropertyBooleanProperty)Canvas TranslateFbo ClearColor ClearBuffersScale)Matrix) EventLoop)Builder)get_current_context) WeakProxy)partial)islicecCst|=t|dSN)_widget_destructorsrZ unbind_widget)uidrr"3/tmp/pip-unpacked-wheel-xzebddm3/kivy/uix/widget.py_widget_destructor sr$c@seZdZdZdS)rz-Fired when the widget gets an exception. N)__name__ __module__ __qualname____doc__r"r"r"r#rsrcs eZdZdZfddZZS)WidgetMetaclasszMetaclass to automatically register new widgets for the :class:`~kivy.factory.Factory`. .. warning:: This metaclass is used by the Widget. Do not use it directly! cs&tt||||tj||ddS)N)cls)superr)__init__rregister)Zmcsnamebasesattrs __class__r"r#r,szWidgetMetaclass.__init__)r%r&r'r(r, __classcell__r"r"r1r#r)sr) WidgetBasecseZdZdZeZdZdZfddZe ddZ dd Z de dfd d Z d d ZddZddZddZddZddZddZdjddZddZdkdd Zd!d"Zd#d$Zdld%d&Zdmd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zdnd2d3Z dod4d5Z!dpd6d7Z"dqd8d9Z#drd:d;Z$dsd=d>Z%dtd?d@Z&dudAdBZ'dvdCdDZ(dwdEdFZ)e*dZ+e*dZ,e*dGZ-e*dGZ.e/e+e,Z0e/e-e.Z1dHdIZ2dJdKZ3e4e2e3dLde/e;e>Z?e@gZAe@gZBeCdd`_. .. versionchanged:: 1.0.9 Everything related to event properties has been moved to the :class:`~kivy.event.EventDispatcher`. Event properties can now be used when constructing a simple class without subclassing :class:`Widget`. .. versionchanged:: 1.5.0 The constructor now accepts on_* arguments to automatically bind callbacks to properties or events, as in the Kv language. ) on_motion on_touch_down on_touch_move on_touch_up on_kv_postNc stt|dst|_d|k}d|_|r2|d=dd|D}|D] }||=qHd|_tt |j f||j dkrt |j d|_ |sg}|j|j|d|D]}|d |q|d ||r|jf|dS) N_contextZ __no_builderFcSs&i|]\}}|dddkr||qS)NZon_r").0kvr"r"r# _sz#Widget.__init__..r)opacityignored_consts rule_childrenr9)rZ ensure_windowhasattrrr:_disabled_valueitems_disabled_countr+rr,canvasrr@apply_class_lang_rulesZ_kwargs_applied_initdispatchbind)selfkwargsZ no_builderZon_argskeyrCwidgetr1r"r#r,Ss2   zWidget.__init__cCs@|j}|dk r|Stt|j}t|||_}||ft|j<|S)aReturn a proxy reference to the widget, i.e. without creating a reference to the widget. See `weakref.proxy `_ for more information. .. versionadded:: 1.7.2 N) _proxy_refrr$r rr)rLrPfr"r"r# proxy_refzs  zWidget.proxy_refcCst|Sr)idrLr"r"r#__hash__szWidget.__hash__cCstj|||ddS)a# Method that is called by kivy to apply the kv rules of this widget's class. :Parameters: `root`: :class:`Widget` The root widget that instantiated this widget in kv, if the widget was instantiated in kv, otherwise ``None``. `ignored_consts`: set (internal) See :meth:`~kivy.lang.builder.BuilderBase.apply`. `rule_children`: list (internal) See :meth:`~kivy.lang.builder.BuilderBase.apply`. This is useful to be able to execute code before/after the class kv rules are applied to the widget. E.g. if the kv code requires some properties to be initialized before it is used in a binding rule. If overwriting remember to call ``super``, otherwise the kv rules will not be applied. In the following example, .. code-block:: python class MyWidget(Widget): pass class OtherWidget(MyWidget): pass .. code-block:: kv : my_prop: some_value : other_prop: some_value When ``OtherWidget`` is instantiated with ``OtherWidget()``, the widget's :meth:`apply_class_lang_rules` is called and it applies the kv rules of this class - ```` and ````. Similarly, when the widget is instantiated from kv, e.g. .. code-block:: kv : height: 55 OtherWidget: width: 124 ``OtherWidget``'s :meth:`apply_class_lang_rules` is called and it applies the kv rules of this class - ```` and ````. .. note:: It applies only the class rules not the instance rules. I.e. in the above kv example in the ``MyBox`` rule when ``OtherWidget`` is instantiated, its :meth:`apply_class_lang_rules` applies the ```` and ```` rules to it - it does not apply the ``width: 124`` rule. The ``width: 124`` rule is part of the ``MyBox`` rule and is applied by the ``MyBox``'s instance's :meth:`apply_class_lang_rules`. .. versionchanged:: 1.11.0 rAN)rapply)rLrootrBrCr"r"r#rIs DzWidget.apply_class_lang_rulescCs8|j|ko|jkno6|j|ko2|jkSS)a Check if a point (x, y) is inside the widget's axis aligned bounding box. :Parameters: `x`: numeric x position of the point (in parent coordinates) `y`: numeric y position of the point (in parent coordinates) :Returns: A bool. True if the point is inside the bounding box, False otherwise. .. code-block:: python >>> Widget(pos=(10, 10), size=(50, 50)).collide_point(40, 40) True )xrightytop)rLrXrZr"r"r# collide_pointszWidget.collide_pointcCsD|j|jkrdS|j|jkr dS|j|jkr0dS|j|jkr@dSdS)a Check if another widget collides with this widget. This function performs an axis-aligned bounding box intersection test by default. :Parameters: `wid`: :class:`Widget` class Widget to test collision with. :Returns: bool. True if the other widget collides with this widget, False otherwise. .. code-block:: python >>> wid = Widget(size=(50, 50)) >>> wid2 = Widget(size=(50, 50), pos=(25, 25)) >>> wid.collide_widget(wid2) True >>> wid2.pos = (55, 55) >>> wid.collide_widget(wid2) False FT)rYrXr[rZ)rLZwidr"r"r#collide_widgets    zWidget.collide_widgetcCs|js|jtkrdS|j|jkr$dS|j|j}|d|krLt|dkrLdS|jtkr|d}|jddD]&}|d||rdS||krldSql|jt kr|d|kr|ddn |dd}|D]}|d||rdSqdS)aCalled when a motion event is received. :Parameters: `etype`: `str` Event type, one of "begin", "update" or "end" `me`: :class:`~kivy.input.motionevent.MotionEvent` Received motion event :Returns: `bool` `True` to stop event dispatching .. versionadded:: 2.1.0 .. warning:: This is an experimental method and it remains so while this warning is present. Nrr5T) disabledZ dispatch_modertype_id motion_filterlenrchildrenrJr)rLetypemefilteredZ last_filteredrOwidgetsr"r"r#r5s&    $zWidget.on_motioncCs@|jr|j|jrdS|jddD]}|d|r$dSq$dS)aReceive a touch down event. :Parameters: `touch`: :class:`~kivy.input.motionevent.MotionEvent` class Touch received. The touch is in parent coordinates. See :mod:`~kivy.uix.relativelayout` for a discussion on coordinate systems. :Returns: bool If True, the dispatching of the touch event will stop. If False, the event will continue to be dispatched to the rest of the widget tree. TNr6)r`r\posrdrJrLtouchchildr"r"r#r6<s  zWidget.on_touch_downcCs4|jr dS|jddD]}|d|rdSqdS)zReceive a touch move event. The touch is in parent coordinates. See :meth:`on_touch_down` for more information. Nr7Tr`rdrJrjr"r"r#r7Ps  zWidget.on_touch_movecCs4|jr dS|jddD]}|d|rdSqdS)zReceive a touch up event. The touch is in parent coordinates. See :meth:`on_touch_down` for more information. Nr8Trmrjr"r"r#r8[s  zWidget.on_touch_upcCsdSrr")rLZ base_widgetr"r"r#r9fszWidget.on_kv_postrc Csnt|tstd|j}||kr(td|j}|rBtd||f||_}||j|dkrh|jjn|dkrx|jj n|j}|dkst |j dkr|j d|| |jn|j}|j }|t |krt |}||dj}n0||}||j}|dkr |}n|d7}| |||dkr4|jr4d}| ||j|jD]}|||qH|d |jd S) aIAdd a new widget as a child of this widget. :Parameters: `widget`: :class:`Widget` Widget to add to our list of children. `index`: int, defaults to 0 Index to insert the widget in the list. Notice that the default of 0 means the widget is inserted at the beginning of the list and will thus be drawn on top of other sibling widgets. For a full discussion of the index and widget hierarchy, please see the :doc:`Widgets Programming Guide `. .. versionadded:: 1.0.5 `canvas`: str, defaults to None Canvas to add widget's canvas to. Can be 'before', 'after' or None for the default canvas. .. versionadded:: 1.9.0 .. code-block:: python >>> from kivy.uix.button import Button >>> from kivy.uix.slider import Slider >>> root = Widget() >>> root.add_widget(Button()) >>> slider = Slider() >>> root.add_widget(slider) zAadd_widget() can be used only with instances of the Widget class.z/Widget instances cannot be added to themselves.z)Cannot add %r, it already has a parent %rbeforeafterrr_r^rbN) isinstancerr__self__parent inc_disabledrGrHrnrorcrdinsertaddindexoflengthZ has_beforerbregister_for_motion_eventZfbind_update_motion_filter) rLrOindexrHrrrdZ next_indexZ next_childrar"r"r# add_widgetlsN         zWidget.add_widgetcCs||jkrdS|j||j|jjkr8|j|jnB|j|jjjkrZ|jj|jn |j|jjjkrz|jj|j|jD]}|||q|d|jd|_ | |j dS)aRemove a widget from the children of this widget. :Parameters: `widget`: :class:`Widget` Widget to remove from our children list. .. code-block:: python >>> from kivy.uix.button import Button >>> root = Widget() >>> button = Button() >>> root.add_widget(button) >>> root.remove_widget(button) Nrb) rdremoverHrornrbunregister_for_motion_eventZfunbindryrr dec_disabledrG)rLrOrar"r"r# remove_widgets   zWidget.remove_widgetcCs<|dks||jkr |jdd}|j}|D] }||q*dS)a8 Remove all (or the specified) :attr:`~Widget.children` of this widget. If the 'children' argument is specified, it should be a list (or filtered list) of children of the current widget. .. versionchanged:: 1.8.0 The `children` argument can be used to specify the children you want to remove. .. versionchanged:: 2.1.0 Specifying an empty ``children`` list leaves the widgets unchanged. Previously it was treated like ``None`` and all children were removed. N)rdr)rLrdrrlr"r"r# clear_widgetss zWidget.clear_widgetscCsjg}|jD]\}}||kr||q|D]}||kr.|||q.|D]}||krL|||qLdSr)rbrFappendr}rx)rLZ child_widgetZchild_motion_filterZ old_eventsrarhr"r"r#rys zWidget._update_motion_filtercCst||kr dS|jj}||d}|j|}|d|kr:dnd}t|t|D]"}||||krj|d7}qLqpqL|S)Nrr^)rdrzrbrangerc)rLrarOZ find_indexZ max_indexZmotion_widgetsZ insert_indexrzr"r"r#_find_index_in_motion_filters   z#Widget._find_index_in_motion_filtercCsN|p|}|j}||kr"|g||<n(|||krJ|||}||||dS)ahRegister to receive motion events of `type_id`. Override :meth:`on_motion` or bind to `on_motion` event to handle the incoming motion events. :Parameters: `type_id`: `str` Motion event type id (eg. "touch", "hover", etc.) `widget`: `Widget` Child widget or `self` if omitted .. versionadded:: 2.1.0 .. note:: Method can be called multiple times with the same arguments. .. warning:: This is an experimental method and it remains so while this warning is present. N)rbrrt)rLrarOa_widgetrbrzr"r"r#rxs   z Widget.register_for_motion_eventcCsB|p|}|j}||kr>|||kr>|||||s>||=dS)aUnregister to receive motion events of `type_id`. :Parameters: `type_id`: `str` Motion event type id (eg. "touch", "hover", etc.) `widget`: `Widget` Child widget or `self` if omitted .. versionadded:: 2.1.0 .. note:: Method can be called multiple times with the same arguments. .. warning:: This is an experimental method and it remains so while this warning is present. N)rbr|)rLrarOrrbr"r"r#r}$s z"Widget.unregister_for_motion_eventcOs|j||j|dddS)aSaves an image of the widget and its children in png format at the specified filename. Works by removing the widget canvas from its parent, rendering to an :class:`~kivy.graphics.fbo.Fbo`, and calling :meth:`~kivy.graphics.texture.Texture.save`. .. note:: The image includes only this widget and its children. If you want to include widgets elsewhere in the tree, you must call :meth:`~Widget.export_to_png` from their common parent, or use :meth:`~kivy.core.window.WindowBase.screenshot` to capture the whole window. .. note:: The image will be saved in png format, you should include the extension in your filename. .. versionadded:: 1.9.0 :Parameters: `filename`: str The filename with which to save the png. `scale`: float The amount by which to scale the saved image, defaults to 1. .. versionadded:: 1.11.0 F)ZflippedN)export_as_imagesave)rLfilenameargsrMr"r"r# export_to_png>szWidget.export_to_pngc Osddlm}|dd}|jdk rJ|jj|j}|dkrJ|jj|jt|j||j |fdd}|Lt ddddt t dddt ||dt |j |j |j dW5QRX||j|||j}||j|jdk r|dkr|jj||j|S) zwReturn an core :class:`~kivy.core.image.Image` of the actual widget. .. versionadded:: 1.11.0 r)Imagescaler^Nr_T)sizeZwith_stencilbuffer)Zkivy.core.imagergetrrrHrvr|rwidthheightrrrrrXrZruZdrawZtexturert)rLrrMrrZcanvas_parent_indexZfboimgr"r"r#r]s,     $   zWidget.export_as_imagecCs|jr|jSdS)zReturn the root window. :Returns: Instance of the root window. Can be a :class:`~kivy.core.window.WindowBase` or :class:`Widget`. N)rrget_root_windowrTr"r"r#rszWidget.get_root_windowcCs|jr|jSdS)zReturn the parent window. :Returns: Instance of the parent window. Can be a :class:`~kivy.core.window.WindowBase` or :class:`Widget`. N)rrget_parent_windowrTr"r"r#rszWidget.get_parent_windowFccs|dkrt|j}|Vt|jd|D]}|jddD] }|Vq:q*|s|j}z&|dksft|tsjt|j|}Wn&tk r|sYdS|}d}YnX|j||dD] }|VqdS)NT)restrict)loopbackrz) rcrdreversed_walkrrrpr ValueErrorrz)rLrrrzrl walk_childrrr"r"r#rs&   z Widget._walkccs8|||}t|V|D]}||kr,dS|VqdS)ak Iterator that walks the widget tree starting with this widget and goes forward returning widgets in the order in which layouts display them. :Parameters: `restrict`: bool, defaults to False If True, it will only iterate through the widget and its children (or children of its children etc.). Defaults to False. `loopback`: bool, defaults to False If True, when the last widget in the tree is reached, it'll loop back to the uppermost root and start walking until we hit this widget again. Naturally, it can only loop back when `restrict` is False. Defaults to False. :return: A generator that walks the tree, returning widgets in the forward layout order. For example, given a tree with the following structure: .. code-block:: kv GridLayout: Button BoxLayout: id: box Widget Button Widget walking this tree: .. code-block:: python >>> # Call walk on box with loopback True, and restrict False >>> [type(widget) for widget in box.walk(loopback=True)] [, , , , , ] >>> # Now with loopback False, and restrict False >>> [type(widget) for widget in box.walk()] [, , , ] >>> # Now with restrict True >>> [type(widget) for widget in box.walk(restrict=True)] [, , ] .. versionadded:: 1.9.0 N)rnext)rLrrgennoder"r"r#walks 1  z Widget.walkccs|}d}|rh|j}z*|dks&t|ts*t|j|d}Wn*tk rf|sVYdSd}d}|}YnXt|j|dD]}|j|dD] }|Vqqv|V|r|j||dD] }|VqdS)Nrr^F)rrgo_up)rrrprrrdrzr _walk_reverse)rLrrrWrzrlrr"r"r#rs.   zWidget._walk_reverseccs,|j|ddD]}|V||krdSqdS)a# Iterator that walks the widget tree backwards starting with the widget before this, and going backwards returning widgets in the reverse order in which layouts display them. This walks in the opposite direction of :meth:`walk`, so a list of the tree generated with :meth:`walk` will be in reverse order compared to the list generated with this, provided `loopback` is True. :Parameters: `loopback`: bool, defaults to False If True, when the uppermost root in the tree is reached, it'll loop back to the last widget and start walking back until after we hit widget again. Defaults to False. :return: A generator that walks the tree, returning widgets in the reverse layout order. For example, given a tree with the following structure: .. code-block:: kv GridLayout: Button BoxLayout: id: box Widget Button Widget walking this tree: .. code-block:: python >>> # Call walk on box with loopback True >>> [type(widget) for widget in box.walk_reverse(loopback=True)] [, , , , , ] >>> # Now with loopback False >>> [type(widget) for widget in box.walk_reverse()] [, ] >>> forward = [w for w in box.walk(loopback=True)] >>> backward = [w for w in box.walk_reverse(loopback=True)] >>> forward == backward[::-1] True .. versionadded:: 1.9.0 TrN)r)rLrrr"r"r# walk_reverse s2zWidget.walk_reversecCs(|jr|j||\}}|j|||dS)zConvert the coordinate from window to local (current widget) coordinates. See :mod:`~kivy.uix.relativelayout` for details on the coordinate systems. relative)rr to_widgetto_localrLrXrZrr"r"r#rCszWidget.to_widgetTcCs:|s|j|||d\}}|jr2|jj||d|dS||fS)a,If ``initial`` is True, the default, it transforms **parent** coordinates to window coordinates. Otherwise, it transforms **local** (current widget) coordinates to window coordinates. See :mod:`~kivy.uix.relativelayout` for details on the coordinate systems. rF)initialr) to_parentrr to_window)rLrXrZrrr"r"r#rNs zWidget.to_windowcCs |r||j||jfS||fS)arTransform local (current widget) coordinates to parent coordinates. See :mod:`~kivy.uix.relativelayout` for details on the coordinate systems. :Parameters: `relative`: bool, defaults to False Change to True if you want to translate relative positions from a widget to its parent coordinates. rXrZrr"r"r#r]s zWidget.to_parentcCs |r||j||jfS||fS)abTransform parent coordinates to local (current widget) coordinates. See :mod:`~kivy.uix.relativelayout` for details on the coordinate systems. :Parameters: `relative`: bool, defaults to False Change to True if you want to translate coordinates to relative widget coordinates. rrr"r"r#rls zWidget.to_localcCsP|jrL|jj|j|p|jddi\}}|||d|jrH|j|n|}|S)NrTr)rrrrri translate_apply_transform)rLmrirXrZr"r"r#r{szWidget._apply_transformcCs"t}|||d||}|S)a2Calculate the transformation matrix to convert between window and widget coordinates. :Parameters: `x`: float, defaults to 0 Translates the matrix on the x axis. `y`: float, defaults to 0 Translates the matrix on the y axis. r)rrr)rLrXrZrr"r"r#get_window_matrixs  zWidget.get_window_matrixdcCs |j|jSrrXrrTr"r"r# get_rightszWidget.get_rightcCs||j|_dSrrrXrLvaluer"r"r# set_rightszWidget.set_rightr)rKcachewatch_before_usecCs |j|jSrrZrrTr"r"r#get_topszWidget.get_topcCs||j|_dSrrrZrr"r"r#set_topszWidget.set_toprcCs|j|jdSNg@rrTr"r"r# get_center_xszWidget.get_center_xcCs||jd|_dSrrrr"r"r# set_center_xszWidget.set_center_xcCs|j|jdSrrrTr"r"r# get_center_yszWidget.get_center_ycCs||jd|_dSrrrr"r"r# set_center_yszWidget.set_center_y) allownoneZrebindr^)rg?cCs|j}|dk r||_dSr)rHr@)rLinstancerrHr"r"r# on_opacityszWidget.on_opacitycCs |jdkS)Nr)rGrTr"r"r# get_disabledszWidget.get_disabledcCs6t|}||jkr2||_|r&|n|dSdS)NT)boolrErsr~rr"r"r# set_disableds  zWidget.set_disabledcCsX|j|7_|j|dkr*|jkr>nn|d||jD]}||qDdS)Nr^r`)rGpropertyrJrdrsrLcountcr"r"r#rs*s   zWidget.inc_disabledcCsX|j|8_|jdkr*|j|kr>nn|d||jD]}||qDdS)Nrr`)rGrrJrdr~rr"r"r#r~1s   zWidget.dec_disabled)r)rN)N)N)N)FFN)FF)FF)F)F)TF)F)F)N)rr)r^)r^)[r%r&r'r(r) __metaclass__Z __events__rPr,rrRrUsetrIr\r]r5r6r7r8r9r{rrryrrxr}rrrrrrrrrrrrrrr rXrZrrr rirrrr rYrrr[rrZcenter_xrrZcenter_ycenterrr*rdr rrZ size_hint_xZ size_hint_yZ size_hintZpos_hintZsize_hint_min_xZsize_hint_min_yZ size_hint_minZsize_hint_max_xZsize_hint_max_yZ size_hint_maxridsr@rrHrrrsr~r`rbr3r"r"r1r#r's$ '  K!(   M    "   8 ! 7                 6  rN)0r(__all__Z kivy.eventrZkivy.eventmanagerrrrZ kivy.factoryrZkivy.propertiesr r r r r rrrZ kivy.graphicsrrrrrrZkivy.graphics.transformationrZ kivy.baserZ kivy.langrZ kivy.contextrZkivy.weakproxyr functoolsr itertoolsrrr$ Exceptionrtyper)r4rr"r"r"r#s(m  (