
    fW$                     H    d dl mZ  G d de      Z G d de      Zd Zd Zy)	   )_gic                   v    e Zd ZdZ G d de      ZddZddej                  dddddfdZ	ddZ
d	 Zdd
Zd Zy)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                   @    e Zd ZdZd Zd Zd Zd Zd Zd Z	d Z
d	 Zy
)Signal.BoundSignalz
        Temporary binding object which can be used for connecting signals
        without specifying the signal name string to connect.
        c                 .    t         j                  | |      S N)str__new__clsnameargskargss       2/usr/lib/python3/dist-packages/gi/_signalhelper.pyr   zSignal.BoundSignal.__new__N   s    ;;sD))    c                 J    t         j                  |        || _        || _        y r	   )r
   __init__signalgobj)selfr   r   s      r   r   zSignal.BoundSignal.__init__Q   s    LL DKDIr   c                     d| z  S )NzBoundSignal("%s") r   s    r   __repr__zSignal.BoundSignal.__repr__V   s    &--r   c                 V     | j                   j                  | j                  g|i |S )zCall the signals closure.)r   funcr   r   r   r   s      r   __call__zSignal.BoundSignal.__call__Y   s'    #4;;##DII>>>>r   c                 D     | j                   j                  | |g|i |S )z^Same as GObject.Object.connect except there is no need to specify
            the signal name.r   connect)r   callbackr   r   s       r   r"   zSignal.BoundSignal.connect]   s'     %499$$T8DdDeDDr   c                 P     | j                   j                  | dz   |z   |g|i |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!   )r   r#   detailr   r   s        r   connect_detailedz#Signal.BoundSignal.connect_detailedb   s0     %499$$TD[6%98TdTeTTr   c                 :    | j                   j                  |       y)z"Same as GObject.Object.disconnect.N)r   
disconnect)r   
handler_ids     r   r(   zSignal.BoundSignal.disconnectj   s    II  ,r   c                 T     | j                   j                  t        |       g|i |S )z[Same as GObject.Object.emit except there is no need to specify
            the signal name.)r   emitr
   r   s      r   r+   zSignal.BoundSignal.emitn   s'     "499>>#d)<d<e<<r   N)__name__
__module____qualname____doc__r   r   r   r   r"   r&   r(   r+   r   r   r   BoundSignalr   I   s1    		*	
	.	?	E
	U	-	=r   r0    c                 \    t        |      r|j                  }t        j                  | |      S r	   )callabler,   r
   r   r   s       r   r   zSignal.__new__s   s#    D>==D{{3%%r   Nc	                    |t        |      r|}|r|s|j                  }t        j                  |        |r|s|st	        |      \  }}|
t               }|| _        || _        || _        || _	        || _        || _
        || _        y r	   )r3   r/   r
   r   get_signal_annotationstupler   flagsreturn_type	arg_typesaccumulator	accu_data)	r   r   r   r7   r8   r9   docr:   r;   s	            r   r   zSignal.__init__x   s    <HTND,,CT	%;D%A"KI	
&"&"r   c                 .    || S | j                  | |      S )z:Returns a BoundSignal when accessed on an object instance.)r0   )r   instanceowners      r   __get__zSignal.__get__   s     Kh//r   c           
      T   t        |t        j                        r | j                  |g|i | yt	        |       rt	        |       }n|j
                  } t        |       ||| j                  | j                  | j                  | j                  | j                  | j                        S )zmAllows for instantiated Signals to be used as a decorator or calling
        of the underlying signal method.r   r   r7   r8   r9   r<   r:   r;   N)
isinstancer   GObjectr   r
   r,   typer7   r8   r9   r/   r:   r;   )r   objr   r   r   s        r   r   zSignal.__call__   s     c3;;'DIIc*D*E* 4y4y||4:4c*.*:*:dnn"&,,D<L<LX\XfXfh hr   c           
           t        |       || j                  | j                  | j                  | j                  | j
                  | j                  | j                        S )z%Returns a renamed copy of the Signal.rB   )rE   r   r7   r8   r9   r/   r:   r;   )r   newNames     r   copyzSignal.copy   sN     tDzwTYYdjj&*&6&6$.."ll8H8HTXTbTbd 	dr   c                 t    | j                   | j                  | j                  | j                  | j                  fS )zKReturns a tuple of: (flags, return_type, arg_types, accumulator, accu_data))r7   r8   r9   r:   r;   r   s    r   get_signal_argszSignal.get_signal_args   s.    

D,,dnnd>N>NPTP^P^__r   )r1   r	   )r,   r-   r.   r/   r
   r0   r   r   SIGNAL_RUN_FIRSTr   r@   r   rI   rK   r   r   r   r   r      sQ    0b(=c (=T&
 T1E1E!TrtW[#.0h(d`r   r   c                       e Zd ZdZd Zy)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                      y)zReturns the string 'override'.overrider   r   s    r   rK   zSignalOverride.get_signal_args   s    r   N)r,   r-   r.   r/   rK   r   r   r   rN   rN      s    r   rN   c                     t               }d}t        | d      rPddl}|j                  |       t        fdj                  D              }dj
                  v rj
                  d   }||fS )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              3   X   K   | ]!  }|j                   v rj                   |    # y wr	   )annotations).0argspecs     r   	<genexpr>z)get_signal_annotations.<locals>.<genexpr>   s1      6C D$4$44 **3/ 6s   '*return)r6   hasattrinspectgetfullargspecr   rU   )r   r9   r8   r\   rX   s       @r   r5   r5      sr     IKt&'%%d+ 6499 6 6	t'''**84K	!!r   c                    | j                   j                  di       }i }| j                   j                         D ]m  \  }}t        |t              st        |      }|s |}|j                  |      }t        | ||       ||v rt        d|z        |||<   |j                         ||<   o || _
        |j                         D ]K  \  }}|j                  d|j                  dd      z   }t        | |      r5t        | ||j                         M y)zAdds 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.Ndo_-_)__dict__getitemsrC   r   r
   rI   setattr
ValueErrorrK   r_   r   replacer[   )r   gsignals
newsignalsr   r   
signalNamefuncNames          r   install_signalsrm      s    ||3HJ**, <fff%VJ !
T*T6*X% !Kd!RSS%+Jz"#)#9#9#;HZ <  C #((* 4f;;"t||C55H3)Xv{{3	4r   N)r1   r   r
   r   rN   r5   rm   r   r   r   <module>rn      s1   ( [`S [`|V $"*4r   