
    gi$%                     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.BoundSignalzTemporary 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|  dS )NzBoundSignal("z") r   s    r   __repr__zSignal.BoundSignal.__repr__V   s    "4&++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 )zkSame 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_detailedc   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.disconnectk   s    II  ,r   c                 T     | j                   j                  t        |       g|i |S )zhSame as GObject.Object.emit except there is no need to specify
            the signal name.
            )r   emitr
   r   s      r   r+   zSignal.BoundSignal.emito   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__u   s#    D>==D{{3%%r   Nc	                     |t        |      r|}|r|s|j                  }t        j                  |        |r|s|st	        |      \  }}|d}|| _        || _        || _        || _        || _        || _	        || _
        y )Nr   )r3   r/   r
   r   get_signal_annotationsr   flagsreturn_type	arg_typesaccumulator	accu_data)	r   r   r   r6   r7   r8   docr9   r:   s	            r   r   zSignal.__init__z   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           
      R   t        |t        j                        r | j                  |g|i | yt	        |       rt	        |       n|j
                  } t        |       ||| j                  | j                  | j                  | j                  | j                  | j                        S )zvAllows for instantiated Signals to be used as a decorator or calling
        of the underlying signal method.
        r   r   r6   r7   r8   r;   r9   r:   N)
isinstancer   GObjectr   r
   r,   typer6   r7   r8   r/   r9   r:   )r   objr   r   r   s        r   r   zSignal.__call__   s     c3;;'DIIc*D*E*   !$D	3t9s||D4:jj ,,..LL ,,..	 	r   c           
           t        |       || j                  | j                  | j                  | j                  | j
                  | j                  | j                        S )z%Returns a renamed copy of the Signal.rA   )rD   r   r6   r7   r8   r/   r9   r:   )r   newNames     r   copyzSignal.copy   sM    tDz**((nn((nn	
 		
r   c                 t    | j                   | j                  | j                  | j                  | j                  fS )zLReturns a tuple of: (flags, return_type, arg_types, accumulator, accu_data).)r6   r7   r8   r9   r:   r   s    r   get_signal_argszSignal.get_signal_args   s5     JJNNNN
 	
r   )r1   r	   )r,   r-   r.   r/   r
   r0   r   r   SIGNAL_RUN_FIRSTr   r?   r   rH   rJ   r   r   r   r   r      sT    0d*=c *=X& ""#@02

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   rJ   zSignalOverride.get_signal_args   s    r   N)r,   r-   r.   r/   rJ   r   r   r   rM   rM      s    r   rM   c                     d}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.
    r   N__annotations__    c              3   Z   K   | ]"  }|j                   v sj                   |    $ y wr	   )annotations).0argspecs     r   	<genexpr>z)get_signal_annotations.<locals>.<genexpr>   s.      
&)#AQAQ:QDS!
s   ++return)hasattrinspectgetfullargspectupler   rT   )r   r8   r7   r[   rW   s       @r   r5   r5      ss     IKt&'%%d+ 
-1YY
 
	 t'''**84K	!!r   c                     | j                   j                  di       }i }| j                   j                         D ]n  \  }}t        |t              st        |      }|s |}|j                  |      }t        | ||       ||v rt        d| d      |||<   |j                         ||<   p || _
        |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 "z" has already been registered.Ndo_-_)__dict__getitemsrB   r   r
   rH   setattr
ValueErrorrJ   r_   r   replacerZ   )r   gsignals
newsignalsr   r   
signalNamefuncNames          r   install_signalsrm      s    ||3HJ**, <fff%VJ !
T*T6*X% 8D61O!PQQ%+Jz"#)#9#9#;HZ <  C #((* 4f;;"t||C55H3)Xv{{3	4r   N)r1   r   r
   r   rM   r5   rm   r   r   r   <module>rn      s/   & x
S x
vV &".4r   