Discussion :

[menthol34]

bonjour

merci pour vos réponses

j'ai été incapable de cacher le code !!

Apparemment il y aurait deux écoles pour tkinter avec ou sans la classe, apres plusieurs essais la classe semble la meilleure solution, mais !!

Ma question est la suivante : comment découper, morceler le code en plusieurs fichiers qui appartiennent tous à la classe ?

Afin de séparer au moins interface et méthodes

merci pour vos réponses

Cordialement

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
 
#-*- coding: utf-8 -*- 
# Exemple montrant comment faire en sorte que les objets dessinés dans un
# canevas puissent être manipulés à l'aide de la souris
 
from Tkinter import *
from random import randrange
 
class Draw(Frame):
	"classe définissant la fenêtre principale du programme"
	def __init__(self):
		Frame.__init__(self)
		# mise en place du canevas - dessin de 15 ellipses colorées :
		self.c = Canvas(self, width =400, height =300, bg ='ivory')
		self.c.pack(padx =5, pady =3)
		for i in range(15):
			# tirage d'une couleur au hasard :
			coul =['brown','red','orange','yellow','green','cyan','blue' ,'violet', 'purple'][randrange(9)]
		# tracé d'une ellipse avec coordonnées aléatoires :
			x1, y1 = randrange(300), randrange(200)
			x2, y2 = x1 + randrange(10, 150), y1 + randrange(10, 150)
			self.c.create_oval(x1, y1, x2, y2, fill =coul)
	# liaison d'événements <souris> au widget <canevas> :
		self.c.bind("<Button-1>", self.mouseDown)
		self.c.bind("<Button1-Motion>", self.mouseMove)
		self.c.bind("<Button1-ButtonRelease>", self.mouseUp)
	# mise en place d'un bouton de sortie :
		b_fin = Button(self, text ='Terminer', bg ='royal blue', fg ='white',
			   font =('Helvetica', 10, 'bold'), command =self.quit)
		b_fin.pack(pady =2)
		self.pack()
 
	def mouseDown(self, event):
		"Op. à effectuer quand le bouton gauche de la souris est enfoncé"
		self.currObject =None
	# event.x et event.y contiennent les coordonnées du clic effectué :
		self.x1, self.y1 = event.x, event.y
	# <find_closest> renvoie la référence du dessin le plus proche :
		self.selObject = self.c.find_closest(self.x1, self.y1)
	# modification de l'épaisseur du contour du dessin :
		self.c.itemconfig(self.selObject, width =3)
	# <lift> fait passer le dessin à l'avant-plan :
		self.c.lift(self.selObject)
 
	def mouseMove(self, event):
		"Op. à effectuer quand la souris se déplace, bouton gauche enfoncé"
		x2, y2 = event.x, event.y
		dx, dy = x2 -self.x1, y2 -self.y1
		if self.selObject:
			self.c.move(self.selObject, dx, dy)
			self.x1, self.y1 = x2, y2
 
	def mouseUp(self, event):
		"Op. à effectuer quand le bouton gauche de la souris est relâché"
		if self.selObject:
			self.c.itemconfig(self.selObject, width =1)
			self.selObject =None
 
if __name__ == '__main__':
	Draw().mainloop()

[PauseKawa]

Bonjour,

La réponse est que si le code se limite a un exemple pourquoi passer par une classe ?

Code :

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

1
2
3
4
5
6
class Foo:
	...
 
 
if __name__ == '__main__':
	...

n'est utile que si Foo est réutilisable ou si l'on sépare le GUI de la logique, il me semble.

Note: Draw().mainloop() ou Draw est un Widget Frame ? Pensez vous cela propre ?

@+

[wiztricks]

Salut,

Apparemment il y aurait deux écoles pour tkinter avec ou sans la classe, apres plusieurs essais la classe semble la meilleure solution, mais!!

Les deux sont possibles.
La vraie question est de savoir ce qui, dans votre cas, motive/justifie ce choix. Je ne vois pas dans l'exemple proposé de raisons "techniques" motivant le choix de l'un ou l'autre.
En effet, dans tous les cas, vos objets doivent être définis "dans" une _boîte_. Qu'importe que le type de la boîte soit "class" ou "module" ? La plupart des objets sont "singletons" associés à des objets tkinter?
Mais comme vous écrivez le code, vous avez le droit de vous faire plaisir.

Plus généralement, les classes sont des fabriques d'objets ayant comportements et attributs similaires. Une fabrique d'objets fait sens lorsqu'il y a "pleins" d'objets à construire. Dans le cas d'exemplaires uniques, le module étant "singleton" est un bon substitut.

