Discussion :

[MzBouba]

Bonjour à tous,

J'ai ci-dessous un bout de code qui permet l'ouverture d'une toplevel via un bouton.
Lorsque le Focus est perdu par la toplevel, cette dernière est détruite.

Mon problème est que lorsque j'appuie deux fois de suite sur le bouton, la toplevel se recréé automatiquement.

Est-il possible de fermer la toplevel lors du deuxième appui bouton.

Merci pour vos réponses

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
def main():
 
    def showtoplevel():
        toplevel=Tk.Toplevel()
        toplevel.overrideredirect(1)
        toplevel.transient()
        toplevel.bind('<FocusOut>', lambda widget: closetoplevel(toplevel))
        listbox=Tk.Listbox(toplevel)
        listbox.grid()
        listbox.focus()
    def closetoplevel(widget):
        widget.destroy()
 
    root=Tk.Tk()
    Tk.Entry(root).grid(row=0, column=0)
    Tk.Button(root, command=showtoplevel).grid(row=0, column=1)
 
    root.mainloop()
 
if __name__ == '__main__':
    try:
        import Tkinter as Tk
    except:
        import tkinter as Tk
    main()

[MzBouba]

Résolu
Si ça peut aider voici ma soluce

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
#!/usr/bin/env python
# -*- coding:UTF-8 -*-
 
def main():
    def active_button():
        button.config(state=Tk.NORMAL, text='ouvrir')
 
    def showtoplevel():
        toplevel=Tk.Toplevel()
        toplevel.overrideredirect(1)
        toplevel.transient()
        toplevel.bind('<FocusOut>', lambda widget: closetoplevel(toplevel))
        button.config(state=Tk.DISABLED, text='fermer')
        listbox=Tk.Listbox(toplevel)
        listbox.grid()
        listbox.focus()
 
    def closetoplevel(widget):
        widget.destroy()
        button.after(1, active_button)
 
    root=Tk.Tk()
    Tk.Entry(root).grid(row=0, column=0)
    button=Tk.Button(root, command=showtoplevel, text='ouvrir')
    button.grid(row=0, column=1)
 
    root.mainloop()
 
if __name__ == '__main__':
    try:
        import Tkinter as Tk
    except:
        import tkinter as Tk
    main()

[PauseKawa]

Bonjour MzBouba,

Deux autres approches:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
def main():
 
    def showtoplevel():
        for widget in root.winfo_children():
            if isinstance(widget, Tk.Toplevel):
                return
        toplevel = Tk.Toplevel(root)
        toplevel.withdraw()
        toplevel.bind('<FocusOut>', closetoplevel)
        listbox = Tk.Listbox(toplevel)
        listbox.grid()
        listbox.focus()
        toplevel.overrideredirect(1)
        toplevel.transient()
        toplevel.deiconify()
 
    def closetoplevel(event):
        toplevel.destroy()
 
    root = Tk.Tk()
    Tk.Entry(root).grid(row=0, column=0)
    Tk.Button(root, command=showtoplevel).grid(row=0, column=1)
    root.mainloop()
 
 
if __name__ == '__main__':
    try:
        import Tkinter as Tk
    except:
        import tkinter as Tk
    main()

