def sel_antifiltre():
''' Sélectionne les anti-filtres, c'est à dire les types de mains que
l'on ne veut pas.
Fonctionnement analogue à sel_filtre
'''
if DEBUG:
print('sel_antifiltre')
def validate(event=None):
if DEBUG:
print("validation")
index_filtre = menu_deroulant.curselection()
sequence.negatif[sequence.position] = \
[liste_des_filtres[i] for i in index_filtre]
affiche_filtre(sequence.position)
clear(f_negatif)
defilement = tk.Scrollbar(f_negatif, orient='vertical')
defilement.grid(row=1, column=1, sticky='ns')
noms_de_filtres = [f.name for f in liste_des_filtres]
menu_deroulant = tk.Listbox(f_negatif,
yscrollcommand=defilement.set,
height=9,
selectmode='multiple')
defilement.configure(command=menu_deroulant.yview)
menu_deroulant.bind("<Return>", validate)
menu_deroulant.grid(row=1, column=0)
for nom in noms_de_filtres:
menu_deroulant.insert(tk.END, nom)
tk.Button(f_negatif, text='Ok', command=validate).grid()
tk.Frame(f_negatif, width=LARGEUR).grid(columnspan=2)
def escape(event=None):
if expert:
clear(fenetre)
barre_de_menu(lm_donne, menu)
else:
clear(fenetre)
barre_de_menu(lm_proto_menu, menu)
def postaction():
''' Actions à effectuer en sortie '''
name = saisie.get()
if DEBUG:
print("sortie:", saisie.get())
name_actif = sequence_active.name
names = [seq.name for seq in liste_des_sequences]
names = [n for n in names if n != name_actif]
if name:
if name in names:
barre_de_message('Ce nom existe déjà', messager)
else:
barre_de_message('Séquence validée', messager)
else:
barre_de_message('Entrez un nom de séquence', messager)
return None
if sequence_active.is_invalide():
mess = 'Filtres incompatibles'
barre_de_message(mess, messager)
else :
sequence_active.name = name
barre_de_menu(lm_sequence, menu)
liste_des_sequences.sort(key=lambda seq: seq.name)
writesequences(liste_des_sequences)
clear(fenetre)
def c_nouvelle_sequence():
''' Crée une nouvelle séquence de filtres'''
def postaction():
global sequence_active
''' Actions à effectuer en sortie '''
names = [seq.name for seq in liste_des_sequences]
name = saisie.get()
if name in names:
mess = "Ce nom existe déjà !"
barre_de_message(mess, messager)
elif name == "":
mess = 'Entrez un nom de séquence'
barre_de_message(mess, messager)
elif sequence.is_invalide():
mess = 'Filtres incompatibles'
barre_de_message(mess, messager)
else:
sequence.name = name
sequence_active = sequence
barre_de_menu(lm_sequence, menu)
liste_des_sequences.append(sequence)
liste_des_sequences.sort(key=lambda seq: seq.name)
writesequences(liste_des_sequences)
clear(fenetre)
def annul():
barre_de_menu(lm_sequence, menu)
clear(fenetre)
clear(fenetre)
sequence = Sequence()
barre_de_validation(menu, postaction, annul)
saisie = regler_sequence(sequence, fenetre, messager)
def c_modifier_filtre():
def validate(event=None):
if DEBUG:
print("validation")
try:
index_filtre, = menu_deroulant.curselection()
clear(fenetre)
c_regler_filtre(index_filtre)
except ValueError:
mess = 'Choisir le filtre à modifier'
barre_de_message(mess, messager)
#c_regler_filre()
def annuler():
clear(fenetre)
barre_de_menu(lm_filtre, menu)
if DEBUG:
print('modifier filtre')
clear(fenetre)
defilement = tk.Scrollbar(fenetre, orient='vertical')
defilement.grid(row=1, column=1, sticky='ns')
lab = tk.Label(fenetre, text='Choisir le filtre à modifier')
lab.grid(row=0, column=0)
noms_de_filtres = [f.name for f in liste_des_filtres]
menu_deroulant = tk.Listbox(fenetre,
yscrollcommand=defilement.set,
height=9)
defilement.configure(command=menu_deroulant.yview)
menu_deroulant.bind("<Double-Button-1>", validate)
menu_deroulant.grid(row=1, column=0)
for nom in noms_de_filtres:
menu_deroulant.insert(tk.END, nom)
barre_de_validation(menu, validate, annuler)
def sel_filtre():
''' Sélectionne un ou plusieurs filtres associée à
la Main de la position active'''
if DEBUG:
print('sel_filtre')
def validate(event=None):
if DEBUG:
print("validation")
index_filtre = menu_deroulant.curselection()
sequence.positif[sequence.position] = \
[liste_des_filtres[i] for i in index_filtre]
affiche_filtre(sequence.position)
clear(f_positif)
defilement = tk.Scrollbar(f_positif, orient='vertical')
defilement.grid(row=1, column=1, sticky='ns')
noms_de_filtres = [f.name for f in liste_des_filtres]
menu_deroulant = tk.Listbox(f_positif,
yscrollcommand=defilement.set,
height=15,
width=35,
selectmode='multiple')
defilement.configure(command=menu_deroulant.yview)
menu_deroulant.bind("<Return>", validate)
menu_deroulant.grid(row=1, column=0)
for nom in noms_de_filtres:
menu_deroulant.insert(tk.END, nom)
tk.Button(f_positif, text='Ok', command=validate).grid()
tk.Frame(f_positif, width=LARGEUR).grid(columnspan=2)
def conclure():
if name.get():
if DEBUG:
print(var_pointH_min.get(), var_HLD_min.get())
print(name.get())
filtre = Filtre(name=name.get(),
pointH_min=var_pointH_min.get(),
pointH_max=var_pointH_max.get(),
trefle_min=trefle_min.get(),
trefle_max=trefle_max.get(),
carreau_min=carreau_min.get(),
carreau_max=carreau_max.get(),
coeur_min=coeur_min.get(),
coeur_max=coeur_max.get(),
pique_min=pique_min.get(),
pique_max=pique_max.get(),
points_totaux_min=var_HLD_min.get(),
points_totaux_max=var_HLD_max.get())
liste_des_filtres.append(filtre)
if isinstance(index_filtre, int):
del liste_des_filtres[index_filtre]
liste_des_filtres.sort(key=lambda filtre: filtre.name)
writefiltres(liste_des_filtres)
barre_de_menu(lm_filtre, menu)
mess = "Filtre enregistré"
barre_de_message(mess, messager)
clear(fenetre)
def c_retour():
''' Retour au menu principal '''
clear(fenetre)
if expert:
menu_principal()
else:
proto_menu()
def escape(event=None):
if expert :
barre_de_menu(lm_sequence, menu)
clear(fenetre)
else :
barre_de_menu(lm_proto_menu, menu)
clear(fenetre)
def c_menu_rapide():
global expert
expert = False
c_charger_donnes()
clear(menu)
barre_de_message("Menu des enchères", messager)
barre_de_menu(lm_enchere_rapide, menu)
initialise_encheres()
def image():
clear(fenetre)
load = Image.open("data/gambling.jpg")
resolution = (375, 300)
img = ImageTk.PhotoImage(load.resize(resolution), master=fenetre)
panel = tk.Label(fenetre, image=img)
panel.grid()
panel.image = img
def postaction():
global sequence_active
barre_de_menu(lm_sequence, menu)
_supprimer_sequence(sequence_active)
writesequences(liste_des_sequences)
barre_de_message(f'{sequence_active.name} effacée', messager)
sequence_active = None
clear(fenetre)
def c_distribuer_donnes():
def validate(event=None):
global pack_actif, index_pack
try:
saisie = int(saisir.get())
except ValueError:
mess = 'Entrez un entier stictement positif'
barre_de_message(mess, messager)
return None
if saisie in range(1, 1000):
mess = 'Cela prend parfois quelques instants'
barre_de_message(mess, messager)
messager.update()
compteur = 0
overflow = 0
pack_actif = []
index_pack = 0
while compteur <= saisie and overflow < 100_000:
donne = Donne()
overflow += 1
if (not sequence_active) or sequence_active.filtre(donne):
compteur += 1
pack_actif.append(donne.identifiant())
if compteur == 0:
mess = 'Filtres incompatibles'
donne = Donne()
pack_actif.append(donne.identifiant())
elif compteur > 0:
mess = 'Donnes rares. Uniquement ' + str(
compteur) + ' donnes distribuées'
else:
mess = 'Donnes distribuées'
barre_de_message(mess, messager)
barre_de_menu(lm_donne, menu)
clear(fenetre)
else:
mess = 'Entrez un entier compris entre 1 et 1000'
barre_de_message(mess, messager)
def cancel():
clear(menu)
barre_de_menu(lm_donne, menu)
clear(fenetre)
clear(fenetre)
w1 = tk.Label(fenetre, text="Combien voulez-vous de donnes : ")
w1.grid(row=0, column=0)
saisir = tk.Entry(fenetre)
saisir.grid(row=0, column=1)
saisir.bind("<Return>", validate)
if sequence_active:
mess = "Séquence de filtres activés : " + sequence_active.name
else:
mess = 'Pas de filtre actif, donnes aléatoires '
w3 = tk.Label(fenetre, text=mess)
w3.grid(row=1, columnspan=2)
barre_de_validation(menu, validate, cancel)
barre_de_message(mess, messager)
def validate(event=None):
if DEBUG:
print("validation")
try:
index_filtre, = menu_deroulant.curselection()
clear(fenetre)
c_regler_filtre(index_filtre)
except ValueError:
mess = 'Choisir le filtre à modifier'
barre_de_message(mess, messager)
def c_reinitialiser_sequences():
global liste_des_sequences
clear(fenetre)
tk.Label(fenetre, text="Attention !").grid()
tk.Label(fenetre, text="Vous allez effacer les séquences !").grid()
tk.Label(fenetre, text="En cas de Bug uniquement !").grid()
if askyesno(title='EFFACEMENT DES SEQUENCES',
message='Continuer ?',
parent=menu):
liste_des_sequences = []
writesequences(liste_des_sequences)
clear(fenetre)
def supprimer():
if DEBUG:
print('supprimer')
if askyesno(title='Etes-vous sûr ?',
message='Vous allez supprimez un filtre'):
if DEBUG:
print('oui')
del liste_des_filtres[index_filtre]
liste_des_filtres.sort(key=lambda filtre: filtre.name)
clear(fenetre)
barre_de_menu(lm_filtre, menu)
mess = 'Le filtre a été supprimé'
barre_de_message(mess, messager)
def c_sauvegarder_donnes():
if DEBUG:
print("sauver")
var = tk.StringVar(fenetre)
def validate(event=None):
text = var.get()
if text:
try:
filename = "data/" + text + ".pak"
with open(filename, "wb") as fichier:
pickle.dump(pack_actif, fichier)
wlabel.destroy()
wentree.destroy()
mess = f"Fichier {filename[5:]} sauvegardé"
barre_de_message(mess, messager)
if expert :
barre_de_menu(lm_donne, menu)
else :
c_enchérir()
except IOError:
barre_de_message("Problème d'entrée/sortie", messager)
def escape(event=None):
if expert:
clear(fenetre)
barre_de_menu(lm_donne, menu)
else:
clear(fenetre)
barre_de_menu(lm_proto_menu, menu)
clear(fenetre)
if len(pack_actif) < 5:
mess = 'Attention, votre pack de donne est presque vide !'
texte = f'nombre de sonnes à sauvegarder : {len(pack_actif)}'
alerte1 = tk.Label(fenetre, text=texte)
alerte1.grid()
alerte2 = tk.Label(fenetre, text='Avez-vous bien distribué ?')
alerte2.grid()
tk.Label(fenetre, text='').grid()
else:
mess = 'Sauvegarde des donnes'
barre_de_message(mess, messager)
wlabel = tk.Label(fenetre, text="Nom du fichier")
wlabel.grid()
wentree = tk.Entry(fenetre, textvariable=var)
wentree.grid()
wentree.bind('<Return>', validate)
barre_de_validation(menu, validate, escape)
def postaction():
global sequence_active
''' Actions à effectuer en sortie '''
names = [seq.name for seq in liste_des_sequences]
name = saisie.get()
if name in names:
mess = "Ce nom existe déjà !"
barre_de_message(mess, messager)
else:
sequence.name = name
sequence_active = sequence
barre_de_menu(lm_sequence, menu)
liste_des_sequences.append(sequence)
liste_des_sequences.sort(key=lambda seq: seq.name)
writesequences(liste_des_sequences)
clear(fenetre)
def c_choisir_sequence():
''' Choix de la séquence active '''
def postaction():
barre_de_menu(lm_sequence, menu)
barre_de_message(f'Séquence active : {sequence_active.name}', messager)
clear(fenetre)
if liste_des_sequences:
clear(fenetre)
_selectionne_sequence(postaction)
else:
clear(fenetre)
tk.Label(fenetre, text="Attention !").grid()
tk.Label(fenetre, text="Aucune séquence sauvegardées !").grid()
tk.Label(fenetre, text="Veuillez en créer une nouvelle !").grid()
def c_menu_normal():
global expert
expert = False
def postaction():
mess = f'Séquence active : {sequence_active.name}'
barre_de_message(mess, messager)
c_distribuer_donnes()
if liste_des_sequences:
clear(fenetre)
_selectionne_sequence(postaction)
else:
clear(fenetre)
expert = True
tk.Label(fenetre, text="Attention !").grid()
tk.Label(fenetre, text="Aucune séquence sauvegardées !").grid()
tk.Label(fenetre, text="Veuillez en créer une nouvelle !").grid()
def initialise_encheres():
global donne_actuelle
clear(fenetre)
fenetre_donne = tk.Frame(fenetre, height=100)
fenetre_donne.grid(row=1, columnspan=4)
visible = position_active.visibilite()
if DEBUG:
print(visible)
if pack_actif:
donne_actuelle = Donne(identifiant=pack_actif[0])
else:
mess = "Aucune donne n'a été chargée"
barre_de_message(mess, messager)
donne_active = Donne_active(donne_actuelle, fenetre_donne, visible)
donne_active.affiche()
widgets_actifs["donne_active"] = donne_active
def select_position():
global position_active
position_active = Position(varRad.get())
if DEBUG:
print(position_active)
donne_active.visible = position_active.visibilite()
donne_active.affiche()
varRad = tk.IntVar(fenetre)
varRad.set(position_active+0)
boutons_de_position_des_encheres = []
for pos in Position:
b = tk.Radiobutton(fenetre,
variable=varRad,
text=pos.name(),
indicatoron=0,
value=int(pos),
command=select_position,
width=10,
anchor='n')
b.grid(row=0, column=pos+0, sticky='ew')
boutons_de_position_des_encheres.append(b)
widgets_actifs['BDPDE'] = boutons_de_position_des_encheres
if DEBUG:
print(widgets_actifs)
mess = 'Choisir son orientation'
barre_de_message(mess, messager)
def c_supprimer_sequence():
''' Choix de la séquence active puis supression'''
def postaction():
global sequence_active
barre_de_menu(lm_sequence, menu)
_supprimer_sequence(sequence_active)
writesequences(liste_des_sequences)
barre_de_message(f'{sequence_active.name} effacée', messager)
sequence_active = None
clear(fenetre)
if liste_des_sequences:
clear(fenetre)
_selectionne_sequence(postaction)
else:
clear(fenetre)
tk.Label(fenetre, text="Attention !").grid()
tk.Label(fenetre, text="Aucune séquence sauvegardées !").grid()
tk.Label(fenetre, text="Veuillez en créer une nouvelle !").grid()
def affiche_filtre(pos):
''' Boutons pour sélectionner les filtres
'''
messages = [
'Filtre de Nord', 'Filtre de Sud', "Filtre d'Est", "Filtre d'Ouest"
]
negsages = [
'Interdit de Nord', 'Interdit de Sud', "Interdit d'Est",
"Interdit d'Ouest"
]
b_positif.configure(text=messages[sequence.position])
b_negatif.configure(text=negsages[sequence.position])
clear(f_positif)
clear(f_negatif)
for filtre in sequence.positif[sequence.position]:
tk.Label(f_positif, text=filtre.name).grid()
tk.Frame(f_positif, width=LARGEUR).grid()
for filtre in sequence.negatif[sequence.position]:
tk.Label(f_negatif, text=filtre.name).grid()
tk.Frame(f_negatif, width=LARGEUR).grid()
if DEBUG:
print('affiche sortie')
def postaction():
global sequence_active
''' Actions à effectuer en sortie '''
names = [seq.name for seq in liste_des_sequences]
name = saisie.get()
if name in names:
mess = "Ce nom existe déjà !"
barre_de_message(mess, messager)
elif name == "":
mess = 'Entrez un nom de séquence'
barre_de_message(mess, messager)
elif sequence.is_invalide():
mess = 'Filtres incompatibles'
barre_de_message(mess, messager)
else:
sequence.name = name
sequence_active = sequence
barre_de_menu(lm_sequence, menu)
liste_des_sequences.append(sequence)
liste_des_sequences.sort(key=lambda seq: seq.name)
writesequences(liste_des_sequences)
clear(fenetre)
def validate(event=None):
global pack_actif, index_pack
try:
saisie = int(saisir.get())
except ValueError:
mess = 'Entrez un entier stictement positif'
barre_de_message(mess, messager)
return None
if saisie in range(1, 1000):
mess = 'Cela prend parfois quelques instants'
barre_de_message(mess, messager)
messager.update()
compteur = 0
overflow = 0
pack_actif = []
index_pack = 0
while compteur <= saisie and overflow < 100_000:
donne = Donne()
overflow += 1
if (not sequence_active) or sequence_active.filtre(donne):
compteur += 1
pack_actif.append(donne.identifiant())
if compteur == 0:
mess = 'Filtres incompatibles'
donne = Donne()
pack_actif.append(donne.identifiant())
elif compteur > 0:
mess = 'Donnes rares. Uniquement ' + str(
compteur) + ' donnes distribuées'
else:
mess = 'Donnes distribuées'
barre_de_message(mess, messager)
barre_de_menu(lm_donne, menu)
clear(fenetre)
else:
mess = 'Entrez un entier compris entre 1 et 1000'
barre_de_message(mess, messager)
def validate(event=None):
global pack_actif, index_pack
try:
saisie = int(saisir.get())
except ValueError:
mess = 'Entrez un entier stictement positif'
barre_de_message(mess, messager)
return None
if saisie in range(1, 1000):
mess = 'Cela prend parfois quelques instants'
barre_de_message(mess, messager)
messager.update()
index_pack = 0
if not sequence_active:
pack_actif = [Donne() for i in range(saisie)]
else:
try :
pack_actif = []
for i in range(saisie):
donne = sequence_active.distribue()
donneur = vardonneur.get()
if donneur == 4 :
donne.donneur = randint(0,3)
else :
donne.donneur = Position(donneur)
vul = varvul.get()
if vul == 4 :
donne.vul = randint(0,3)
else:
donne.vul = Vulnerabilite(vul)
pack_actif.append(donne.identifiant())
except InvalidSequence :
mess = "Séquence invalide "
barre_de_message(mess, messager)
clear(menu)
barre_de_menu(lm_sequence, menu)
clear(fenetre)
return None
mess = 'Donnes distribuées'
barre_de_message(mess, messager)
if expert :
barre_de_menu(lm_donne, menu)
clear(fenetre)
else :
c_sauvegarder_donnes()
else:
mess = 'Entrez un entier compris entre 1 et 1000'
barre_de_message(mess, messager)
def regler_sequence(sequence, fenetre, messager):
'''
filtres : séquence de filtres dans la classe Filtres
fenetre : fentre dans laquelle l'interface aparait
messager : fennetre dans laquelle on envoie des messages d'état
Le rôle de cette interface est d'effectuer les réglages de la séquence
de filtres. Celle-ci est donc modifiée au cours de ces réglages.
Le mot séquence fait référence à une éventuelle séquence d'enchères
correspondant aux différents filtres utilisés.
'''
def select_pos(position):
''' Sélection de la Main à filtrer
La main active est sauvegarder dans la variable globale
sequence.position
'''
sequence.position = position
affiche_filtre(position)
b_positif.configure(state="normal")
b_negatif.configure(state="normal")
for pos in Position:
if pos == position:
boutons[pos].configure(relief='sunken', bg=tc.THEME5)
else:
boutons[pos].configure(relief='raised', bg=tc.THEME4)
def callback(position):
''' Artefact pour que la position soit choisie au moment
de la création du bouton et pas au moment où il est activé.
'''
return lambda: select_pos(position)
def sel_filtre():
''' Sélectionne un ou plusieurs filtres associée à
la Main de la position active'''
if DEBUG:
print('sel_filtre')
def validate(event=None):
if DEBUG:
print("validation")
index_filtre = menu_deroulant.curselection()
sequence.positif[sequence.position] = \
[liste_des_filtres[i] for i in index_filtre]
affiche_filtre(sequence.position)
clear(f_positif)
defilement = tk.Scrollbar(f_positif, orient='vertical')
defilement.grid(row=1, column=1, sticky='ns')
noms_de_filtres = [f.name for f in liste_des_filtres]
menu_deroulant = tk.Listbox(f_positif,
yscrollcommand=defilement.set,
height=9,
selectmode='multiple')
defilement.configure(command=menu_deroulant.yview)
menu_deroulant.bind("<Return>", validate)
menu_deroulant.grid(row=1, column=0)
for nom in noms_de_filtres:
menu_deroulant.insert(tk.END, nom)
tk.Button(f_positif, text='Ok', command=validate).grid()
tk.Frame(f_positif, width=LARGEUR).grid(columnspan=2)
def sel_antifiltre():
''' Sélectionne les anti-filtres, c'est à dire les types de mains que
l'on ne veut pas.
Fonctionnement analogue à sel_filtre
'''
if DEBUG:
print('sel_antifiltre')
def validate(event=None):
if DEBUG:
print("validation")
index_filtre = menu_deroulant.curselection()
sequence.negatif[sequence.position] = \
[liste_des_filtres[i] for i in index_filtre]
affiche_filtre(sequence.position)
clear(f_negatif)
defilement = tk.Scrollbar(f_negatif, orient='vertical')
defilement.grid(row=1, column=1, sticky='ns')
noms_de_filtres = [f.name for f in liste_des_filtres]
menu_deroulant = tk.Listbox(f_negatif,
yscrollcommand=defilement.set,
height=9,
selectmode='multiple')
defilement.configure(command=menu_deroulant.yview)
menu_deroulant.bind("<Return>", validate)
menu_deroulant.grid(row=1, column=0)
for nom in noms_de_filtres:
menu_deroulant.insert(tk.END, nom)
tk.Button(f_negatif, text='Ok', command=validate).grid()
tk.Frame(f_negatif, width=LARGEUR).grid(columnspan=2)
def affiche_filtre(pos):
''' Boutons pour sélectionner les filtres
'''
messages = [
'Filtre de Nord', 'Filtre de Sud', "Filtre d'Est", "Filtre d'Ouest"
]
negsages = [
'Interdit de Nord', 'Interdit de Sud', "Interdit d'Est",
"Interdit d'Ouest"
]
b_positif.configure(text=messages[sequence.position])
b_negatif.configure(text=negsages[sequence.position])
clear(f_positif)
clear(f_negatif)
for filtre in sequence.positif[sequence.position]:
tk.Label(f_positif, text=filtre.name).grid()
tk.Frame(f_positif, width=LARGEUR).grid()
for filtre in sequence.negatif[sequence.position]:
tk.Label(f_negatif, text=filtre.name).grid()
tk.Frame(f_negatif, width=LARGEUR).grid()
if DEBUG:
print('affiche sortie')
#########################################################
##### DEBUT
#########################################################
# Initialisations
liste_des_filtres = readfiltres()
barre_de_message('Séquence de filtres', messager)
clear(fenetre)
LARGEUR = 250
HAUTEUR = 200
# Titre
tk.Label(fenetre, text='Main à filtrer').grid(row=0, columnspan=4)
# Boutons de position
boutons = []
for pos in Position:
boutons.append(
tk.Button(fenetre, command=callback(pos), text=pos.name()))
boutons[pos].grid(row=1, column=int(pos), sticky='ew')
# Fenêtre de sélection de filtres à gauche
b_positif = tk.Button(fenetre,
text=f"Filtre à sélectionner",
command=sel_filtre,
state='disabled')
b_positif.grid(row=2, columnspan=2, sticky='ew')
f_positif = tk.Frame(fenetre, height=HAUTEUR, width=LARGEUR)
f_positif.grid(row=3, columnspan=2)
f_positif.grid_propagate(0)
# fenêtre de sélection d'anti-filtres à droite
b_negatif = tk.Button(fenetre,
text=f"Filtres interdit",
command=sel_antifiltre,
state='disabled')
b_negatif.grid(row=2, column=2, columnspan=2, sticky='ew')
f_negatif = tk.Frame(fenetre, height=HAUTEUR, width=LARGEUR)
f_negatif.grid(row=3, column=2, columnspan=2)
f_negatif.grid_propagate(0)
# Nommer la séquence
saisie = tk.StringVar(fenetre, value=sequence.name)
if DEBUG:
print("entrée:", saisie.get())
tk.Label(fenetre, text='Nom : ').grid(row=4, column=0)
e = tk.Entry(fenetre, textvariable=saisie)
e.grid(row=4, column=1, columnspan=3, sticky='ew')
# Bouton pour sortir
'''
confirmation = tk.Button(fenetre,
text='Valider les filtres',
command=confirmer)
confirmation.grid(row=5, columnspan=2)
annulation = tk.Button(fenetre,
text='Annuler',
command=annuler)
annulation.grid(row=5, column=2, columnspan=2)
'''
if DEBUG:
def verify():
barre_de_message(saisie.get(), messager)
verification = tk.Button(fenetre,
text=" Vérifier le nom",
command=verify)
verification.grid(row=6)
return saisie
def annul():
barre_de_menu(lm_sequence, menu)
clear(fenetre)
def efface(self):
'''
Rend visible la Main dans le Frame
'''
self.visible = False
clear(self.frame)
def c_modifier_sequence():
''' Modification de la séquence active '''
if DEBUG:
print('modifier séquence')
clear(fenetre)
_selectionne_sequence(_modification)
