[tkinter] problème affichage

Version imprimable

Bonjour je crée une fenetre principale contenant un menu (pour quitter) et un canevas
a ce canevas j'attache l'évenement du clic gauche de la souris et qd cet evenement a lieu alors je voudrais afficher unenouvelle fenetre contenant 3 curseurs mais seule la fenetre s'affiche sans les curseurs dedans...
ca doit etre diiot masi je galere et je ne trouve pas
merci de m'indiquer la solution

voila mon code a corriger:

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
 
#! /usr/bin/env python
# -*- coding: Latin-1 -*-
import os, sys
 
from Tkinter import *
import Image
 
class MenuBar(Frame):
    """Barre de menus déroulants"""
    def __init__(self, boss =None):
        Frame.__init__(self, borderwidth =2)
 
        ##### Menu <Fichier> #####
        fileMenu = Menubutton(self, text ='Fichier')
        #fileMenu.grid(row = 0, column = 0)
        fileMenu.pack(side =LEFT)
        # Partie "déroulante" :
        me1 = Menu(fileMenu)
        me1.add_command(label ='Terminer', underline =0, command = boss.quit)
        # Intégration du menu :
        fileMenu.configure(menu = me1)
 
 
class Curseurs(Frame):
    def __init__(self, boss=None):
        Frame.__init__(self)        # constructeur de la classe parente
        self.vR, self.vV, self.vB = -1, -1, -1
        #composante rouge
        Scale(self, length=400, orient=HORIZONTAL, label ='Composante Rouge :',
                troughcolor ='dark grey', sliderlength =20,
                showvalue =0, from_=0, to=255, tickinterval =25,
                command= lambda x, num=1 : updateLabel(x,num)).pack()
        lab1 = Label(self)
        lab1.pack()
        #composante verte
        Scale(self, length=400, orient=HORIZONTAL, label ='Composante Verte :',
                troughcolor ='dark grey', sliderlength =20,
                showvalue =0, from_=0, to=255, tickinterval =25,
                command= lambda x, num=2 : updateLabel(x,num)).pack()
        lab2 = Label(self)
        lab2.pack()
        #composante bleue
        Scale(self, length=400, orient=HORIZONTAL, label ='Composante Bleue :',
                troughcolor ='dark grey', sliderlength =20,
                showvalue =0, from_=0, to=255, tickinterval =25,
                command= lambda x, num=3 : updateLabel(x,num)).pack()
        lab3 = Label(self)
        lab3.pack()
        #on ajoute le bouton pour valider les valeurs choisies
        bouton = Button(self, text = 'Valider les nouvelles valeurs', command= lambda param1=X, param2=Y, param3=self.vR, param4=self.vV, param5=self.vB : validation(param1,param2,param3,param4,param5))
        bouton.pack()
 
        def updateLabel(x, num): #met a jour la valeur de chaque curseur pour l'afficher a l'utilisateur
            if (num == 1):
                lab1.configure(text='Valeur actuelle = ' + str(x))
                self.vR = x
            if (num == 2):
                lab2.configure(text='Valeur actuelle = ' + str(x))
                self.vV = x
            if (num == 3):
                lab3.configure(text='Valeur actuelle = ' + str(x))
                self.vB = x
 
        def validation(X, Y, a, b, c):#modifie les valeurs du pixel
            print 'il faut modifier le pixel en position ('+str(X)+','+str(Y)+') avec les composantes '+str(a)+' '+str(b)+' '+str(c)           
 
class Application(Frame):
    """Application principale"""
    def __init__(self, boss =None):
        Frame.__init__(self)
        self.master.title('test')
        mBar = MenuBar(self)
        mBar.pack()
        self.canevas1 = Canvas(self, bg='light grey', height=500,
                          width=500, borderwidth =2)
        self.canevas1.pack()
        self.canevas1.bind("<Button-3>", self.affich_curseurs)
        self.pack()
 
    def affich_curseurs(self, event):
        X = str(event.x)
        Y = str(event.y)
 
        fen = Tk()
        fra = Curseurs(fen)
        fen.mainloop()
 
if __name__ == '__main__':
    app = Application()
    app.mainloop()

En utilisant un Toplevel ça marche:

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
 
