
    oZ,                         d dl Z d dlmZ ddlmZ d dlZe G d d             Z G d de      Z G d	 d
e      Z G d de      Z	ddZ
d Zd Ze j                  j                  d      s e        yy)    N)total_ordering   )Libevdevc                   "    e Zd ZdZd Zd Zd Zy)EvdevBita  
    Base class representing an evdev bit, comprised of a name and a value.
    These two properties are guaranteed to exist on anything describing an
    event code, event type or input property that comes out of libevdev::

        >>> print(libevdev.EV_ABS.name)
        EV_ABS
        >>> print(libevdev.EV_ABS.value)
        3
        >>> print(libevdev.EV_SYN.SYN_REPORT.name)
        SYN_REPORT
        >>> print(libevdev.EV_SYN.SYN_REPORT.value)
        0
        >>> print(libevdev.INPUT_PROP_DIRECT.name)
        INPUT_PROP_DIRECT
        >>> print(libevdev.INPUT_PROP_DIRECT.value)
        1

    .. attribute:: value

        The numeric value of the event code

    .. attribute:: name

        The string name of this event code
    c                 N    dj                  | j                  | j                        S )Nz{}:{})formatnamevalue)selfs    0/usr/lib/python3/dist-packages/libevdev/const.py__repr__zEvdevBit.__repr__;   s    ~~dii44    c                 4    | j                   |j                   k(  S Nr   r   others     r   __eq__zEvdevBit.__eq__>   s    zzU[[((r   c                 4    | j                   |j                   k  S r   r   r   s     r   __lt__zEvdevBit.__lt__A   s    zzEKK''r   N)__name__
__module____qualname____doc__r   r   r    r   r   r   r      s    65)(r   r   c                   .    e Zd ZdZej
                  Zd Zy)	EventCodea,  
    .. warning ::

        Do not instantiate an object of this class, all objects you'll ever need
        are already present in the libevdev namespace. Use :func:`evbit()`
        to get an :class:`EventCode` from numerical or string values.

    A class representing an evdev event code, e.g. libevdev.EV_ABS.ABS_X.
    To use a :class:`EventCode`, use the namespaced name directly::

        >>> print(libevdev.EV_ABS.ABS_X)
        ABS_X:0
        >>> print(libevdev.EV_ABS.ABS_Y)
        ABS_X:1
        >>> code = libevdev.EV_REL.REL_X
        >>> print(code.type)
        EV_REL:2

    .. attribute:: value

        The numeric value of the event code

    .. attribute:: name

        The string name of this event code

    .. attribute:: type

        The :class:`EventType` for this event code
    c                     t        |t              sy| j                  |j                  k(  xr | j                  |j                  k(  S )NF)
isinstancer   r   typer   s     r   r   zEventCode.__eq__f   s4    %+zzU[[(DTYY%**-DDr   Nr   r   r   r   super__hash__r   r   r   r   r   r   E   s    < ~~HEr   r   c                   .    e Zd ZdZej
                  Zd Zy)	EventTypea  
    .. warning ::

        Do not instantiate an object of this class, all objects you'll ever need
        are already present in the libevdev namespace. Use :func:`evbit()`
        to get an :class:`EventType` from numerical or string values.

    A class represending an evdev event type (e.g. EV_ABS). All event codes
    within this type are available as class constants::

        >>> print(libevdev.EV_ABS)
        EV_ABS:3
        >>> print(libevdev.EV_ABS.ABS_X)
        ABS_X:0
        >>> print(libevdev.EV_ABS.max)
        63
        >>> print(libevdev.EV_ABS.ABS_MAX)
        63
        >>> for code in libevdev.EV_ABS.codes[:3]:
        ...     print(code)
        ...
        ABS_X:0
        ABS_Y:1
        ABS_Z:2

    .. attribute:: value

        The numeric value of the event type

    .. attribute:: name

        The string name of this event type

    .. attribute:: codes

        A list of :class:`EventCode` objects for this type

    .. attribute:: max

        The maximum event code permitted in this type as integer
    c                 X    t        |t              sJ | j                  |j                  k(  S r   )r    r&   r   r   s     r   r   zEventType.__eq__   s%    %+++zzU[[((r   Nr"   r   r   r   r&   r&   m   s    (R ~~H)r   r&   c                   .    e Zd ZdZej
                  Zd Zy)InputPropertya  
    .. warning ::

        Do not instantiate an object of this class, all objects you'll ever need
        are already present in the libevdev namespace. Use :func:`propbit()`
        to get an :class:`InputProperty` from numerical or string values.

    A class representing an evdev input property::

        >>> print(libevdev.INPUT_PROP_DIRECT)
        INPUT_PROP_DIRECT:1


    .. attribute:: value

        The numeric value of the property

    .. attribute:: name

        The string name of this property
    c                 X    t        |t              sJ | j                  |j                  k(  S r   )r    r)   r   r   s     r   r   zInputProperty.__eq__   s%    %///zzU[[((r   Nr"   r   r   r   r)   r)      s    * ~~H)r   r)   c                    d}t         j                  D ]$  }|j                  | k(  s|j                  | k(  s"|} n |\t	        | t
              rL| j                  d      s;t         j                  D ](  }|j                  D ]  }|j                  | k(  s|c c S  * |||S d}|j                  D ]#  }|j                  |k(  s|j                  |k(  s"|}% |S )a  
    Takes an event type and an (optional) event code and returns the Enum
    representing that type or code, whichever applies. For example::

        >>> print(libevdev.evbit(0))
        EV_SYN:0

        >>> print(libevdev.evbit(2))
        EV_REL:2

        >>> print(libevdev.evbit(2, 1))
        REL_Y:1

        >>> print(libevdev.evbit(3, 4))
        ABS_RY:4

        >>> print(libevdev.evbit('EV_ABS'))
        EV_ABS:3

        >>> print(libevdev.evbit('EV_ABS', 'ABS_X'))
        ABS_X:0

    A special case is the lookup of an string-based event code without
    the type. Where the string identifier is unique, this will return the
    right value.

        >>> print(libevdev.evbit('ABS_X'))
        ABS_X:0

    The return value can be used in the libevdev API wherever an
    :class:`EventCode` or :class:`EventType` is expected.

    Notable behavior for invalid types or names:

    * If the type does not exist, this function returns None
    * If the type exists but the event code's numeric value does not have a
      symbolic name (and is within the allowed max of the type), this
      function returns a valid event code
    * If the code is outside the allowed maximum for the given type, this
      function returns None
    * If the type name exists but the string value is not a code name, this
      function returns None

    Examples for the above behaviour::

        >>> print(libevdev.evbit(8))
        None
        >>> print(libevdev.evbit('INVALID'))
        None
        >>> print(libevdev.evbit('EV_ABS', 62))
        ABS_3E:62
        >>> print(libevdev.evbit('EV_ABS', 5000))
        None
        >>> print(libevdev.evbit('EV_ABS', 'INVALID'))
        None

    :param evtype: the numeric value or string identifying the event type
    :param evcode: the numeric value or string identifying the event code
    :return: An event code value representing the code
    :rtype: EventCode or EventType
    NEV_)libevdevtypesr   r
   r    str
startswithcodes)evtypeevcodeetypetcecodes         r   evbitr8      s    | E^^ 77f& 0E
 ~*VS1&:K:KE:R 	AWW 66V#H	
 }E[[ 77f& 0E Lr   c                     	 t         j                  D cg c]#  }|j                  | k(  s|j                  | k(  s"|% c}d   S c c}w # t        $ r Y yw xY w)a'  
    Takes a property value and returns the :class:`InputProperty`
    representing that property::

        >>> print(libevdev.propbit(0))
        INPUT_PROP_POINTER:0
        >>> print(libevdev.propbit('INPUT_PROP_POINTER'))
        INPUT_PROP_POINTER:0
        >>> print(libevdev.propbit(1000))
        None
        >>> print(libevdev.propbit('Invalid'))
        None

    :param prop: the numeric value or string identifying the property
    :return: the converted :class:`InputProperty` or None if it does not exist
    :rtype: InputProperty
    r   N)r-   propsr   r
   