Dans votre exemple les seuls objets ayant attributs, comportements semblables et fabriqués en nombre sont les 15 ovales colorés.
Ils peuvent être déplacés en fonction de clics et de déplacements de la "souris".

Les méthodes de la classe Draw sont des callbacks déclenchés par des actions sur un canvas (associé à Draw) induisant des déplacements d'items créés dans ce canvas. Il fallait bien les mettre quelque part! Mais quelle est la relation entre "méthode" et "objet" auquel elle s'applique?

Plutôt que de créer une classe Draw, un peu fourre-tout, il pourrait y avoir un classe Drawing dont les instances seraient les "ovales colorés" et une sous-classe de Canvas permettant de dispatcher les actions sur la souris en appels de méthodes des "Drawing"s.

Ma question est la suivante : comment découper, morceler le code en plusieurs fichiers qui appartiennent tous à la classe ?
Afin de séparer au moins interface et méthodes

Un script peut définir plusieurs "class" mais la déclaration d'une "class" se termine à la fin du bloc correspondant tout comme la déclaration d'une "fonction".

Cela n'empêche pas une "class" d'être agrégat de plusieurs objets définis ailleurs (exemple votre classe Draw agrège frame, canvas,... définis dans le module tkinter) ni de définir les méthodes d'une class à partir de fonctions définies "ailleurs".

Techniquement "interfaces" et "méthodes" peuvent être regroupées dans des classes distinctes (vous mettriez quoi dans votre exemple?).
Le module abc offre l'infrastructure permettant d'enregistrer les classes "interfaces" "abstraites" et de les associer à une classe X autrement que par héritage.

Ceci dit, l'intérêt du découpage du code en modules, classes,... est fonction de la taille (i.e. nombre de lignes), et de la réutilisation possible. L'exemple proposé n'est pas très significatif pour lui appliquer ce genre de traitement.

Cordialement,
- W

[menthol34]

merci pour vos réponses

le code que j'ai déposé n'était que pour illustrer mes propos, la plupart des tutoriels sont faits sans classe et les exemples complets avec.

Difficile de se faire une idée sur la bonne méthode

cordialement

résolu !

[PauseKawa]

Bonjour,

Comme dit wiztricks votre code ne demande pas de classe mais rien ne vous empêche d'en faire.
Si la plupart des tutos n'en utilisent pas c'est que c'est des tutos: Ils montrent l'utilisation de Tkinter, qui en soit n'as pas besoin de classes, et non la POO. Tkinter étant le premier GUI utilisé* par les débutants il serait déplacer de compliquer la chose. En fait pour un débutant passer directement de l'apprentissage de Tkinter à de la POO est l'erreur la plus courante: Il manque les bases (Vous trouverez pas mal d'exemples sur le forum, principalement sur la portée des variables).
Pour ce qui est des codes 'complets' utilisant les classe c'est soit justifier par des éléments identiques (le cas de vos ovales), soit par un besoin de structurer, soit par le besoin d'apporter plus au code. Un exemple bidon de ce cas:

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
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
#
#
import sys
running_python3 = sys.version_info[0] > 2
if running_python3:
      import tkinter as tk
else:
      import Tkinter as tk
import webbrowser
 
 
class TkHelp(tk.Frame):
    def __init__(self, master):
        tk.Frame.__init__(self, master)
        self.links = {}
        self.tags = [0]
        self.master = master
        self.helptext = tk.Text(self)
        self.helptext.pack(expand=True, fill="both")
        self.helptext.config(state="disabled")
 
    def insert(self, txt, color='black', link=None, html=None,
               font=None, end=0):
        self.helptext.config(state="normal")
        tgid = self.tags[-1:][0] + 1
        self.tags.append(tgid)
        if end:
            txt += '\n'
        self.helptext.insert(tk.END, txt, tgid)
        if font:
           self.helptext.tag_config(tgid, font=font)
        if html:
            self.helptext.tag_config(tgid, foreground="blue")
            self.helptext.tag_bind(tgid, '<Button-1>',
                                   lambda ev=None: self.showhtml(html))
        self.helptext.config(state="disabled")
        return tgid
 
    def showhtml(self, url):
        webbrowser.open(url, new=0, autoraise=True)
 
 