class Curseurs(Frame):
    def __init__(self, boss=None):
        Frame.__init__(self)        # constructeur de la classe parente
        if boss is None:
            boss = self
        self.vR, self.vV, self.vB = -1, -1, -1
        #composante rouge
        Scale(boss, length=400, orient=HORIZONTAL, label ='Composante Rouge :',
                troughcolor ='dark grey', sliderlength =20,
                showvalue =0, from_=0, to=255, tickinterval =25,
                command= lambda x, num=1 : updateLabel(x,num)).pack()
        lab1 = Label(boss)
        lab1.pack()
        #composante verte
        Scale(boss, length=400, orient=HORIZONTAL, label ='Composante Verte :',
                troughcolor ='dark grey', sliderlength =20,
                showvalue =0, from_=0, to=255, tickinterval =25,
                command= lambda x, num=2 : updateLabel(x,num)).pack()
        lab2 = Label(boss)
        lab2.pack()
        #composante bleue
        Scale(boss, length=400, orient=HORIZONTAL, label ='Composante Bleue :',
                troughcolor ='dark grey', sliderlength =20,
                showvalue =0, from_=0, to=255, tickinterval =25,
                command= lambda x, num=3 : updateLabel(x,num)).pack()
        lab3 = Label(boss)
        lab3.pack()
        #on ajoute le bouton pour valider les valeurs choisies
        bouton = Button(boss, text = 'Valider les nouvelles valeurs', command= lambda param1=X, param2=Y, param3=self.vR, param4=self.vV, param5=self.vB : validation(param1,param2,param3,param4,param5))
        bouton.pack()
[...]
    def affich_curseurs(self, event):
        X = str(event.x)
        Y = str(event.y)
 
        top = Toplevel()
        fra = Curseurs(top)
        fra.pack()

merci ca marche niquel mais j'ai un souci
losrque l'utilisateur deplace les curseurs de la petite fenetre affichée au clic de la souris, je veux mettre a jours les valeurs des curseurs puis lorsqu'il valide avec le bouton "valider els nouvelles valeurs" je voudrais passer ces valeurs a ma fonction "validation" mais malheureusement ici ma fonction recoit les valeurs initiales (-1, -1, -1) et non les valeurs définies par les curseurs
autre probleme, je n'arrive pas a faire passer les valeurs X et Y (coordonnées du clic de souris) a ma fonction "validation"

comment puis-je passer ces nouvelles valeurs ?

merci pour votre aide

voici 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
 
#! /usr/bin/env python
# -*- coding: Latin-1 -*-
import os, sys
from Tkinter import *
import Image
class MenuBar(Frame):
    """Barre de menus déroulants"""
    def __init__(self, boss =None):
        Frame.__init__(self, borderwidth =2)
        ##### Menu <Fichier> #####
        fileMenu = Menubutton(self, text ='Fichier')
        #fileMenu.grid(row = 0, column = 0)
        fileMenu.pack(side =LEFT)
        # Partie "déroulante" :
        me1 = Menu(fileMenu)
        me1.add_command(label ='Terminer', underline =0, command = boss.quit)
        # Intégration du menu :
        fileMenu.configure(menu = me1)
 
class Curseurs(Frame):
    def __init__(self, boss=None):
        Frame.__init__(self)        # constructeur de la classe parente
        if boss is None:
            boss = self
 
        self.vR, self.vV, self.vB = -1, -1, -1
        #composante rouge
        Scale(boss, length=400, orient=HORIZONTAL, label ='Composante Rouge :',
                troughcolor ='dark grey', sliderlength =20,
                showvalue =0, from_=0, to=255, tickinterval =25,
                command= lambda x, num=1 : updateLabel(x,num)).pack()
        lab1 = Label(boss)
        lab1.pack()
        #composante verte
        Scale(boss, length=400, orient=HORIZONTAL, label ='Composante Verte :',
                troughcolor ='dark grey', sliderlength =20,
                showvalue =0, from_=0, to=255, tickinterval =25,
                command= lambda x, num=2 : updateLabel(x,num)).pack()
        lab2 = Label(boss)
        lab2.pack()
        #composante bleue
        Scale(boss, length=400, orient=HORIZONTAL, label ='Composante Bleue :',
                troughcolor ='dark grey', sliderlength =20,
                showvalue =0, from_=0, to=255, tickinterval =25,
                command= lambda x, num=3 : updateLabel(x,num)).pack()
        lab3 = Label(boss)
        lab3.pack()
        #on ajoute le bouton pour valider les valeurs choisies
        bouton = Button(boss, text = 'Valider les nouvelles valeurs', command= lambda param1=X, param2=Y, param3=self.vR, param4=self.vV, param5=self.vB : validation(param1,param2,param3,param4,param5))
        bouton.pack()
        def updateLabel(x, num): #met a jour la valeur de chaque curseur pour l'afficher a l'utilisateur
            if (num == 1):
                lab1.configure(text='Valeur actuelle = ' + str(x))
                self.vR = x
            if (num == 2):
                lab2.configure(text='Valeur actuelle = ' + str(x))
                self.vV = x
            if (num == 3):
                lab3.configure(text='Valeur actuelle = ' + str(x))
                self.vB = x
        def validation(X, Y, a, b, c):#modifie les valeurs du pixel
            print 'il faut modifier le pixel en position ('+str(self.X)+','+str(self.Y)+') avec les composantes '+str(a)+' '+str(b)+' '+str(c)           
 
