U

��dZ�1�@s�dd
lm
Z
mZ
ddlZddlZGdd�de�Zdd�ZGdd�de�Z	Gd	d
�d
e�Z
e
�ZejZ
ejZejZejZejZdS)�)�division�print_functionNcs eZ
dZd
Z�f
dd�Z�ZS)�MetaSignalszl
    register the list of signals in the class variable signals,
    including signals in superclasses.
    csn|�d
g�}|j
D]}|�t|d
g��

qttdd�|D�
�
���
}||d
<t||�
tt	|��
|
||�
dS)N�signalsc
Ssg|]}
|
df�qS�
N�)�.0�
xrr�//usr/lib/python3/dist-packages/urwid/signals.py�
<listcomp>%sz(MetaSignals.__init__.<locals>.<listcomp>)�get�	__bases__�extend�getattr�list�dict�keys�register_signal�superr�__init__)�cls�name�bases�
drZ
superclass�
�	__class__rr
r!s








zMetaSignals.__init__)�__name__�
__module__�__qualname__�__doc__r�
__classcell__rrrr
rs
rcCs$t||
�rt
||
�St||
|�
|Sr)�hasattrr�setattr)�objr�valuerrr
�setdefaultattr*s




r%c
@seZ
dZd
ZgZdS)�KeyzX
    Minimal class, whose only purpose is to produce objects with a
    unique hash
    N)rrrr�	__slots__rrrr
r&1s
r&c@sVeZ
dZd
Zdd�Zdd�Zddd�
Zdd	d
�
Zddd�
Zd
d�Z	dd�Z
dd�ZdS)�SignalsZ_urwid_signalsc

Cs
i|_dSr�
�
_supported)
�selfrrr
r;s
zSignals.__init__cCs||j|
<d
S)a�

        :param sig_class: the class of an object that will be sending signals
        :type sig_class: class
        :param signals: a list of signals that may be sent, typically each
                        signal is represented by a string
        :type signals: signal names

        This function must be called for a class before connecting any
        signal callbacks or emitting any signals from that class' objects
        Nr))r+�sig_clsrrrr
�register>szSignals.registerNcs�|
j}�
�j
�|g�kr(td
�
|
f�
�
t��t|
�ji�}|��
g�}	t�	|
�
���
��fdd�}
��
|||
�}|	��|||f�

�S)a7
        :param obj: the object sending a signal
        :type obj: object
        :param name: the signal to listen for, typically a string
        :type name: signal name
        :param callback: the function to call when that signal is sent
        :type callback: function
        :param user_arg: deprecated additional argument to callback (appended
                         after the arguments passed when the signal is
                         emitted). If None no arguments will be added.
                         Don't use this argument, use user_args instead.
        :param weak_args: additional arguments passed to the callback
                          (before any arguments passed when the signal
                          is emitted and before any user_args).

                          These arguments are stored as weak references
                          (but converted back into their original value
                          before passing them to callback) to prevent
                          any objects referenced (indirectly) from
                          weak_args from being kept alive just because
                          they are referenced by this signal handler.

                          Use this argument only as a keyword argument,
                          since user_arg might be removed in the future.
        :type weak_args: iterable
        :param user_args: additional arguments to pass to the callback,
                          (before any arguments passed when the signal
                          is emitted but after any weak_args).

                          Use this argument only as a keyword argument,
                          since user_arg might be removed in the future.
        :type user_args: iterable

        When a matching signal is sent, callback will be called. The
        arguments it receives will be the user_args passed at connect
        time (as individual arguments) followed by all the positional
        parameters sent with the signal.

        As an example of using weak_args, consider the following snippet:

        >>> import urwid
        >>> debug = urwid.Text('')
        >>> def handler(widget, newtext):
        ...    debug.set_text("Edit widget changed to %s" % newtext)
        >>> edit = urwid.Edit('')
        >>> key = urwid.connect_signal(edit, 'change', handler)

        If you now build some interface using "edit" and "debug", the
        "debug" widget will show whatever you type in the "edit" widget.
        However, if you remove all references to the "debug" widget, it
        will still be kept alive by the signal handler. This because the
        signal handler is a closure that (implicitly) references the
        "edit" widget. If you want to allow the "debug" widget to be
        garbage collected, you can create a "fake" or "weak" closure
        (it's not really a closure, since it doesn't reference any
        outside variables, so it's just a dynamic function):

        >>> debug = urwid.Text('')
        >>> def handler(weak_debug, widget, newtext):
        ...    weak_debug.set_text("Edit widget changed to %s" % newtext)
        >>> edit = urwid.Edit('')
        >>> key = urwid.connect_signal(edit, 'change', handler, weak_args=[debug])

        Here the weak_debug parameter in print_debug is the value passed
        in the weak_args list to connect_signal. Note that the
        weak_debug value passed is not a weak reference anymore, the
        signals code transparently dereferences the weakref parameter
        before passing it to print_debug.

        Returns a key associated by this signal handler, which can be
        used to disconnect the signal later on using
        urwid.disconnect_signal_by_key. Alternatively, the signal
        handler can also be disconnected by calling
        urwid.disconnect_signal, which doesn't need this key.
        zNo such signal %r for object %rc
s<��}
|
r8zt|
�j
i��
�=Wntk
r6


