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_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 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 validate(event=None):
global sequence_active
if DEBUG:
print("Validation sequence")
try:
index_sequence, = menu_deroulant.curselection()
except ValueError:
barre_de_message('Sélectionnez une séquence', messager)
return None
sequence_active = liste_des_sequences[index_sequence]
postaction()
def c_donne_precedente():
global index_pack
if index_pack < 2:
mess = 'Début de paquet'
barre_de_message(mess, messager)
else:
donne_active = widgets_actifs["donne_active"]
index_pack -= 1
donne = Donne(identifiant=pack_actif[index_pack])
donne_active.visible = position_active.visibilite()
donne_active.reconfigure(donne)
barre_de_message(f'Enchérir la donne n°{index_pack}', messager)
def c_donne_suivante():
global index_pack
if index_pack == len(pack_actif)-1:
mess = 'Dernière donne atteinte'
barre_de_message(mess, messager)
else:
donne_active = widgets_actifs["donne_active"]
index_pack += 1
donne = Donne(identifiant=pack_actif[index_pack])
donne_active.visible = position_active.visibilite()
donne_active.reconfigure(donne)
barre_de_message(f'Enchérir la donne n°{index_pack}', messager)
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():
''' 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 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()
barre_de_message(f"Fichier {filename[5:]} sauvegardé",
messager)
barre_de_menu(lm_donne, menu)
except IOError:
barre_de_message("Problème d'entrée/sortie", messager)
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)
'''
if sequence.negatif[sequence.position] :
tlb = tk.Label(fenetre,
text='Attention ! Filtres négatifs actifs')
tlb.grid()
'''
mess = "Validité des filtres négatifs non implémentée"
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 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 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_charger_donnes():
if DEBUG:
print("charger")
global pack_actif, index_pack
donnename = tk.StringVar(fenetre)
donnename.set(askopenfilename(filetypes=[DONNETYPE], initialdir='data/'))
filename = donnename.get()
if DEBUG:
print("file : ", filename)
if filename:
with open(filename, "rb") as fichier:
pack_actif = pickle.load(fichier)
index_pack = 0
if DEBUG:
print(pack_actif)
mess = f'Donne du fichier {filename} chargées'
barre_de_message(mess, messager)
else:
mess = "Pas de fichier sélectionné"
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()
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 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 c_gestion_filtre():
clear(menu)
image()
barre_de_message("Menu des filtres", messager)
barre_de_menu(lm_filtre, menu)
def postaction():
barre_de_menu(lm_sequence, menu)
barre_de_message(f'Séquence active : {sequence_active.name}', messager)
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()
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 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, columnspan=4)
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, column=0)
vardonneur = tk.IntVar(fenetre)
varvul = tk.IntVar(fenetre)
tk.Label(fenetre, text="Donneur").grid(row=2, column=0)
for pos in Position:
b = tk.Radiobutton(fenetre,
variable=vardonneur,
text = pos.name(),
value = int(pos),
width=8,
anchor="w"
)
b.grid(row=2, column = pos+1)
if pos ==0 :
b.select()
b = tk.Radiobutton(fenetre,
variable=vardonneur,
text = "aléatoire",
value = 4,
width=8,
anchor="w"
)
b.grid(row=2, column = 5)
tk.Label(fenetre, text="Vulnérabilité").grid(row=3, column=0)
for vul in Vulnerabilite:
b = tk.Radiobutton(fenetre,
variable=varvul,
text = vul.name(),
value = int(vul),
width=8,
anchor="w"
)
b.grid(row=3, column = vul+1)
if vul ==0 :
b.select()
b = tk.Radiobutton(fenetre,
variable=varvul,
text = "aléatoire",
value = 4,
width=8,
anchor="w"
)
b.grid(row=3, column = 5)
barre_de_validation(menu, validate, cancel)
mess = " Distribution des donnes "
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 postaction():
mess = f'Séquence active : {sequence_active.name}'
barre_de_message(mess, messager)
c_distribuer_donnes()
def c_regler_filtre(index_filtre=None):
clear(menu)
barre_de_message('Réglage du filtre', messager)
def init_vars(selection):
var_pointH_min.set(selection.pointH_min)
var_pointH_max.set(selection.pointH_max)
var_HLD_min.set(selection.points_totaux_min)
var_HLD_max.set(selection.points_totaux_max)
pique_min.set(selection.pique_min)
pique_max.set(selection.pique_max)
coeur_min.set(selection.coeur_min)
coeur_max.set(selection.coeur_max)
carreau_min.set(selection.carreau_min)
carreau_max.set(selection.carreau_max)
trefle_min.set(selection.trefle_min)
trefle_max.set(selection.trefle_max)
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())
mess = filtre.controle_couleurs()
if mess :
barre_de_message(mess, messager)
init_vars(filtre)
return None
mess = filtre.controle_HLD()
if mess :
barre_de_message(mess, messager)
init_vars(filtre)
return None
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 annuler():
clear(fenetre)
barre_de_menu(lm_filtre, menu)
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)
writefiltres(liste_des_filtres)
clear(fenetre)
barre_de_menu(lm_filtre, menu)
mess = 'Le filtre a été supprimé'
barre_de_message(mess, messager)
clear(fenetre)
var_pointH_min, var_pointH_max = scale_couple(fenetre, 'Points H', 0, 40)
var_HLD_min, var_HLD_max = scale_couple(fenetre, 'Points HLD', 1, 58)
pique_min, pique_max = scale_couple(fenetre, 'Nombre de piques', 2)
coeur_min, coeur_max = scale_couple(fenetre, 'Nombre de coeurs', 3)
carreau_min, carreau_max = scale_couple(fenetre, 'Nombre de carreaux', 4)
trefle_min, trefle_max = scale_couple(fenetre, 'Nombre de trèfles', 5)
name = tk.StringVar(fenetre)
tk.Label(fenetre, text='Nom du filtre').grid(row=10, column=0)
tk.Entry(fenetre, textvariable=name).grid(row=10, column=1)
if isinstance(index_filtre, int):
selection = liste_des_filtres[index_filtre]
name.set(selection.name)
init_vars(selection)
lm_regler_filtre = [['Sauvegarder', conclure],
['Supprimer', supprimer],
['Annuler', annuler]
]
else:
var_pointH_max.set(40)
var_HLD_max.set(58)
pique_max.set(13)
coeur_max.set(13)
carreau_max.set(13)
trefle_max.set(13)
lm_regler_filtre = [['Sauvegarder', conclure],
['Annuler', annuler]
]
barre_de_menu(lm_regler_filtre, menu)
def c_charger_archives():
mess = 'Option indisponible dans cette version'
barre_de_message(mess, messager)
def c_enchérir():
clear(menu)
barre_de_message("Menu des enchères", messager)
barre_de_menu(lm_enchere, menu)
initialise_encheres()
def c_archiver_donne():
mess = 'Fonctionnalité non disponible dans cette version'
barre_de_message(mess, messager)
def verify():
barre_de_message(saisie.get(), messager)
def menu_principal():
image()
barre_de_menu(lm_principale, menu)
barre_de_message("Menu principal", messager)
