Comment visualiser qu'un label à le focus

Version imprimable

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:

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

09/04/2020, 15h47
wiztricks

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
09/04/2020, 17h07
MPython Alaplancha

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)
09/04/2020, 17h30
Cemalatowilo

Citation:

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?
09/04/2020, 18h08
wiztricks

Citation:

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
09/04/2020, 20h11
Cemalatowilo

Citation:

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?
09/04/2020, 22h28
wiztricks

Salut,

Citation:

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
09/04/2020, 22h38
Beginner.

Salut,

Citation:

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...

Citation:

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:

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

10/04/2020, 19h26
Beginner.

Ah effectivement c'est mieux comme ça.

Citation:

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:

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

11/04/2020, 21h31
Beginner.

Merci Hominidé,
J'ai testé ton code c'est intéressant...
12/04/2020, 14h38
Cemalatowilo

Citation:

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

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:

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.

12/04/2020, 21h49
Cemalatowilo

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?

Salut,

Citation:

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:

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:

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:

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

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:

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

13/04/2020, 16h25
Cemalatowilo
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:

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.
13/04/2020, 17h18
wiztricks
Citation:
Envoyé par Cemalatowilo

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

Code:

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.

Citation:

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
13/04/2020, 17h39
Cemalatowilo

Citation:

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
14/04/2020, 00h51
Beginner.

Salut,

Citation:

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 :

Citation:

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.

Citation:

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

Citation:

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).
14/04/2020, 09h06
wiztricks

Salut,

Citation:

Envoyé par Cemalatowilo

Je suis désolé wiztricks, 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.

Il ne faut pas vous bloquer la dessus.
L'important, c'est le mécanisme qui associe modification d'une valeur à la notification des entités intéressées.
C'est lui qui permet de "cloisonner" les différentes entités et de partitionner le tout "global" de départ.

On aurait pu écrire çà juste avec des fonctions Python: çà fonctionnerait pareil, juste qu'on aurait écrit du code pour rien.

Tenez, j'ai utilisé trace et fabriqué ma liste de callbacks ignorant que je pouvais faire sans (i.e. on peut ajouter autant de callbacks qu'on veut).

