Discussion :

[wiztricks]

N'en voyant pas le fonctionnement :

A quoi sert le "cnf = {}", si souvent utilisé dans tkinter ?

Il faut vérifier dans les sources mais le constructeur d'un widget à pour arguments: (master, cnf={}, **kwds)
La première chose qui est faite est un merge des kwds avec le contenu de cnf.
Dans votre cas, vous pourriez mettre la configuration par défaut dans une variable de classe et laisser Tk gérer le reste (s'ils sont des paramètres de configuration des s/widgets)
- W

[MzBouba]

Merci pour l'information wiztricks.

Désagréable apparition furtive de self__toplevel en haut à gauche pour moi.
Regardez le code d'InfoBulle.

essayez avec cette portion de 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
 
    def __ToplevelOpen(self, event):
        """Fonction interne"""
        if self.__toplevel.state() == 'withdrawn':
            if sys.platform.startswith('win'):
                self.__button.unbind('<1>')
            self.__button.state('up')
            self.__toplevel.wm_attributes('-topmost', 1)
            self.__listbox.index('active')
            item = self.__listbox.get('active')
            value = self.__entry.get()
            if (value in self.__values) and (value != item):
                index = self.itemToIndex(value)
                self.__listbox.activate(index)
                self.__listbox.see('active')
                self.__listbox.selection_clear(0, 'end')
                self.__listbox.selection_set('active')
            self.__toplevel.geometry("%dx%d+%d+%d" %
                                     (self.winfo_reqwidth(),
                                      self.__listbox.winfo_reqheight(),
                                      self.winfo_rootx(),
                                      self.winfo_rooty() +
                                      self.winfo_reqheight()))
            self.__toplevel.deiconify()

Pour l'Autoscrollbar, que penser vous de ça (pas aussi bon que votre code) mais adapté à tous les placements.

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
Class AutoScrollbar(tk.Scrollbar):
    """Scrollbar se masquant automatiquement si inutile."""
    def __init__(self, parent = None, **kw):
        tk.Scrollbar.__init__(self, parent, **kw)
 
    def set(self, lo, hi):
        if float(lo) <= 0.0 and float(hi) >= 1.0:
            self.tk.call(self.__manage, 'forget', self._w)
        else:
            self.tk.call((self.__manage, 'configure', self._w))
        tk.Scrollbar.set(self, lo, hi)
 
    def __widget_manage(self, manage = None, cnf = {}, **kw):
        self.__manage = manage
        self.tk.call((self.__manage, 'configure', self._w) + self._options(cnf, kw))
 
    def grid(self, cnf = {}, **kw):
        self.__widget_manage('grid', cnf, **kw)
 
    def pack(self, cnf = {}, **kw):
        self.__widget_manage('pack', cnf, **kw)
 
    def place(self, cnf = {}, **kw):
        self.__widget_manage('place', cnf, **kw)

[PauseKawa]

Bonjour,

Parfais pour le Toplevel.

Par contre pour AutoScrollbar si c'est grid qui est utilisé c'est que celui ci dispose de l'option "remove", qui contrairement à forget, conserve les informations de géométrie.
Bien entendu vous pourriez stocker self.tk.call(self.__manage, 'info', self._w)) avant self.tk.call(self.__manage, 'forget', self._w) pour les utiliser pour le configure. Mais là il vas falloir la jouer fine pour ne pas casser la géométrie.
Puisque AutoScrollbar est interne je resterais sur grid.

@+

[PauseKawa]

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
class AutoScrollbar(tk.Scrollbar):
    """Scrollbar se masquant automatiquement si inutile."""
    def __init__(self, parent=None, **kw):
        tk.Scrollbar.__init__(self, parent, **kw)
 
    def set(self, lo, hi):
        if float(lo) <= 0.0 and float(hi) >= 1.0:
            self.tk.call(self.__manage, 'forget', self._w)
        else:
            self.tk.call((self.__manage, 'configure', self._w) + self._geometry)
        tk.Scrollbar.set(self, lo, hi)
 
    def __widget_manage(self, manage = None, cnf = {}, **kw):
        self.__manage = manage
        self._geometry = self._options(cnf, kw)
        self.tk.call((self.__manage, 'configure', self._w) + self._geometry)
 
    def grid(self, cnf = {}, **kw):
        self.__widget_manage('grid', cnf, **kw)
 
    def pack(self, cnf = {}, **kw):
        self.__widget_manage('pack', cnf, **kw)
 
    def place(self, cnf = {}, **kw):
        self.__widget_manage('place', cnf, **kw)

