Operation   : Linux premium131.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
Software     : Apache
Server IP    : 162.0.232.56 | Your IP: 216.73.216.111
Domains      : 1034 Domain(s)
Permission   : [ 0755 ]

B

� f�H�@s&dZd
dl
Z
d
dlZd
dlZd
ZdZdZdZdZdZ	dZ
d	Zd
ZdZ
dZd
ZdZdZdZdZdZdZdZdZdZdZdZdZdZd
ZdZdZdZ ej!dkr�dZ"eeee fZ#ndZ"eeeefZ#e$dd �e%e&e"�
�
D�
�
Z'd!Z(Gd"d#�d#�Z)e%de&e"�
>�
Z*d$d �e*D�
Z+d%d&�Z,e,e*�
Z-gZ.xNe*D]FZ/d
Z0x0e%e&e"�
�
D] Z1de1>e/@�
r6e0e#e1OZ0�
q6We.�2e0�

�
q WGd'd(�d(�Z3d)Z4e3f
de)f
e&e4�
dZ5e$d*d �e%e&e4�
�
D�
�
Z6e
�7d+�
Z8e
�7d,�
Z9d-d.�Z:d/d0�Z;iZ<d1d2�Z=d3d4�Z>e?d5k�r"d
d6l@mAZA
eAd7dd8d9�
d
d:lBmCZC
eCe>�

dS);a�
MultiCall - a class which inherits its methods from a Tkinter widget (Text, for
example), but enables multiple calls of functions per virtual event - all
matching events will be called, not only the most specific one. This is done
by wrapping the event functions - event_add, event_delete and event_info.
MultiCall recognizes only a subset of legal event sequences. Sequences which
are not recognized are treated by the original Tk handling mechanism. A
more-specific event will be called before a less-specific event.

The recognized sequences are complete one-event sequences (no emacs-style
Ctrl-X Ctrl-C, no shortcuts like <3>), for all types of events.
Key/Button Press/Release events can have modifiers.
The recognized modifiers are Shift, Control, Option and Command for Mac, and
Control, Alt, Shift, Meta/M for other platforms.

For all events which were handled by MultiCall, a new member is added to the
event instance passed to the binded functions - mc_type. This is one of the
event type constants defined in this module (such as MC_KEYPRESS).
For Key/Button events (which are handled by MultiCall and may receive
modifiers), another member is added - mc_state. This member gives the state
of the recognized modifiers, as a combination of the modifier constants
also defined in this module (for example, MC_SHIFT).
Using these members is absolutely portable.

The order by which events are called is defined by these rules:
1. A more-specific event will be called before a less-specific event.
2. A recently-binded event will be called before a previously-binded event,
   unless this conflicts with the first rule.
Each function will be called at most once for each event.
�N�
��������	�
���
���������� �@��darwin))
�Shift)
�Control)
ZOption)
ZCommand))
r)
ZAlt)
r)ZMeta�
Mc
Cs"g|]}
t|
D]}||
f�qqS�)
�
_modifiers)�.0�number�namerr�6/opt/alt/python37/lib64/python3.7/idlelib/multicall.py�
<listcomp>7s

r%zapplication has been destroyedc@s,eZ
dZd
d�Zdd�Zdd�Zdd�Zd	S)
�
_SimpleBindercCs8|
|_d
t
|
dd|_||_||_g|_d|_dS)N�
<r
�
>)�type�_types�sequence�widget�
widgetinst�bindedfuncs�	handlerid)�selfr)r,r-rrr$�__init__Js





z_SimpleBinder.__init__cCs>|js.|j
|jfd
d�
}|j�|j|j|�|_|j
�|�

dS)NcSsT||_i}xDt
t|
�
d
dd�D],}|
|}||kr d||<||�
}|r |Sq WdS)Nr���T)�mc_type�range�len)�event�
lr3�	wascalled�
i�func�
rrrr$�handlerTs








z#_SimpleBinder.bind.<locals>.handler)r/r.r)r,�bindr-r+�append)r0�tripletr:r<rrr$r=Rs






z_SimpleBinder.bindcCs2|j�
|�

|js.|j�|j|j|j�
d|_dS)
N)r.�remover,�unbindr-r+r/)r0r?r:rrr$rAbs



