Comment visualiser qu'un label à le focus

**Cemalatowilo** · 09/04/2020, 14h34

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()

**wiztricks** · 09/04/2020, 15h47

Salut,

Je ne suis jamais arrivé à faire fonctionner çà sous Windows (et je n'ai pas essayé sous Linux): je change le background pour signaler la navigation "à la main".

- W

**MPython Alaplancha** · 09/04/2020, 17h07

Bonjour,
Après avoir cliqué sur un chiffre de la liste et en survolant la partie label avec la souris , je vois bien le focus.
Idem en partant du label ...
(je suis sous linux)

**Cemalatowilo** · 09/04/2020, 17h30

Envoyé par Hominidé

Bonjour,
Après avoir cliqué sur un chiffre de la liste et en survolant la partie label avec la souris , je vois bien le focus.
Idem en partant du label ...
(je suis sous linux)

Je suis sous windows 10
J'ai commencé à travailler sur ce programme sur un apple, et je voyais le focus de manière aléatoire (du certainement à un manque de mise au point)
Ce serait donc un problème windows?
Y at il un moyen de contourner le problème, je voudrais que le focus soit indiqué par un cadre de couleur?

**wiztricks** · 09/04/2020, 18h08

Envoyé par Cemalatowilo

Y at il un moyen de contourner le problème, je voudrais que le focus soit indiqué par un cadre de couleur?

Ne vous ai je pas suggéré de changer le background "à la main"?

- W

**Cemalatowilo** · 09/04/2020, 20h11

Envoyé par wiztricks

Ne vous ai je pas suggéré de changer le background "à la main"?

- W

Exact, mais ce programme est une maquette pour visualiser des couleurs par le background des labels, alors que la liste indiquera le nom de la couleur.
Donc l'utilisation du background ne me convient pas. J'ai essayé d'utiliser l'option relief. Cela fonctionne mais je crains que ce ne soit pas assez visible.
J'ai vu également que je peux utiliser l'option borderwidth pour modifier l'épaisseur de la bordure du label.
Savez vous s'il est possible de modifier la couleur de de cette bordure?

**wiztricks** · 09/04/2020, 22h28

Salut,

Envoyé par Cemalatowilo

J'ai vu également que je peux utiliser l'option borderwidth pour modifier l'épaisseur de la bordure du label.
Savez vous s'il est possible de modifier la couleur de de cette bordure?

L'épaisseur de la bordure n'est prise en compte que si vous préciser un "relief".
Vous pouvez au mieux changer le "relief" pour visualiser le Label sélectionné.

Si vous voulez un truc plus "cool", vous pourriez utiliser un Canvas et fabriquer vos propres étiquettes.
Pour visualiser la sélection, vous pourriez déplacer un cercle (ou autre), modifier les dimensions d'un rectangle (autour du texte) avec la couleur que vous voulez.

C'est en général ce que j'utilise lorsque je fabrique ce genre d'interface.
Mais je dois vous avouer que le Canvas (et le widget Text) sont assez puissants et demandent du temps à pouvoir être utilisés. Si vous êtes pressé, ce n'est peut être pas une bonne idée.

- W

**Beginner.** · 09/04/2020, 22h38

Salut,

Envoyé par Cemalatowilo

Donc l'utilisation du background ne me convient pas. J'ai essayé d'utiliser l'option relief. Cela fonctionne mais je crains que ce ne soit pas assez visible.

J'ai testé avec un relief solid et c'est bien visible chez moi...

Ailleurs j'ai vu une idée : mettre une frame derrière le label...

**Cemalatowilo** · 10/04/2020, 18h05

Envoyé par Beginner.

Salut,
J'ai testé avec un relief solid et c'est bien visible chez moi...

Ailleurs j'ai vu une idée : mettre une frame derrière le label...

Merci à tous pour vos suggestions pertinentes.
L'utilisation du widget Canvas m'est trop compliqué pour l'instant, j'opte pour l'option relief.
Voici ma maquette finale:

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
149
150
import tkinter as tk
nombres=list(range(30))
global index
 
'''
Programme maquette pour synchroniser une liste avec les élements d'un tableau de Labels
=======================================================================================
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 visualisé.
 
Les options highlightcolor et highlightthickness ne fonctionnent pas lorsque
le focus est sur le Label. Pour contourner le problème j'utilise
l'option relief.
'''
 
def MaJ(np,n):
    lab[n].focus_set()
    lab[np]["relief"]="flat"
    lab[n]["relief"]="groove"
    labelSelection["text"]=lab[n]["text"]
    liste.selection_clear(0,tk.END)
    liste.selection_set(n)
    liste.see(n)
 
def actionClickG(evt):
    nump.set(num.get())
    num.set(lab.index(evt.widget))
    MaJ(nump.get(),num.get())
 
def actionFlecheH(evt):
    nump.set(num.get())
    num.set((num.get()-1)%30)
    MaJ(nump.get(),num.get())
 
def actionFlecheB(evt):
    nump.set(num.get())
    num.set((num.get()+1)%30)
    MaJ(nump.get(),num.get())
 
def actionFlecheD(evt):
    nump.set(num.get())
    num.set((num.get()+5)%30)
    MaJ(nump.get(),num.get())
 
def actionFlecheG(evt):
    nump.set(num.get())
    num.set((num.get()-5)%30)
    MaJ(nump.get(),num.get())
 
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
    nump.set(num.get())
    num.set(liste.curselection()[0])
    labelSelection["textvariable"]=str(num)
    lab[nump.get()]["relief"]="flat"
    lab[num.get()]["relief"]="groove"
    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()
nump=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",bg="Gray50",takefocus=1,
                          highlightthickness=1,highlightcolor ="red")
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=0,bg="Gray90",width=3,height=1,bd=5))
    lab[j].bind("<Button-1>",actionClickG) #focus géré par un click gauche
    lab[j].bind("<Up>",actionFlecheH) # focus géré par flèche haut
    lab[j].bind("<Down>",actionFlecheB) # focus géré par flèche bas
    lab[j].bind("<Right>",actionFlecheD) # focus géré par flèche droite
    lab[j].bind("<Left>",actionFlecheG) # focus géré par flèche gauche
    lab[j].grid(row=ligne,column=colonne)
    j+=1
    ligne+=1
    if ligne>4:
        ligne=0
        colonne+=1