IndexError)propps     r   propbitr>     sK    $#>>OaQWW_$OPQRRO s&   A #AAA A 	AAc            
         t                t        j                  d      } | J g }t        | dz         D ]	  }t        j                  |      }|t        j                  |      }t        |t        f|||d      } |       }t        t        ||       |j                  |       |t        |dg        g }t        |dz         D ]j  }t        j                  ||      }	|	dj                  |dd |      }	t        |	t        f||	|d      } |       }
t        ||	|
       |j                  |
       l t        |d|        t        t        d	|       t        j                  d
      }|J g }t        |dz         D ]X  }t        j                  |      }|t        |t        f||d      } |       }t        t        ||       |j                  |       Z t        t        d|       y)a]  
    Loads all event type, code and property names and makes them available
    as enums in the module. Use as e.g. libevdev.EV_SYN.SYN_REPORT.

    Available are::

    libevdev.types ... an list containing all event types, e.g.
                         libevdev.EV_TYPES.EV_REL

    libevdev.EV_REL ... an enum containing all REL event types, e.g.
                        libevdev.EV_REL.REL_X. The name of each enum value
                        is the string of the code ('REL_X'), the value is the integer
                        value of that code.

    libevdev.EV_ABS ... as above, but for EV_ABS

    libevdev.EV_BITS ... libevdev.EV_FOO as an enum

    Special attributes are (an apply to all EV_foo enums):
        libevdev.EV_REL.type ... the EV_TYPES entry of the event type
        libevdev.EV_REL.max  ... the maximum code in this event type
    EV_MAXNr   )r   r
   maxr1   z	{}_{:02X}   )r!   r
   r   r.   INPUT_PROP_MAX)r   r
   r:   )r   event_to_valuerangeevent_to_nametype_maxr!   r&   setattrr-   appendr	   r   property_to_valueproperty_to_namer)   )tmaxr.   r5   tnamecmax	new_classtype_objectr1   r6   cnamecode_objectpmaxr:   r=   pnameprop_objects                   r   _load_constsrV   (  s   . J""8,DE4!8_ %-&&q)=  ##$"'!%'(	
  k%-[!<K"-tax 	&A**1a0E }#**59a8UYM&1&+'(*+I $+KK4LL%	& 	We,K%-P Hgu%%%&67DE4!8_ "))!,= 1#$"')*	  k%-[!" Hgu%r   READTHEDOCSr   )os	functoolsr   _clibr   r-   r   r   r&   r)   r8   r>   rV   environgetr   r   r   <module>r]      s   . 
 $   #( #( #(L%E %EP.) .)b)H ):Rj0X&v 
zz~~m$N %r   