Quand vous regardez la richesse les bibliothèques standards de Python (ou de celles de tkinter) impossible de tout savoir. Et quand on code, on arbitre entre chercher dans la documentation (qu'on n'a peut être pas sous la main ou la flemme d'ouvrir) et coder par soi-même (en ré-inventant parfois la roue).

Plus tard, la tête reposée, on peut se donner un temps pour lire/relire la documentation et y découvrir que pour tel code, on aurait pu utiliser telle ou telle fonctionnalité (si on avait "su").

Pire, une bibliothèque, c'est du savoir faire en boîte. Inutile de la lire si vous ne vous posez pas de bonnes questions sur les problèmes qu'elle va permettre de vous résoudre. C'est un peu comme les vieux outils qu'on voit dans les brocantes, pas facile de savoir à quoi ils pouvaient servir sans la culture technique de l'époque.

Citation:

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

Çà c'est un problème général "python".
Python est un langage interprété dans lequel il serait inefficace de vouloir tout coder.
Donc on l'interface avec des bibliothèques externes écrites et documentées pour d'autres langages (TCL/Tk pour tkinter, C++ pour Qt,...).

Le minimum est de permettre au programmeur Python de savoir comment s'y retrouver entre ce qu'on utilise côté Python et la documentation officielle (c'est ce que fait la documentation tkinter).
Après vous avez des tutos. qui couvrent en partie le sujet.

Pour ce qui est de documentation correctes à jour et en français....

Pour répondre à votre question, TCL documente "trace variable" comme "trace add variable" qui détaille tout çà en plusieurs paragraphes.
Ils ne sont lisibles qu'en diagonale car çà s'applique à n'importe quelle variable TCL (et côté tkinter on n'en utilise pas beaucoup).

De toutes façons, il faudra passer du temps à écrire des bouts de code pour vérifier qu'on a bien compris ce que çà dit. Donc on fait "à l'économie" en regardant si on peut résoudre le problème qu'on se pose "avec" et en zappant une grande partie du reste (souvent à tord).

- W
14/04/2020, 09h12
Cemalatowilo

Citation:

Envoyé par Beginner.

Salut,
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 :

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

Merci pour votre réponse.
Mais je n'avais pas penser à regarder dans l'aide de tkinter avec la fonction Help().
Et, si j'ai bien compris il vaut mieux utiliser la fonction trace_add().
14/04/2020, 10h51
wiztricks

Salut,

Citation:

Envoyé par Cemalatowilo

Et, si j'ai bien compris il vaut mieux utiliser la fonction trace_add().

Ce sont les mêmes.

Côté tkinter, trace, trace_variable sont identiques et exécutent la commande TCL "trace variable" qui équivaut côté TCL à "trace add variable".
Côté tkinter, trace_add va exécuter le TCL "trace add variable".

Les cafouillages sont dus aux principes qui sont posés côté passerelle entre tkinter et Tk.

Si trace add variable et trace variable existent côté TCL, il faut que le programmeur Python les retrouve côté tkinter.
Et si côté tkinter, on a "trace" comme synonyme de "trace_variable", c'est peut être parce que côté TCL, trace est une commande qui s'applique à différents objets alors que côté tkinter on se retrouve avec une méthode (on sait à quel objet on l'applique).

- W

Bonjour,
Je pense avoir compris toutes les notions que vous m'avez gentiment fournis.
J'ai donc repris ma maquette en la programmant en POO, pour des motifs pédagogiques (merci confinement).
Voici donc mon nouveau code. Merci de me dire ce que vous en penser.

Code:

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
import tkinter as tk
class LabelListe(tk.LabelFrame):
    def __init__(self,maitre,nombre,selection,**arg):
        arg['text']='Contient une Listebox'
        arg['bg']='Gray90'
        arg['fg']='Black'
        arg['takefocus']=1
        # Création du LabelFrame contenat le widget Listbox
        super(LabelListe,self).__init__(maitre,arg)
        self.nombre=nombre
        self.selectionne=selectionne
        self.grid()
        # Création de la Listebox
        self.lb=tk.Listbox(self,height=5,width=10,
                           highlightcolor="blue",highlightthickness=2)
        self.lb.grid(row=0,column=0,sticky="ns")
        self.lb.insert(tk.END,*range(0,30))
 
        # Le focus est donné à la Listbox quand le curseur
        # entre dans le LabelFrame et il lui est enlevé quand
        # on sort du LabelFrame en le donnant à maitre
        self.bind('<Enter>',lambda evt:self.lb.focus_set())
        self.bind('<Leave>',lambda evt:maitre.focus_set())
        # Création du widget Scrollbarr associé à la Listebox
        self.sb=tk.Scrollbar(self)
        self.sb.grid(row=0,column=1,sticky="ns")
        # Mise en relation de la Listebox et du Scrollbar
        self.lb["yscrollcommand"]=self.sb.set
        self.sb["command"]=self.lb.yview
 
        self.lb.bind('<<ListboxSelect>>',lambda evt: self.selectionListe(evt))
 
    def selectionListe(self,evt):
        if (cs:=self.lb.curselection()):
            val=int(cs[0])
            if val!=self.selectionne.get():
                self.nombre.set(val)
 
    def MaJ(self,*arg): # l'argument *arg est obligatoire pour l'utilisation de trace_add
        if (val := self.nombre.get()) != self.selectionne.get():
            self.lb.selection_clear(0, tk.END)
            self.lb.selection_set(val)
            self.lb.see(val)
            self.lb.activate(val)
 
class LabelAfficheur(tk.LabelFrame):
    def __init__(self,maitre,nombre,selection,**arg):
        arg['text']='Selectionné'
        arg['bg']='Misty rose'
        arg['fg']='Black'
        # Création du LabelFrame contenant le widget Label
        super(LabelAfficheur,self).__init__(maitre,arg)
        self.nombre=nombre
        self.selectionne=selectionne
        self.grid()
        # Création du Label qui affiche le nombre selectionné
        labelSelection=tk.Label(self,width=10,
                                textvariable=self.nombre,height=6,justify="center")
        labelSelection.grid(row=0,column=0)
 
class LabelGrille(tk.LabelFrame):
    def __init__(self,maitre,nombre,selection,**arg):
        arg['text']='Ne contient que des Labels'
        arg['bg']='Gray50'
        arg['fg']='Black'
        arg['takefocus']=1
        arg['highlightthickness']=1
        arg['highlightcolor']="red"
        # Création du LabelFrame contenant la grille de labels
        super(LabelGrille,self).__init__(maitre,arg)
        self.nombre=nombre
        self.selectionne=selectionne
        # Le focus est donné au LabelFrame quand le curseur
        # entre dans le LabelFrame et il lui est enlevé quand
        # on sort du LabelFrame en le donnant à maitre        
        self.bind('<Enter>',lambda evt:self.focus_set())
        self.bind('<Leave>',lambda evt:maitre.focus_set())
 
 
        # Création de la grille de Labels
        ligne=0
        colonne=0
        self.lab=list()
        i=0
        for j in range(0,30):
            self.lab.append(tk.Label(self,text=str(j),takefocus=0,
                                bg="Gray90",width=3,height=1,bd=5))
            self.lab[j].bind('<Button>',lambda evt: self.Bouge(evt))
            self.lab[j].grid(row=ligne,column=colonne)
            j+=1
            ligne+=1
            if ligne>4:
                ligne=0
                colonne+=1
 
        self.event_add('<<Fleches>>','<Up>', '<Down>', '<Right>', '<Left>')
        self.bind('<<Fleches>>',lambda evt: self.Bouge(evt))
 
        self.mvt={'Up':-1,
                  'Down':+1,
                  'Right':+5,
                  'Left':-5}        
 
        self.grid
 
    # Fonction qui gère les flèches
    def Bouge(self,evt):
        val=self.mvt.get(evt.keysym)
        if val is None:
            val=self.lab.index(evt.widget)
        else:
            val=(nombre.get()+val)%30
        nombre.set(val)
 
    # Fonction de mise à jour de la grille. Permet de
    # visualiser le nombre choisi
    def MaJ(self,*arg): # l'argument *arg est obligatoire pour l'utilisation de trace_add
        if self.selectionne.get() is not None:
            self.lab[self.selectionne.get()]['relief']='flat'
        self.selectionne.set(nombre.get())
        self.lab[self.selectionne.get()]['relief']='groove'
 
if __name__=="__main__":
    fp=tk.Tk()
    nombre=tk.IntVar(value=1)
    selectionne=tk.IntVar(value=1)
 
    l=list()
    for j, f in enumerate((LabelListe, LabelAfficheur,LabelGrille)):
        w= f(fp, nombre,selectionne)
        w.grid(row=0,column=j, sticky="ns")
        l.append(w)
    nombre.trace_add('write',l[2].MaJ) # L'ordre d'enregistrement de la fonction
    nombre.trace_add('write',l[0].MaJ) # dans trace est important
 
    nombre.set(0)
 
    tk.mainloop()

Je n'en suis pas totalement satisfait pour les raisons suivantes:

1)Je n'ai pu mettre en mémoire le précédent choix qu'en utilisant une variable IntVar() et non pas une variable interne aux classes.
J'utilise donc 2 variables IntVar().
Y-a-t-il un autre moyen plus pythonique et/ou plus conforme aux règles de l'art de la POO?

2) j'ai mis les trace_add après if __name__=='__main__:
Y-a-t-il un moyen de les mettre dans le corps des classe?
Ne serait-ce pas plus pythonique et/ou plus conforme aux règles de l'art de la POO?