Non ?

[MzBouba]

Oui cela semble bien.

Par contre, imaginons un placement avec pack tel que ci-dessous:
(juste à titre d'exemple, le placement de yscroll est volontairement mauvais au début.
Dans ce cas de figure les bouton aurait du être placé avant cela aurait pu être d'autre listbox).

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
try:
    import tkinter as tk
except:
    import Tkinter as tk
 
class AutoScrollbar(tk.Scrollbar):
    """Scrollbar se masquant automatiquement si inutile."""
    def __init__(self, parent = None, **kw):
        tk.Scrollbar.__init__(self, parent, **kw)
 
    def set(self, lo, hi):
        if float(lo) <= 0.0 and float(hi) >= 1.0:
            self.tk.call(self.__manage, 'forget', self._w)
        else:
            self.tk.call((self.__manage, 'configure', self._w) + self._geometry)
        tk.Scrollbar.set(self, lo, hi)
 
    def __widget_manage(self, manage = None, cnf = {}, **kw):
        self.__manage = manage
        self._geometry = self._options(cnf, kw)
        self.tk.call((self.__manage, 'configure', self._w) + 
                        self._options(cnf, kw))
 
    def grid(self, cnf = {}, **kw):
        self.__widget_manage('grid', cnf, **kw)
 
    def pack(self, cnf = {}, **kw):
        self.__widget_manage('pack', cnf, **kw)
 
    def place(self, cnf = {}, **kw):
        self.__widget_manage('place', cnf, **kw)
 
 
def main():
 
    def vide_list():
        lbx.delete(0, tk.END)
 
    def rempli_list():
        for i in range(100):
            lbx.insert(tk.END, i)
 
    root = tk.Tk()
    lbx = tk.Listbox(root)
    lbx.pack(side = tk.LEFT, expand = tk.YES, fill = tk.BOTH)
    yscroll = AutoScrollbar(root, command = lbx.yview)
    yscroll.pack(side = tk.RIGHT, expand = tk.YES, fill = tk.Y)
    frm = tk.Frame(root)
    frm.pack(side = tk.RIGHT, expand = tk.YES, fill = tk.Y)
    tk.Button(frm, text = 'vide', command = vide_list, width = 10).grid(row = 0, column = 0, sticky = tk.NSEW)
    tk.Button(frm, text = 'rempli', command = rempli_list, width = 10).grid(row = 1, column = 0, sticky = tk.NSEW)
    lbx['yscrollcommand'] = yscroll.set
    rempli_list()
 
    root.mainloop()
 
if __name__ == '__main__':
    main()

[MzBouba]

Quoi que non ......
Si dès le début, nous organisons notre géométrie ainsi
lbx.pack(side = LEFT)
lbx1.pack(side = LEFT)
lbx2.pack(side = LEFT)
lbx3.pack(side = LEFT)
yscroll.pack(side = RIGHT)

l'ensemble étant dans une frame, plus de problème

Donc c'est bon.

[MzBouba]

Au faite pour info, testé sous python 3.2, 2.7, linux et windows :
La quatrième coordonnée n'est apparemment pas utile

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
import Tkinter as tk
 
 
def OnClic(event):
    global state
    canvas.update()
    xcanvas = canvas.winfo_width()
    ycanvas = canvas.winfo_height()
    if state == 'up':
        canvas.delete(tk.ALL)
        canvas.create_polygon(((0, 0), (xcanvas/2, ycanvas), (xcanvas, 0)), fill='red')
        state = 'down'
    else:
        canvas.delete(tk.ALL)
        canvas.create_polygon(((0, ycanvas), (xcanvas/2, 0), (xcanvas, ycanvas)), fill='red')
        state = 'up'
 
 
root = tk.Tk()
canvas = tk.Canvas(root)
canvas.pack()
state = 'down'
OnClic(None)
canvas.bind('<1>', OnClic)
root.mainloop()

Code :

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

1
2
        canvas.create_polygon(((0, 0), (xcanvas/2, ycanvas), (xcanvas, 0), (0, 0)), fill='red')
        canvas.create_polygon(((0, ycanvas), (xcanvas/2, 0), (xcanvas, ycanvas), (0, ycanvas)), fill='red')

[MzBouba]

Concernant le ButtonCanvas, j'ai voulu le réutilisé pour un autre widget:

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
import Tkinter as tk
 
class ButtonCanvas(tk.Canvas):
    """Canvas servant de bouton."""
    def __init__(self, parent=None, g_parent=None, state='down', **kw):
        tk.Canvas.__init__(self, parent)
        self._state = state
        self._fill = 'black'
        self.g_parent = g_parent
 
    def state(self, value):
        if value in ('down', 'up'):
            self.update()
            self._state = value
            x = self.winfo_width()
            y = self.winfo_height()
            if self._state == 'up':
                self.delete(tk.ALL)
                self.create_polygon(((0, 0), (x/2, y), (x, 0),
                                    fill=self._fill)
            else:
                self.delete(tk.ALL)
                self.create_polygon(((0, y), (x/2, 0), (x, y),
                                    fill=self._fill)
 
    def getstate(self):
        return self._state
 
    def _widget_manage(self, cnf={}, **kw):
        g_value = self.g_parent.winfo_reqheight()-self.g_parent['bd']*2
        self.config(width=g_value)
        self.config(height=g_value)
        self.tk.call((self.g_parent.winfo_manager(), 'configure',
                      self._w) + self._options(cnf, kw))
        self.state(self._state)
 
    grid = place = pack = _widget_manage
 
def main():
 
    def OnClic(event):
        if canvas.state() == 'up':
            canvas.state('down')
        elif canvas.state() == 'down':
            canvas.state('up')
 
    root = tk.Tk()
    btn = tk.Button(root)
    btn.pack(side = tk.RIGHT)
    canvas = ButtonCanvas(root, g_parent = btn)
    canvas.pack(side = tk.LEFT)
    OnClic(None)
    canvas.bind('<1>', OnClic)
    root.mainloop()
 
if __name__ in '__main__':
    main()

Malheureusement :

Code :

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

1
2
3
4
5
6
7
8
Traceback (most recent call last):
  File "Canvas Up and down.py", line 112, in <module>
    main()
  File "Canvas Up and down.py", line 106, in main
    canvas.pack(side = tk.LEFT)
  File "Canvas Up and down.py", line 85, in _widget_manage
    g_value = self.g_parent.winfo_reqheight()-self.g_parent['bd']*2
TypeError: unsupported operand type(s) for *: '_tkinter.Tcl_Obj' and 'int'

Suivant le widget associé au ButtonCanvas, il récupère ou non la la valeur du borderwidth

[MzBouba]

Sinon que pensez vous de cela ?

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
import sys
runPython3 = sys.version_info.major > 2
if runPython3:
    import tkinter as tk
else:
    import Tkinter as tk
 
#-------------------------------------------------------------------------------
class ButtonCanvas(tk.Canvas):
    """Canvas servant de bouton."""
    def __init__(self, parent = None, fill = 'black', wdgt_asso = None, state = 'down', **kw):
        tk.Canvas.__init__(self, parent, kw)
        self.__fill = fill
        self.__state = state
        self.__wdgt_asso = wdgt_asso
    #---------------------------------------------------------------------------
    def __widget_manage(self, manage = None, cnf={}, **kw):
        """Fonction interne"""
        if self.__wdgt_asso != None:
            wdgt_bd = self.__wdgt_asso.cget('borderwidth')
            if not isinstance(wdgt_bd, int):
                wdgt_bd = 2  # La quasi totalité des widgets ont par défaut bd = 2
            g_value = self.__wdgt_asso.winfo_reqheight() - (wdgt_bd * 2)
            self.config(width = g_value)
            self.config(height = g_value)
            self.tk.call((self.__wdgt_asso.winfo_manager(), 'configure',
                          self._w) + self._options(cnf, kw))
            self.state(self.__state)
        else:
            self._geometry = self._options(cnf, kw)
            self.tk.call((manage, 'configure', self._w) + self._geometry)
 
    def grid_configure(self, **kw):
        self.__widget_manage('grid', **kw)
    grid = grid_configure
 
    def pack_configure(self, **kw):
        self.__widget_manage('pack', **kw)
    pack = pack_configure
 
    def place_configure(self, **kw):
        self.__widget_manage('place', **kw)
    place = place_configure
 
    def state(self, value = ''):
        """Modifie le contenu du bouton.
        Si aucun argument n'est envoyé lors de l'appel de la fonction,
        renvoi le statut du bouton ('up', 'down', None)."""
        if value in ('down', None, 'up'):
            self.update_idletasks()
            self.__state = value
            x = self.winfo_width()
            y = self.winfo_height()
            if self.__state == 'down':
                self.delete(tk.ALL)
                self.create_polygon(((5, 5), (x/2, y - 5), (x - 5 , 5)),
                                    fill = self.__fill)
            elif self.__state == 'up':
                self.delete(tk.ALL)
                self.create_polygon(((5, y - 5), (x/2, 5), (x - 5, y - 5)),
                                    fill = self.__fill)
            else:
                self.delete(tk.ALL)
        elif value == '':
            return self.__state
 
def main():
    def change():
        if btnc.state() == None:
            btnc.state('up')
            lbl['text'] = 'UP'
        elif btnc.state() == 'up':
            btnc.state('down')
            lbl['text'] = 'DOWN'
        elif btnc.state() == 'down':
            btnc.state(None)
            lbl['text'] = 'NONE'
 
    root = tk.Tk()
    lbl = tk.Label(root, background = 'white')
    btn = tk.Button(root, command = change, text = 'change', width = 10)
    btn.grid(row = 1, column = 1, padx = 5, pady = 5)
    btnc = ButtonCanvas(root, wdgt_asso = btn)
    lbl.grid(row = 0, column = 0, padx = 5, pady = 5, sticky = tk.EW, columnspan = 2)
    btnc.grid(row = 1, column = 0, padx = 5, pady = 5)
    change()
    root.mainloop()
 
if __name__ == '__main__':
    main()

[wiztricks]

Salut,

Je ne comprends plus trop quel problème vous essayez de résoudre.

Pourquoi utiliser un Canvas pour dessiner l'équivalent d'une icone que l'on pourrait afficher directement dans un "Button"?

Pourquoi ce CanvasButton devrait-il s'inquiéter du layout manager utilisé pour l'afficher? Et puis pourquoi s'occuper de "grid", "pack" et "place" en omettant "panels", "canvas", ...

- W

[MzBouba]

C'est dans la continuité de la proposition de Pausekawa.
Il propose d'utiliser un canvas plutôt qu'un widget qui utiliserais du texte.
Texte dans lequel nous aurions les caractères spéciaux up down (alt+30 / alt+31 sous windows).

Bien entendu le fonctionnement de la combobox peut s'en passer, mais je trouvais l'idée intéressante et pas dénué de sens.

[PauseKawa]

Bonsoir,

C'est dans la continuité de la proposition de Pausekawa.
Il propose d'utiliser un canvas plutôt qu'un widget qui utiliserais du texte.

Mon exemple est basé sur

Problème de géométrie ? Le plus simple c'est de faire un Widget composite mais sans trop toucher à votre code cela (+-) donne quelque chose comme

D’où les g_parent et autre.

Pour l'Autoscrollbar, que penser vous de ça (pas aussi bon que votre code) mais adapté à tous les placements.

Que c'est inutile pour votre 'Widget':

.grid() est le seul à conserver les informations (grid_remove). Pour les deux autres c'est plus compliqué : A la limite avec place() si c'est bien utiliser (x/y) par l'utilisateur c'est jouable mais avec pack() c'est quasiment pas jouable.
Le gros problème c'est que vous aurez les informations (widget.pack_info() etc...) mais comment retrouver l'ordre de positionnement pour un même niveau de widget (widget.winfo_children()) ? Pas possible de jouer sur le nom du widget puisqu'il est construit avant l'application du gestionnaire de géométrie.
Si vous trouvez merci

Vous pouvez rechercher cela pour vous même (et si vous trouvez pour moi ) mais qu'en est l'utilité ici ? C'est vous qui gérez le code donc vous savez que vous aller utiliser .grid(). Pas besoin de se compliquer la vie.

Au faite pour info, testé sous python 3.2, 2.7, linux et windows :
La quatrième coordonnée n'est apparemment pas utile

Oui... polygon... j'avais fais mumuse avec des effets de style et des create_line juste avant: sorry...

Pourquoi utiliser un Canvas pour dessiner l'équivalent d'une icone que l'on pourrait afficher directement dans un "Button"?

Et cela c'est l'idée qui règle tout.
Mettre le Canvas dans le Button.

@+

[PauseKawa]

Bonsoir,

Pourquoi utiliser un Canvas pour dessiner l'équivalent d'une icone que l'on pourrait afficher directement dans un "Button"?

Et utiliser une image externe ? Je me doute que le Widget Canvas est 'lourd' juste pour cela mais pour avoir un 'code sans pièces jointes' sur le forum sans passer par du base64 (aussi lourd et inutile ici puisque Tkinter only) comment faire ?

@+

[wiztricks]

Salut,

Et utiliser une image externe ? Je me doute que le Widget Canvas est 'lourd' juste pour cela mais pour avoir un 'code sans pièces jointes' sur le forum sans passer par du base64 (aussi lourd et inutile ici puisque Tkinter only) comment faire ?

Si ce n'est qu'une question de logistique pourquoi ne pas attacher un fichier .7z ou .zip aux réponses?
2Mo on peut mettre quelques icones et un peu de code quand même.

- W

[MzBouba]

Etant dans ma phase apprentissage python, tout exemple pouvant améliorer, modifier, m'aider dans cette phase est bonne a prendre.
De plus, étant perfectionniste j'ai tendance à vouloir sans cesse optimiser le code. (peut être une mauvaise habitude).

Il est vrai que je préfère le tout tkinter car j'ai voulu tester d'autre GUI mais rien que l'installation m'a exaspéré, et si la distribution du code doit passer par moult étape avant de pouvoir l'utiliser, je ne vois pas trop l'intérêt.

Comme je dis j'en suis au stade apprenti.

Sinon, l'avantage du texte est la possibilité de pouvoir modifier la taille d'une traite.
La proposition du Canvas est très bonne car adapté au redimensionnement.

Sinon,

Que c'est inutile pour votre 'Widget':

.grid() est le seul à conserver les informations (grid_remove). Pour les deux autres c'est plus compliqué : A la limite avec place() si c'est bien utiliser (x/y) par l'utilisateur c'est jouable mais avec pack() c'est quasiment pas jouable.
Le gros problème c'est que vous aurez les informations (widget.pack_info() etc...) mais comment retrouver l'ordre de positionnement pour un même niveau de widget (widget.winfo_children()) ? Pas possible de jouer sur le nom du widget puisqu'il est construit avant l'application du gestionnaire de géométrie.
Si vous trouvez merci

Vous pouvez rechercher cela pour vous même (et si vous trouvez pour moi ) mais qu'en est l'utilité ici ? C'est vous qui gérez le code donc vous savez que vous aller utiliser .grid(). Pas besoin de se compliquer la vie.

J'utilise cette scrollbar dans d'autre code notamment une multilistbox.

La gestion du pack peut très bien se gérer au début, comme je disait pour la scrollbar,
si vous la placé en side = RIGHT et tout les autres widget en LEFT, nous n'avons plus cette problématique d'emplacement.
De plus, rien n'empêche l'utilisation de frame afin d'aider à mieux gérer les placements.

Mais bon dans ce cas, autant rester sur du grid lol.

[wiztricks]

Salut,

...mais avec pack() c'est quasiment pas jouable.
Le gros problème c'est que vous aurez les informations (widget.pack_info() etc...) mais comment retrouver l'ordre de positionnement pour un même niveau de widget (widget.winfo_children()) ? Pas possible de jouer sur le nom du widget puisqu'il est construit avant l'application du gestionnaire de géométrie.
Si vous trouvez merci

Techniquement, la relation construite par "master"/"children" à des adhérences avec le positionnement mais elles sont plutôt "faibles".

Pour ce qui est de "pack" (et d'autres layout managers"), on peut créer le widget contenant et les widgets contenus avec le même "master" et faire des .pack_in(master) ou .pack_after(slave), .pack_before(slave).
Dans le cas de .pack_after et .pack_before, le master sera le même que celui du "slave"
=> le "master" n'étant pas nécessairement le "master" utilisé pour la création du widget, ils n’apparaîtront pas dans les "children" de ce "master" (celui de la création).

L'ordre des "pack_in" est retourné par pack_slaves.
Le "master" d'un slave est retourné via la valeur "in" de la clé retournée par pack_info

En espérant avoir enrichi votre journée par ces explications.

- W

[PauseKawa]

Bonjour wiztricks,

Code :

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

1
2
3
grid slaves master ?-option value?
 
If no options are supplied, a list of all of the slaves in master are returned, most recently manages first. Option can be either -row or -column which causes only the slaves in the row (or column) specified by value to be returned

Et cela fonctionne pour pack/place

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
root = Tk.Tk()
b1 = Tk.Button(root, text='1')
print(b1)
b1.pack()
b2 = Tk.Button(root, text='2')
print(b2)
b2.pack()
b3 = Tk.Button(root, text='3')
print(b3)
b4 = Tk.Button(root, text='4')
print(b4)
b5 = Tk.Button(root, text='5')
print(b5)
b5.pack()
b4.pack()
b3.pack()
pack_list = root.tk.call('pack', 'slaves', root)
print(pack_list)
root.mainloop()

Comme quoi cela sert de lire la doc...

Merci wiztricks

[MzBouba]

Et bah voilà :!!!

On en résout des choses

[MzBouba]

Par contre, test infructueux pour mise en pratique sur la scrollbar

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
#!/usr/bin/env python
# -*- coding:UTF-8 -*-
#-------------------------------------------------------------------------------
# Name:        module1
# Purpose:
#
# Author:      AlienWare
#
# Created:     13/05/2012
# Copyright:   (c) AlienWare 2012
# Licence:     <your licence>
#-------------------------------------------------------------------------------
 
import sys
runPython3 = sys.version_info.major > 2
if runPython3:
    import tkinter as tk
else:
    import Tkinter as tk
from sys import platform
from MyScrollBar import *
 
class AutoScrollbar(tk.Scrollbar):
    """Scrollbar se masquant automatiquement si inutile."""
    def __init__(self, parent = None, **kw):
        tk.Scrollbar.__init__(self, parent, **kw)
        self.__parent = parent
    #    self.bind('<Map>', 
 
    #def __widgets_orders(self, event):
 
 
    def set(self, lo, hi):
        if float(lo) <= 0.0 and float(hi) >= 1.0:
            self.tk.call(self.__manage, 'forget', self._w)
        else:
            if self.__manage in ('pack', 'place'):
                self.tk.call((self.__manage, 'after', self.__widgetsOrders[-1]))
                self.tk.call((self.__manage, 'configure', self._w) + self.__geometry)
                print(self.__widgetsOrders[-1])
                self.nametowidget(self.__widgetsOrders[-1]).insert('end', 'rien')
            else:
                self.tk.call((self.__manage, 'configure', self._w) + self.__geometry)
        tk.Scrollbar.set(self, lo, hi)
 
    def __widget_manage(self, manage = None, cnf = {}, **kw):
        self.__manage = manage
        self.__geometry = self._options(cnf, kw)
        self.__widgetsOrders = self.__parent.tk.call(manage, 'slaves', self.__parent).split(' ')
        print(self.__widgetsOrders)
        self.tk.call((self.__manage, 'configure', self._w) + 
                        self._options(cnf, kw))
 
    def grid(self, cnf = {}, **kw):
        self.__widget_manage('grid', cnf, **kw)
 
    def pack(self, cnf = {}, **kw):
        self.__widget_manage('pack', cnf, **kw)
 
    def place(self, cnf = {}, **kw):
        self.__widget_manage('place', cnf, **kw)
 
def main():
 
    def vide_list():
        lbx.delete(0, tk.END)
 
    def rempli_list():
        for i in range(100):
            lbx.insert(tk.END, i)
 
    root = tk.Tk()
    frm = tk.Frame(root)
    frm.grid(row = 0, column = 0)
    lbx = tk.Listbox(frm)
    lbx.insert('end', 1)
    lbx.insert('end', lbx)
 
    lbx2 = tk.Listbox(frm)
    lbx2.insert('end', 2)
    lbx2.insert('end', lbx2)
    lbx3 = tk.Listbox(frm)
    lbx3.insert('end', 3)
    lbx3.insert('end', lbx3)
    yscroll = AutoScrollbar(frm, command = lbx.yview)
    lbx['yscrollcommand'] = yscroll.set
    lbx.pack(side = tk.LEFT, expand = tk.YES, fill = tk.BOTH)
    lbx2.pack(side = tk.RIGHT, expand = tk.YES, fill = tk.BOTH)
    lbx3.pack(side = tk.RIGHT, expand = tk.YES, fill = tk.BOTH)
    yscroll.pack(side = tk.RIGHT, expand = tk.YES, fill = tk.Y)
    frm1 = tk.Frame(root)
    frm1.grid(row = 0, column = 1, sticky = tk.N)
    tk.Button(frm1, text = 'vide', command = vide_list, width = 10).grid(row = 0, column = 0, sticky = tk.NW)
    tk.Button(frm1, text = 'rempli', command = rempli_list, width = 10).grid(row = 1, column = 0, sticky = tk.NW)
    rempli_list()
 
    root.mainloop()
 
if __name__ == '__main__':
    main()

[wiztricks]

Salut,

Par contre, test infructueux pour mise en pratique sur la scrollbar

Vous vouliez que ça fasse quoi?
- W