lab[0]["relief"]="groove"
 
fenetrePrincipale.mainloop()

**Beginner.** · 10/04/2020, 19h26

Ah effectivement c'est mieux comme ça.

**MPython Alaplancha** · 11/04/2020, 09h27

Envoyé par Cemalatowilo

L'utilisation du widget Canvas m'est trop compliqué pour l'instant,

Bonjour,
Ton post m'a donné l'envie de m'y essayer. Je t'en joins le résultat.

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
 
from tkinter import Canvas
 
 
class Select(Canvas):
    def __init__(self):
        Canvas.__init__(self)
        self.configure(bg='black',width=950, height=110)
        self.grid()
        self.ovale ={}
        self.chiffre = {}
        x = 0
        for i in range(8): 
            self.ovale[i] = self.create_oval(10+x, 10, 100+x, 100,
                                             outline='red',
                                             width=4,
                                             fill='Blue',
                                             tag= "marque"+str(i))
            self.chiffre[i] = self.create_text(55+x, 55, text=str(i),
                                               font=("Courrier", 30, 'bold')
                                               ,fill="white",
                                               tag= "marque"+str(i))
            x += 120
        self.ev()
 
    def ev(self):
        for i in range(8):
            self.tag_bind("marque"+str(i),"<Motion>",
                          lambda event, couleur="pink":
                          self.action(event,couleur))
 
            self.tag_bind("marque"+str(i),"<Leave>",
                          lambda event, couleur="Blue":
                          self.action(event,couleur))
 
    def action(self,event,couleur):
        for i in range(8):
            if "marque"+str(i) in self.gettags('current'):
                self.itemconfig(self.ovale[i],fill=couleur)
 
 
F = Select()
F.mainloop()

**Beginner.** · 11/04/2020, 21h31

Merci Hominidé,
J'ai testé ton code c'est intéressant...

**Cemalatowilo** · 12/04/2020, 14h38

Envoyé par Beginner.

Merci Hominidé,
J'ai testé ton code c'est intéressant...

Merci Hominidé,
ton programme m'est très pédagogique, surtout pour la manière dont tu utilises les évènements

**Cemalatowilo** · 12/04/2020, 14h52

Je vous soumets le programme pour lequel j'ai posé ma question.
Il visualise les couleurs nommées de tkinter en indiquant les valeurs RVB, HEXA et TSL.

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
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
import tkinter as tk
'''
Affiche les couleurs nommées de tkinter qui sont documentées dans le fichier:
C:/Program Files (x86)/Python/Tools/pynche/X/rgb.txt, fourni avec le package python.
J'ai lu ce fichier via un programme qui m'a éliminé les couleurs non compréhensibles
par mon système (windows 10).
J'ai également constaté quelques incohérences entre la couleur nommée et les valleurs
rvb associées.
J'ai ensuite trié les couleurs par valeurs tsl décroissantes.
'''
 
