^ j KdZddlmZddlZddlZddlmZddlm Z m Z m Z ddl m Z ddlZe r ddlmZmZmZdZdZe e ddfZGd d eZGd d ZdS) aEvent dispatch framework. All objects that produce events in pyglet implement :py:class:`~pyglet.event.EventDispatcher`, providing a consistent interface for registering and manipulating event handlers. A commonly used event dispatcher is `pyglet.window.Window`. Event types =========== For each event dispatcher there is a set of events that it dispatches; these correspond with the type of event handlers you can attach. Event types are identified by their name, for example, ''on_resize''. If you are creating a new class which implements :py:class:`~pyglet.event.EventDispatcher`, you must call `EventDispatcher.register_event_type` for each event type. Attaching event handlers ======================== An event handler is simply a function or method. You can attach an event handler by setting the appropriate function on the instance:: def on_resize(width, height): # ... dispatcher.on_resize = on_resize There is also a convenience decorator that reduces typing:: @dispatcher.event def on_resize(width, height): # ... You may prefer to subclass and override the event handlers instead:: class MyDispatcher(DispatcherClass): def on_resize(self, width, height): # ... Event handler stack =================== When attaching an event handler to a dispatcher using the above methods, it replaces any existing handler (causing the original handler to no longer be called). Each dispatcher maintains a stack of event handlers, allowing you to insert an event handler "above" the existing one rather than replacing it. There are two main use cases for "pushing" event handlers: * Temporarily intercepting the events coming from the dispatcher by pushing a custom set of handlers onto the dispatcher, then later "popping" them all off at once. * Creating "chains" of event handlers, where the event propagates from the top-most (most recently added) handler to the bottom, until a handler takes care of it. Use `EventDispatcher.push_handlers` to create a new level in the stack and attach handlers to it. You can push several handlers at once:: dispatcher.push_handlers(on_resize, on_key_press) If your function handlers have different names to the events they handle, use keyword arguments:: dispatcher.push_handlers(on_resize=my_resize, on_key_press=my_key_press) After an event handler has processed an event, it is passed on to the next-lowest event handler, unless the handler returns `EVENT_HANDLED`, which prevents further propagation. To remove all handlers on the top stack level, use `EventDispatcher.pop_handlers`. Note that any handlers pushed onto the stack have precedence over the handlers set directly on the instance (for example, using the methods described in the previous section), regardless of when they were set. For example, handler ``foo`` is called before handler ``bar`` in the following example:: dispatcher.push_handlers(on_resize=foo) dispatcher.on_resize = bar Dispatching events ================== pyglet uses a single-threaded model for all application code. Event handlers are only ever invoked as a result of calling EventDispatcher.dispatch_events`. It is up to the specific event dispatcher to queue relevant events until they can be dispatched, at which point the handlers are called in the order the events were originally generated. This implies that your application runs with a main loop that continuously updates the application state and checks for new events:: while True: dispatcher.dispatch_events() # ... additional per-frame processing Not all event dispatchers require the call to ``dispatch_events``; check with the particular class documentation. .. note:: In order to prevent issues with garbage collection, the :py:class:`~pyglet.event.EventDispatcher` class only holds weak references to pushed event handlers. That means the following example will not work, because the pushed object will fall out of scope and be collected:: dispatcher.push_handlers(MyHandlerClass()) Instead, you must make sure to keep a reference to the object before pushing it. For example:: my_handler_instance = MyHandlerClass() dispatcher.push_handlers(my_handler_instance) ) annotationsN)partial) TYPE_CHECKINGLiteralUnion) WeakMethod)AnyCallable GeneratorTceZdZdZdS)EventExceptionz@An exception raised when an event handler could not be attached.N)__name__ __module__ __qualname____doc__G/home/agentuser/manim-venv/lib/python3.11/site-packages/pyglet/event.pyr r sJJJJrr ceZdZUdZded<dZded<ed'd Zd(dZd)dZ d(dZ d*dZ d+dZ d(dZ d*dZd*dZd,dZd,d Zd-d#Zd+d$Zd.d%Zd&S)/EventDispatcherzQGeneric event dispatcher interface. See the module docstring for usage. list event_typesrz tuple | list _event_stackcls type[object]namestrreturncht|dsg|_|j||S)a1Register an event type with the dispatcher. Before dispatching events, they must first be registered by name. Registering event types allows the dispatcher to validate event handler names as they are attached, and to search attached objects for suitable handlers. r)hasattrrappend)rrs rregister_event_typez#EventDispatcher.register_event_types8sM** ! CO t$$$ rargsr kwargsNonect|jturg|_|jdi|j|i|dS)aPush a new level onto the handler stack, and add 0 or more handlers. This method first pushes a new level to the top of the handler stack. It then attaches any handlers that were passed to this new level. If keyword arguments are given, they name the event type to attach. Otherwise, a callable's ``__name__`` attribute will be used. Any other object may also be specified, in which case it will be searched for callables with event names. rN)typertupleinsert set_handlers)selfr#r$s r push_handlerszEventDispatcher.push_handlerss[ ! " "e + + "D    B'''4*6*****rdict+Generator[tuple[str, Callable], None, None]c #K|D]}tj|rh|j}||jvrd|d}t |tj|r(|t |t|j|fVw||fV~t|D]B}||jvr7t||}|t |t|j|fVC| D]e\}}||jvrd|d}t |tj|r(|t |t|j|fV_||fVfdS)zMImplement handler matching on arguments for set_handlers and remove_handlers.zUnknown event ""N) inspect isroutinerrr ismethodrr_remove_handlerdirgetattritems)r+r#r$objrmsgmethhandlers r _get_handlerszEventDispatcher._get_handlerss Z ZC %% ZLt///3D333C(---#C(($ 38Ld0S0S T TTTTTT)OOOO HHZZDt///&sD11"JtWT=QSW5X5X$Y$YYYYYZ $\\^^ $ $MD'4+++////$S)))(( $Jw8Ld0S0STTTTTTTGm#### $ $rct|jturig|_|||D]\}}|||dS)zAttach one or more event handlers to the top level of the handler stack. See :py:meth:`~pyglet.event.EventDispatcher.push_handlers` for the accepted argument types. N)r'rr(r< set_handler)r+r#r$rr;s rr*zEventDispatcher.set_handlerssj ! " "e + +!#D !//f== , ,MD'   T7 + + + + , ,rr;r clt|jturig|_||jd|<dS)zAttach a single event handler.rN)r'rr()r+rr;s rr>zEventDispatcher.set_handlers< ! " "e + +!#D %,!T"""rc8|js Jd|jd=dS)z2Pop the top level of event handlers off the stack.zNo handlers pushedrNr)r+s r pop_handlerszEventDispatcher.pop_handlerss+ 66"666  a rct||dfd }|}|sdSD]%\}} |||kr||=#t$rY"wxYw|sj|dSdS)aRemove event handlers from the event stack. See :py:meth:`~pyglet.event.EventDispatcher.push_handlers` for the accepted argument types. All handlers are removed from the first stack frame that contains any of the given handlers. No error is raised if any handler does not appear in that frame, or if no stack frame contains any of the given handlers. If the stack frame is empty after removing the handlers, it is removed from the stack. Note that this interferes with the expected symmetry of :py:meth:`~pyglet.event.EventDispatcher.push_handlers` and :py:meth:`~pyglet.event.EventDispatcher.pop_handlers`. r dict | NonecZjD]!}D]\}}||vr |||kr|ccS"dSNrA)_frame_name_handlerhandlersr+s r find_framez3EventDispatcher.remove_handlers..find_framesc+ & &'/&&OE8F** e}00% 1& 4rN)rrD)rr<KeyErrorrremove)r+r#r$rKframerr;rJs` @rremove_handlerszEventDispatcher.remove_handlerss**48899          F&  MD' ;'))d      ,   $ $U + + + + + , ,sA A A c`|jD]%} |||kr||=dS#t$rY"wxYwdS)aRemove a single event handler. The given event handler is removed from the first handler stack frame it appears in. The handler must be the exact same callable as passed to `set_handler`, `set_handlers` or :py:meth:`~pyglet.event.EventDispatcher.push_handlers`; and the name must match the event type it is bound to. No error is raised if the event handler is not set. N)rrLr+rr;rNs rremove_handlerzEventDispatcher.remove_handlersi&  E ;'))d EE*       s  ++ct|jD]C}||vr= |||kr||=|s|j|3#t$rY?wxYwDdS)zUsed internally to remove all handler instances for the given event name. This is normally called from a dead ``WeakMethod`` to remove itself from the event stack. N)rrrM TypeErrorrQs rr4zEventDispatcher._remove_handler2s$+,,  Eu}}T{g--!$K$< -44U;;; D   s+A AA event_type bool | Nonec t|ds Jd||jvsJ|d|d|jd}t|jD]~}||d}|st |t r|}|J d}||r tcSP#t$r"}| ||||Yd}~wd}~wwxYw t|||rtS d}nq#t$r,}t||d}t|r|Yd}~n@d}~wt$r0}| ||t|||Yd}~nd}~wwxYw|rtSdS)aDispatch an event to the attached event handlers. The event is propagated to all registered event handlers in the stack, starting and the top and going down. If any registered event handler returns ``EVENT_HANDLED``, no further handlers down the stack will receive this event. This method has several possible return values. If any event handler has returned ``EVENT_HANDLED``, then this method will also return ``EVENT_HANDLED``. If not, this method will return ``EVENT_UNHANDLED``. If there were no events registered to receive this event, ``False`` is returned. Returns: ``EVENT_HANDLED`` if any event handler returned ``EVENT_HANDLED``; ``EVENT_UNHANDLED`` if one or more event handlers were invoked without any of them returning `EVENT_HANDLED`; ``False`` if no event handlers were registered. rzNo events registered on this EventDispatcher. You need to register events with the class method EventDispatcher.register_event_type('event_name').z not found in z.event_types == FNT)r rrrget isinstancer EVENT_HANDLEDrT_raise_dispatch_exceptionr6AttributeErrorcallableEVENT_UNHANDLED) r+rUr#invokedrNr; exceptioneevent_ops rdispatch_eventzEventDispatcher.dispatch_eventEs;(t]++   A  + T----*/t/tD/t/tbfbr/t/t---$+,, U UEii D11G ':.. +!'))*** U7D>)(((() U U U..z4)TTTTTTTT U (wtZ(($/ %$$ %GG   tZ66H!!       c c c  * *:tWT:=V=VXa b b b b b b b b c  #" "us< B!! C +CC C// E9"D  E-&EEc@tjjj||g|RdS)aPost an event to the main application thread. Unlike the :py:meth:`~pyglet.event.EventDispatcher.dispatch_event` method, this method does not dispatch events directly. Instead, it hands off the dispatch call to the main application thread. This ensures that any event handlers are also executed in the main thread. This method aliases :py:meth:`~pyglet.app.PlatformEventLoop.post_event`, which can be seen for more information on behavior. N)pygletappplatform_event_loop post_event)r+rUr#s rrhzEventDispatcher.post_events*  &1$ JTJJJJJJrr` Exceptionc t|}tj|}|j}|j}|j} t|} tj|r |jr| dz} |rt| |} | r"| |cxkr| t| z krnn|} | |krtj |stj|rGtj |j j\} } d|jd| d|j j} nt#|} d|vr|d|jjd|}d|d|d t)|d | d | d | }t+||) N'z' in :r+.zThe 'z' event was dispatched with z arguments: z, but your handler z is written to expect z arguments: )lenr1getfullargspecr#varargsdefaultsr3__self__max isfunctionospathsplit__code__ co_filenamerco_firstlinenoreprrM __class__rrT)r+rUr#r;r`n_argsargspecs handler_argshandler_varargshandler_defaultsn_handler_args_filenamedescr caller_namer9s rr[z)EventDispatcher._raise_dispatch_exceptionsT)'22} "*#,\**  G $ $ )9 a N  9 88N  $ a a a a>CP`LaLa;a a a a a a#N V # #!'** &g.>w.G.G & gmmG,<,HII 8_G,__8__g>N>]__W %%##F+++!^4CCzCCKo;ooFooY]^bYcYcoo',ooDRoo`looCC.. rct|jD]F\}}td||D]\}}td|d|GdS)Nzlevel: z - 'z': ) enumeraterprintr7)r+levelrJrUr;s r_dump_handlerszEventDispatcher._dump_handlerss():;; 7 7OE8 #E## $ $ $'/~~'7'7 7 7# G5Z55G556666 7 7 7rcDt|dkrd fd }|Stj|dr-|d}|j||dSt |dt r|dd fd }|Sd}t|) a?Function decorator for an event handler. If the function or method name matches the event name, the decorator can be added without arguments. Likewise, if the name does not match, you can provide the target event name by passing it as an argument. Name matches:: win = window.Window() @win.event def on_resize(self, width, height): # ... Name does not match:: @win.event('on_resize') def foo(self, width, height): # ... rfunctionr rcB|j}|||SrF)rr>)r func_namer+s r decoratorz(EventDispatcher.event..decorators&$-   H555rc4||SrF)r>)rrr+s rrz(EventDispatcher.event..decorators  x000rz2Argument must be the name of the event as a `str`.N)rr rr )ror1r2rr>rYrrT)r+r#rfuncr9rs` @reventzEventDispatcher.events0 t99>>         T!W % % 7D=D   T4 ( ( (7N d1gs # # 7D        BnnrN)rrrrrr)r#r r$r rr%)r#rr$r-rr.)rrr;r rr%)rr%)rUrr#r rrV) rUrr#r r;r r`rirr%)r#r rr )rrrr__annotations__r classmethodr"r,r<r*r>rBrOrRr4rcrhr[rrrrrrrsh!#L####   [ ++++&$$$$< , , , ,----!!!! *,*,*,*,X&&<<<<| K K K K0000d7777333333rr)r __future__rr1os.pathrv functoolsrtypingrrrweakrefrrer r r rZr^EVENT_HANDLE_STATErir rrrrrs7uul#"""""0000000000 0////////// 74=$./KKKKKYKKKoooooooooor