3)Question subsidière:
Y-a-t-il un autre moyen que celui que j'utilise pour enlever le focus à un widget (c'est à dire en le donnant à un autre)?

Salut,

Citation:

Envoyé par Cemalatowilo

3)Question subsidière:
Y-a-t-il un autre moyen que celui que j'utilise pour enlever le focus à un widget (c'est à dire en le donnant à un autre)?

Je me souviens t'avoir suggéré ce moyen dans un autre fil... Perso je n'ai toujours pas trouvé un autre moyen que celui-là...

Citation:

Envoyé par Cemalatowilo

1)Je n'ai pu mettre en mémoire le précédent choix qu'en utilisant une variable IntVar() et non pas une variable interne aux classes.

Si tu utilises des variables "classiques" tu ne pourras pas les tracer il me semble...

Citation:

Envoyé par Cemalatowilo

2) j'ai mis les trace_add après if __name__=='__main__:
Y-a-t-il un moyen de les mettre dans le corps des classe?
Ne serait-ce pas plus pythonique et/ou plus conforme aux règles de l'art de la POO?

Tu pourrais les mettre dans une classe principale (MainClass)... Et on peut en profiter pour mettre les variables IntVar() et le bout de code qui va avec, ça fera des variables globales en moins...

Exemple en reprenant ton code :