liste_couleur=[
'Lightpink1',
'Lightpink3',
'Lightpink4',
'Lightpink2',
'Lightpink',
'Pink',
'Pink3',
'Pink1',
'Pink2',
'Pink4',
'Palevioletred2',
'Palevioletred4',
'Palevioletred3',
'Palevioletred1',
'Palevioletred',
'Lavenderblush',
'Lavenderblush1',
'Lavenderblush3',
'Lavenderblush2',
'Lavenderblush4',
'Hotpink3',
'Violetred1',
'Violetred2',
'Violetred3',
'Violetred4',
'Hotpink2',
'Hotpink1',
'Hotpink',
'Hotpink4',
'Deeppink2',
'Deeppink3',
'Deeppink',
'Deeppink1',
'Deeppink4',
'Mediumvioletred',
'Violetred',
'Maroon3',
'Maroon4',
'Maroon2',
'Maroon1',
'Orchid2',
'Orchid4',
'Orchid3',
'Orchid1',
'Orchid',
'Magenta',
'Magenta1',
'Magenta2',
'Magenta3',
'Darkmagenta',
'Magenta4',
'Purple',
'Violet',
'Plum',
'Plum2',
'Plum3',
'Plum1',
'Plum4',
'Thistle1',
'Thistle2',
'Thistle3',
'Thistle',
'Thistle4',
'Mediumorchid4',
'Mediumorchid2',
'Mediumorchid1',
'Mediumorchid3',
'Mediumorchid',
'Darkviolet',
'Darkorchid1',
'Darkorchid2',
'Darkorchid3',
'Darkorchid4',
'Darkorchid',
'Purple2',
'Purple3',
'Purple4',
'Purple1',
'Blueviolet',
'Mediumpurple3',
'Mediumpurple1',
'Mediumpurple',
'Mediumpurple2',
'Mediumpurple4',
'Mediumslateblue',
'Slateblue4',
'Slateblue2',
'Slateblue3',
'Slateblue1',
'Darkslateblue',
'Slateblue',
'Lightslateblue',
'Blue',
'Blue1',
'Blue2',
'Blue3',
'Mediumblue',
'Blue4',
'Darkblue',
'Navyblue',
'Navy',
'Midnightblue',
'Lavender',
'Ghostwhite',
'Royalblue4',
'Royalblue2',
'Royalblue1',
'Royalblue3',
'Royalblue',
'Cornflowerblue',
'Lightsteelblue2',
'Lightsteelblue1',
'Lightsteelblue',
'Lightsteelblue3',
'Lightsteelblue4',
'Slategray1',
'Slategray4',
'Slategray2',
'Dodgerblue4',
'Dodgerblue3',
'Dodgerblue',
'Dodgerblue1',
'Dodgerblue2',
'Slategray3',
'Lightslategray',
'Lightslategrey',
'Slategray',
'Slategrey',
'Steelblue4',
'Aliceblue',
'Steelblue3',
'Steelblue2',
'Steelblue1',
'Steelblue',
'Skyblue2',
'Skyblue4',
'Skyblue3',
'Skyblue1',
'Lightskyblue',
'Lightskyblue3',
'Lightskyblue2',
'Lightskyblue1',
'Lightskyblue4',
'Skyblue',
'Deepskyblue',
'Deepskyblue1',
'Deepskyblue2',
'Deepskyblue3',
'Deepskyblue4',
'Lightblue2',
'Lightblue1',
'Lightblue3',
'Lightblue',
'Lightblue4',
'Powderblue',
'Cadetblue3',
'Cadetblue1',
'Cadetblue2',
'Cadetblue4',
'Turquoise1',
'Turquoise2',
'Turquoise3',
'Turquoise4',
'Cadetblue',
'Darkturquoise',
'Cyan',
'Cyan1',
'Cyan2',
'Cyan3',
'Cyan4',
'Darkcyan',
'Darkslategray4',
'Darkslategray3',
'Darkslategray1',
'Darkslategray2',
'Darkslategray',
'Darkslategrey',
'Paleturquoise2',
'Paleturquoise3',
'Paleturquoise1',
'Paleturquoise4',
'Paleturquoise',
'Lightcyan4',
'Lightcyan3',
'Lightcyan2',
'Lightcyan',
'Lightcyan1',
'Azure',
'Azure1',
'Azure2',
'Azure3',
'Azure4',
'Mediumturquoise',
'Lightseagreen',
'Turquoise',
'Aquamarine2',
'Aquamarine4',
'Aquamarine3',
'Mediumaquamarine',
'Aquamarine',
'Aquamarine1',
'Mediumspringgreen',
'Springgreen',
'Springgreen1',
'Springgreen2',
'Springgreen3',
'Springgreen4',
'Mintcream',
'Seagreen3',
'Mediumseagreen',
'Seagreen2',
'Seagreen1',
'Seagreen',
'Seagreen4',
'Green1',
'Lime',
'Green2',
'Green3',
'Green4',
'Green',
'Darkgreen',
'Limegreen',
'Forestgreen',
'Palegreen1',
'Palegreen4',
'Palegreen3',
'Lightgreen',
'Palegreen2',
'Palegreen',
'Darkseagreen4',
'Darkseagreen3',
'Darkseagreen2',
'Darkseagreen1',
'Darkseagreen',
'Honeydew',
'Honeydew1',
'Honeydew2',
'Honeydew3',
'Honeydew4',
'Chartreuse',
'Chartreuse1',
'Lawngreen',
'Chartreuse2',
'Chartreuse3',
'Chartreuse4',
'Greenyellow',
'Darkolivegreen2',
'Darkolivegreen4',
'Darkolivegreen3',
'Darkolivegreen1',
'Darkolivegreen',
'Olivedrab1',
'Olivedrab2',
'Olivedrab3',
'Yellowgreen',
'Olivedrab',
'Olivedrab4',
'Yellow',
'Yellow1',
'Yellow2',
'Yellow3',
'Olive',
'Lightgoldenrodyellow',
'Lightyellow4',
'Lightyellow3',
'Lightyellow2',
'Lightyellow',
'Lightyellow1',
'Beige',
'Ivory',
'Ivory1',
'Ivory2',
'Ivory3',
'Ivory4',
'Darkkhaki',
'Lemonchiffon4',
'Khaki2',
'Khaki1',
'Khaki3',
'Khaki4',
'Palegoldenrod',
'Khaki',
'Lemonchiffon2',
'Lemonchiffon',
'Lemonchiffon1',
'Lemonchiffon3',
'Gold',
'Gold1',
'Gold2',
'Gold3',
'Gold4',
'Lightgoldenrod',
'Cornsilk4',
'Lightgoldenrod1',
'Lightgoldenrod2',
'Lightgoldenrod3',
'Lightgoldenrod4',
'Cornsilk2',
'Cornsilk3',
'Cornsilk',
'Cornsilk1',
'Darkgoldenrod4',
'Darkgoldenrod3',
'Darkgoldenrod2',
'Darkgoldenrod',
'Goldenrod3',
'Goldenrod2',
'Goldenrod4',
'Goldenrod1',
'Goldenrod',
'Darkgoldenrod1',
'Floralwhite',
'Orange',
'Orange1',
'Orange2',
'Orange3',
'Orange4',
'Wheat1',
'Wheat',
'Wheat2',
'Wheat3',
'Wheat4',
'Oldlace',
'Moccasin',
'Papayawhip',
'Navajowhite4',
'Navajowhite2',
'Navajowhite3',
'Navajowhite',
'Navajowhite1',
'Blanchedalmond',
'Antiquewhite4',
'Burlywood1',
'Burlywood',
'Burlywood2',
'Burlywood3',
'Tan',
'Bisque4',
'Antiquewhite2',
'Antiquewhite',
'Darkorange',
'Burlywood4',
'Bisque',
'Bisque1',
'Bisque2',
'Antiquewhite3',
'Antiquewhite1',
'Bisque3',
'Darkorange1',
'Darkorange2',
'Darkorange3',
'Darkorange4',
'Peru',
'Tan3',
'Linen',
'Tan2',
'Tan4',
'Tan1',
'Sandybrown',
'Peachpuff',
'Peachpuff1',
'Peachpuff4',
'Peachpuff3',
'Peachpuff2',
'Seashell4',
'Seashell3',
'Seashell2',
'Chocolate4',
'Saddlebrown',
'Chocolate2',
'Chocolate1',
'Chocolate3',
'Chocolate',
'Seashell',
'Seashell1',
'Sienna4',
'Sienna2',
'Sienna3',
'Sienna1',
'Sienna',
'Lightsalmon4',
'Lightsalmon3',
'Lightsalmon',
'Lightsalmon1',
'Lightsalmon2',
'Orangered',
'Orangered1',
'Orangered2',
'Orangered3',
'Orangered4',
'Coral',
'Darksalmon',
'Salmon3',
'Salmon4',
'Salmon1',
'Salmon2',
'Tomato4',
'Coral2',
'Coral3',
'Coral1',
'Coral4',
'Tomato2',
'Tomato3',
'Tomato',
'Tomato1',
'Mistyrose4',
'Salmon',
'Mistyrose',
'Mistyrose1',
'Mistyrose2',
'Mistyrose3',
'Red',
'Red1',
'Red2',
'Red3',
'Darkred',
'Red4',
'Maroon',
'Firebrick2',
'Firebrick3',
'Firebrick4',
'Firebrick1',
'Firebrick',
'Brown2',
'Brown3',
'Brown1',
'Brown4',
'Brown',
'Indianred3',
'Indianred1',
'Indianred2',
'Indianred4',
'Indianred',
'Lightcoral',
'Rosybrown4',
'Rosybrown3',
'Rosybrown2',
'Rosybrown1',
'Rosybrown',
'Snow2',
'Snow',
'Snow1',
'Snow3',
'Snow4',
'Gray100',
'Grey100',
'White',
'Gray99',
'Grey99',
'Gray98',
'Grey98',
'Gray97',
'Grey97',
'Gray96',
'Grey96',
'Whitesmoke',
'Gray95',
'Grey95',
'Gray94',
'Grey94',
'Gray93',
'Grey93',
'Gray92',
'Grey92',
'Gray91',
'Grey91',
'Gray90',
'Grey90',
'Gray89',
'Grey89',
'Gray88',
'Grey88',
'Gray87',
'Grey87',
'Gainsboro',
'Gray86',
'Grey86',
'Gray85',
'Grey85',
'Gray84',
'Grey84',
'Gray83',
'Grey83',
'Lightgray',
'Lightgrey',
'Gray82',
'Grey82',
'Gray81',
'Grey81',
'Gray80',
'Grey80',
'Gray79',
'Grey79',
'Gray78',
'Grey78',
'Gray77',
'Grey77',
'Gray76',
'Grey76',
'Gray75',
'Grey75',
'Gray74',
'Grey74',
'Gray73',
'Grey73',
'Gray72',
'Grey72',
'Gray71',
'Grey71',
'Gray70',
'Grey70',
'Gray69',
'Grey69',
'Gray68',
'Grey68',
'Gray67',
'Grey67',
'Darkgray',
'Darkgrey',
'Gray66',
'Grey66',
'Gray65',
'Grey65',
'Gray64',
'Grey64',
'Gray63',
'Grey63',
'Gray62',
'Grey62',
'Gray61',
'Grey61',
'Gray60',
'Grey60',
'Gray59',
'Grey59',
'Gray58',
'Grey58',
'Gray57',
'Grey57',
'Gray56',
'Grey56',
'Gray55',
'Grey55',
'Gray54',
'Grey54',
'Gray53',
'Grey53',
'Gray52',
'Grey52',
'Gray51',
'Grey51',
'Gray',
'Grey',
'Gray50',
'Grey50',
'Gray49',
'Grey49',
'Gray48',
'Grey48',
'Gray47',
'Grey47',
'Gray46',
'Grey46',
'Gray45',
'Grey45',
'Gray44',
'Grey44',
'Gray43',
'Grey43',
'Gray42',
'Grey42',
'Dimgray',
'Dimgrey',
'Gray41',
'Grey41',
'Gray40',
'Grey40',
'Gray39',
'Grey39',
'Gray38',
'Grey38',
'Gray37',
'Grey37',
'Gray36',
'Grey36',
'Gray35',
'Grey35',
'Gray34',
'Grey34',
'Gray33',
'Grey33',
'Gray32',
'Grey32',
'Gray31',
'Grey31',
'Gray30',
'Grey30',
'Gray29',
'Grey29',
'Gray28',
'Grey28',
'Gray27',
'Grey27',
'Gray26',
'Grey26',
'Gray25',
'Grey25',
'Gray24',
'Grey24',
'Gray23',
'Grey23',
'Gray22',
'Grey22',
'Gray21',
'Grey21',
'Gray20',
'Grey20',
'Gray19',
'Grey19',
'Gray18',
'Grey18',
'Gray17',
'Grey17',
'Gray16',
'Grey16',
'Gray15',
'Grey15',
'Gray14',
'Grey14',
'Gray13',
'Grey13',
'Gray12',
'Grey12',
'Gray11',
'Grey11',
'Gray10',
'Grey10',
'Gray9',
'Grey9',
'Gray8',
'Grey8',
'Gray7',
'Grey7',
'Gray6',
'Grey6',
'Gray5',
'Grey5',
'Gray4',
'Grey4',
'Gray3',
'Grey3',
'Gray2',
'Grey2',
'Gray1',
'Grey1',
'Black',
'NA',
'NA',
'NA',
'NA',
]
 
