U Pe @sUdZdZddlmZddlmZddlmZmZddl m Z ddl m Z ddl mZdd lmZdd lZz dd lmZmZmZmZmZWn ek red YnXdd lmZddZzdd lZedkrej j!Z"ddZdddZ#YnXGddde/Z0d e0j_Gd!d"d"e0Z1Gd#d$d$e1Z2Gd%d&d&e0eZ3Gd'd(d(e1eZ4Gd)d*d*e2eZ5Gd+d,d,e2eZ6d-d.Z7d?d0d1Z8d2ekr d Z9e3e:d3<nfe3e4e5e6d4Z;ed8?e=e@e;Ae d3e;e=e`_ python module:: from functools import partial def my_callback(value, key, *largs): pass Clock.schedule_interval(partial(my_callback, 'my value', 'my key'), 0.5) Conversely, if you want to schedule a function that doesn't accept the dt argument, you can use a `lambda `_ expression to write a short function that does accept dt. For Example:: def no_args_func(): print("I accept no arguments, so don't schedule me in the clock") Clock.schedule_once(lambda dt: no_args_func(), 0.5) .. note:: You cannot unschedule an anonymous function unless you keep a reference to it. It's better to add \*args to your function definition so that it can be called with an arbitrary number of parameters. .. important:: The class method callback is weak-referenced: you are responsible for keeping a reference to your original object/callback. If you don't keep a reference, the ClockBase will never execute your callback. For example:: class Foo(object): def start(self): Clock.schedule_interval(self.callback, 0.5) def callback(self, dt): print('In callback') # A Foo object is created and the method start is called. # Because no reference is kept to the instance returned from Foo(), # the object will be collected by the Python Garbage Collector and # your callback will be never called. Foo().start() # So you should do the following and keep a reference to the instance # of foo until you don't need it anymore! foo = Foo() foo.start() .. _schedule-before-frame: Schedule before frame --------------------- .. versionadded:: 1.0.5 Sometimes you need to schedule a callback BEFORE the next frame. Starting from 1.0.5, you can use a timeout of -1:: Clock.schedule_once(my_callback, 0) # call after the next frame Clock.schedule_once(my_callback, -1) # call before the next frame The Clock will execute all the callbacks with a timeout of -1 before the next frame even if you add a new callback with -1 from a running callback. However, :class:`Clock` has an iteration limit for these callbacks: it defaults to 10. If you schedule a callback that schedules a callback that schedules a ... etc more than 10 times, it will leave the loop and send a warning to the console, then continue after the next frame. This is implemented to prevent bugs from hanging or crashing the application. If you need to increase the limit, set the :attr:`max_iteration` property:: from kivy.clock import Clock Clock.max_iteration = 20 .. _triggered-events: Triggered Events ---------------- .. versionadded:: 1.0.5 :meth:`CyClockBase.create_trigger` is an advanced method way to defer a callback. It functions exactly like :meth:`CyClockBase.schedule_once` and :meth:`CyClockBase.schedule_interval` except that it doesn't immediately schedule the callback. Instead, one schedules the callback using the :class:`ClockEvent` returned by it. This ensures that you can call the event multiple times but it won't be scheduled more than once. This is not the case with :meth:`CyClockBase.schedule_once`:: # will run the callback twice before the next frame Clock.schedule_once(my_callback) Clock.schedule_once(my_callback) # will run the callback once before the next frame event = Clock.create_trigger(my_callback) event() event() # will also run the callback only once before the next frame event = Clock.schedule_once(my_callback) # now it's already scheduled event() # won't be scheduled again event() In addition, it is more convenient to create and bind to the triggered event than using :meth:`CyClockBase.schedule_once` in a function:: from kivy.clock import Clock from kivy.uix.widget import Widget class Sample(Widget): def __init__(self, **kwargs): self._trigger = Clock.create_trigger(self.cb) super(Sample, self).__init__(**kwargs) self.bind(x=self._trigger, y=self._trigger) def cb(self, *largs): pass Even if x and y changes within one frame, the callback is only run once. Unscheduling ------------- An event scheduled with :meth:`CyClockBase.schedule_once`, :meth:`CyClockBase.schedule_interval`, or with :meth:`CyClockBase.create_trigger` and then triggered can be unscheduled in multiple ways. E.g:: def my_callback(dt): pass # call my_callback every 0.5 seconds event = Clock.schedule_interval(my_callback, 0.5) # call my_callback in 5 seconds event2 = Clock.schedule_once(my_callback, 5) event_trig = Clock.create_trigger(my_callback, 5) event_trig() # unschedule using cancel event.cancel() # unschedule using Clock.unschedule Clock.unschedule(event2) # unschedule using Clock.unschedule with the callback # NOT RECOMMENDED Clock.unschedule(my_callback) The best way to unschedule a callback is with :meth:`ClockEvent.cancel`. :meth:`CyClockBase.unschedule` is mainly an alias for that for that function. However, if the original callback itself is passed to :meth:`CyClockBase.unschedule`, it'll unschedule all instances of that callback (provided ``all`` is True, the default, otherwise only the first match is removed). Calling :meth:`CyClockBase.unschedule` on the original callback is highly discouraged because it's significantly slower than when using the event. Clock Lifecycle --------------- Kivy's clock has a lifecycle. By default, scheduling a callback after the Clock has ended will not raise an error, even though the callback may never be called. That's because most callbacks are like services, e.g. responding to a user button press - if the app is running the callbacks need to service the app and respond to the input, but once the app has stopped or is stopping, we can safely not process these events. Other events always need to be processed. E.g. another thread may request a callback in kivy's thread and then process some result. If the event is not processed in Kivy's thread because the app stopped, the second thread may block forever hanging the application as it exits. Consequently, we provide a API (:meth:`CyClockBase.create_lifecycle_aware_trigger`) for scheduling callbacks that raise a :class:`ClockNotRunningError` if the clock has stopped. If the scheduling succeeded it guarantees that one of its callbacks will be called. I.e. the new :meth:`CyClockBase.create_lifecycle_aware_trigger` accepts an additional ``clock_ended_callback`` parameter. Normally, ``callback`` will be called when the event is processed. But, if the clock is stopped before it can be processed, if the application exited normally (and the app was started) and the event wasn't canceled, and the callbacks are not garbage collected, then ``clock_ended_callback`` will be called instead when the clock is stopped. That is, given these conditions, if :class:`ClockNotRunningError` was not raised when the event was scheduled, then one of these callbacks will be called - either ``callback`` if the event executed normally, or ``clock_ended_callback`` if the clock is stopped while the event is scheduled. By default, events can be scheduled before the clock is started because it is assumed the clock will eventually be started when the app starts. I.e. calling :meth:`CyClockBase.create_lifecycle_aware_trigger` before the clock and application starts will succeed. But if the app never actually starts, then neither of the callbacks may be executed. .. versionadded:: 2.0.0 The lifecycle was added in 2.0.0 Exception Handling ------------------ Kivy provides a exception handling manager, :attr:`~kivy.base.ExceptionManager`, to handle its internal exceptions including exceptions raised by clock callbacks, without crashing the application. By default when an exception is raised, the app will crash. But, if a handler is registered with the exception manager and the handler handles the exception, the app will not crash and will continue as normal.:: from kivy.base import ExceptionHandler, ExceptionManager class MyHandler(ExceptionHandler): def handle_exception(self, inst): if isinstance(inst, ValueError): Logger.exception('ValueError caught by MyHandler') return ExceptionManager.PASS return ExceptionManager.RAISE ExceptionManager.add_handler(MyHandler()) Then, all ValueError exceptions will be logged to the console and ignored. Similarly, if a scheduled clock callback raises a ValueError, other clock events will still be processed normally. If an event's callback raises an exception, before the exception handler is executed, the callback is immediately canceled. It still is possible for the app to be corrupted if kivy itself is the source of the exception. I.e. even with a handler that ignores exceptions and doesn't crash, the app may be in a corrupted state if the error originates from within Kivy itself. However, the exception handler can help protect the app from crashing and can help protect against user callbacks crashing the app. .. versionchanged:: 2.0.0 Prior to Kivy 2.0.0, an exception raised in a event's callback would cause the clock to crash and subsequent events may or may not be executed. Even if the exception was handled by an :class:`~kivy.base.ExceptionHandler`, there was no guarantee that some scheduled events would not be skipped. From 2.0.0 onward, if a event's exception is handled by an :class:`~kivy.base.ExceptionHandler`, other events will be shielded from the exception and will execute normally. Scheduling from ``__del__`` --------------------------- It is not safe to schedule Clock events from a object's ``__del__`` or ``__dealloc__`` method. If you must schedule a Clock call from this method, use :meth:`CyClockBase.schedule_del_safe` or :meth:`CyClockBase.schedule_lifecycle_aware_del_safe` instead. Threading and Callback Order ----------------------------- Beginning with 1.10.0, all the events scheduled for the same frame, e.g. all the events scheduled in the same frame with a ``timeout`` of ``0``, well be executed in the order they were scheduled. Also, all the scheduling and canceling methods are fully thread safe and can be safely used from external threads. As a a consequence, calling :meth:`CyClockBase.unschedule` with the original callback is now significantly slower and highly discouraged. Instead, the returned events should be used to cancel. As a tradeoff, all the other methods are now significantly faster than before. Advanced Clock Details ----------------------- The following section goes into the internal kivy clock details as well as the various clock options. It is meant only for advanced users. Fundamentally, the Kivy clock attempts to execute any scheduled callback rhythmically as determined by the specified fps (frame per second, see ``maxfps`` in :mod:`~kivy.config`). That is, ideally, given e.g. a desired fps of 30, the clock will execute the callbacks at intervals of 1 / 30 seconds, or every 33.33 ms. All the callbacks in a frame are given the same timestamp, i.e. the ``dt`` passed to the callback are all the same and it's the difference in time between the start of this and the previous frame. Because of inherent indeterminism, the frames do not actually occur exactly at intervals of the fps and ``dt`` may be under or over the desired fps. Also, once the timeout is "close enough" to the desired timeout, as determined internally, Kivy will execute the callback in the current frame even when the "actual time" has not elapsed the ``timeout`` amount. Kivy offers now, since ``1.10.0``, multiple clocks with different behaviors. Default Clock ^^^^^^^^^^^^^^ The default clock (``default``) behaves as described above. When a callback with a timeout of zero or non-zero is scheduled, they are executed at the frame that is near the timeout, which is a function of the fps. So a timeout of zero would still result in a delay of one frame or about 1 / fps, typically a bit less but sometimes more depending on the CPU usage of the other events scheduled for that frame. In a test using a fps of 30, a callback with a timeout of 0, 0.001, and 0.05, resulted in a mean callback delay of 0.02487, 0.02488, and 0.05011 seconds, respectively. When tested with a fps of 600 the delay for 0.05 was similar, except the standard deviation was reduced resulting in overall better accuracy. Interruptible Clock ^^^^^^^^^^^^^^^^^^^^ The default clock suffers from the quantization problem, as frames occur only on intervals and any scheduled timeouts will not be able to occur during an interval. For example, with the timeout of 0.05, while the mean was 0.05011, its values ranged between 0.02548 - 0.07348 and a standard deviation of 0.002. Also, there's the minimum timeout of about 0.02487. The interruptible clock (``interrupt``) will execute timeouts even during a frame. So a timeout of zero will execute as quickly as possible and similarly a non-zero timeout will be executed even during the interval. This clock, and all the clocks described after this have an option, :attr:`ClockBaseInterruptBehavior.interupt_next_only`. When True, any of the behavior new behavior will only apply to the callbacks with a timeout of zero. Non-zero timeouts will behave like in the default clock. E.g. for this clock when True, only zero timeouts will execute during the the interval. In a test using a fps of 30, a callback with a timeout of 0, 0.001, and 0.05, resulted in a mean callback delay of 0.00013, 0.00013, and 0.04120 seconds, respectively when :attr:`ClockBaseInterruptBehavior.interupt_next_only` was False. Also, compared to the default clock the standard deviation was reduced. When :attr:`ClockBaseInterruptBehavior.interupt_next_only` was True, the values were 0.00010, 0.02414, and 0.05034, respectively. Free Clock ^^^^^^^^^^^ The interruptible clock may not be ideal for all cases because all the events are executed during the intervals and events are not executed anymore rhythmically as multiples of the fps. For example, there may not be any benefit for the graphics to update in a sub-interval, so the additional accuracy wastes CPU. The Free clock (``free_all``) solves this by having ``Clock.xxx_free`` versions of all the Clock scheduling methods. By free, we mean the event is free from the fps because it's not fps limited. E.g. :meth:`CyClockBaseFree.create_trigger_free` corresponds to :meth:`CyClockBase.create_trigger`. Only when an event scheduled using the ``Clock.xxx_free`` methods is present will the clock interrupt and execute the events during the interval. So, if no ``free`` event is present the clock behaves like the ``default`` clock, otherwise it behaves like the ``interrupt`` clock. In a test using a fps of 30, a callback with a timeout of 0s, 0.001s, and 0.05s, resulted in a mean callback delay of 0.00012s, 0.00017s, and 0.04121s seconds, respectively when it was a free event and 0.02403s, 0.02405s, and 0.04829s, respectively when it wasn't. Free Only Clock ^^^^^^^^^^^^^^^^^ The Free clock executes all events when a free event was scheduled. This results in normal events also being execute in the middle of the interval when a free event is scheduled. For example, above, when a free event was absent, a normal event with a 0.001s timeout was delayed for 0.02405s. However, if a free event happened to be also scheduled, the normal event was only delayed 0.00014s, which may be undesirable. The Free only clock (``free_only``) solves it by only executing free events during the interval and normal events are always executed like with the default clock. For example, in the presence of a free event, a normal event with a timeout of 0.001s still had a delay of 0.02406. So this clock, treats free and normal events independently, with normal events always being fps limited, but never the free events. Summary ^^^^^^^^ The kivy clock type to use can be set with the ``kivy_clock`` option the :mod:`~kivy.config`. If ``KIVY_CLOCK`` is present in the environment it overwrites the config selection. Its possible values are as follows: * When ``kivy_clock`` is ``default``, the normal clock, :class:`ClockBase`, which limits callbacks to the maxfps quantization - is used. * When ``kivy_clock`` is ``interrupt``, a interruptible clock, :class:`ClockBaseInterrupt`, which doesn't limit any callbacks to the maxfps - is used. Callbacks will be executed at any time. * When ``kivy_clock`` is ``free_all``, a interruptible clock, :class:`ClockBaseFreeInterruptAll`, which doesn't limit any callbacks to the maxfps in the presence of free events, but in their absence it limits events to the fps quantization interval - is used. * When ``kivy_clock`` is ``free_only``, a interruptible clock, :class:`ClockBaseFreeInterruptAll`, which treats free and normal events independently; normal events are fps limited while free events are not - is used. Async clock support ------------------- .. versionadded:: 2.0.0 Experimental async support has been added in 2.0.0. The Clock now has a :meth:`ClockBaseBehavior.async_tick` and :meth:`ClockBaseBehavior.async_idle` coroutine method which is used by the kivy EventLoop when the kivy EventLoop is executed in a asynchronous manner. When used, the kivy clock does not block while idling. The async library to use is selected with the `KIVY_EVENTLOOP` environmental variable or by calling :meth:`~kivy.clock.ClockBaseBehavior.init_async_lib` directly. The library can be one of `"asyncio"` when the standard library `asyncio` should be used, or `"trio"` if the trio library should be used. If not set it defaults to `"asyncio"`. See :mod:`~kivy.app` for example usage. )ClockClockNotRunningError ClockEventFreeClockEvent CyClockBaseCyClockBaseFree triggeredClockBaseBehaviorClockBaseInterruptBehaviorClockBaseInterruptFreeBehavior ClockBaseClockBaseInterruptClockBaseFreeInterruptAllClockBaseFreeInterruptOnly mainthread)platform)environ)wrapspartial)register_context)Config)Logger)clockN)rrrrraClock: Unable to import kivy._clock. Have you perhaps forgotten to compile kivy? Kivy contains Cython code which needs to be compiled. A missing kivy._clock often indicates the Cython code has not been compiled. Please follow the installation instructions and make sure to compile Kivy)EventcCsdSNrrr./tmp/pip-unpacked-wheel-xzebddm3/kivy/clock.py_get_sleep_objsr)win32cygwincCstdddS)NT) _kernel32ZCreateWaitableTimerArrrrrscCsFtt| d}t|t|dttdt|ddS)N rFl)ctypes c_longlongintr ZSetWaitableTimerbyrefc_void_pZWaitForSingleObject) microsecondsobjdelayrrr_usleepsr*darwinz libc.dylib) find_librarycT) use_errnocsddlmGdddtj}tjtjt|g_dt krDdn2dt krddt d t nd t krrd nd |fd d}|S)Nr)strerrorc@s eZdZdejfdejfgZdS)z._libc_clock_gettime_wrapper..struct_tvtv_sectv_usecN)__name__ __module__ __qualname__r"c_long_fields_rrrr struct_tvsr7linuxZfreebsd z clock.py: {{{:s}}} clock ID {:d}Zopenbsdcs@ttdkr0t}t||jjdS)Nrg& .>)r"r5pointer get_errnoOSErrorr0r1)Z_ernnoZ_clock_gettimeZ_clockidr/tvrr_times z*_libc_clock_gettime_wrapper.._time) osr/r" Structure_libc clock_gettimer5POINTERargtypesrrdebugformat)r7rBrr@r_libc_clock_gettime_wrappers( rKcCstt|dSr) _libc_usleepr$r'r(rrrr*+scCst|ddSNg.A)timesleeprMrrrr*5scseZdZdZdZdZdZdZdZdZ dZ dZ dZ dZ dZdZdZdZedZdZdZd.fdd Zd d Zed d ZeddZeddZddZddZddZddZddZddZ ddZ!d d!Z"d"d#Z#d$d%Z$d&d'Z%d(d)Z&d*d+Z'e(e)e*Z+d,d-Z,Z-S)/raThe base of the kivy clock. :parameters: `async_lib`: string The async library to use when the clock is run asynchronously. Can be one of, `"asyncio"` when the standard library asyncio should be used, or `"trio"` if the trio library should be used. It defaults to `'asyncio'` or the value in the environmental variable `KIVY_EVENTLOOP` if set. :meth:`init_async_lib` can also be called directly to set the library. g-C6?Nrg{Gzt?gMbP?asyncioc sH||tt|jf|||_|_|_tt dd|_ dS)NZgraphicsZmaxfps) init_async_libsuperr__init__rO _duration_ts0 _start_tick _last_tickfloatrgetint_max_fps)self async_libkwargs __class__rrrTes zClockBaseBehavior.__init__cs\|dkr*ddl|_fdd}||_n.|dkrJddl}||_|j|_ntd|dS)aManually sets the async library to use internally, when running in a asynchronous manner. This can be called anytime before the kivy event loop has started, but not once the kivy App is running. :parameters: `lib`: string The async library to use when the clock is run asynchronously. Can be one of, `"asyncio"` when the standard library asyncio should be used, or `"trio"` if the trio library should be used. triorNc s$||IdHW5QRXdSr)Z move_on_after)corotr`rrwait_for}s z2ClockBaseBehavior.init_async_lib..wait_forrQzasync library {} not recognized)r` _async_lib_async_wait_forrQrd ValueErrorrJ)r[librdrQrrcrrRks  z ClockBaseBehavior.init_async_libcCs|jS)zwTime spent between the last frame and the current frame (in seconds). .. versionadded:: 1.8.0 )_dtr[rrr frametimeszClockBaseBehavior.frametimecCs|jS)zNumber of internal frames (not necessarily drawn) from the start of the clock. .. versionadded:: 1.8.0 )_framesrjrrrframesszClockBaseBehavior.framescCs|jS)z@Number of displayed frames from the start of the clock. )_frames_displayedrjrrrframes_displayedsz"ClockBaseBehavior.frames_displayedcCsdS)z/Sleeps for the number of microseconds. Nrr[r'rrrusleepszClockBaseBehavior.usleepc Csz|j}|dkr\|}d|}|j}|j}||||\}}|s\|d|||||\}}q:|}||j|_||_|S)z4(internal) waits here until the next frame. r皙?i@B)rZget_resolutionrq _check_readyrOrWri) r[fps min_sleep undershootrqreadydone sleeptimecurrentrrridles  zClockBaseBehavior.idlec s|j}|dkr||}d|}|j}d}||||\}}|sdd}|j|IdH||||\}}q8|s|jdIdHn|jdIdH|}||j|_||_|S)z2(internal) async version of :meth:`idle`. rrrFTN)rZrsrtrerPrOrWri) r[rurvrwrxsleptryrzr{rrr async_idles$ zClockBaseBehavior.async_idlecCs*d|||j}|||k||fS)Nr<)rOrW)r[rurvrwrzrrrrtszClockBaseBehavior._check_readycCs$||}|||dS)zAdvance the clock to the next step. Must be called every frame. The default clock has a tick() function called by the core Kivy framework.N)pre_idlerO post_idler|)r[tsrrrtickszClockBaseBehavior.tickcs.||}|IdH}|||dS)zasync version of :meth:`tick`. N)rrOr~r)r[rr{rrr async_tickszClockBaseBehavior.async_tickcCs |dS)z4Called before :meth:`idle` by :meth:`tick`. N)Z_release_referencesrjrrrrszClockBaseBehavior.pre_idlecCs|jd7_|jd7_|jd7_|j||7_||j}|dkrv||jt|j|_||_d|_|_|jdkr||_nB||jdkrt||j}|j||_|j |_ ||_d|_d|_ | |j S)z3Called after :meth:`idle` by :meth:`tick`. r<g?rN) rl _fps_counter_duration_count _sleep_timerUrX_events_duration_last_fps_tick_fps _rfps_counter_rfpsZ_process_eventsri)r[rr{Zt_totdrrrrs*    zClockBaseBehavior.post_idlecCs(||jd7_|jd7_dS)z"Tick the drawing counter. r<N)Z_process_events_before_framerrnrjrrr tick_draw szClockBaseBehavior.tick_drawcCs|jS)z=Get the current average FPS calculated by the clock. )rrjrrrget_fpsszClockBaseBehavior.get_fpscCs|jS)aGet the current "real" FPS calculated by the clock. This counter reflects the real framerate displayed on the screen. In contrast to get_fps(), this function returns a counter of the number of frames, not the average of frames per second. )rrjrrrget_rfpsszClockBaseBehavior.get_rfpscCs|jS)z$Get the last tick made by the clock.)rWrjrrrget_time!szClockBaseBehavior.get_timecCs |j|jS)z3Get the time in seconds from the application start.)rWrVrjrrr get_boottime%szClockBaseBehavior.get_boottimecCs"ddlm}|||jkrdS)Nr)ExceptionManager)Z kivy.baserhandle_exceptionZRAISE)r[errrrr+s z"ClockBaseBehavior.handle_exception)rQ).r2r3r4__doc__rirrVrrrrrlrnrrrrUZ MIN_SLEEPZSLEEP_UNDERSHOOTrerfrTrRpropertyrkrmrorqr|r~rtrrrrrrrrr staticmethodr _default_timerOr __classcell__rrr^rr9sR   !  rz-Proxy method for :func:`~kivy.compat.clock`. csneZdZdZdZdZdZdZdfdd ZfddZ dd Z d d Z d d Z ddZ ddZddZZS)r zLA kivy clock which can be interrupted during a frame to execute events. FNc s,tt|jf|t|_||_|j|_dSr)rSr rTThreadingEvent_eventinterupt_next_onlyZget_min_timeout_get_min_timeout_func)r[rr]r^rrrT?sz#ClockBaseInterruptBehavior.__init__cs^tt|||dkr6ddl}||_|jn$|dkrZddl}||_|jdS)Nr`rrQ)rSr rRr`r _async_eventsetrQ)r[rhr`rQr^rrrREs   z)ClockBaseInterruptBehavior.init_async_libcCs|j|j|ddSrN)rclearwaitrprrrrqSs z!ClockBaseInterruptBehavior.usleepcs*|j||j|dIdHdSrN)rrrfrrprrr async_usleepWs  z'ClockBaseInterruptBehavior.async_usleepcCs`|j}|sdS|jrB|js\|jd|||jd|kr\|j|jr\|jdS)Nr<rr) rZtimeoutrrOrWrsrrr)r[eventrurrr on_schedule\s"   z&ClockBaseInterruptBehavior.on_schedulecCsh|j}|j}|}|dkrB|||d||\}}|sB|||}||j|_||_||SNrrr) rZrrsrtrrOrWrirr[rur resolutionryrzr{rrrr|js"  zClockBaseInterruptBehavior.idlecs|j}|j}|}|dkrd|||d||\}}|sP|||IdHqv|jdIdHn|jdIdH|}||j |_ ||_ | |Sr) rZrrsrtrfrrerPrOrWrirrrrrr~s& z%ClockBaseInterruptBehavior.async_idlecCsr|r dS|}|sdS|jsH|}td|||j||}nd|||j}|||k||fS)N)Trr<)is_setrrrOminrW)r[rurvrwrrbZcurr_trzrrrrtsz'ClockBaseInterruptBehavior._check_ready)F)r2r3r4rrrrrrTrRrqrrr|r~rtrrrr^rr 6s r cs,eZdZdZfddZfddZZS)r zWA base class for the clock that interrupts the sleep interval for free events. c stt|jf||j|_dSr)rSr rTget_min_free_timeoutrr[r]r^rrrTsz'ClockBaseInterruptFreeBehavior.__init__cs$|js dS||_tt||Sr)freerOZ_last_dtrSr r)r[rr^rrrs z*ClockBaseInterruptFreeBehavior.on_schedule)r2r3r4rrTrrrrr^rr s r cs,eZdZdZdZfddZddZZS)r z8The ``default`` kivy clock. See module for details. Nc stt|jf|t|_dSr)rSr rTr _sleep_objrr^rrrTszClockBase.__init__cCst||jdSr)r*rrprrrrqszClockBase.usleep)r2r3r4rrrTrqrrrr^rr s r c@seZdZdZdS)r z:The ``interrupt`` kivy clock. See module for details. Nr2r3r4rrrrrr sr c@seZdZdZdS)r z9The ``free_all`` kivy clock. See module for details. Nrrrrrr sr c@s eZdZdZddZddZdS)rz:The ``free_only`` kivy clock. See module for details. c Cs|j}|}|j}|dkr|}|j}d|}|j}|j}d|||j} | ||kr|rjd} n4|} | szd} n$|rd} nt | | |} | ||k} | r| | |n| | ||}d|||j} qP||j|_ ||_| |S)Nrrrr<TF)rZrOrrsrqrrrWrrr_process_free_eventsrri) r[rur{rrvrqrwmin_trrzdo_freerbrrrr|s<    zClockBaseFreeInterruptOnly.idlec s@|j}|}|j}|dkr|}|j}d|}|j}|j}d|||j} d} | ||kr|rpd} n4|} | sd} n$|rd} nt | | |} | ||k} | r| | |nd} | | | |IdH|}d|||j} qV| s"|jdIdHn|jdIdH||j|_||_| |S)Nrrrr<FT)rZrOrrsrqrrrWrrrrrfrrerPri) r[rur{rrvrqrwrrrzr}rrbrrrr~sL      z%ClockBaseFreeInterruptOnly.async_idleN)r2r3r4rr|r~rrrrrs&rcstfdd}|S)a{Decorator that will schedule the call of the function for the next available frame in the mainthread. It can be useful when you use :class:`~kivy.network.urlrequest.UrlRequest` or when you do Thread programming: you cannot do any OpenGL-related work in a thread. Please note that this method will return directly and no result can be returned:: @mainthread def callback(self, *args): print('The request succeeded!', 'This callback is called in the main thread.') self.req = UrlRequest(url='http://...', on_success=callback) .. versionadded:: 1.8.0 cs fdd}t|ddS)NcsdSrrdt)argsfuncr]rr callback_funcFsz7mainthread..delayed_func..callback_funcr)rZ schedule_once)rr]rrrr]r delayed_funcDsz mainthread..delayed_func)r)rrrrrr1srFcsfdd}|S)aDecorator that will trigger the call of the function at the specified timeout, through the method :meth:`CyClockBase.create_trigger`. Subsequent calls to the decorated function (while the timeout is active) are ignored. It can be helpful when an expensive function (i.e. call to a server) can be triggered by different methods. Setting a proper timeout will delay the calling and only one of them will be triggered. @triggered(timeout, interval=False) def callback(id): print('The callback has been called with id=%d' % id) >> callback(id=1) >> callback(id=2) The callback has been called with id=2 The decorated callback can also be unscheduled using: >> callback.cancel() .. versionadded:: 1.10.1 cs\gifdd}tj|dtfdd}fdd}t|d||S) NcstdSr)tupler)_args_kwargsrrr cb_functionisz9triggered..wrapper_triggered..cb_function)rintervalcs6gdd<t||dSr)extendlistrupdater)rr cb_triggerrrtrigger_functionqs   z>triggered..wrapper_triggered..trigger_functioncs dSr)cancelr)rrrtrigger_cancelysz.wrapper_triggered..trigger_cancelr)rZcreate_triggerrsetattr)rrrrrr)rrrrrwrapper_triggeredds  z$triggered..wrapper_triggeredr)rrrrrrrLsrZKIVY_DOC_INCLUDEr)defaultZ interruptZfree_allZ free_onlyZ KIVY_CLOCKZkivyZ kivy_clockz1{} is not a valid kivy clock. Valid clocks are {}ZKIVY_EVENTLOOPrQ)r\)N)N)N)rF)Br__all__sysrrCr functoolsrrZ kivy.contextrZ kivy.configrZ kivy.loggerrZ kivy.compatrrrOZ kivy._clockrrrrr ImportErrorerror threadingrrrr"windllkernel32r r*CDLLrEZ ctypes.utilr,rKc_ulongrqrHrLr?AttributeErrorobjectrr r r r r rrrr__annotations__Z_classesgetZ_clk ExceptionrJsortedkeysrrrrsD            & {r  Z 7