class Application(Frame):
    """Application principale"""
    def __init__(self, boss =None):
        Frame.__init__(self)
        self.master.title('test')
        mBar = MenuBar(self)
        mBar.pack()
        self.canevas1 = Canvas(self, bg='light grey', height=500,
                          width=500, borderwidth =2)
        self.canevas1.pack()
        self.canevas1.bind("<Button-3>", self.affich_curseurs)
        self.pack()
    def affich_curseurs(self, event):
        self.X = str(event.x)
        self.Y = str(event.y)
        top = Toplevel()
        fra = Curseurs(top)
        fra.pack()
if __name__ == '__main__':
    app = Application()
    app.mainloop()

Plutôt que d'appeler une fonction à chaque fois qu'un curseur est déplacé, je te conseille d'utiliser les IntVar (ou StringVar) Tkinter:

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
 
class Curseurs(Frame):
    def __init__(self, boss=None):
        Frame.__init__(self)        # constructeur de la classe parente
        if boss is None:
            boss = self
 
        self.vR, self.vV, self.vB = IntVar(0),IntVar(0),IntVar(0)
        #composante rouge
        Scale(boss, length=400, orient=HORIZONTAL, label ='Composante Rouge :',
                troughcolor ='dark grey', sliderlength =20,
                showvalue =0, from_=0, to=255, tickinterval =25,
                variable=self.vR).pack()
        lab1 = Label(boss, textvariable=self.vR)
        lab1.pack()
        #composante verte
        Scale(boss, length=400, orient=HORIZONTAL, label ='Composante Verte :',
                troughcolor ='dark grey', sliderlength =20,
                showvalue =0, from_=0, to=255, tickinterval =25,
                variable=self.vV).pack()
        lab2 = Label(boss, textvariable=self.vV)
        lab2.pack()
        #composante bleue
        Scale(boss, length=400, orient=HORIZONTAL, label ='Composante Bleue :',
                troughcolor ='dark grey', sliderlength =20,
                showvalue =0, from_=0, to=255, tickinterval =25,
                variable=self.vB).pack()
        lab3 = Label(boss, textvariable=self.vB)
        lab3.pack()

La valeur d'une variable (e.g., self.vR) sera mise à jour automatiquement pour un curseur en la passant comme valeur de l'argument variable:

Code:

1
2
 
Scale(self,..., variable=self.vR)

Sa valeur sera automatiquement affichée dans un label en faisant de la même façon:

Code:

1
2
 
Label(self,..., textvariable=self.vR)

self.X et self.Y n'existent que dans la classe Application. Si tu veux y accéder depuis Curseurs, tu peux les passer en arguments à l'instanciation de Curseurs, par exemple.

13/05/2006, 14h13
frizou11

tres bien merci bcp
encore un dernier point :
dans la fonction validation les 3 nouvelles valeurs passées (a,b,c) sont affichées comme ca: Y_VAR0 PY_VAR1 PY_VAR2
comment dois-je en tirer une valeur ?
13/05/2006, 14h46
naxelas
Pour obtenir la valeur d'une IntVar() ou StringVar():
Code:

1 2 3 4 self.vR.get() self.vV.get() ...

désolé mais mon problème n'est toujours pas résolu
maintenant on m'affiche les valeurs 0,0,0 qui sont je pense les valeurs initiales du curseurs lors de leur affichage
lorsque l'utilisateur modifie les curseurs les nouvelles valeurs ne sont pas envoyées a la fonction validation on obtient toujours 0,0,0 meme en ayant modifier les curseurs

je n'arrive vraiment pas a obtenir les valeurs des curseurs dans la fonction validation

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
 