def RVBtoTSL(RVB=(0,0,0)):
    """
    Calcule les valeurs TSL (teinte, saturation, luminance) d'une couleur
    à partir de ses valeurs RVB.
    0<=R,V,B<=65535, 0<=T<=360, 0.<=S<=1., 0.<=L<=1.
    """
    R,V,B=RVB[0],RVB[1],RVB[2]
    M=max(RVB)
    m=min(RVB)
    Luminance=M/65535.
    if M==0:
        Saturation=0.
    else:
        Saturation=1.-m/M
    Chroma=M-m
    if Chroma==0:
        Teinte=0
    elif M==R:
        Teinte=(V-B)/Chroma
        Teinte=(60*Teinte+360)%360
    elif M==V:
        Teinte=(2+(B-R)/Chroma)*60
    elif M==B:
        Teinte=(4+(R-V)/Chroma)*60
    if Teinte<0: Teinte+=360 #La teinte doit toujours être positive
    return(int(round(Teinte)),round(Saturation,4),round(Luminance,4))
 
def couleurTexteLabelFrame(rvb=(0,0,0)):
    m=20000
    r,v,b=int(rvb[0]),int(rvb[1]),int(rvb[2])
    if (m>r and m>v) or (m>r and m>b) or (m>v and m>b):
        return (65535,65535,65535)
    else:
        return(0,0,0)
 