if __name__ == "__main__":
    def showhelp():
        top = tk.Toplevel(root)
        frmhelp = TkHelp(top)
        frmhelp.insert('SOMMAIRE', font=("Helvetica", 16), end=1)
        frmhelp.insert('Ceci est un ')
        url = "http://www.developpez.net/forums/f96/autres-langages/python-zope/"
        frmhelp.insert('lien', html=url, end=1)
        frmhelp.grid(row=0, column=0)
 
    root = tk.Tk()
    root.title('.:: TkHelp Demo ::.')
    tk.Button(root, text='Show help', command=showhelp).pack(padx=5, pady=5,
                                                             ipadx=2, ipady=2)
    root.mainloop()

Le code ci dessus répond à deux besoins: L'ajout de méthodes à TkHelp et la possibilité d'importer/voir la démo.
On retrouve encore des exemples ou les classes sont utilisées pour 'comparer' le code, comme pour Construire une interface graphique pas à pas en Python avec Tkinter et wxPython sur sebsauvage.

@+


* Pour la bonne raison qu'il est présenté comme 'simple'. Je ne suis pas trop de cet avis.
En fait pas grand monde n'en vas jusqu'au bout, et passe à un autre GUI dit plus 'pro', pour en découvrir la totalité.

[wiztricks]

Juste parce que l'exemple donné passe à côté de fonctionnalités importantes des items du Canvas concernant:
- les tags dynamiques et la possibilité de leur associer des "bindings",
- les options active* permettant de visualiser l'item courant.

Le sujet de la discussion étant "classes" ou "pas", je me suis appliqué à faire une version "avec" et "sans".
Commençons par la version sans...

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
import tkinter as tk
from tkinter.constants import *
 
selected = None
last_xy = None
 
def bind_item(canvas, idOrTag):
    canvas.tag_bind(idOrTag, "<ButtonPress-1>", on_item_click)
    canvas.tag_bind(idOrTag, "<Button1-Motion>",
                  lambda e: _move_selected(e.widget, e.x, e.y))
    canvas.tag_bind(idOrTag, "<ButtonRelease-1>",
                  lambda e: _move_selected(e.widget, e.x, e.y, 0))
 
def _move_selected(canvas, x1, y1, min_pixels=5):
    global last_xy
    x0, y0 = last_xy
    dx, dy = x1 - x0, y1 - y0
    if abs(dx) > min_pixels or abs(dy) > min_pixels:
        canvas.move(selected, dx, dy)
        last_xy = x1, y1
 
def on_item_click(event):
    global last_xy, selected
    canvas = event.widget
    selected = canvas.find_withtag('current')
    last_xy = event.x, event.y
 
if __name__ == '__main__':
    c = tk.Canvas()
    c.pack(fill=BOTH, expand=YES)
    c.create_oval(10, 10, 150, 100, fill='blue', tag='item',
                        activeoutline='red', activewidth=3)
    c.create_rectangle(150, 100, 300, 200, fill='green', tag='item',
                        activeoutline='red', activewidth=3)
    bind_item(c, 'item')
    tk.mainloop()

Pour la version "avec", le plus simple est de créer une s/classe de Canvas et d'y inclure méthodes et variables "globales" (avec les ajouts de "self" qui vont bien).

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
import tkinter as tk
from tkinter.constants import *
 
class Canvas(tk.Canvas):
    selected = None
    last_xy = None
 
    def bind_item(self, idOrTag):
        self.tag_bind(idOrTag, "<ButtonPress-1>", self.on_item_click)
        self.tag_bind(idOrTag, "<Button1-Motion>",
                      lambda e: self._move_selected(e.x, e.y))
        self.tag_bind(idOrTag, "<ButtonRelease-1>",
                      lambda e: self._move_selected(e.x, e.y, 0))
 
    def _move_selected(self, x1, y1, min_pixels=5):
        x0, y0 = self.last_xy
        dx, dy = x1 - x0, y1 - y0
        if abs(dx) > min_pixels or abs(dy) > min_pixels:
            self.move(self.selected, dx, dy)
            self.last_xy = x1, y1
 
    def on_item_click(self, event):
        self.selected = self.find_withtag('current')
        self.last_xy = event.x, event.y
 
if __name__ == '__main__':
    c = Canvas()
    c.pack(fill=BOTH, expand=YES)
    c.create_oval(10, 10, 150, 100, fill='blue', tag='item',
                        activeoutline='red', activewidth=3)
    c.create_rectangle(150, 100, 300, 200, fill='green', tag='item',
                        activeoutline='red', activewidth=3)
    c.bind_item('item')

Le regroupement en "class" des différentes "fonctions" et "variables" ouvre plus de questions qu'il n'apporte de réponses:

• "last_xy" pourrait relever d'un objet "souris"/"mouse"
• "selected" et "_move_selected" relèvent d'un objet "selection"
• "on_item_click" et "bind_item" sont associés à des "items".