#! /usr/bin/env python
# -*- coding: Latin-1 -*-
import os, sys
from Tkinter import *
import Image
class MenuBar(Frame):
    """Barre de menus déroulants"""
    def __init__(self, boss =None):
        Frame.__init__(self, borderwidth =2)
        ##### Menu <Fichier> #####
        fileMenu = Menubutton(self, text ='Fichier')
        #fileMenu.grid(row = 0, column = 0)
        fileMenu.pack(side =LEFT)
        # Partie "déroulante" :
        me1 = Menu(fileMenu)
        me1.add_command(label ='Terminer', underline =0, command = boss.quit)
        # Intégration du menu :
        fileMenu.configure(menu = me1)
 
class Curseurs(Frame):
    def __init__(self, X, Y, boss=None):
        Frame.__init__(self)        # constructeur de la classe parente
        if boss is None:
            boss = self
        self.X = X
        self.Y = Y
        self.vR, self.vV, self.vB = IntVar(0),IntVar(0),IntVar(0)
        #composante rouge
        Scale(boss, length=400, orient=HORIZONTAL, label ='Composante Rouge :',
                troughcolor ='dark grey', sliderlength =20,
                showvalue =0, from_=0, to=255, tickinterval =25,
                variable=self.vR).pack()
        lab1 = Label(boss, textvariable=self.vR)
        lab1.pack()
        #composante verte
        Scale(boss, length=400, orient=HORIZONTAL, label ='Composante Verte :',
                troughcolor ='dark grey', sliderlength =20,
                showvalue =0, from_=0, to=255, tickinterval =25,
                variable=self.vV).pack()
        lab2 = Label(boss, textvariable=self.vV)
        lab2.pack()
        #composante bleue
        Scale(boss, length=400, orient=HORIZONTAL, label ='Composante Bleue :',
                troughcolor ='dark grey', sliderlength =20,
                showvalue =0, from_=0, to=255, tickinterval =25,
                variable=self.vB).pack()
        lab3 = Label(boss, textvariable=self.vB)
        lab3.pack()
        #on ajoute le bouton pour valider les valeurs choisies
        bouton = Button(boss, text = 'Valider les nouvelles valeurs', command= lambda param1=X, param2=Y, param3=self.vR.get(), param4=self.vV.get(), param5=self.vB.get() : validation(param1,param2,param3,param4,param5))
        bouton.pack()
        def validation(X, Y, a, b, c):#modifie les valeurs du pixel
            print 'il faut modifier le pixel en position ('+self.X+','+self.Y+') avec les composantes '+str(a)+' '+str(b)+' '+str(c)           
 
class Application(Frame):
    """Application principale"""
    def __init__(self, boss =None):
        Frame.__init__(self)
        self.master.title('test')
        mBar = MenuBar(self)
        mBar.pack()
        self.canevas1 = Canvas(self, bg='light grey', height=500,
                          width=500, borderwidth =2)
        self.canevas1.pack()
        self.canevas1.bind("<Button-3>", self.affich_curseurs)
        self.pack()
    def affich_curseurs(self, event):
        X = str(event.x)
        Y = str(event.y)
        top = Toplevel()
        fra = Curseurs(X, Y, top)
        fra.pack()
if __name__ == '__main__':
    app = Application()
    app.mainloop()

13/05/2006, 16h04
naxelas

Essaye de ne pas utiliser de fonctions lamda. Renvoie plutôt l'appel vers une méthode de ta classe qui récupèrera les données dont elle a besoin (self.X, self.Y,...).
13/05/2006, 16h16
frizou11

oui mais comment créer cette méthode? je suis un peu perdu merci de me donner un exemple d'une méthode récupérant les données dont j'ai besoin
ca serait sympa

En disant "toutes les données que tu as besoin" je sous-entendais les arguments passés à validation().

Soit tu changes les arguments de ton lambda comme ceci:
Code:

1 2 3 4 param3=self.vR, ... # pas self.vR.get(), sinon la valeur initiale de zero sera toujours passée # même chose pour self.vV et self.vB
et validation() comme cela:
Code:

1 2 3 4 a.get() # a la place de str(a) # même chose pour b et c
Sinon, personnellement, je trouve l'utilisation des lambda très peu lisible. Je préfère:
Code:

1 2 3 4 5 6 class MaClasse: def __init__(self): Button(..., command=self.callback) def callback(self, event=None): #blablabla

13/05/2006, 17h20
frizou11

Merci beaucoup, ca marche tres bien!
Je me sus embrouilé, je faisais l'appel a la valeur avec la methode get() au mauvais moment... autant pour moi
encore merci