(Si l'on considère que le Toplevel est unique)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
def main():
    def showtoplevel():
        if root.top:
            return
        toplevel = Tk.Toplevel(root)
        root.top = toplevel
        toplevel.withdraw()
        toplevel.bind('<FocusOut>', closetoplevel)
        listbox = Tk.Listbox(toplevel)
        listbox.grid()
        listbox.focus()
        toplevel.overrideredirect(1)
        toplevel.transient()
        toplevel.deiconify()
 
    def closetoplevel(event):
        root.top = None
        toplevel.destroy()
 
    root = Tk.Tk()
    root.top = None
    Tk.Entry(root).grid(row=0, column=0)
    Tk.Button(root, command=showtoplevel).grid(row=0, column=1)
    root.mainloop()
 
 
if __name__ == '__main__':
    try:
        import Tkinter as Tk
    except:
        import tkinter as Tk
    main()

(Qu'importe la boite ici)

@+

[MzBouba]

Bonjour PauseKawa,

Merci d'avoir pris le temps de répondre.

Après test de tes codes, j'en suis toujours à avoir une réouverture de la TopLevel après un deuxième clique <Button-1> sur le bouton.
Logique après tout car la toplevel('<FocusOut>') ferme automatiquement la Toplevel, avant le clique sur le bouton qui la ré ouvre de suite.

La seule soluce (et c'est pas faute d'avoir chercher !!) que j'ai trouvé est donc de <DISABLED> le bouton pour le remettre à son état normal après une tempo.

[PauseKawa]

Bonjour,

Après test de tes codes, j'en suis toujours à avoir une réouverture de la TopLevel après un deuxième clique <Button-1> sur le bouton.

?
Alors je n'ai pas compris la question.

J'ai ci-dessous un bout de code qui permet l'ouverture d'une toplevel via un bouton.
Lorsque le Focus est perdu par la toplevel, cette dernière est détruite.

Mon problème est que lorsque j'appuie deux fois de suite sur le bouton, la toplevel se recréé automatiquement.

Est-il possible de fermer la toplevel lors du deuxième appui bouton.

Code :

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

button.after(1, lambda: button.config(state=Tk.NORMAL, text='ouvrir'))

N’empêche en rien la réouverture d'un Toplevel après 1 ms.

Code :

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

1
2
3
4
    def showtoplevel():
        for widget in root.winfo_children():
            if isinstance(widget, Tk.Toplevel):
                return

ou

Code :

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

1
2
3
    def showtoplevel():
        if root.top:
            return

Par contre oui.

@+

[MzBouba]

Autant pour moi, j'ai du mal m'exprimer.

En fait le but de ce code était de parvenir à avoir le même effet qu'une combobox.

Le premier clique bouton, ouvre la toplevel.
Le deuxième la détruit/ferme.

De plus, il faut qu'un click (listbox inclus),détruise la toplevel.
D'où mon toplevel.bind('<FocusOut>') qui permettait de simuler cette évènement.

(Je comprend mieux l'utilisation de votre code qui empêche, bien la réouverture d'une deuxième toplevel)

[PauseKawa]

Ok : Dans ce cas pourquoi détruire le Toplevel ? Vous pouvez jouer avec
.withdraw()

Le code suivant (de l'indulgence svp, c'est un de mes premiers)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
try:
    from tkinter import *
except:
    from Tkinter import *
 
 
# Class TkComboBox
# ComboBox en pur Tkinter
#
# Options:
# width, height, border, background (bg) , foreground (fg), font, relief, cursor,
# exportselection, selectbackground, selectforeground
#
# Methodes:
# activate(int=index)
# focus_set()
# focus()
# curselection()
# delete(ALL ou int)
# start (int)
# end (END ou int)
# insert(index, valeur)
# get()
# pack(padx=int, pady=int, fill(X, Y, BOTH), expand=bool, side=LEFT, RIGHT, TOP, BOTTOM, CENTER)
# grid(row=int, column=int, columnspan=int, rowspan=int, sticky=NSEW, padx=int, pady=int)
# place(relheight=int, relwidth=int, relx=int, rely=int, width=int, height=int, anchor=NSEW, x=int, y=int)
# config/configure(Option=Valeur)
# defaultindex(int=index)
# defaultvalue(str=value)
#
class TkComboBox(Toplevel):
    listeobjets = []
 
    # Positionnement
    def widgetstate(self, event=None):
        # True : Visible
        # False : Cache la listbox
        # self.update_idletasks()
        self.geometry("%dx%d+%d+%d" % (self.zoneselection.winfo_reqwidth(),self.winfo_reqheight(),self.zoneselection.winfo_rootx(),self.zoneselection.winfo_rooty()))
        self.resizable(width=False, height=False)
        if self.valeur_widget_state == True:
            self.valeur_widget_state = False
            self.withdraw()
        elif self.valeur_widget_state == False:
            self.valeur_widget_state = True
            self.deiconify()
 
    def widgetcache(self, event=None):
        if self.valeur_widget_state == True:
            self.valeur_widget_state == False
        self.withdraw()
 
    # Gestionnaires de geometrie
    def pack(self, padx=None, pady=None, fill=None, expand=None, side=None):
        self.zoneselection.pack(padx=padx, pady=pady, fill=fill, expand=expand, side=side)
 
    def grid(self, row=None, column=None, columnspan=None, rowspan=None, sticky=None, padx=None, pady=None):
        self.zoneselection.grid(row=row, column=column, columnspan=columnspan, rowspan=rowspan, sticky=sticky, padx=padx, pady=pady)
 
    def place(self, relheight=None, relwidth=None, relx=None, rely=None, width=None, height=None, anchor=None, x=None, y=None):
        self.zoneselection.place(relheight=relheight, relwidth=relwidth, relx=relx, rely=rely, width=width, height=height, anchor=anchor, x=x, y=y)
 
    # Configuration
    def configure(self, **kw):
        for cle in kw:
            option = cle
            valeur = kw[cle]
            self.zoneselection[option] = valeur
            self.cache[option] = valeur
            self.selection[option] = valeur
 
    config = configure
 
    # Methodes
    def activate(self, index):
        self.selection.activate(index)
 
    def size(self):
        return self.selection.size()
 
    def focus(self):
        self.zoneselection.get_focus()
 
    get_focus = focus
 
    def curselection(self):
        return map(int, self.selection.curselection())[0]
 
    def delete(self, objet=None, start=None, end=None):
        if objet == 'ALL':
            self.selection.delete(0, END)
        elif start == None and end == None:
            self.selection.delete(objet)
        else:
            self.selection.delete(start, end)
 
    def get(self):
        return self.v_zoneselection.get()
 
    def insert(self, start, objet):
        self.listeobjets.append(objet)
        self.selection.insert(start, objet)
        self.selection.select_set(0)
        self.v_zoneselection.set(objet)
        self.v_cache.set(objet)
 
    def selectionner(self, event):
        def index(event):
            items = self.selection.curselection()
            self.v_zoneselection.set(self.selection.get(items))
            self.v_cache.set(self.selection.get(items))
            self.zoneselection.focus_set()
            self.widgetstate()
        self.selection.bind("<ButtonRelease-1>", index)
 
    def v_cache_Callback(self, varName, index, mode):
        self.v_zoneselection.set(self.v_cache.get())
 
    def v_zoneselection_Callback(self, varName, index, mode):
        self.v_cache.set(self.v_zoneselection.get())
 
    def defaultindex(self, objet):
        if type(objet) == int and objet < self.selection.size() and self.selection.size() > 0:
            self.selection.select_set(objet)
            self.v_zoneselection.set(self.selection.get(objet))
            self.v_cache.set(self.selection.get(objet))
        elif type(objet) != int:
            raise TypeError('index must be an integer')
        elif type(objet) == int and objet >= self.selection.size():
            raise ValueError('index out of range')
        elif self.selection.size() == 0:
            raise Exception('defaultindex before values')
        else:
            raise Exception('error on defaultindex')
 
    def defaultvalue(self, objet):
        if type(objet) == str and objet in self.listeobjets:
            self.selection.select_set(self.listeobjets.index(objet))
            self.v_zoneselection.set(objet)
            self.v_cache.set(objet)
        elif self.selection.size() == 0:
            raise Exception('defaultvalue before values')
        elif type(objet) != str:
            raise TypeError('value must be an string')
        elif type(objet) == str and objet not in self.listeobjets:
            raise ValueError('bad value')
        else:
            raise Exception('error on defaultvalue')
 
    def __init__(self, parent=None, width=None, border=1, background=None, foreground=None, fg=None, bg=None, font=None, relief=None, cursor=None, exportselection=None, selectbackground=None, selectforeground=None, activebackground=None, activeforeground=None, height=None):
        Toplevel.__init__(self, parent, bd=0)
        self.withdraw()
        self.parent = parent
        # Inutile ?
        self.transient()
        # StringVar()
        self.v_zoneselection = StringVar()
        self.v_cache = StringVar()
        # Interface
        # TODO : Revoir les options
        self.zoneselection = Entry(parent, border=border, fg=fg, bg=bg, font=font, relief=relief, cursor=cursor, exportselection=exportselection, selectbackground=selectbackground, selectforeground=selectforeground, height=height, width=width, background=background, foreground=foreground, highlightthickness=0, textvariable=self.v_zoneselection)
        self.cache = Entry(self, border=border, fg=fg, bg=bg, font=font, relief=relief, cursor=cursor, exportselection=exportselection, selectbackground=selectbackground, selectforeground=selectforeground, width=width, height=height, background=background, foreground=foreground, highlightthickness=0, textvariable=self.v_cache)
        self.cache.pack(fill=X)
        self.listescroll = Scrollbar(self)
        self.listescroll.pack(side=RIGHT, fill=Y)
        self.selection = Listbox(self, yscrollcommand=self.listescroll.set, border=border, background=background, foreground=foreground, fg=fg, bg=bg, font=font, relief=relief, cursor=cursor, exportselection=exportselection, selectbackground=selectbackground, selectforeground=selectforeground, height=height)
        self.selection.pack(side=LEFT, fill=BOTH)
        self.listescroll.config(command=self.selection.yview)
        #
        self.overrideredirect(1)
        # Binds
        self.selection.bind("<ButtonPress-1>", self.selectionner)
        self.cache.bind("<ButtonPress-1>", self.widgetstate)
        self.zoneselection.bind("<ButtonPress-1>", self.widgetstate)
        # withdraw le toplevel si la fenetre est reduite
        self.parent.bind("<Unmap>", self.widgetcache)
        # withdraw le toplevel si on deplace la fenetre
        self.parent.bind("<Configure>", self.widgetcache)
        # Pour eviter que le toplevel reste afficher si une autre fenetre est selectionnee.
        # FIXME
        # self.parent.bind("<FocusOut>", self.widgetcache)
        # Trace des StringVar()
        self.v_zoneselection_StringVar_traceName = self.v_zoneselection.trace_variable("w", self.v_zoneselection_Callback)
        self.v_cache_StringVar_traceName = self.v_cache.trace_variable("w", self.v_cache_Callback)
        # Init de self.valeur_widget_state
        self.valeur_widget_state = True
        self.widgetstate()
 
# Demo
class test(Tk):
    def clic(self, event):
        if self.tkcb2.get() == 'Widget':
            self.txt.delete(1.0, END)
            self.txt.insert(END, self.Widget)
        elif self.tkcb2.get() == 'Sample':
            self.txt.delete(1.0, END)
            self.txt.insert(END, self.Sample)
 
    def __init__(self):
        Tk.__init__(self)
        self.Widget = """# Class TkComboBox
#
# Options:
# width, height, border, background (bg) , foreground (fg), font, relief,
# cursor,exportselection, selectbackground, selectforeground
#
# Methodes:
# activate(int=index)
# focus_set()
# focus()
# curselection()
# delete(ALL ou int)
# start (int)
# end (END ou int)
# insert(index, valeur)
# get()
# pack(padx=int, pady=int, fill(X, Y, BOTH), expand=bool, side=LEFT, RIGHT,
# TOP, BOTTOM, CENTER)
# grid(row=int, column=int, columnspan=int, rowspan=int, sticky=NSEW, padx=int,
# pady=int)
# place(relheight=int, relwidth=int, relx=int, rely=int, width=int, height=int,
# anchor=NSEW, x=int, y=int)
# config/configure(Option=Valeur)
# defaultindex(int=index)
# defaultvalue(str=value)"""
        self.Sample = """Sample:
    def clic(self, event):
        if self.tkcb2.get() == 'Widget':
            self.txt.delete(1.0, END)
            self.txt.insert(END, self.Widget)
        elif self.tkcb2.get() == 'Sample':
            self.txt.delete(1.0, END)
            self.txt.insert(END, self.Sample)
 
    def __init__(self):
        Tk.__init__(self)
        self.txt = Text(self, bg='white')
        self.txt.insert(END, self.Widget)
        self.txt.pack(side=TOP)
        #
        self.tkcb1 = TkComboBox(self, width=10, bg='black', fg='white')
        self.tkcb1.pack(side=LEFT, pady=20, padx=20)
        self.tkcb1.config(bg='white', fg='black')
        for index in range(0,100):
            self.tkcb1.insert(index, index)
        self.tkcb1.defaultvalue(50)
        #
        self.tkcb2 = TkComboBox(self, width=20, bg='black', fg='white')
        self.tkcb2.pack(side=RIGHT, pady=20, padx=20)
        self.tkcb2.insert(END, 'Sample')
        self.tkcb2.insert(END, 'Widget')
        self.tkcb2.defaultvalue('Widget')
        # Event
        self.tkcb2.bind('<ButtonRelease-1>', self.clic)
        Button(self, text='QUIT', command=self.quit).pack(side=TOP, pady=20)"""
        self.txt = Text(self, bg='white')
        self.txt.insert(END, self.Widget)
        self.txt.pack(side=TOP)
        #
        self.tkcb1 = TkComboBox(self, width=10, bg='black', fg='white')
        self.tkcb1.pack(side=LEFT, pady=20, padx=20)
        self.tkcb1.config(bg='white', fg='black')
        for index in range(0,100):
            self.tkcb1.insert(index, index)
        self.tkcb1.defaultindex(50)
        #
        self.tkcb2 = TkComboBox(self, width=20, bg='black', fg='white')
        self.tkcb2.pack(side=RIGHT, pady=20, padx=20)
        self.tkcb2.insert(END, 'Sample')
        self.tkcb2.insert(END, 'Widget')
        self.tkcb2.defaultvalue('Widget')
        # Event
        self.tkcb2.bind('<ButtonRelease-1>', self.clic)
        Button(self, text='QUIT', command=self.quit).pack(side=TOP, pady=20)
 
if __name__ == '__main__':
    app = test()
    app.mainloop()

Utilise self.valeur_widget_state pour indiquer l'état mais vous pouvez (et je pense que c'est mieux) utiliser .wm_state() pour connaitre l'état de votre Toplevel.

@+

[MzBouba]

Ok : Dans ce cas pourquoi détruire le Toplevel ? Vous pouvez jouer avec
.withdraw()

Je me dit que le fait de garder la toplevel "cacher" utilise plus de ressource que de la "détruire".

Dans le même principe que le votre, j'ai aussi créé une combobox

http://www.developpez.net/forums/d12...ement-tkinter/

Mais mon code est moins 'propre' que le votre. (c'est aussi mon premier script)

[PauseKawa]

Je doute franchement qu'il y ai une grosse différence au niveau ressource et je trouve plus propre de garder une référence mais bon...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
def main():
 
    def showtoplevel():
        for Widget in root.winfo_children():
            if Widget._name == 'top':
                Widget.destroy()
                return
        toplevel = Tk.Toplevel(root, name='top')
        toplevel.overrideredirect(1)
        toplevel.transient()
        toplevel.bind('<FocusOut>', lambda e: toplevel.destroy)
        listbox = Tk.Listbox(toplevel)
        listbox.grid()
        listbox.focus()
 
 
    root=Tk.Tk()
    Tk.Entry(root).grid(row=0, column=0)
    Tk.Button(root, command=showtoplevel).grid(row=0, column=1)
    root.mainloop()
 
if __name__ == '__main__':
    try:
        import Tkinter as Tk
    except:
        import tkinter as Tk
    main()

[PauseKawa]

Ou encore

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
def main():
 
    def showtoplevel():
        if hasattr(root, 'toplevel'):
            deltop()
            return
        root.toplevel = Tk.Toplevel(root)
        root.toplevel.overrideredirect(1)
        root.toplevel.transient()
        root.toplevel.bind('<FocusOut>', deltop)
        listbox = Tk.Listbox(root.toplevel)
        listbox.grid()
        listbox.focus()
 
    def deltop():
        root.toplevel.destroy()
        del(root.toplevel)
 
 
 
    root = Tk.Tk()
    Tk.Entry(root).grid(row=0, column=0)
    Tk.Button(root, command=showtoplevel).grid(row=0, column=1)
    root.mainloop()
 
if __name__ == '__main__':
    try:
        import Tkinter as Tk
    except:
        import tkinter as Tk
    main()

etc...

[PauseKawa]

Grosse bêtise:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
def main():
 
    def showtoplevel(Widget):
        if hasattr(Widget, 'toplevel'):
            deltop(Widget)
            return
        Widget.toplevel = Tk.Toplevel()
        Widget.toplevel.overrideredirect(1)
        Widget.toplevel.transient()
        Widget.toplevel.bind('<FocusOut>', lambda: deltop(Widget))
        listbox = Tk.Listbox(Widget.toplevel)
        listbox.grid()
        listbox.focus()
 
    def deltop(Widget):
        Widget.toplevel.destroy()
        del(Widget.toplevel)
 
    root = Tk.Tk()
    ComboEntry = Tk.Entry(root)
    ComboEntry.grid(row=0, column=0)
    Tk.Button(root, command=lambda: showtoplevel(ComboEntry)).grid(row=0, column=1)
    root.mainloop()
 
if __name__ == '__main__':
    try:
        import Tkinter as Tk
    except:
        import tkinter as Tk
    main()

[PauseKawa]

Appliqué à votre code

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
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
 
#!/usr/bin/env python
# -*- coding:UTF-8 -*-
 
#-------------------------------------------------------------------------------
# Name:        module1
# Purpose:
#
# Author:      MACHADO.F
#
# 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.toplevel = None
        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.__create_toplevel__,
                            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"""
        # Ferme la liste
        def close_list(event=None):
            """Fonction interne"""
            self.sVarbutton.set('▼')
            self.toplevel.destroy()
            self.toplevel = None
 
        # 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>------------------------------------------------------------
        if self.toplevel:
            close_list()
            return
        self.sVarbutton.set('▲')
        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)
 
        # <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
                        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
 
    # 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"""
        del(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)
 
def main():
    mylist=('Pommes', 'Poires', 'Abricot', 'Ananas', 'Raisin','Orange',
            'Clémentine', 'Cerise', 'Mandarine', 'Peche', 'Poires', 'Abricot', )
    nlist='autre'
    listempty=['saucisse', 'merguez']
 
    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()