z_SimpleBinder.unbindc

CsZ|jrVy|j
�|j|j|j�
Wn4tjk
rT
}

zt|
jd
krD�Wdd}
~
XYnXdS)Nr
)	r/r,rAr-r+�tkinter�TclError�APPLICATION_GONE�args)r0�
errr$�__del__hs






z_SimpleBinder.__del__N)�__name__�
__module__�__qualname__r1r=rArGrrrr$r&Is
r&c

s(g|] �d��f
d
d�t
t�
D�
�
�qS)�c
3s*|]"\}
}d|
>�@r|d
dV
qdS)rr
�
-Nr)r!r9�
m)
�
srr$�	<genexpr>ws

z<listcomp>.<genexpr>)�join�	enumerater )
r!r)
rNr$r%wsc
sPd
d�}
g}x>|D]6�tt
�f
dd�|D�
�
�
}|j|
dd�
|�|�

qW|S)z�For each item of states return a list containing all combinations of
    that item with individual bits reset, sorted by the number of set bits.
    c
Ss(d
}
x|r"t|d�\}}|
|7}
qW|
S)znumber of bits set in n base 2r
r)
�divmod)�
nZnbZremrrr$�nbits�s




zexpand_substates.<locals>.nbitsc
3s|]}
�|
@V
qdS)
Nr)r!�
x)
�staterr$rO�sz#expand_substates.<locals>.<genexpr>T)�key�reverse)�list�set�sortr>)ZstatesrTZ	statelistZ	substatesr)
rVr$�expand_substates|s





r\c@s4eZ
dZd
d�Zdd�Zdd�Zdd�Zd	d
�ZdS)�_ComplexBindercCs|
|||j|j
fd
d�
}|S)NcSs�d
g
|dd�<||_||_
i}d}xZ|
D]R}xFtt|�
ddd�D].}	||	}
|
|krBd
||
<||	|�
}|rBPqBW|r(Pq(Wg|dd�<x|D]
}|�
q�Wg|dd�<|r�|SdS)NTrr2)r3�mc_stater4r5)r6�listsr3r^�ishandlerrunning�doafterhandlerr8r;r7r9r:�
frrr$r<�s*





















z0_ComplexBinder.__create_handler.<locals>.handler)r`ra)r0r_r3r^r<rrr$Z__create_handler�s




z_ComplexBinder.__create_handlerc	s�|
�_t
|
d
�_|�_|�_ddd�tD�
i
�_g�_g�_g�_	xhtD]`}�f
dd�t
|D�
}��||
t|�}dt
|�jd}�j�|�j��j||�f�

qLWdS)Nr
c
Ssg|]}
g�qSrr)r!rNrrr$r%�sz+_ComplexBinder.__init__.<locals>.<listcomp>c
sg|]}
�jd|
�qS)
N)
r.)r!r9)
r0rr$r%�sr'r()r)r*�typenamer,r-�_statesr.�
handleridsr`ra�_state_subsets�_ComplexBinder__create_handler�_state_codes�_state_namesr>r=)r0r)r,r-rNr_r<�seqr)
r0r$r1�s













z_ComplexBinder.__init__c	s��d
�jkr�dd�t
D�
�j�d
<xrt
D]j�
�
�fdd��d
dfD�
}��|�jt�
�}dt�
�j�d
f}�j�|�j	�
�j||�f�

q,W���fdd�}�js�|�
n�j
�|�

dS)Nrc
Ssg|]}
g�qSrr)r!rNrrr$r%�sz'_ComplexBinder.bind.<locals>.<listcomp>c
s(g|] }
t�D]}�
j
|
|�qqSr)rfr.)r!�detailr9)rNr0rr$r%�s

z	<%s%s-%s>cs�
j�d
�d�
��
S)Nrr
)r.r>r)r:r0r?rr$�<lambda>��z%_ComplexBinder.bind.<locals>.<lambda>)r.rdrgr)rhrircrer>r,r=r-r`ra)r0r?r:r_r<rj�doitr)r:rNr0r?r$r=�s














z_ComplexBinder.bindcs.��
�fd
d�}�
js|�
n�
j
�|�

dS)Ncs�
j�d
�d�
��
S)Nrr
)r.r@r)r:r0r?rr$rl�rmz'_ComplexBinder.unbind.<locals>.<lambda>)r`rar>)r0r?r:rnr)r:r0r?r$rA�s


z_ComplexBinder.unbindc
Csdx^|jD]T\}
}y|j
�|j|
|�
Wqtjk
rZ
}
zt|jd
krJ�Wdd}~XYqXqWdS)Nr
)rer,rAr-rBrCrDrE)r0rj�idrFrrr$rG�s





z_ComplexBinder.__del__N)rHrIrJrgr1r=rArGrrrr$r]�s
r]))�KeyPressZKey)
�
KeyRelease)ZButtonPressZButton)
Z
ButtonRelease)
ZActivate)
Z	Circulate)
ZColormap)
Z	Configure)
Z
Deactivate)
ZDestroy)
ZEnter)
ZExpose)
ZFocusIn)
ZFocusOut)
ZGravity)
ZLeave)
ZMap)
ZMotion)
Z
MouseWheel)
ZProperty)
ZReparent)
ZUnmap)
Z
Visibilityc
Cs"g|]}
t|
D]}||
f�qqSr)
r*)r!r"r#rrr$r%
s

z^\w+$z^[1-5]$c
Cs
|r|d
dks|ddkr dS|dd��d�
}
d
}x.|
rd|
d
t
krd|dt
|
d
>O}|
d
=q8W|
r�|
d
tkr�t|
d
}|
d
=ndSt|tkr�|s�|
r�dSd}nN|dd	�d
D�
kr�t}nt}|
s�d}n(t|
�
dkr�|�|
d
�
r�|
d
}ndS|||fS)a-
Get a string which should describe an event sequence. If it is
    successfully parsed as one, return a tuple containing the state (as an int),
    the event type (as an index of _types), and the detail - None if none, or a
    string if there is one. If the parsing is unsuccessful, return None.
    r
r'r2r(NrrLc
Ssg|]}
t|
�qSr)
�_type_names)r!rNrrr$r%$
sz#_parse_sequence.<locals>.<listcomp>)rprq)	�split�_modifier_namesrr�_binder_classesr&�
_keysym_re�
_button_rer5�match)r+ZwordsZ	modifiersr)rkZtype_rerrr$�_parse_sequence
s0

















ryc

Cs`|d
r8dt|dt
|ddd|d
dSdt|dt
|dddSdS)Nrr'r
rrLr()rir*)
r?rrr$�_triplet_to_sequence2
s
0rzc
s0�tkrt�SG�f
d
d�d��}
|
t�<|
S)z�Return a MultiCall class which inherits its methods from the
    given widget class (for example, Tkinter.Text). This is used
    instead of a templating mechanism.
    csreZ
dZe�ej�st�
�f
d
d�Zd�f
dd�	Zd�f
dd�	Z	�f
dd	�Z
�f
d
d�Zd�f
dd
�	Zdd�Z
dS)z#MultiCallCreator.<locals>.MultiCallc
s:�
j�f
|
�|�

i�_
��
fd
d�ttt�
�
D�
�_dS)Nc
sg|]}
t|
|
�
���qSr)
ru)r!r9)r0r,rr$r%K
s
z@MultiCallCreator.<locals>.MultiCall.__init__.<locals>.<listcomp>)r1�_MultiCall__eventinfor4r5r*�_MultiCall__binders)r0rE�kwargs)
r,)
r0r$r1E
s


z,MultiCallCreator.<locals>.MultiCall.__init__Ncs�t|
�
t
kr�t|
�
d
kr�|
dd
�dkr�|
dd�dkr�|
|jkr�|j|
}|ddk	r�x*|dD]}|j|d�||d�
qbW||d<|ddk	r�x6|dD]}|j|d�||�
q�Wn|gg|j|
<��||
||�S)Nrz<<���z>>r
r)r)�strr5r{r|rAr=)r0r+r:�addZeir?)
r,rr$r=N
s
 











z(MultiCallCreator.<locals>.MultiCall.bindcs�t|
�
t
kr�t|
�
d
kr�|
dd
�dkr�|
dd�dkr�|
|jkr�|j|
\}}|dk	r�x"|D]}|j|d�||�
q^Wd|j|
d<��||
|�S)Nrz<<r~z>>rr
)r)rr5r{r|rA)r0r+Zfuncidr:�tripletsr?)
r,rr$rA`
s

 