Code:

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
import tkinter as tk
 
 
class LabelListe(tk.LabelFrame):
    def __init__(self, maitre, nombre, selectionne, **arg):
        arg['text'] = 'Contient une Listebox'
        arg['bg'] = 'Gray90'
        arg['fg'] = 'Black'
        arg['takefocus'] = 1
        # Création du LabelFrame contenat le widget Listbox
        super(LabelListe, self).__init__(maitre, arg)
        self.nombre = nombre
        self.selectionne = selectionne
        self.grid()
        # Création de la Listebox
        self.lb = tk.Listbox(self, height=5, width=10,
                             highlightcolor="blue", highlightthickness=2)
        self.lb.grid(row=0, column=0, sticky="ns")
        self.lb.insert(tk.END, *range(0, 30))
 
        # Le focus est donné à la Listbox quand le curseur
        # entre dans le LabelFrame et il lui est enlevé quand
        # on sort du LabelFrame en le donnant à maitre
        self.bind('<Enter>', lambda evt: self.lb.focus_set())
        self.bind('<Leave>', lambda evt: maitre.focus_set())
        # Création du widget Scrollbarr associé à la Listebox
        self.sb = tk.Scrollbar(self)
        self.sb.grid(row=0, column=1, sticky="ns")
        # Mise en relation de la Listebox et du Scrollbar
        self.lb["yscrollcommand"] = self.sb.set
        self.sb["command"] = self.lb.yview
 
        self.lb.bind('<<ListboxSelect>>', lambda evt: self.selectionListe(evt))
 
    def selectionListe(self, evt):
        cs = self.lb.curselection()
        if (cs):
            val = int(cs[0])
            if val != self.selectionne.get():
                self.nombre.set(val)
 
    def MaJ(self, *arg):  # l'argument *arg est obligatoire pour l'utilisation de trace_add
        val = self.nombre.get()
        if val != self.selectionne.get():
            self.lb.selection_clear(0, tk.END)
            self.lb.selection_set(val)
            self.lb.see(val)
            self.lb.activate(val)
 
 
class LabelAfficheur(tk.LabelFrame):
    def __init__(self, maitre, nombre, selectionne, **arg):
        arg['text'] = 'Selectionné'
        arg['bg'] = 'Misty rose'
        arg['fg'] = 'Black'
        # Création du LabelFrame contenant le widget Label
        super(LabelAfficheur, self).__init__(maitre, arg)
        self.nombre = nombre
        self.selectionne = selectionne
        self.grid()
        # Création du Label qui affiche le nombre selectionné
        labelSelection = tk.Label(self, width=10,
                                  textvariable=self.nombre, height=6, justify="center")
        labelSelection.grid(row=0, column=0)
 
 
