Bonjour,
Je souhaite synchroniser une liste contenant des nombres et une matrices de labels qui contiennent chacun un nombre de la liste.
Entre les 2, un autre label affiche le nombre sélectionné soit par la liste, soit par la matrice de labels.
Lorsque je suis dans la matrice, je veux visualiser le label qui a le focus.
J'utilise pour cela widget.focus_set(), en initialisant les options highlightthickness et highlightcolor pour chaque label de la matrice.
Je choisis un nombre par les labels, soit par un click gauche de la souris, soit grâce au flèche haut, bas, droite, gauche.
Le programme fonctionne bien, sauf que je n'arrive pas à visualiser le label qui a le focus.
Quelqu'un peut-il m'aider à trouver mon erreur?
Voici mon programme:
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
import tkinter as tk
nombres=list(range(12))
global index
 
'''
La fenêtre principale comprend de gauche à droite:
---> Un label contenant une liste avec son ascenseur
     Chaque ligne de la liste contient un nombre
---> Un label affichant ce qui est selectionné par la liste ou par les labels
     contenus dans le labelFrame de droite
---> Des labels contenus dans un LabelFrame. Chaque label renferme un nombre
     présent dans la liste.
Le but est de choisir un nombre soit en selectionnant une ligne de la liste,
soit en selectionnant un label
Le label qui contient le nombre selectionné devra être entouré d'un cadre noir
'''
 
def donneFocusC(evt):
    evt.widget.focus_set()
    num.set(lab.index(evt.widget))
    labelSelection["text"]=lab[num.get()]["text"]
    liste.selection_clear(0,tk.END)
    liste.selection_set(lab.index(evt.widget))
    liste.see(lab.index(evt.widget))
 
def donneFocusH(evt):
    num.set((num.get()-1)%12)
    lab[num.get()].focus_set()
    labelSelection["text"]=lab[num.get()]["text"]
    liste.selection_clear(0,tk.END)
    liste.selection_set(lab[num.get()]["text"])
    liste.see(lab[num.get()]["text"])
 
def donneFocusB(evt):
    num.set((num.get()+1)%12)
    lab[num.get()].focus_set()
    labelSelection["text"]=lab[num.get()]["text"]
    liste.selection_clear(0,tk.END)
    liste.selection_set(lab[num.get()]["text"])
    liste.see(lab[num.get()]["text"])
 
def donneFocusD(evt):
    num.set((num.get()+3)%12)
    lab[num.get()].focus_set()
    labelSelection["text"]=lab[num.get()]["text"]
    liste.selection_clear(0,tk.END)
    liste.selection_set(lab[num.get()]["text"])
    liste.see(lab[num.get()]["text"])
 
def donneFocusG(evt):
    num.set((num.get()-3)%12)
    lab[num.get()].focus_set()
    labelSelection["text"]=lab[num.get()]["text"]
    liste.selection_clear(0,tk.END)
    liste.selection_set(lab[num.get()]["text"])
    liste.see(lab[num.get()]["text"])
 
def donneFocusLFlabels(evt):
    labelLabels.focus_set()
    lab[num.get()].focus_set()
    labelSelection["fg"]="red"
 
def donneFocusLFliste(evt):
    labelListe.focus_set()
    liste.focus_set()
    liste.activate(num.get())
    labelSelection["fg"]="blue"
 
def ParcourirListe():
    global p
    num.set(liste.curselection()[0])
    labelSelection["textvariable"]=str(num)
    p=labelSelection.after(200,ParcourirListe)
 
 
def NePlusParcourirListe():
    global p
    labelSelection.after_cancel(p)
 
#Création de la fenêtre principale
##################################
fenetrePrincipale=tk.Tk()
fenetrePrincipale.title("Un essai sur la gestion du focus")
fenetrePrincipale.grid()
num=tk.IntVar()
 
#Création du label contenant la liste et l'ascenseur
####################################################
labelListe=tk.LabelFrame(fenetrePrincipale,text="Contient une liste",bg="gray90",fg='black',
                         highlightcolor="blue",highlightthickness=2,takefocus=1)
labelListe.bind("<Enter>",donneFocusLFliste)
labelListe.grid(row=0,column=0,sticky="ns")
labelListe.grid()
 
#   Création de la liste
liste=tk.Listbox(labelListe,height=5,width=10)
liste.grid(row=0,column=0,sticky="ns")
for i in nombres:
    liste.insert(tk.END,str(i))
liste.selection_set(0)
num.set(liste.curselection()[0])
#   Création de l'ascenseur
ascenseur=tk.Scrollbar(labelListe)
ascenseur.grid(row=0,column=1,sticky="ns")
#   Mise en relation de la liste et de l'ascenseur
liste["yscrollcommand"]=ascenseur.set
ascenseur["command"]=liste.yview
 
liste.bind("<Enter>",lambda evt: ParcourirListe())
liste.bind("<Leave>",lambda evt: NePlusParcourirListe())
 
#Création du LabelFrame afficheur
#################################
labelAfficheur=tk.LabelFrame(fenetrePrincipale,text="Selection",bg="Misty rose")
labelAfficheur.grid(row=0,column=1,sticky="ns")
labelAfficheur.grid()
#    Création du Label qui affiche le nombre selectionné
labelSelection=tk.Label(labelAfficheur,width=10,textvariable=str(num),height=6,justify="center")
labelSelection.grid(row=0,column=0)
 
#Création du LabelFrame contenant les labels
############################################
labelLabels=tk.LabelFrame(fenetrePrincipale,text="Contient des labels",
                          highlightcolor="red",highlightthickness=1,takefocus=1)
labelLabels.grid(row=0,column=2,sticky="ns",)
labelLabels.grid()
labelLabels.bind("<Enter>",donneFocusLFlabels)
#    Création de tous les labels contenant un nombre
ligne=0
colonne=0
lab=list()
i=0
for j in nombres:
    lab.append(tk.Label(labelLabels,text=str(j),takefocus=1,highlightthickness=1,
                        highlightcolor ="red",bg="Gray50",width=3,height=1))
    lab[j].bind("<Button-1>",donneFocusC) #focus géré par un click gauche
    lab[j].bind("<Up>",donneFocusH) # focus géré par flèche haut
    lab[j].bind("<Down>",donneFocusB) # focus géré par flèche bas
    lab[j].bind("<Right>",donneFocusD) # focus géré par flèche droite
    lab[j].bind("<Left>",donneFocusG) # focus géré par flèche gauche
    lab[j].grid(row=ligne,column=colonne)
    j+=1
    ligne+=1
    if ligne>2:
        ligne=0
        colonne+=1
 
fenetrePrincipale.mainloop()