Comme n'est qu'un exemple illustrant des méthodes du Canvas inutile de noyer les fonctions/méthodes qu'on souhaite montrer dans un tas d'objets.

Cordialement,
- W

[PauseKawa]

Bonsoir,

Juste une réaction sur

Code :

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

1
2
3
4
5
6
7
8
9
if __name__ == '__main__':
    c = tk.Canvas()
    c.pack(fill=BOTH, expand=YES)
    c.create_oval(10, 10, 150, 100, fill='blue', tag='item',
                        activeoutline='red', activewidth=3)
    c.create_rectangle(150, 100, 300, 200, fill='green', tag='item',
                        activeoutline='red', activewidth=3)
    bind_item(c, 'item')
    tk.mainloop()

Code :

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

1
2
3
4
5
6
7
8
if __name__ == '__main__':
    c = Canvas()
    c.pack(fill=BOTH, expand=YES)
    c.create_oval(10, 10, 150, 100, fill='blue', tag='item',
                        activeoutline='red', activewidth=3)
    c.create_rectangle(150, 100, 300, 200, fill='green', tag='item',
                        activeoutline='red', activewidth=3)
    c.bind_item('item')

Je veux bien que _setup s'occupe du _default_root = Tk() dans BaseWidget mais je pense que dans un exemple cela doit être 'explicite'

Code :

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

1
2
root = tk.Tk()
c = tk.Canvas(root)

Non ?

@+

[PauseKawa]

J'ai une hypothèse sur ceci:

Juste parce que l'exemple donné passe à côté de fonctionnalités importantes des items du Canvas

Si la plupart des tutos n'en utilisent pas c'est que c'est des tutos: Ils montrent l'utilisation de Tkinter, qui en soit n'as pas besoin de classes, et non la POO. Tkinter étant le premier GUI utilisé* par les débutants il serait déplacer de compliquer la chose. En fait pour un débutant passer directement de l'apprentissage de Tkinter à de la POO est l'erreur la plus courante: Il manque les bases (Vous trouverez pas mal d'exemples sur le forum, principalement sur la portée des variables).
...
* Pour la bonne raison qu'il est présenté comme 'simple'. Je ne suis pas trop de cet avis.
En fait pas grand monde n'en vas jusqu'au bout, et passe à un autre GUI dit plus 'pro', pour en découvrir la totalité.

Les tutos Tkinter sont si basiques* que le 'débutant' pense que la solution 'classe' est la solution.

*Je n'en connais pas qui ne soit vraiment avancé au point de parler des tags, c'est pourtant énorme. Et je ne parle pas de Misc...
A vrais dire je ne connais pas de tuto complet sur Tkinter.

[menthol34]

bonsoir

je suis allé chercher mon trike aujourd'hui : 6 heures de bagnole au chaud

en tout cas si je ne suis pas capable de comprendre tout ce que vous m'expliquez, je vous remercie pour tous vos efforts

je lirai ceci demain apres ma balade inaugurale

bonsoir

merci pour vos réponses

[wiztricks]

Je veux bien que _setup s'occupe du _default_root = Tk() dans BaseWidget mais je pense que dans un exemple cela doit être 'explicite'

Pour cet exemple là, çà ne sert à rien.
Est-on plus explicite en déroulant le babillage "conventionnel" :
root = tk.Tk(); c = Canvas(root);...; root.mainloop()
qu'en écrivant:
c = Canvas() ;...; tk.mainloop()
Est-ce qu'un exemple doit rassurer ou titiller la curiosité?

- W

[PauseKawa]

Bonsoir,

mais je pense que dans un exemple cela doit être 'explicite'

C'est juste pour différencier un exemple formel (le sujet du PO) d'une réponse sur un forum.

Est-ce qu'un exemple doit rassurer ou titiller la curiosité?

Pour un exemple ? Il se doit juste d’être complet/le plus juste possible/utilisable.
Sur un forum ? Faire le code du PO ? Jamais sans une ouverture pour le PO.

@+

[wiztricks]

Salut,
Pour l'instant le sujet du PO porte sur "classe" ou pas.
Un autre sujet étant le code, montré en exemple, pour animer les items crées sur un Canvas tk.

Une difficulté est que les objets Python ne se réduisent pas à des instances de "class", ils peuvent être aussi module, fonction, type,...
Cela laisse une grande liberté côté "design", i.e. des choix dans l'organisation de son code...
Mais un exemple d'utilisation des méthodes x, y, z,... implique trop peu d'objets pour qu'un style d'organisation s'impose réellement.
- W