class LabelGrille(tk.LabelFrame):
    def __init__(self, maitre, nombre, selectionne, **arg):
        arg['text'] = 'Ne contient que des Labels'
        arg['bg'] = 'Gray50'
        arg['fg'] = 'Black'
        arg['takefocus'] = 1
        arg['highlightthickness'] = 1
        arg['highlightcolor'] = "red"
        # Création du LabelFrame contenant la grille de labels
        super(LabelGrille, self).__init__(maitre, arg)
        self.nombre = nombre
        self.selectionne = selectionne
        # Le focus est donné au LabelFrame quand le curseur
        # entre dans le LabelFrame et il lui est enlevé quand
        # on sort du LabelFrame en le donnant à maitre
        self.bind('<Enter>', lambda evt: self.focus_set())
        self.bind('<Leave>', lambda evt: maitre.focus_set())
 
        # Création de la grille de Labels
        ligne = 0
        colonne = 0
        self.lab = list()
        i = 0
        for j in range(0, 30):
            self.lab.append(tk.Label(self, text=str(j), takefocus=0,
                                     bg="Gray90", width=3, height=1, bd=5))
            self.lab[j].bind('<Button>', lambda evt: self.Bouge(evt))
            self.lab[j].grid(row=ligne, column=colonne)
            j += 1
            ligne += 1
            if ligne > 4:
                ligne = 0
                colonne += 1
 
        self.event_add('<<Fleches>>', '<Up>', '<Down>', '<Right>', '<Left>')
        self.bind('<<Fleches>>', lambda evt: self.Bouge(evt))
 
        self.mvt = {'Up': -1,
                    'Down': +1,
                    'Right': +5,
                    'Left': -5}
 
        self.grid
 
    # Fonction qui gère les flèches
    def Bouge(self, evt):
        val = self.mvt.get(evt.keysym)
        if val is None:
            val = self.lab.index(evt.widget)
        else:
            val = (self.nombre.get()+val) % 30
        self.nombre.set(val)
 
    # Fonction de mise à jour de la grille. Permet de
    # visualiser le nombre choisi
    def MaJ(self, *arg):  # l'argument *arg est obligatoire pour l'utilisation de trace_add
        if self.selectionne.get() is not None:
            self.lab[self.selectionne.get()]['relief'] = 'flat'
        self.selectionne.set(self.nombre.get())
        self.lab[self.selectionne.get()]['relief'] = 'groove'
 
 
class MainClass():
    def __init__(self):        
        nombre = tk.IntVar(value=1)
        selectionne = tk.IntVar(value=1)
 
        l = list()
        for j, f in enumerate((LabelListe, LabelAfficheur, LabelGrille)):
            w = f(fp, nombre, selectionne)
            w.grid(row=0, column=j, sticky="ns")
            l.append(w)
        # L'ordre d'enregistrement de la fonction
        nombre.trace_add('write', l[2].MaJ)
        nombre.trace_add('write', l[0].MaJ)  # dans trace est important
        nombre.set(0)
 
 
 
if __name__ == "__main__":
    fp = tk.Tk() # on peut mettre cette ligne dans MainClass...
    MainClass()
    tk.mainloop()

Ceci dit j'ai changé quelques points :
1- Dans les constructeurs des trois classes tu as mis en paramètre "selection" au lieu de "selectionne"...
2- Il manque quelque self. : self.nombre à la place de nombre.

Salut,

D'abord les questions:

Citation:

Envoyé par Cemalatowilo

1)Je n'ai pu mettre en mémoire le précédent choix qu'en utilisant une variable IntVar() et non pas une variable interne aux classes.

Si lorsqu'on exécute number.set(value), tous les widgets se mettent à jour pour rendre compte de "value" à quoi sert de connaître la valeur "actuelle" ?
Essentiellement à optimiser: si on est déjà à jour, il n'y a rien à faire.

De plus chaque widget devra faire un boulot différent: rien côté Label, un peu côté Listbox et grid. Dans la mouture de code ci après, j'ai gardé la variable "interne" en guise d'exemple.

Citation:

Envoyé par Cemalatowilo

2) j'ai mis les trace_add après if __name__=='__main__:
Y-a-t-il un moyen de les mettre dans le corps des classe?

"trace" et "trace_variable" sont des méthodes de number (l'IntVar qui sert de "Model"). "number" est passé en paramètre lors de la création des différents widgets, pas de soucis pour qu'ils appellent eux mêmes number.trace(...)

Citation:

Envoyé par Cemalatowilo

Y-a-t-il un autre moyen que celui que j'utilise pour enlever le focus à un widget (c'est à dire en le donnant à un autre)?

Lorsque l'application est "active", le "focus" désigne le widget vers lequel seront dirigées les entrées clavier. Difficile de ne pas le retirer de l'un sans le donner à un autre. Mais je n'ai peut être pas compris la question.

Côté code, bel effort!
Je ne peux que vous livrer ma mouture pour vous montrer comment j'adresse les soucis que vous avez exposé. Je me suis appliqué à garder l'organisation de la mouture précédente.
Normalement vous devriez avoir des questions.

Code:

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

- W

17/04/2020, 10h37
Cemalatowilo

