Discussion :

[guizmo91]

Bonjour, pour les cours Python je suis le Cours Apprendre à programmer avec Python 3 par Gérard Swinnen pour m'autoformer et je suis rendu à l'exercice 13.19, qui m'en a fait baver. Le but est de contrôler la taille d'un cercle avec un widget curseur.
J'ai trouvé une solution, sur le net, ci dessous.
Je trouve assez compliqué, voire tordu, la manière de communiquer entre widgets qui consiste à générer un évènement clavier <ctrl z> depuis le curseur et a l'intercepter depuis la fenêtre mère qui appelle une fonction chargée de faire varier le cercle.
N'est-il pas possible de faire varier la taille du cercle dans une fonction appelée par le curseur?
Peut être que je suis à coté de la plaque, je n'ai pas encore assimilé les us et coutumes pythonesques.
J'espère avoir été clair

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
 
#! /usr/bin/env python
# -*- coding: Utf-8 -*-
from Tkinter import *
 
class DessinCercle(Canvas):
    "Canevas dans lequel sera dessiné le cercle"
    def __init__(self,larg=300,haut=300,coul='white'):
        Canvas.__init__(self)
        self.configure(width=larg,height=haut,bg=coul)
        self.larg,self.haut=larg,haut
        self.x,self.y=larg/2,haut/2
 
    def traceCercle(self,r=5):
        "dessin d'un cercle de rayon <r> en <x,y> dans le canevas"
#        self.create_oval(self.x-r, self.y-r, self.x+r, self.y+r,outline='black')
        return self.create_oval(self.x-r, self.y-r, self.x+r, self.y+r,outline='black')
 
class CurseurCercle(Scale):
    "Curseur faisant varier le rayon d'un cercle"
    def __init__(self):
        Scale.__init__(self)
        self.configure(length=200, orient=HORIZONTAL, sliderlength =25,
        label ='Rayon :', from_=5, to=151, tickinterval =25,
        resolution =1,
        showvalue =1, command = self.setRayon)
        self.rayon=5
 
    def setRayon(self,rayon):
        "Communiquer le nouveau rayon à d'autres widgets"
        self.rayon=int(rayon)
        self.event_generate('<Control-Z>')
 
    def valeurRayon(self):
        "Renvoie le rayon du cercle"
        return self.rayon 
 
class WidgetCercle(Frame):
    "Widget principal contenant le canevas et son cercle ainsi que le curseur faisant varier son rayon"
    def __init__(self):
        Frame.__init__(self)
        self.can1=DessinCercle(larg=300,haut=300,coul='white')
        self.cercle1=self.can1.traceCercle(r=5)
        self.can1.pack()
        self.curseur1=CurseurCercle()
        self.master.bind('<Control-Z>',self.montreCercle)
        self.master.title("Dessin d'un cercle")
        self.curseur1.pack()
 
    def montreCercle(self,event):
        "Efface l'ancien cercle dans le canevas et le remplace par le nouveau de même centre mais de rayon différent"
        self.can1.delete(self.cercle1)
        self.cercle1=self.can1.traceCercle(r=self.curseur1.valeurRayon())
 
if __name__=='__main__':
    #script principal
    fen1=Tk()
    a=WidgetCercle()
    a.pack()
    fen1.mainloop()

[tyrtamos]

Bonjour,

Tu as raison: on n'a pas besoin de passer par un évènement clavier, parce que Scale envoie à chaque modif sa nouvelle valeur dans setRayon() qui, alors, peut dessiner directement le nouveau cercle.

Sans vouloir te fournir un "modèle", voilà comment moi je coderais:

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
 
#!/usr/bin/python
# -*- coding: utf-8 -*-
 
from Tkinter import *
 
class Application(Frame):
 
    def __init__(self, master=None, larg=0, haut=0):
        Frame.__init__(self, master)
 
        # création d'un layout_manager sur self
        self.grid()
 
        # création du canvas
        self.can1 = Canvas(self, width=larg, height=haut, bg='white')
        self.x, self.y = larg/2, haut/2
        self.can1.grid(sticky="nwe")
 
        # création du curseur (qui enverra chaque nouvelle valeur dans setRayon())
        self.curseur1 = Scale(self, length=200, orient=HORIZONTAL, sliderlength =25, label ='Rayon :',
            from_=5, to=larg/2, tickinterval =25, resolution =1, showvalue =1, command = self.setRayon)
        self.curseur1.grid(sticky="swe")
 
        # création du cercle
        self.rayon=5
        self.cercle1=self.can1.create_oval(self.x-self.rayon, self.y-self.rayon, self.x+self.rayon,
                                           self.y+self.rayon, outline='black')
 
    def setRayon(self,rayon):
        #Dessine le nouveau cercle correspondant à la nouvelle valeur du rayon
        self.rayon=int(rayon)
        self.can1.delete(self.cercle1)
        self.cercle1 = self.can1.create_oval(self.x-self.rayon, self.y-self.rayon, self.x+self.rayon,
                                           self.y+self.rayon, outline='black')
 
if __name__=='__main__':
    fen = Tk()
    app = Application(fen,300,300)
    fen.mainloop()

Avantage complémentaire: en changeant l'appel d'Application, tu peux changer la taille du canvas, et la taille du cercle suit (ex: app = Application(fen,500,500)).

Tyrtamos

[guizmo91]

Merci beaucoup 'tyrtamos', la comparaison entre les 2 programmes est très instructive.

Et merci pour les Cours et tutoriels Python: http://python.developpez.com/cours/ !