def MaJLabel(np,n):
    #lab[n].focus_set()
    couleur=liste_couleur[n]
    lab[np]["relief"]="flat"
    lab[n]["relief"]="ridge"
    try:
        rvb=fenetrePrincipale.winfo_rgb(couleur)
        labelAfficheur['bg']=labelAfficheur['text']=couleur
        ca=couleurTexteLabelFrame(rvb)
        labelAfficheur['fg']="#{0:0>4}{1:0>4}{2:0>4}".format(str(hex(ca[0]))[2::],str(hex(ca[1]))[2::],str(hex(ca[2]))[2::])
        labelhexa["text"]="hexa=#{0:0>4}  {1:0>4}  {2:0>4}\nrvb={3:0>5}  {4:0>5}  {5:0>5}\ntsl={6:>6}  {7:0<6}  {8:0<6}".format(
            str(hex(rvb[0]))[2::],str(hex(rvb[1]))[2::],str(hex(rvb[2]))[2::],
            rvb[0],rvb[1],rvb[2],RVBtoTSL(rvb)[0],RVBtoTSL(rvb)[1],RVBtoTSL(rvb)[2])
    except:
        rvb=fenetrePrincipale.winfo_rgb("white")
        labelAfficheur['bg']="white"
        labelAfficheur['text']=couleur
        labelhexa["text"]=""
 
def MaJListe(np,n):
    liste.selection_clear(0,tk.END)
    liste.selection_set(n)
    liste.see(n)
 
def donneFocusC(evt):
    nump.set(num.get())
    num.set(lab.index(evt.widget))
    lab[num.get()].focus_set()
    MaJLabel(nump.get(),num.get())
    MaJListe(nump.get(),num.get())
 
def donneFocusH(evt):
    nump.set(num.get())
    num.set((num.get()-1)%660)
    lab[num.get()].focus_set()
    MaJLabel(nump.get(),num.get())
    MaJListe(nump.get(),num.get())
 
