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
|
#!/usr/bin/env python
# -*- coding:UTF-8 -*-
#-------------------------------------------------------------------------------
# Name: module1
# Purpose:
#
# Author: MzBouba
#
# Created: 13/04/2012
# Copyright: (c) MACHADO.F 2012
# Licence: <your licence>
#-------------------------------------------------------------------------------
"""
Options standard
activestyle :Spécifie l'apparence de la ligne active de la liste.
background / bg :Couleur de fond.
disabledbackground :Couleur de fond quand le widget est à l'état DISABLED.
disabledforeground :Couleur de premier plan affichée quand l'état
du widget est DISABLED.
exportselection :Par défaut, l'utilisateur sélectionner le texte avec
la souris et le texte choisi sera exporté au
presse-papiers.
Pour mettre hors service ce comportement,
utilisez exportselection=0.
command :Lance une commande lors du changement de la valeur du
champ de saisie.
borderwidth / bd :Largeur de la frontière autour de la combobox.
cursor :Curseur utilisé quand la souris est sur le widget.
foreground / fg :Couleur du texte.
highlightbackground :Couleur highlight quand le widget n'a pas de focus.
highlightcolor :Couleur highlight quand le widget a un focus.
highlightthickness :Intensité de la couleur de focus.
height :Nombre de lignes affichés dans la liste.
insertbackground :Couleur du curseur d'insertion.
insertborderwidth :
insertofftime :Clignotement du curseur, temps où il est éteint.
insertontime :Clignotement du curseur, temps où il est allumé.
insertwidth :Largeur du curseur. 2 pixels par défaut.
items :Liste de éléments.
justify :Emplacement du texte.
listvariable :StringVar connecté à la liste complète.
matchrequired :La valeur de saisie doit être dans la liste.
Si elle n'y figure pas, le premier élément de la liste
est sélectionné
nodouble :Enlève les doubles de la liste.
0:Ne fait rien (par défaut)
1:Supprime les doubles
readonlybackground :Couleur de fond l'état du widget est "readonly".
relief :Effets tridimensionnels autour de l'entrée de texte.
selectbackground :Couleur de fond à l'affichage du texte sélectionné.
selectborderwidth :Largeur de la frontière utilisé autour du texte
sélectionné. Par défaut un pixel.
selectforeground :Couleur de premier plan du texte sélectionné.
sort :Tri la liste suivant la valeur renseignée.
None :Pas de tri (par défaut)
sort :Tri croissant par ordre alphanumérique
reversed :Tri décroissant par ordre alphanumérique
reverse :inversion de la liste
state :Etat du widget (NORMAL, DISABLED).
takefocus :Normalement, le focus contrôle le widget;
fournissez la valeur 0 à cette option pour obtenir
l'interruption du contrôle de focus.
textvariable :StringVar associé à la zone de saisie.
width :Largeur de l'étiquette en caractères (pas pixels!).
La largeur est basée sur la moyenne des caractères,
donc quelques chaînes dans des polices de caractères.
proportionnelles ne peuvent pas aller à cette longueur.
xscrollcommand :A lier avec une scrollbar pour faire défiler le texte
de la boite de saisie si ce texte est trop long.
Methode
append_ :Ajout d'un élément à la fin d'une liste.*
change_list :Remplace la liste par une nouvelle.*
clear_list :Vide la liste
extend_ :Concatène la liste d'origine avec la liste <otherlist>.*
get :Récupère la valeur du champ de saisie.
index_to_item :Renvoi l'élément de la liste se trouvant à la ligne(index)
insert_ :Ajout d'un élément dans la liste à la ligne index.*
item_to_index :Renvoi l'<index> (ligne), de la liste, correspondant
à <item>
remove_ :Supprime un élément de la liste
set :Modifie le champ de saisie avec la valeur renseignée.
size :Renvoi le nombre d'élément de la liste
* Les méthodes de suppression de double et de tri sont aussi appelé.
Vérifier les options nodouble et sort.
"""
from tkinter import *
from time import *
#import tkinter.messagebox as tkMessageBox
class Combobox(Frame):
"""Champ de saisie associé à une liste déroulante"""
def __init__(self, master=None, command = '', height=10, items=[],
matchrequired=0, nodouble = 0, sort=None, width=20, **Arg
):
"""Construit un Widget Combobox avec master comme parent
Option Standard
activestyle, background / bg,
disabledbackground, disabledforeground,
exportselection, borderwidth / bd, command,
cursor, foreground / fg, highlightbackground,
highlightcolor, highlightthickness, height,
insertbackground, insertborderwidth,
insertofftime, insertontime, insertwidth,
items, justify, listvariable, matchrequired,
nodouble, readonlybackground, relief,
selectbackground, selectborderwidth,
selectforeground, sort, state, takefocus,
textvariable, width, xscrollcommand
Methode
append_, change_list, clear_list, extend_,
get, index_to_item, insert_, item_to_index,
remove_, set, size
"""
self.Arg=Arg # Dictionnaire des options de configuration de la Combobox
self.command=command
self.height = height
self.index = -1
self.items = items
self.master = master
self.matchrequired = matchrequired
self.nodouble = nodouble
self.sort = sort
self.sVar = StringVar()
self.width = width
self.widget_option = {}
self.widget_option['button'] = ('bg', 'background', 'cursor', 'fg',
'foreground', 'highlightbackground', 'highlightcolor',
'highlightthickness', 'relief',
)
self.widget_option['entry'] = ('bg', 'background', 'cursor',
'disabledbackground', 'disabledforeground',
'exportselection','fg', 'foreground', 'highlightbackground',
'highlightcolor', 'highlightthickness', 'insertbackground',
'insertborderwidth', 'insertofftime', 'insertontime',
'insertwidth', 'justify', 'readonlybackground', 'relief',
'selectbackground', 'selectborderwidth', 'selectforeground',
'state', 'takefocus', 'textvariable', 'width',
'xscrollcommand',
)
self.widget_option['frame'] = ('bd', 'borderwidth', 'cursor',
'height', 'highlightbackground',
'highlightcolor', 'highlightthickness', 'padx', 'pady',
'relief', 'takefocus', 'width',
)
self.widget_option['listbox'] = ('activestyle', 'bg', 'background',
'cursor', 'exportselection', 'fg', 'foreground', 'height',
'highlightbackground', 'highlightcolor',
'highlightthickness', 'listvariable', 'relief',
'selectbackground', 'selectborderwidth', 'selectforeground',
'width',
)
self.widget_option['scrollbar'] = ('bg', 'background', 'cursor',
'highlightbackground', 'highlightcolor',
'highlightthickness', 'relief',
)
self.widget_option['toplevel'] = ('bg', 'background', 'cursor',
'highlightbackground', 'highlightcolor',
'highlightthickness', 'relief',
)
# <Frame>---------------------------------------------------------------
Frame.__init__(self, master, self.__widget_arg__('frame', self.Arg))
if type(self.items) != list:
if type(self.items) == tuple:
self.items = list(self.items)
else:
self.items=['Liste incorrecte']
self.bind('<FocusOut>', self.__match_required__)
self.__nodouble_in_list__()
self.__sort_list__()
self.__initialize__()
def test(self, event):
print(event.widget)
# Initialise la partie graphique
def __initialize__(self):
"""Fonction interne"""
# Actualise <Entry> en fonction de <self.index>
def __actu_entry__():
"""Fonction interne"""
if len(self.items)!= 0:
indexmax=len(self.items) - 1
if self.index >= indexmax:
self.index = indexmax
if self.index <= 0:
self.index= 0
self.set(self.index_to_item(self.index))
self.__command__()
else: self.index = -1
# Autocomplétion lors de la saisie de texte
def __auto_completion__(event):
"""Fonction interne"""
if event.keysym not in ['BackSpace', 'Delete', 'Down', 'Up']:
index = -1
for item in self.items:
index += 1
if self.sVar.get() in item[:(len(self.sVar.get()))]:
self.sVar.set(item)
self.entry.select_range(INSERT,END)
self.index = index
self.__command__()
break
else:
self.__command__()
# Action de la touche bas du clavier.
# fait défiler les items de la liste vers le bas
def __keypress_down__(event=None):
"""Fonction interne"""
self.index = self.index + 1
__actu_entry__()
# Action de la touche haut du clavier.
# fait défiler les items de la liste vers le haut
def __keypress_up__(event=None):
"""Fonction interne"""
self.index = self.index - 1
__actu_entry__()
# Déplacement de la molette de souris quand le focus est sur <Entry>
# Action de la molette de la souris. Défilement des items de la liste.
def __mouse_wheel__(event):
"""Fonction interne"""
self.index = self.index + int(-event.delta/120)
__actu_entry__()
# <Entry>---------------------------------------------------------------
self.entry=Entry(self, self.__widget_arg__('entry', self.Arg),
borderwidth=0, font='Arial, 8', textvariable=self.sVar,
width = self.width)
self.entry.grid(row=0, column=0)
self.entry.bind('<Down>',__keypress_down__) # touche bas
self.entry.bind('<KeyRelease>',__auto_completion__)
self.entry.bind('<MouseWheel>',__mouse_wheel__) # Molette de souris
self.entry.bind('<Up>',__keypress_up__) # touche haut
# <Button>--------------------------------------------------------------
self.sVarbutton=StringVar()
self.sVarbutton.set('▼')
self.button=Button(self, self.__widget_arg__('button', self.Arg),
background='white', disabledforeground='black',
borderwidth=0, command=self.__open_list__,
font='Arial, 7', height=1, takefocus=0,
textvariable=self.sVarbutton)
self.button.grid(row=0, column=1)
# lance la commande associé à la combobox en récupérant le contenu de <Entry>
def __command__(self):
"""Fonction interne"""
try: self.command(self.sVar.get())
except: pass
# Créer la <Toplevel> contenant la <Listbox>
def __create_toplevel__(self):
"""Fonction interne"""
# Rend l'utilisation du <bouton-1> au <Button>
def active_button(event_add=None):
self.button.config(state=NORMAL)
self.sVarbutton.set('▼')
# Ferme la liste
def close_list(event=None):
"""Fonction interne"""
self.toplevel.destroy()
self.after(1, active_button)
# Déplacement de la souris dans <Listbox>
def move_mouse(event):
"""Fonction interne"""
self.listbox.selection_clear(0,END)
self.listbox.activate(self.listbox.nearest(event.y))
self.listbox.selection_set(self.listbox.nearest(event.y))
# Sélection d'une item dans <Listbox>
def select_item(event=None):
"""Fonction interne"""
if int(self.listbox.size()): # <Listbox> non vide
index=self.listbox.curselection() # renvoie un tuple d'index
ind0 =int(index[0]) # on ne garde que le premier
self.index=ind0
item=self.listbox.get(ind0)
# <Entry>: Actualisation suivant l'item choisi dans la <Listbox>
self.sVar.set(item)
# <Entry>: Prend le focus
self.entry.focus_set()
# <Entry>: Déplace le curseur au début
self.entry.icursor(0)
# <Entry>: Sélectionne le mot
self.entry.select_range(0,END)
# <Toplevel>: Destruction
close_list()
self.__command__()
# <Toplevel>------------------------------------------------------------
self.toplevel=Toplevel(self,
self.__widget_arg__('toplevel', self.Arg),
#height=self.height,
)
#<Toplevel>: Supprime le contour de fenetre
self.toplevel.overrideredirect(1)
#<Toplevel>: Geometrie
x=self.entry.winfo_rootx() # Coordonnees reelles de
y=self.entry.winfo_rooty() # <Entry>
xTop, yTop=x-2, y + 18
self.toplevel.geometry("+{}+{}".format(xTop, yTop))
# <Toplevel> tjs en 1er plan
self.toplevel.transient()
# <Toplevel>: Perte du focus, la <Toplevel> se ferme
self.toplevel.bind('<FocusOut>', close_list)
self.button.config(state=DISABLED)
# <Listbox>-------------------------------------------------------------
self.listbox=Listbox(self.toplevel,
self.__widget_arg__('listbox', self.Arg),
width = self.width+2, height=self.height,
)
self.listbox.pack(side=LEFT)
# <ListBox>: Remplissage
for it in self.items:
self.listbox.insert(END, it)
# <Listbox>: prend le focus
self.listbox.focus()
# <Listbox>: Action
self.listbox.bind('<Button-1>', select_item)
self.listbox.bind('<Motion>', move_mouse)
# <listbox>: Sélection de l'item = <Entry>
index = self.item_to_index(self.sVar.get())
if self.index_to_item(self.index) == self.sVar.get():
if self.index != index:
index=self.index
else:
index=0
# <listbox>: Positionne le cuseur sur la valeur de <Entry>
self.listbox.activate(index)
self.listbox.selection_set(index)
self.listbox.see(index)
# <Scrollbar>-----------------------------------------------------------
if len(self.items) > self.height:
# <Scrollbar>: Association avec <Listbox>
self.scrollbar=Scrollbar(self.toplevel,
self.__widget_arg__('scrollbar', self.Arg),
borderwidth=0,
command=self.listbox.yview, width=15,
)
# <scrollbar>: Implantation
self.scrollbar.pack(expand =YES, fill =Y)
# <Listbox>: Association avec <scrollbar>
self.listbox.config(yscrollcommand=self.scrollbar.set)
self.listbox.config(width=self.width)
# Vérifie que la valeur saisie est dans la liste
def __match_required__(self, event=None):
"""Fonction interne"""
if self.matchrequired:
listboxId = 0
try:
# Si la <Listbox> prend le focus on ne vérifie pas
if self.nametowidget(self.focus_get()) == self.nametowidget(self.listbox):
listboxId = 1
except:
pass
if not listboxId:
if not self.sVar.get() in self.items:
if self.index == -1:
self.sVar.set(self.items[0])
self.index=0
else:
self.sVar.set(self.items[self.index])
# Suppression des doubles dans la liste
def __nodouble_in_list__(self):
"""Fonction interne"""
if self.nodouble:
index0=0
while index0 < len(self.items)-1:
index1 = len(self.items)-1
while index1 != index0:
if self.items[index0] == self.items[index1]:
del(self.items[index1])
index1 -= 1
index0 += 1
# Ouvre la liste
def __open_list__(self, event=None):
"""Fonction interne"""
self.__create_toplevel__()
self.sVarbutton.set('▲')
# Tri la liste suivant l'option
def __sort_list__(self):
"""Fonction interne"""
if self.sort == 'sort': self.items.sort()
elif self.sort == 'reversed': self.items.sort(reverse=True)
elif self.sort == 'reverse': self.items.reverse()
# Retourne la liste des options d'un widget
def __widget_arg__(self, name, arg = {}):
"""Fonction interne"""
dic_arg={}
for option in arg:
if option in self.widget_option[name]:
dic_arg[option]=arg[option]
return dic_arg
#
def append_(self, string=''):
"""Ajout d'un élément à la fin d'une liste.
Les méthodes de suppression de double et de tri sont
aussi appelé.
Vérifier les options nodouble et sort."""
self.items.append(string)
self.__nodouble_in_list__()
self.__sort_list__()
#
def change_list(self, newlist=()):
"""Remplace la liste par une nouvelle"""
self.items=newlist
self.__nodouble_in_list__()
self.__sort_list__()
#
def clear_list(self):
"""Vide la liste"""
self.items = []
#
def extend_(self, otherlist=[]):
"""Concatène la liste d'origine avec la liste <otherlist>.
Les méthodes de suppression de double et de tri sont
aussi appelé.
Vérifier les options nodouble et sort."""
self.items.extend(otherlist)
self.__nodouble_in_list__()
self.__sort_list__()
#
def get(self):
"""Récupère la valeur du champ de saisie"""
return self.sVar.get()
#
def index_to_item(self, index=0):
"""Renvoi l'élément de la liste se trouvant à la ligne(index)"""
try: return self.items[index]
except: pass
#
def insert_(self, index = END, string = ''):
"""Ajout d'un élément dans la liste à la ligne index.
Les méthodes de suppression de double et de tri sont
aussi appelé.
Vérifier les options nodouble et sort."""
if index == END: index = len(self.items)
self.items.insert(index, string)
self.__nodouble_in_list__
self.__sort_list__
#
def item_to_index(self, string=''):
"""Renvoi la ligne (index) dans la liste du premier élément
correspondant trouvé"""
try: self.items.index[string]
except: index = -1
return index
#
def remove_(self, string=''):
"""Supprime un élément de la liste"""
try: self.items.remove(string)
except: pass
#
def set(self, string = ''):
"""Modifie le champ de saisie avec la valeur renseignée"""
self.sVar.set(string)
# <Entry>: Déplace le curseur au début
self.entry.icursor(0)
self.entry.selection_range(0, END)
#
def size(self):
"""Renvoi le nombre d'élément de la liste"""
return len(self.items)
mylist=('Pommes', 'Poires', 'Abricot', 'Ananas', 'Raisin','Orange',
'Clémentine', 'Cerise', 'Mandarine', 'Peche', 'Poires', 'Abricot', )
nlist='autre'
listempty=['saucisse', 'merguez']
def main():
def label_value():
label.config(text=combobox.index_to_item(0) )
combobox.extend_(['rien', 'autre'])
window=Tk()
frame=Frame(window)
frame.grid()
combobox=Combobox(frame, activestyle='dotbox', borderwidth=2, insertborderwidth=10, troughcolor='#357',
items= mylist, relief=GROOVE, font='Arial, 8',height=5,
width=25, matchrequired=1, sort='reverse')
combobox1=Combobox(frame, activestyle='dotbox', borderwidth=2, items=listempty,
matchrequired=1, width=25)
button=Button(frame, text='test', command=label_value)
label=Label(frame)
button.grid(row=0,column=0)
label.grid(row=0,column=1)
combobox.grid(row=1,column=0)
combobox1.grid(row=2,column=0)
window.mainloop()
if __name__ == '__main__':
main() |
Combobox uniquement avec Tkinter
Répondre avec citation
Partager