z*MultiCallCreator.<locals>.MultiCall.unbindcs�|
|jkrdgg|j|
<|j|
\}}xT|D]L}t
|�
}|dkrP��||
|�
q,|dk	rn|j|d
�||�
|�|�

q,WdS)Nr)r{ry�	event_addr|r=r>)r0�virtual�	sequencesr:r�rjr?)
r,rr$r�k
s







z-MultiCallCreator.<locals>.MultiCall.event_addcsv|
|jkrdS|j|
\}}xT|D]L}t
|�
}|dkrF��||
|�
q"|dk	rd|j|d
�||�
|�|�

q"WdS)Nr)r{ry�event_deleter|rAr@)r0r�r�r:r�rjr?)
r,rr$r�|
s









z0MultiCallCreator.<locals>.MultiCall.event_deletecsF|
dks|
|jkr��
||
�Sttt|j|
d
��
��
||
�SdS)Nr)r{�
event_info�tuple�maprz)r0r�)
r,rr$r��
s




z.MultiCallCreator.<locals>.MultiCall.event_infoc
Ss�x~|jD]t}
|j|
\}}|rx\|D]T}y|j
|d
�||�
Wq$tjk
rv
}
zt|jdkrf�Wdd}~XYq$Xq$WqWdS)Nrr
)r{r|rArBrCrDrE)r0r�r:r�r?rFrrr$rG�
s









z+MultiCallCreator.<locals>.MultiCall.__del__)NNN)
N)
N)rHrIrJ�
issubclassrBZMisc�AssertionErrorr1r=rAr�r�r�rGr)
r,rr$�	MultiCallB
s
	r�)
�_multicall_dict)r,r�r)
r,r$�MultiCallCreator:
s

[
r�c
s�t�
|�
}
|
�d
�

tt|���d�
dd��\}}|
�d||df�

ttj�
|
�
���	�
dg
f
�f
dd�	}|d	�

|d
�

|d�

|d�

|d
�

|d�

|d�

|d�

|d�

|d�

|d�

|d�

dS)NzTest MultiCall�
+rz+%d+%d�r
csH�f
d
d�}�
�d|
d|�
�
�
d|
d��
|
dd7<dS)Nc

st��

dS)
N)
�print)
r6)
rjrr$r<�
s
z-_multi_call.<locals>.bindseq.<locals>.handlerz
<<handler%d>>r
r)r=r�)rjrSr<)
�text)
rjr$�bindseq�
s


z_multi_call.<locals>.bindseqz<Key>z
<Control-Key>z<Alt-Key-a>z<Control-Key-a>z<Alt-Control-Key-a>z<Key-b>z<Control-Button-1>z
<Button-2>z<Alt-Button-1>z
<FocusOut>z<Enter>z<Leave>)
rBZToplevel�titler��intZgeometryrsr�ZTextZpack)�parent�toprU�
yr�r)
r�r$�_multi_call�
s&




 














r��__main__)
�mainzidlelib.idle_test.test_mainmenuF)�	verbosity�exit)
�run)D�__doc__�re�sysrBZMC_KEYPRESSZ
MC_KEYRELEASEZMC_BUTTONPRESSZMC_BUTTONRELEASEZMC_ACTIVATEZMC_CIRCULATEZMC_COLORMAPZMC_CONFIGUREZ
MC_DEACTIVATEZ
MC_DESTROYZMC_ENTERZ	MC_EXPOSEZ
MC_FOCUSINZMC_FOCUSOUTZ
MC_GRAVITYZMC_LEAVEZMC_MAPZ	MC_MOTIONZ
MC_MOUSEWHEELZMC_PROPERTYZMC_REPARENTZMC_UNMAPZ
MC_VISIBILITYZMC_SHIFTZ
MC_CONTROLZMC_ALTZMC_METAZ	MC_OPTIONZ
MC_COMMAND�platformr Z_modifier_masks�dictr4r5rtrDr&rdrir\rfrhrNr;r9r>r]r*rurr�compilervrwryrzr�r�r�rHZunittestr�Zidlelib.idle_test.htestr�rrrr$�<module>s�












-







`	




'
g