Bonjour et merci wiztricks,
Je vais étudier votre réponse en détail.
Quand au focus, je veux seulement éviter des modifications de sélection involontaires lorsque le pointeur de la souris est hors des zones de la Listbox
ou de la grille.
Pour se faire je veux seulement supprimer le focus sur les zones concernées, sans pour autant le donner à un autre widget, mais c'est vraiment chercher le détail.
17/04/2020, 11h20
wiztricks

Salut,

Citation:

Envoyé par Cemalatowilo

je veux seulement éviter des modifications de sélection involontaires lorsque le pointeur de la souris est hors des zones de la Listbox
ou de la grille.

Hmmm. En fait, c'est le "self.bind("<Enter>", lambda e: self.focus_set())" qui fait que çà marche comme çà. Il faudrait définir une autre logique (le comportement attendu) et essayer de le coder (sans se prendre les pieds avec la gestion "normale" du focus).

- W
17/04/2020, 17h54
Cemalatowilo

Bonjour,
Ca y est j'ai modifier mon programme conformément à tes remarques.
Je n'avais pas remarqué que la variable "selected" n'a pas a être une variable globale.
C'est seulement un paramètre interne de la listebox et de la grille.

J'ai encore 2 questions:
1) Où puis-je trouver la liste des étiquettes type '<<ListboxSelect>>' et leur définition? Je n'ai rien trouvé sur la toile. A vrai dire je ne sais pas formuler ma recherche.
Je pense qu'il doit exister le même type d'étiquette pour tous les widgets.

2) Si j'ai bien compris toute variable écrite en majuscule dans tkinter (comme NUMBERS) est automatiquement une variable globale. Il n'est pas nécessaire de la passer en paramètres dans les déclaration de classe. très partique.
Est-ce la même chose dans python?
17/04/2020, 18h07
Beginner.

Citation:

Envoyé par Cemalatowilo

2) Si j'ai bien compris toute variable écrite en majuscule dans tkinter (comme NUMBERS) est automatiquement une variable globale. Il n'est pas nécessaire de la passer en paramètres dans les déclaration de classe. très partique.
Est-ce la même chose dans python?

Je ne crois pas que cela soit dû au fait que le nom de la variable soit en majuscule... C'est une variable globale car elle est définie en dehors de toute fonction (et de toute classe)...

Ce serait mieux d'éviter d'avoir une variable globale (on pourrait la passer en paramètre et en faire une "variable de classe")...
17/04/2020, 18h37
wiztricks

Salut,

Citation:

Envoyé par Cemalatowilo

1) Où puis-je trouver la liste des étiquettes type '<<ListboxSelect>>' et leur définition? Je n'ai rien trouvé sur la toile. A vrai dire je ne sais pas formuler ma recherche.
Je pense qu'il doit exister le même type d'étiquette pour tous les widgets.

Çà se trouve dans la documentation Tk officielle (hélas en anglais. J'avais vu passer une traduction mais je suis infoutu de la retrouver).
On cherche listbox et comme pour tous les widgets, tout en bas, dans les derniers paragraphes, il y en a un qui s'appelle DEFAULT BINDING

Citation:

Envoyé par Cemalatowilo

2) Si j'ai bien compris toute variable écrite en majuscule dans tkinter (comme NUMBERS) est automatiquement une variable globale. Il n'est pas nécessaire de la passer en paramètres dans les déclaration de classe. très partique.

NUMBERS n'est pas une variable "tkinter", c'est une variable que j'ai créé au tout début du programme: c'est la liste des nombres de 0..29.
Les "variables" tkinter (END, FLAT, GROOVE) deviennent globales par la magie de from tkinter.constants import *.
Les majuscules sont là pour signaler que ce sont des constantes.
note: j'ai du oublié de remplacer "flat" et "groove" par les constantes "normales".

NUMBERS et LINES auraient pu être passées en paramètres. C'était des variables globales dans la première mouture que vous avez réalisé et c'est resté comme çà. Cà ne me semblait pas essentiel (tant qu'elles restent des constantes).

- W
17/04/2020, 20h47
Cemalatowilo

Honte à moi, j'ai oublié le principe des espaces de nom.
Pour ma décharge, cela fait longtemps que j'avais programmé en POO.
Merci pour vos temps passé avec moi, je passe le sujet en résolu.