YnXdSr)r�_signal_attr�KeyError)�weakref�
o��keyrZobj_weakr+rr
�weakref_callback�s





z)Signals.connect.<locals>.weakref_callback)rr*r�	NameErrorr&r%r.�
setdefaultr0�ref�_prepare_user_args�append)r+r#r�callback�user_arg�	weak_args�	user_argsr,r�handlersr4rr2r
�connectKsM


�



zSignals.connectcs�f
d
d�|
pgD�
|pgS)Nc
sg|]}
t�
|
���qSr)r0r7)r�
a�
r:rr
r�sz.Signals._prepare_user_args.<locals>.<listcomp>r)r+r<r=r:rrAr
r8�szSignals._prepare_user_argsc
Csht|
|j
i�}||krd
S||}|�||�}|D]0}	|	dd
�|||fkr2|�|
||	d�
Sq2d
S)aI
        :param obj: the object to disconnect the signal from
        :type obj: object
        :param name: the signal to disconnect, typically a string
        :type name: signal name
        :param callback: the callback function passed to connect_signal
        :type callback: function
        :param user_arg: the user_arg parameter passed to connect_signal
        :param weak_args: the weak_args parameter passed to connect_signal
        :param user_args: the weak_args parameter passed to connect_signal

        This function will remove a callback from the list connected
        to a signal with connect_signal(). The arguments passed should
        be exactly the same as those passed to connect_signal().

        If the callback is not connected or already disconnected, this
        function will simply do nothing.
        N�
r
)r%r.r8�disconnect_by_key)
r+r#rr:r;r<r=rr>�
hrrr
�
disconnect�s



zSignals.disconnectcs8t|
|j
i�}|�|g�}�f
d
d�|D�
|dd�<dS)an
        :param obj: the object to disconnect the signal from
        :type obj: object
        :param name: the signal to disconnect, typically a string
        :type name: signal name
        :param key: the key for this signal handler, as returned by
                    connect_signal().
        :type key: Key

        This function will remove a callback from the list connected
        to a signal with connect_signal(). The key passed should be the
        value returned by connect_signal().

        If the callback is not connected or already disconnected, this
        function will simply do nothing.
        c
sg|]}
|
d�k	r|
�qS)
r
r)rrD�
r3rr
r�sz-Signals.disconnect_by_key.<locals>.<listcomp>N)r%r.r)r+r#rr3rr>rrFr
rC�s

zSignals.disconnect_by_keycGsHd
}t|
|j
i�}|�|g�}|D] \}}}	}
||�||	|
|�O}q"|S)a�

        :param obj: the object sending a signal
        :type obj: object
        :param name: the signal to send, typically a string
        :type name: signal name
        :param \*args: zero or more positional arguments to pass to the signal
                      callback functions

        This function calls each of the callbacks connected to this signal
        with the args arguments as positional parameters.

        This function returns True if any of the callbacks returned True.
        F)rr.r�_call_callback)r+r#r�args�resultrr>r3r:r;r=rrr
�emit�s




zSignals.emitcCsn|rHg}|D].}t|t
j�r0|�}|dkr0
d
S|�|�

q|�|�

n|}|dk	rbt�||f
�}t|
|��
S)NF)�
isinstancer0�
ReferenceTyper9r�	itertools�chain�bool)r+r:r;r=Z	emit_argsZargs_to_pass�argrrr
rG
s







zSignals._call_callback)NNN)
N)NNN)rrrr.rr-r?r8rErCrJrGrrrr
r(8s

p

"r()Z
__future__rrrMr0�typerr%�objectr&r(Z_signalsrJZemit_signalr-rr?Zconnect_signalrEZdisconnect_signalrCZdisconnect_signal_by_keyrrrr
�<module>s
r