def donneFocusB(evt):
    nump.set(num.get())
    num.set((num.get()+1)%660)
    lab[num.get()].focus_set()
    MaJLabel(nump.get(),num.get())
    MaJListe(nump.get(),num.get())
 
def donneFocusD(evt):
    nump.set(num.get())
    num.set((num.get()+33)%660)
    lab[num.get()].focus_set()
    MaJLabel(nump.get(),num.get())
    MaJListe(nump.get(),num.get())
 
def donneFocusG(evt):
    nump.set(num.get())
    num.set((num.get()-33)%660)
    lab[num.get()].focus_set()
    MaJLabel(nump.get(),num.get())
    MaJListe(nump.get(),num.get())
 
def donneFocusLFlabels(evt):
    labelLabels.focus_set()
    lab[num.get()].focus_set()
 
def donneFocusLFliste(evt):
    liste.focus_set()
    liste.activate(num.get())
 
def ParcourirListe():
    global p
    nump.set(num.get())
    num.set(liste.curselection()[0])
    MaJLabel(nump.get(),num.get())
    p=labelhexa.after(200,ParcourirListe)
 
def NePlusParcourirListe():
    global p
    labelhexa.after_cancel(p)
 
#Création de la fenêtre principale
##################################
fenetrePrincipale=tk.Tk()
fenetrePrincipale.title("VISUALISATION DES COULEURS NOMMEES DE TKINTER")
fenetrePrincipale.grid()
num=tk.IntVar()
nump=tk.IntVar()
couleur_initiale=liste_couleur[0]
maFont="{courrier new} 10"
 
#Création du label contenant la liste et l'ascenseur
####################################################
labelListe=tk.LabelFrame(fenetrePrincipale,text="lISTE DES COULEURS",bg="gray90",fg='black',
                         highlightcolor="BLACK",highlightthickness=3,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=51,width=16)
liste.grid(row=0,column=0,sticky="ns")
for i in liste_couleur:
    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=couleur_initiale,bg=couleur_initiale,fg='black')
labelAfficheur.grid(row=0,column=1,sticky="ns")
labelAfficheur.grid()
#    Création du Label qui montre la valeur rvb en hexa
rvb=fenetrePrincipale.winfo_rgb(couleur_initiale)
labelhexa=tk.Label(labelAfficheur,
               text="hexa=#{0:0>4}  {1:0>4}  {2:0>4}\nrvb={3:0>5}  {4:0>5}  {5:0>5}\ntsl={6:>6}  {7:0<6}  {8:0<6}".format(
                    str(hex(rvb[0]))[2::],str(hex(rvb[1]))[2::],str(hex(rvb[2]))[2::],
                    rvb[0],rvb[1],rvb[2],RVBtoTSL(rvb)[0],RVBtoTSL(rvb)[1],RVBtoTSL(rvb)[2]),
               bg='gray90',width=20,height=3,bd=5,relief="raised",font=maFont)
labelhexa.grid(row=0,column=0,sticky='ew')
 
