a

��	^W$�@s@dd
lm
Z

Gdd�de�ZGdd�de�Zdd�Zdd	�Zd
S)�
)
�_gic@sjeZ
dZd
ZGdd�de�Zddd�
Zddejdddddfdd	�
Z	dd
d�
Z
dd
�Zddd�
Zdd�Z
dS)�Signala�Object which gives a nice API for creating and binding signals.

    :param name:
        Name of signal or callable closure when used as a decorator.
    :type name: str or callable
    :param callable func:
        Callable closure method.
    :param GObject.SignalFlags flags:
        Flags specifying when to run closure.
    :param type return_type:
        Return type of the Signal.
    :param list arg_types:
        List of argument types specifying the signals function signature
    :param str doc:
        Documentation of signal object.
    :param callable accumulator:
        Accumulator method with the signature:
        func(ihint, return_accu, handler_return, accu_data) -> boolean
    :param object accu_data:
        User data passed to the accumulator.

    :Example:

    .. code-block:: python

        class Spam(GObject.Object):
            velocity = 0

            @GObject.Signal
            def pushed(self):
                self.velocity += 1

            @GObject.Signal(flags=GObject.SignalFlags.RUN_LAST)
            def pulled(self):
                self.velocity -= 1

            stomped = GObject.Signal('stomped', arg_types=(int,))

            @GObject.Signal
            def annotated_signal(self, a:int, b:str):
                "Python3 annotation support for parameter types.

        def on_pushed(obj):
            print(obj)

        spam = Spam()
        spam.pushed.connect(on_pushed)
        spam.pushed.emit()
    c@sPeZ
dZd
Zdd�Zdd�Zdd�Zdd	�Zd
d�Zdd
�Z	dd�Z
dd�ZdS)zSignal.BoundSignalz�
        Temporary binding object which can be used for connecting signals
        without specifying the signal name string to connect.
        cOst�
||
�S�
N)�str�__new__��cls�name�args�kargs�r�6/usr/lib64/python3.9/site-packages/gi/_signalhelper.pyrNs
zSignal.BoundSignal.__new__cCst�
|�

|
|_||_dSr)r�__init__�signal�gobj)�selfrrrrr
rQs



zSignal.BoundSignal.__init__c

Csd
|S)NzBoundSignal("%s")r�
rrrr
�__repr__Vs
zSignal.BoundSignal.__repr__c
Os|jj
|jg
|
�
Ri|�
�
S)
zCall the signals closure.)r�funcr�rr
rrrr
�__call__YszSignal.BoundSignal.__call__cOs|jj
||
g|�
Ri|�
�
S)
z^Same as GObject.Object.connect except there is no need to specify
            the signal name.�r�connect)r�callbackr
rrrr
r]szSignal.BoundSignal.connectcOs$|jj
|d
||
g|�
Ri|�
�
S)a

Same as GObject.Object.connect except there is no need to specify
            the signal name. In addition concats "::<detail>" to the signal name
            when connecting; for use with notifications like "notify" when a property
            changes.
            z::r)rrZdetailr
rrrr
�connect_detailedbsz#Signal.BoundSignal.connect_detailedcCs|j�
|
�

d
S)z"Same as GObject.Object.disconnect.N)r�
disconnect)rZ
handler_idrrr
rjszSignal.BoundSignal.disconnectc
Os|jj
t|�
g
|
�
Ri|�
�
S)
z[Same as GObject.Object.emit except there is no need to specify
            the signal name.)r�emitrrrrr
rnszSignal.BoundSignal.emitN)�__name__�
__module__�__qualname__�__doc__rrrrrrrrrrrr
�BoundSignalIs
r!�cOst|
�
r|
j
}
t�||
�Sr)�callablerrrrrrr
rss


zSignal.__new__Nc		Cs�|durt|
�
r|
}|r"|s"|j
}t�|�

|rD|sD|sDt|�
\}}|durRt�}||_||_||_||_	||_
||_
||_dSr)r#r rr�get_signal_annotations�tupler�flags�return_type�	arg_types�accumulator�	accu_data)	rr	rr&r'r(�docr)r*rrr
rxs 











zSignal.__init__cCs|
d
ur|S|�||
�S)z:Returns a BoundSignal when accessed on an object instance.N)
r!)r�instance�ownerrrr
�__get__�s

zSignal.__get__c
Osjt|
t
j�r&|j|
g
|�
Ri|�
�

n@t|�
r8t|�
}n|
j}t|�
||
|j|j|j	|j
|j|jd
�SdS)zmAllows for instantiated Signals to be used as a decorator or calling
        of the underlying signal method.�r	rr&r'r(r+r)r*N)
�
isinstancerZGObjectrrr�typer&r'r(r r)r*)r�objr
rr	rrr
r�s




�zSignal.__call__c
Cs*t|�
|
|j
|j|j|j|j|j|jd
�S)z%Returns a renamed copy of the Signal.r/)r1rr&r'r(r r)r*)rZnewNamerrr
�copy�s

�zSignal.copyc

Cs|j|j
|j|j|jfS)
zKReturns a tuple of: (flags, return_type, arg_types, accumulator, accu_data))r&r'r(r)r*rrrr
�get_signal_args�szSignal.get_signal_args)
r")
N)
N)rrrr rr!rrZSIGNAL_RUN_FIRSTrr.rr3r4rrrr
rs
1*


�


rc@seZ
dZd
Zdd�ZdS)�SignalOverridea&
Specialized sub-class of Signal which can be used as a decorator for overriding
    existing signals on GObjects.

    :Example:

    .. code-block:: python

        class MyWidget(Gtk.Widget):
            @GObject.SignalOverride
            def configure_event(self):
                pass
    c


Csd
S)zReturns the string 'override'.�overriderrrrr
r4�szSignalOverride.get_signal_argsN)rrrr r4rrrr
r5�s
r5c
sZt�}
d
}t
|d�rRdd
l}|�|�
�t�f
dd��jD�
�
}
d�jvrR�jd}||
fS)a
Attempt pulling python 3 function annotations off of 'func' for
    use as a signals type information. Returns an ordered nested tuple
    of (return_type, (arg_type1, arg_type2, ...)). If the given function
    does not have annotations then (None, tuple()) is returned.
    N�__annotations__�c
3s"|]}
|
�jvr�j|
V
qdSr)
�annotations)�.0�arg�
�specrr
�	<genexpr>�s

�z)get_signal_annotations.<locals>.<genexpr>�return)r%�hasattr�inspectZgetfullargspecr
r9)rr(r'rArr<r
r$�s







r$c
Cs�|j�
d
i�}
i}|j��D]`\}}t|t�rt|�
}|sT|}|�|�
}t|||�
||
vrhtd|�
�
|||<|�	�|
|<q|
|_
|��D]:\}}|jdu
r�d|�dd�}t
||�s�t|||j�
q�dS)z�Adds Signal instances on a GObject derived class into the '__gsignals__'
    dictionary to be picked up and registered as real GObject signals.
    �__gsignals__z(Signal "%s" has already been registered.NZdo_�
-�
_)�__dict__�get�itemsr0rrr3�setattr�
ValueErrorr4rBr�replacer@)rZgsignalsZ
newsignalsr	rZ
signalNameZfuncNamerrr
�install_signals�s&


















rKN)r"rrrr5r$rKrrrr
�<module>s