#Création du LabelFrame contenant les labels
############################################
labelLabels=tk.LabelFrame(fenetrePrincipale,text="VISUALIATION DES COULEURS",
                          highlightcolor="Black",highlightthickness=3,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()
j=0
for i in liste_couleur:
    try: #Pour passer la couleur "NA" en fin de tableau
        lab.append(tk.Label(labelLabels,bg=i,width=9,height=1,bd=4,relief="flat"))
    except:
        lab.append(tk.Label(labelLabels,text="NA",bg="white",width=9,height=1,bd=4,relief="flat"))
    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>32:
        ligne=0
        colonne+=1
lab[0]["relief"]="ridge"
 
fenetrePrincipale.mainloop()

Je suis preneur de toute amélioration de ce code, étant complétement autodidacte en python et tkinter.

**Cemalatowilo** · 12/04/2020, 21h49

Je viens de m'apercevoir que la touche <Tab> ne fonctionne pas correctement. Elle me permet d'aller du Labelframe de la liste à celle des Labels des couleurs.
Quand le focus est sur la liste, pas de pb, les flèches haut et bas et le click gauchede la souris fonctionnentcorrectement.
Mais quand le focus est sur les couleurs par la touche <Tab>, il n'y a aucune action possible.
Quelqu'un peut-il m'aider?

**wiztricks** · 13/04/2020, 14h07

Salut,

Envoyé par Cemalatowilo

Quelqu'un peut-il m'aider?

Je ne sais pas si çà va vous aider mais quand j'ai vu votre code, j'ai vu beaucoup de temps à suer pour faire fonctionner tout çà.

Dans votre application, il y a 3 composants/entités: une listbox à gauche, un label au milieu, et une grille de nombres à droite.

Quand l'utilisateur modifie la sélection sur la listbox (ou sur la grille de nombre), il faut "propager" la mise à jour pour que les différentes entités rendent compte de la même chose.

Il faut le faire comme on le raconte.
Lorsque la listbox "voit" que la sélection a changée, elle peut juste dire "la sélection a changé" à une mécanique qui va expédier un message à toutes les entités qui doivent se mettre à jour.

tkinter vous offre un mécanisme de base pour faire çà: les Variables (tkinter/Tk) (vous les utilisez: num et nump sont des "IntVar" i.e. de ces variables là).
On peut appeler une fonction/callback lorsque la variable est modifiée (par .set(n)) avec variable.trace('w', on_update).
La fonction on_update appelée à chaque mise à jour se charge d'appeler les fonctions qui vont mettre à jour les différentes entités qui en on besoin.
Sauf le Label car lui peut directement afficher la Variable!

Côté code, çà donne un juste truc comme çà:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
    number = tk.IntVar(value=1)
    callbacks = []
    register_callback = lambda cb: callbacks.append(cb)
 
    def on_update(*args):
        for f in callbacks:
            f()
    number.trace('w', on_update)

register_callback est la fonction que devra appeler une de nos entités pour s'abonner à la distribution des changements. Dans la pratique, elle appellent register_callback avec une fonction qu'on_update aura à appeler dans ce cas.

note: pour les lettrés de la programmation, on est en train de faire du MVC à la sauce tkinter.

Une fois que j'ai fait çà, je me contente de créer les différentes entités:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
    for j, f in enumerate((create_listbox, create_label, create_grid)):
        w = f(root, number)
        w.grid(row=0,column=j, sticky="ns")

Puis on donne un coup de cymbale pour qu'elle se mettent à jour: number.set(0)

create_listbox, create_label, create_grid fabriquent les différentes entités.

Ces entités sont composées de widgets, de callbacks, de variables d'états,...
Soit on reste avec des variables globales (votre choix), soit on fait des classes (ce que font les programmeurs), soit on fait des closures/fermeture.

J'ai opté pour closures/fermeture parce que l'interface entre ces entités et le reste du monde est assez réduite: number (pour faire number.set) et la fonction à appeler pour les mises à jour. Et comme vous semblez ne pas être à l'aise avec les classes, peut être que ce sera plus compréhensible.

Le code:

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
import tkinter as tk
from tkinter.constants import *
 
NUMBERS = list(range(30))
LINES = 5
 
 
def create_my_label_frame(master, **kwds):
    kwds['takefocus'] = 1
    frame = tk.LabelFrame(master, kwds)
    frame.bind("<Enter>", lambda e: frame.focus_set())
    return frame
 
 
def create_listbox(master, number):
    frame = create_my_label_frame(master,text="Contient une liste",bg="gray90",fg='black',
                         highlightcolor="blue",highlightthickness=2)
 
    listbox = tk.Listbox(frame, height=5, width=10)
    listbox.insert(END, *NUMBERS)
    listbox.grid(row=0,column=0,sticky="ns")
    #   Création de l'ascenseur
    sb = tk.Scrollbar(frame)
    sb.grid(row=0,column=1,sticky="ns")
    #   Mise en relation de la liste et de l'ascenseur
    listbox["yscrollcommand"] = sb.set
    sb["command"]=listbox.yview
 
    selected = None
    def on_selection_change(e):
        nonlocal selected
 
        if (cs := listbox.curselection()):
            value = int(cs[0])
            if value != selected:
                selected = value
                number.set(value)
 
    listbox.bind('<<ListboxSelect>>', on_selection_change)
 
    def on_update():
        nonlocal selected
 
        if (value := number.get()) != selected:
            listbox.selection_clear(0, END)
            listbox.selection_set(value)
            listbox.see(value)
            selected = value
 
    register_callback(on_update)
 
    return frame
 
 
def create_label(master, number):
    #Création du LabelFrame afficheur
    frame = tk.LabelFrame(master, text="Selection",bg="Misty rose")
 
    #    Création du Label qui affiche le nombre selectionné
    label = tk.Label(frame, width=10, textvariable = number, height=6, justify="center")
    label.grid(row=0,column=0) 
 
    return frame
 
def create_grid(master, number):
    #Création du LabelFrame contenant les labels
 
    frame = create_my_label_frame(master,text="Contient des labels",bg="Gray50",
                          highlightthickness=1,highlightcolor ="red")
 
    motions = {
        'Up' : -1,
        'Down' : 1,
        'Left' : -LINES,
        'Right' : LINES,
        }
 
    def do_action(event):
        value = motions.get(event.keysym)
        if value is None:
            value = labels.index(event.widget)
        else:
            value = (number.get() + value) % len(NUMBERS)
        number.set(value)     
 
    frame.event_add('<<arrows>>',  '<Up>', '<Down>', '<Right>', '<Left>')    
    frame.bind('<<arrows>>', do_action)
 
    # Création de tous les labels contenant un nombre
    assert len(NUMBERS) % LINES == 0
    labels = []  
    for c in range(0, len(NUMBERS), LINES):
        for r in range(LINES):
            label = tk.Label(frame, text=str(c + r), bg="Gray90", width=3, height=1, bd=5)
            label.bind('<Button-1>', do_action)
            label.grid(row=r, column=c)
            labels.append(label)
 
    selected = None
    def on_update():
        nonlocal selected
 
        if selected is not None:
            labels[selected]['relief'] = 'flat'
        selected = number.get()
        labels[selected]['relief'] = 'groove'
 
    register_callback(on_update)
    return frame
 
if __name__ == '__main__':
    root = tk.Tk()
 
    number = tk.IntVar(value=1)
    callbacks = []
    register_callback = lambda cb: callbacks.append(cb)
 
    def on_update(*args):
        for f in callbacks:
            f()
    number.trace('w', on_update)
 
    for j, f in enumerate((create_listbox, create_label, create_grid)):
        w = f(root, number)
        w.grid(row=0,column=j, sticky="ns")
 
    number.set(0)
 
    tk.mainloop()

Envoyé par Cemalatowilo

Mais quand le focus est sur les couleurs par la touche <Tab>, il n'y a aucune action possible.

Par sur que j'ai tout compris mais <Tab> sur la grille devrait avoir le même effet que sur la listbox (passer au suivant).
Pour çà on peut dire "attrape le <Tab> pour sélectionner le nombre suivant et qu'on aborte le traitement "normal" du <Tab>.

Ca ne change que quelques lignes dans la portion de code suivant:

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
   motions = {
        'Up' : -1,
        'Down' : 1,
        'Left' : -LINES,
        'Right' : LINES,
        'Tab' : 1,
        }
 
    def do_action(event):
 
        value = motions.get(event.keysym)
        if value is None:
            value = labels.index(event.widget)
        else:
            value = (number.get() + value) % len(NUMBERS)
        number.set(value)     
 
        if event.keysym == 'Tab':
            frame.focus_set()
            return 'break'
 
    frame.event_add('<<arrows>>',  '<Up>', '<Down>', '<Right>', '<Left>', '<Tab>')    
    frame.bind('<<arrows>>', do_action)

- W

**Cemalatowilo** · 13/04/2020, 16h25

Merci beaucoup wiztricks pour ce cours de programmation.
Je ne suis pas sûr de pouvoir comprendre toutes ces nouvelles notions.
Je vais prendre ma tête à 2 mains ce soir pour plonger dans votre programme et me renseigner sur le principe du motif de conception VMC.

Je viens de faire tourner votre programme. La seule différence est qu'il est nécessaire de cliquer gauche dans la liste pour pouvoir la parcourir dans votre programme, alors que dans le mien il suffit que le curseur soit dans le labelFrame qui la contient.
C'est certainement un pb d'activation de la liste, mais pour l'instant je ne sais pas où la mettre dans votre programme.
J'ai bien essayé de mettre listbox.activate(value) dans la fonction on_update(), mais cela ne fonctionne pas!

J'ai également un problème de méconnaissance de la syntaxe de tkinter. C'est la première que je vois ce type d'écriture: <<arrows>>, <<ListboxSelect>> ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
   motions = {
        'Up' : -1,
        'Down' : 1,
        'Left' : -LINES,
        'Right' : LINES,
        'Tab' : 1,
        }

Pourtant je fouille sur internet pour récupérer de la doc, et j'en possède une demi-douzaine (malheureusement en français, mon anglais étant trop limité).
Merci de m'en conseiller une.

**wiztricks** · 13/04/2020, 17h18

Envoyé par Cemalatowilo

C'est la première que je vois ce type d'écriture: <<arrows>>, <<ListboxSelect>> ou

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
   motions = {
        'Up' : -1,
        'Down' : 1,
        'Left' : -LINES,
        'Right' : LINES,
        'Tab' : 1,
        }

C'est juste un dictionnaire qui traduit le déplacement en décalage dans la liste.

Envoyé par Cemalatowilo

<<arrows>>, <<ListboxSelect>>

Ce sont des évènements virtuel on en parle ici dans un bon tuto. en français.

Sinon vous en avez toute une collection dans cette discussion.

- W

**Cemalatowilo** · 13/04/2020, 17h39

Envoyé par wiztricks

C'est juste un dictionnaire qui traduit le déplacement en décalage dans la liste.

Ce sont des évènements virtuel on en parle ici dans un bon tuto. en français.

Sinon vous en avez toute une collection dans cette discussion.

- W

Merci wiztricks de votre rapide réponse, je vais étudier tout ceci

**Beginner.** · 14/04/2020, 00h51

Salut,

Envoyé par Cemalatowilo

..., mais je bloque déjà sur la méthode trace d'une variable tkinter.
Je ne trouve aucune doc à ce sujet digne de ce nom.
...
Merci de m'envoyer un lien sur un tuto, même en anglais.

Voici les premiers liens qui me sont venus : https://effbot.org/tkinterbook/variable.htm et https://kite.com/python/docs/Tkinter.StringVar.trace...

On a :

MODE is one of "r", "w", "u" for read, write, undefine. CALLBACK must be a function which is called when the variable is read, written or undefined.

trace

trace(mode, callback) => string
trace_variable(mode, callback)
Add a variable observer. Returns the internal name of the observer (you can use this to unregister the observer; see below).
The mode argument is one of “r” (call observer when variable is read by someone), “w” (call when variable is written by someone), or “u” (undefine; call when the variable is deleted).

Envoyé par Cemalatowilo

Elle semble posséder 3 paramètres, quels sont-ils? A quoi correspond 'w' qui revient systématiquement comme premier paramètre?

Ben moi je n'en vois que deux : mode et callback.

Le "w" c'est pour "write" (quand "la variable est écrite" ---> quand elle est modifiée alors exécute la fonction callback).

Comment visualiser qu'un label à le focus

Tkinter Python

Discussions similaires

Partager

Partager