mini logiciel de dessin

Version imprimable

Bonjour à tous,

je suis actuellement en dernière année du collège, en option informatique. Cela fait seulement quelques semaines que l'on a commencer le language python avec le cours Swinnen et je dois déjà réaliser un projet, il doit être rendu pour vendredi et j'éprouve quelques difficultés, c'est pourquoi j'aimerais bien un ptit coup de pouce, svp. Ce projet débouchera sur une note et je compte dessus pour remonter ma pauvre petite moyenne...
Mon projet est de réaliser un mini logiciel de dessin. En m'inspirant de notre cours, ainsi que d'internet, je suis arrivé à quelque chose de potable, mais il y a des endroits du code que je ne comprend pas. Comme à la fin, je vais devoir être capable d'expliquer entièrement le code, je fais appelle à votre lumière.:zoubi:
Je vous mets ci-dessous les lignes que je ne comprend pas(excusez-moi pour la clareté):
- command=lambda :

- epaisseur=IntVar()
epaisseur.set(1)
repaisseur={}
for e in range(1,9):

- Les variables StringVar et IntVar

- global etatboutonsouris,x1,y1

Est-ce que quelqu'un aurait une réponse, ce serait vraiment sympa de votre part!!!!

Voilà 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
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
from tkinter import*
 
# creation d’une fenêtre
fen1=Tk()
fen1.title('Draweasy')
 
def tabeffacer(): 
    tableau.delete(ALL)         # ça effacera tout ce qu'il y a dans le tableau  
 
# creation de la barre de menu
menuDraweasy = Menu(fen1)
 
# creation du menu fichier
fichier = Menu(menuDraweasy)
menuDraweasy.add_cascade(label="Fichier",menu=fichier)                 # on crée une barre de menu
fichier.add_command(label="Quitter", command=fen1.destroy)         # on ajoute une option au menu
 
# creation du menu effacer
effacer = Menu(menuDraweasy)
menuDraweasy.add_cascade(label="Effacer",menu=effacer)
effacer.add_command(label="Effacer tout", command=lambda : tabeffacer())        
 
# afficher le menu
fen1.config(menu=menuDraweasy)
 
# creation des differents cadres
Tableau=LabelFrame(fen1)
Tableau.configure(text='',bd=2,relief='flat')
Tableau.grid(row=0,rowspan=3,column=2,padx=0,pady=0)
Couleur=LabelFrame(fen1)
Couleur.configure(text='Couleur du trait',font='Courier 10',bd=2,relief='flat')
Couleur.grid(row=0,column=1,padx=0,pady=0,sticky=W)
Style=LabelFrame(fen1)
Style.configure(text='Style de forme',font='Courier 10',bd=2,relief='flat')
Style.grid(row=1,column=1,padx=0,pady=0,sticky=W)
Epaisseur=LabelFrame(fen1)
Epaisseur.configure(text='Epaisseur du trait',font='Courier 10',bd=2,relief='flat')
Epaisseur.grid(row=2,column=1,padx=0,pady=0,sticky=W)
 
# creation des boutons du cadre Tableau
tableau=Canvas(Tableau)
tableau.configure(width=800,height=700,bg='white')
tableau.grid() 
 
# creation des boutons du cadre Couleur
couleur=IntVar()
couleur.set(0)
palette=['#ffffff','#c0c0c0','#808080','#000000','#800000','#808000','#008000',
        '#00ff00','#00ffff','#008080','#0000ff','#000080','#800080','#ff00ff',
        '#c0000f','#ff0000','#ffcc00','#ffff00']
rcouleur={}
for c in range(0,18):
    rcouleur[c]=Radiobutton(Couleur)
    rcouleur[c].configure(variable=couleur,value=c,bg=palette[c],padx=8,indicatoron=0)
    rcouleur[c].grid(sticky=W, padx=5)
 
# creation des boutons du cadre Epaisseur
epaisseur=IntVar()                 
epaisseur.set(1)
repaisseur={}
for e in range(1,9):
    repaisseur[e]=Radiobutton(Epaisseur)
    repaisseur[e].configure(variable=epaisseur,value=e,text=str(e),indicatoron=0)
    repaisseur[e].grid()
 
# creation des boutons du cadre Style
style=StringVar()
style.set('droite')
bou1=Radiobutton(Style)
bou1.configure(variable=style,value='droite',text='droite',padx=12,indicatoron=0)
bou1.grid(sticky=W)                      # .grid permet de bien placer les cadres
bou2=Radiobutton(Style)
bou2.configure(variable=style,value='courbe',text='courbe',padx=10,indicatoron=0)
bou2.grid(sticky=W)
bou3=Radiobutton(Style)
bou3.configure(variable=style,value='oval',text='ovale',padx=13,indicatoron=0)
bou3.grid(sticky=W)
bou4=Radiobutton(Style)
bou4.configure(variable=style,value='rectangle',text='rectangle',padx=4,indicatoron=0)
bou4.grid(sticky=W)
 
# etat du bouton gauche de la souris au début
etatboutonsouris='haut'
 
# evenement associe au clic sur le tableau
def clic(event):                                # creation d'un objet "event" lorsque l'on appuie sur le tableau
    global etatboutonsouris,x1,y1               # x1 et y1 sont les attributs qui contiennent les coordonnées
    etatboutonsouris='bas'      
    x1=event.x                                  # event.x et event.y contiennent les coordonnées cu clic
    y1=event.y
tableau.bind('<ButtonPress-1>',clic)            # .bind créer un évènement
 
# evenement associe au mouvement sur le tableau
def mouvement(event):
    global etatboutonsouris,x,y
    if (style.get()=='courbe' and etatboutonsouris=='bas'):
        tableau.create_line(x,y,event.x,event.y,fill=palette[couleur.get()],width=epaisseur.get())
    x=event.x
    y=event.y
tableau.bind('<Motion>',mouvement)
 
# evenement associe au declic sur le tableau
def declic(event):
    global etatboutonsouris,x2,y2
    etatboutonsouris='haut'
    x2=event.x
    y2=event.y
    if (style.get()=='droite'):
        tableau.create_line(x1,y1,x2,y2,fill=palette[couleur.get()],width=epaisseur.get())
    elif (style.get()=='oval'):
        tableau.create_oval(x1,y1,x2,y2,fill=palette[couleur.get()],width=epaisseur.get())
    elif (style.get()=='rectangle'):
        tableau.create_rectangle(x1,y1,x2,y2,fill=palette[couleur.get()],width=epaisseur.get())
tableau.bind('<ButtonRelease-1>',declic)
 
# attente des evenements
fen1.mainloop()             # démarre l'observateur d'évènements

21/05/2012, 22h32
Bear the french

Bonsoir,

Je ne suis pas expérimenté - tout juste débutant mais je peux essayer de répondre à certaines de tes questions.

epaisseur=IntVar()
Tu initialises ta variable epaisseur (tu l'annonces pour la première fois, tu la présentes) et tu fais comprendre à Python que tu vas stocker un entier dans cette variable. IntVar est en quelques sortes un format que tu appliques à epaisseur.

StringVar
Idem l'explication du dessus mais au lieu d'indiquer un entier, là tu préviens que c'est pour une chaîne de caractères

for e in range(1,9):
traduction littérale --> Pour e qui prend les valeurs entières de 1 à 9.
En bref, cela va faire une boucle avec le paramètre e changeant de valeur à chaque tour... donc 9 fois ce qui est indenté (décalé au dessous), va se produire.

epaisseur.set(1)
Cela stocke la valeur entière 1 dans la variable epaisseur.

repaisseur={}
Python qui considère les accolades vides comme un objet de type dictionnaire. Révises la distinction entre liste, tuple et dictionnaire.

global etatboutonsouris,x1,y1
Placée dans une fonction, cette indication permet l'usage de tes 3 variables en global, c'est à dire dans tout le programme.

Voilà pour ce que je peux t'apporter comme infos avec mes mots de néophyte.

Bertrand
22/05/2012, 08h30
dymz03

Merci beaucoup d'avoir pris un peu de votre temps pour répondre à mes questions certes basiques, mais qui bien me servir lors de mon oral.:ccool:

J'avais juste encore une petite question concernant mon projet. Je ne sais pas si vous ou quelqu'un d'autre saura me répondre.
En fait, j'aimerais pour un peu améliorer le programme réussir à faire bouger dans le tableau, les objets que je dessine. Problème: étant grand débutant, j'ai vu quelques trucs sur internet, mais je comprend pas les codes, je serais donc incapable d'expliquer quoi que ce soit. Je vous demande de l'aide, pour savoir si vous aviez une solution simple avec quelques explications de votre code.

Merci d'avance, à tous bonhomme qui aurait la patience de me répondre.:P

Bonjour,

Citation:

Envoyé par dymz03

En fait, j'aimerais pour un peu améliorer le programme réussir à faire bouger dans le tableau, les objets que je dessine.

C'est à dire 'bouger' ?
Dans tous les cas cela passe par les coordonnées des items (.coords(item)/.coords(item, coords)).
Un exemple sur votre 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
# evenement associe au clic sur le tableau
def clic(event):
    global etatboutonsouris, x1, y1, Item
    if style.get() == 'couper':
        # On recherche les items en event.x, event.y, event.x, event.y
        # Et on ne garde que celui au dessu de la pile (tuple[-1:])
        Item = tableau.find_overlapping(event.x, event.y, event.x, event.y)[-1:]
        # Note: Je n'utilise pas .find_closest(x, y) qui a tendance à retourner (1,)
        # Si nous avons un item on passe en mode 'coller'
        if Item:
            style.set('coller')
    elif style.get() == 'coller':
        # On récupère les coordonnées de l'item
        oldcoords = tableau.coords(Item)
        # On garde la géométrie
        xb = event.x + (oldcoords[2] - oldcoords[0])
        yb = event.y + (oldcoords[3] - oldcoords[1])
        # On déplace l'item
        # A noter que event.x/event.y est ici le bord haut/gauche du cadre
        # a vous de voir si vous voulez center tout cela.
        tableau.coords(Item, (event.x, event.y, xb, yb))
        # On place l'item au dessu des autres
        tableau.tag_raise(Item)
        # On repasse en 'couper'
        style.set('couper')
    etatboutonsouris='bas'      
    x1=event.x                                  # event.x et event.y contiennent les coordonnées cu clic
    y1=event.y
tableau.bind('<ButtonPress-1>',clic)            # .bind créer un évènement

Code:

1
2
3
bou5 = Radiobutton(Style)
bou5.configure(variable=style, value='couper', text='Déplacer', padx=4, indicatoron=0)
bou5.grid(sticky=W)

Explications

Petites explications sur

Code:

# Note: Je n'utilise pas .find_closest(x, y) qui a tendance à retourner (1,)

En fait c'est faux et il est préférable que je précise.

.find_closest retourne toujours quelque chose (un tuple) qui dépend de ce que contient le Canvas.
S'il est vide c'est un tuple vide ()

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
try:
    from tkinter import *
except:
    from Tkinter import *
 
 
def OnEvent(event):
    print(canvas.find_closest(event.x, event.y))
 
root = Tk()
canvas = Canvas(root, width=500, height=500, bg="white")
canvas.pack() 
root.bind("<1>", OnEvent)
root.mainloop()

sortie

Code:

()

Si le Canvas comporte un élément la méthode retourne cet élément ((1,) donc puisque l'index des éléments d'un Canvas commence à 1) quelque soit l'endroit ou se produit l'event.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
try:
    from tkinter import *
except:
    from Tkinter import *
 
 
def OnEvent(event):
    label.config(text=canvas.find_closest(event.x, event.y))
    root.after(120, lambda: label.config(text=""))
 
root = Tk()
canvas = Canvas(root, width=500, height=500, bg="white")
canvas.pack() 
label = Label(root)
label.pack()
canvas.create_oval(10, 10, 50, 50, fill="red")
root.bind("<1>", OnEvent)
root.mainloop()

Si le Canvas comporte plusieurs éléments il retourne l'élément cliqué ou le plus proche

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
try:
    from tkinter import *
except:
    from Tkinter import *
 
 
def OnEvent(event):
    label.config(text=canvas.find_closest(event.x, event.y))
    root.after(120, lambda: label.config(text=""))
 
root = Tk()
canvas = Canvas(root, width=500, height=500, bg="white")
canvas.pack() 
label = Label(root)
label.pack()
canvas.create_oval(10, 10, 50, 50, fill="red")
canvas.create_oval(450, 10, 490, 50, fill="blue")
canvas.create_oval(10, 450, 50, 490, fill="yellow")
canvas.create_oval(450, 450, 490, 490, fill="green")
root.bind("<1>", OnEvent)
root.mainloop()

Vous avez dans le code plus haut une astuce pour vraiment sélectionner l'élément qui est sous le clic de souris: Utiliser .find_overlapping(event.x, event.y, event.x, event.y)[-1:] pour récupérer l'élément au premier plan pour un rectangle (event.x, event.y, event.x, event.y)

Une autre est 'd'occuper l'index 1' en créant un élément (rectangle, image*, ...)

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
try:
    from tkinter import *
except:
    from Tkinter import *
 
 
def OnEvent(event):
    item = canvas.find_closest(event.x, event.y)
    if item != (1,):
        label.config(text=item)
        root.after(120, lambda: label.config(text=""))
 
root = Tk()
canvas = Canvas(root, width=500, height=500, bg="white")
canvas.pack() 
label = Label(root)
label.pack()
canvas.create_rectangle(0, 0, 500, 500, fill="white") # < Ici
canvas.create_oval(10, 10, 50, 50, fill="red")
canvas.create_oval(450, 10, 490, 50, fill="blue")
canvas.create_oval(10, 450, 50, 490, fill="yellow")
canvas.create_oval(450, 450, 490, 490, fill="green")
root.bind("<1>", OnEvent)
root.mainloop()

C'est a prendre en compte en cas de delete

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
try:
    from tkinter import *
except:
    from Tkinter import *
 
 
def OnEvent(event):
    item = canvas.find_closest(event.x, event.y)
    if item != (1,):
        label.config(text=item)
        root.after(120, lambda: label.config(text=""))
 
def Delete():
    for item in canvas.find_all():
        if item != 1:
            canvas.delete(item)
    label.config(text="I'am alive : %d" % canvas.find_all())
 
root = Tk()
canvas = Canvas(root, width=500, height=500, bg="white")
canvas.pack() 
label = Label(root)
label.pack()
Button(root, text='Delete items', command=Delete).pack()
canvas.create_rectangle(0, 0, 500, 500, fill="white")
canvas.create_oval(10, 10, 50, 50, fill="red")
canvas.create_oval(450, 10, 490, 50, fill="blue")
canvas.create_oval(10, 450, 50, 490, fill="yellow")
canvas.create_oval(450, 450, 490, 490, fill="green")
root.bind("<1>", OnEvent)
root.mainloop()

Attention : Nous travaillons ici avec un Canvas qui a ses propres coordonnées. Ce n'est pas très grave ici mais si l'on utilise une Scrollbar, par exemple, il est nécessaire de convertir les coordonnées de l'event vers celle du Canvas.

Code:

1
2
3
4
5
6
7
def callback(event):
    x = canvas.canvasx(event.x)
    y = canvas.canvasy(event.y)
    item = canvas.find_closest(x, y)
    if item != (1,):
        label.config(text=item)
        root.after(120, lambda: label.config(text=""))

@+

* C'est l'astuce utilisée dans le code suivant:

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
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
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
#
#
"""whiteboard.py
Shootscreen utility for Python 2.x.
Needed : Tkinter et PIL
Under Linux : ImageMagick
Under Mac : screencapture
"""
import sys
import os
try:
    import Tkinter as Tk
    import tkFileDialog as tkFD
    from Tkconstants import *
    import Image, ImageTk
except:
    import tkinter as Tk
    import tkinter.filedialog as tkFD
    from tkinter.constants import *
    # WARNING: Experimental import for PIL under Python 3.
    from PIL import Image, ImageTk
 
 
class ScreenCap(object):
    def __init__(self):
        """Screenshot class"""
        if sys.platform == 'linux2':
            self.grab = self._GarbLinux
        elif sys.platform == 'win32':
            import Image, ImageGrab
            self.grab = self._GrabWin
        elif sys.platform == 'darwin':
            self.grab = self._GrabMac
        else:
            sys.exit(1)
        self._currentf = None
 
    def _FicNormalyze(self, name):
        """Internal Function for generate temp file.
           Use home user directory for rights.
        """
        if name:
            if os.path.basename(name) == name:
                _grabfile = os.path.join(os.path.expanduser('~'), name)
            else:
                _grabfile = name
        else:
            # default name
            _grabfile = os.path.join(os.path.expanduser('~'), 'scrcap.jpg')
        self._currentf = _grabfile
        return _grabfile
 
    def _GarbLinux(self, name=None):
        """Internal function for screen capture under Linux
           Use ImageMagick import utility
        """
        _grabfile = self._FicNormalyze(name)
        _grabcommand = "import -silent -window root " + _grabfile
        os.system(_grabcommand)
        return _grabfile
 
    def _GrabWin(self, name=None):
        """Internal function for screen capture under Windows.
           Use PIL ImageGrab.
        """
        try:
            import ImageGrab
        except:
            # Experimental import for PIL under Python 3.
            from PIL import ImageGrab
        _grabfile = self._FicNormalyze(name)
        ImageGrab.grab().save(_grabfile, "JPEG")
        return _grabfile
 
    def _GrabMac(self, name=None):
        """Internal function for screen capture under Mac.
           Use screencapture command.
        """
        _grabfile = self._FicNormalyze(name)
        _grabcommand = "screencapture -m -x -t jpg " + _grabfile
        os.system(_grabcommand)
        return _grabfile
 
    def delete(self):
        """Internal function. Delete temp file."""
        if os.path.isfile(self._currentf):
            os.remove(self._currentf)
 
 
class MainMenu(object):
    """Main menu class"""
    def __init__(self, master, bg=None, fg=None, activefg=None):
        self.master = master
        # {'titre': callback}
        self._DicItem = {}
        self._DicCtrl = {}
        if bg:
            self._Bg = bg
        else:
            self._Bg = 'gray'
        if fg:
            self._Fg = fg
        else:
            self._Fg = 'black'
        if activefg:
            self._ActiveFg = activefg
        else:
            self._ActiveFg = 'blue'
 
    def _RootQuit(self, event):
        """Internal function"""
        self.master.quit()
 
    def _Position(self, widget, x, y):
        """Internal function for the geometry"""
        # Update the widget
        widget.update()
        # Get the geometry
        reqw = widget.winfo_reqwidth()
        reqh = widget.winfo_reqheight()
        winw = widget.winfo_screenwidth()
        winh = widget.winfo_screenheight()
        posx = x - (reqw/2)
        if x + reqw/2 > winw:
            posx =  posx - ((x + reqw/2) - winw)
        elif x - reqw/2 < 0:
            posx =  0
        posy = y - reqh/2
        if y + reqh/2 > winh:
            posy =  posy - ((y + reqh/2) - winh)
        elif y - reqh/2 < 0:
            posy =  0
        # Set the widget geometry
        widget.geometry("%dx%d+%d+%d" % (reqw, reqh, posx, posy))
 
    def ShowMenu(self, event=None):
        # Clean the screen
        for widget in (widget for widget in self.master.winfo_children()
            if isinstance(widget, Tk.Toplevel)):
                return
        # Get the position
        position = self.master.winfo_pointerxy()
        x, y = position[0], position[1]
        # Create the Toplevel
        self._TopMenu = Tk.Toplevel(self.master, bg=self._Bg)
        self._TopMenu.withdraw()
        CtnFrm = Tk.Frame(self._TopMenu, bd=1, relief=RIDGE, bg=self._Bg)
        Tk.Label(CtnFrm, text='MENU', fg=self._Fg,
                 bg=self._Bg).pack(padx=3, pady=2)
        Tk.Frame(CtnFrm, height=2, bd=1, relief=SUNKEN,
                 bg=self._Bg).pack(fill=X, padx=5, pady=5)
        # Labels
        _Lab = {}
        _tri = []
        # Sort _DicItem keys
        for cle in self._DicItem.keys():
            _tri.append(cle)
        _tri.sort()
        for elems in _tri:
            _Lab[elems] = Tk.Label(CtnFrm, text=elems, fg=self._Fg, bg=self._Bg)
            _Lab[elems].pack(padx=3, pady=2)
            # bind the callback
            _Lab[elems].bind("<1>", self._DicItem[elems])
            # focus
            self._FocusCtrl(_Lab[elems])
        _tri = []
        for cle in self._DicCtrl.keys():
            _tri.append(cle)
        _tri.sort()
        for elems in _tri:
            _Lab[elems] = Tk.Label(CtnFrm, text=elems, fg=self._Fg, bg=self._Bg)
            _Lab[elems].pack(padx=3, pady=2)
            _Lab[elems].bind("<1>", self._DicCtrl[elems])
            self._FocusCtrl(_Lab[elems])
        LabelQuit = Tk.Label(CtnFrm, text='Quitter', fg=self._Fg, bg=self._Bg)
        LabelQuit.pack(padx=3, pady=2)
        self._FocusCtrl(LabelQuit)
        CtnFrm.pack(padx=3, pady=2)
        LabelQuit.bind("<1>", self._RootQuit)
        self._Position(self._TopMenu, x, y)
        self._TopMenu.bind("<1>", self._Hide)
        self._TopMenu.overrideredirect(True)
        self._TopMenu.deiconify()
 
    def _Hide(self, event=None):
        self._TopMenu.destroy()
 
    def _FocusCtrl(self, widget):
        widget.bind("<Leave>", lambda e: self._NotActive(widget))
        widget.bind("<Enter>", lambda e: self._IsActive(widget))
 
    def _IsActive(self, widget):
        # Text color
        widget['fg'] = self._ActiveFg
        widget.update()
 
    def _NotActive(self, widget):
        widget['fg'] = self._Fg
        widget.update()
 
    # for items and controls
    def additem(self, name, cb):
        self._DicItem[name] = cb
 
    def delitem(self, name):
        del self._DicItem[name]
 
    def addctrl(self, name, cb):
        self._DicCtrl[name] = cb
 
    def delctrl(self, name):
        del self._DicCtrl[name]
 
 
class GUI(Tk.Tk):
    def __init__(self, parent):
        Tk.Tk.__init__(self, parent)
        self.title('Whiteboard')
        self._Pts = []
        self._ToTrace = None
        self.Color = Tk.StringVar()
        self.Color.set('red')
        self.Width = Tk.IntVar()
        self.Width.set(3)
        self.Sccap = ScreenCap()
        _Img = self.Sccap.grab(name='scrcap.jpg')
        _FCapture = Image.open(_Img)
        self.photo = ImageTk.PhotoImage(_FCapture)
        self.C = Tk.Canvas(self, width=self.winfo_screenwidth(),
                           height=self.winfo_screenheight())
        t = self.C.create_image(0, 0, image=self.photo, anchor=NW)
        self.update()
        self.Sccap.delete()
        self.C.pack(fill=BOTH)
        mainmenu = MainMenu(self, bg='white', fg='black', activefg='blue')
        mainmenu.additem('Ligne', lambda e: self._Trace('ligne'))
        mainmenu.additem('Rectangle', lambda e: self._Trace('rectangle'))
        mainmenu.additem('Ovale', lambda e: self._Trace('ovale'))
        mainmenu.additem('Texte', lambda e: self._Trace('texte'))
        mainmenu.addctrl('Effacer', lambda e: self._Trace('delete'))
        mainmenu.addctrl('Sauvegarder', lambda e: self.after(2, self._Save))
        mainmenu.addctrl('Configurer', self.config)
        mainmenu.addctrl("Réduire", self._Reduce)
        self.bind('<Escape>', self._Intercepte)
        self.bind('<3>', mainmenu.ShowMenu)
        self.bind('<1>', self.addlist)
        self.wm_attributes('-fullscreen', 1)
        self.iconify()
 
    def _Reduce(self, event=None):
        self.iconify()
 
    def addlist(self, event):
        self._Pts.append((event.x, event.y))
        if self._ToTrace == 'delete':
            item = self.C.find_closest(event.x, event.y)
            if item != (1,):
                self.C.delete(item)
            self._Clear()
        elif self._ToTrace == 'ligne' and len(self._Pts) == 2:
            self.C.create_line(self._Pts[0][0], self._Pts[0][1],
                               self._Pts[1][0], self._Pts[1][1],
                               fill=self.Color.get(),
                               width=self.Width.get())
            self._Clear()
        elif self._ToTrace == 'rectangle' and len(self._Pts) == 2:
            self.C.create_rectangle(self._Pts[0][0], self._Pts[0][1],
                                    self._Pts[1][0], self._Pts[1][1],
                                    outline=self.Color.get(),
                                    width=self.Width.get())
            self._Clear()
        elif self._ToTrace == 'ovale' and len(self._Pts) == 2:
            self.C.create_oval(self._Pts[0][0], self._Pts[0][1],
                               self._Pts[1][0], self._Pts[1][1],
                               outline=self.Color.get(),
                               width=self.Width.get())
            self._Clear()
        elif self._ToTrace == 'texte':
            for widget in (widget for widget in self.winfo_children()
                if isinstance(widget, Tk.Toplevel)):
                    widget.destroy()
            self.MenuText = Tk.Toplevel()
            self.MenuText.title("Ajout d'un texte")
            self.textentry = Tk.Entry(self.MenuText, width=80)
            self.textentry.grid(row=0, column=0, columnspan=2, padx=5,
                                pady=5)
            self.textentry.focus_set()
            Tk.Button(self.MenuText, fg='green', text='Valider',
                      command=self._CreateTxt
                      ) .grid(row=1, column=0, padx=5, pady=5)
            Tk.Button(self.MenuText, fg='red', text='Annuler',
                      command=lambda: self._DelWidget(self.MenuText)
                      ).grid(row=1, column=1, padx=5, pady=5)
            self.MenuText.update()
            self.MenuText.geometry("%dx%d+%d+%d" %
                                   (self.MenuText.winfo_reqwidth(),
                                   self.MenuText.winfo_reqheight(),
                                   event.x, event.y))
            self.MenuText.bind('<Escape>', lambda e:
                               self._DelWidget(self.MenuText))
 
    def _DelWidget(self, widget):
        widget.destroy()
        self._Clear()
 
    def _CreateTxt(self):
        self.C.create_text(self._Pts[0][0], self._Pts[0][1],
                           fill=self.Color.get(), text=self.textentry.get())
        self._DelWidget(self.MenuText)
 
    # Cleaning
    def _Clear(self):
        self._ToTrace = None
        del(self._Pts[:])
 
    def _Intercepte(self, event=None):
        self.quit()
 
    # set self._ToTrace and clear self.Pts
    def _Trace(self, obj):
        del(self._Pts[:])
        self._ToTrace = obj
 
    def _Save(self, event=None):
        """Internal function"""
        img = self.Sccap.grab(name='scrcap.jpg')
        filetosave = tkFD.asksaveasfilename(initialdir=os.path.expanduser('~'),
                                            title="Enregistrement",
                                            filetypes=[('JPEG / JFIF','*.jpg')],
                                            defaultextension='jpg',
                                            initialfile='capture.jpg')
        if filetosave:
            if os.path.isfile(filetosave):
                os.remove(filetosave)
            os.rename(img, filetosave)
        else:
            self.Sccap.delete()
 
    def config(self, event=None):
        for widget in (widget for widget in self.winfo_children()
            if isinstance(widget, Tk.Toplevel)):
                widget.destroy()
        self.MenuConfig = Tk.Toplevel()
        self.MenuConfig.title("Configuration")
        Tk.Label(self.MenuConfig, text='Epaisseur de ligne').grid(row=0,
                                                                  column=0,
                                                                  padx=5,
                                                                  pady=5)
        for i in range(0, 11):
            Tk.Radiobutton(self.MenuConfig, text=str(i), variable=self.Width,
                           value=i).grid(row=1+i, column=0, padx=5, pady=5)
        Tk.Label(self.MenuConfig, text='Couleur').grid(row=0, column=2,
                                                       padx=5, pady=5)
        col = 0
        for c, n in [('Noir', 'black'), ('Blanc', 'white'), ('Rouge', 'red'),
            ('Vert', 'green'), ('Bleu', 'blue'), ('Jaune', 'yellow'),
            ('Violet', 'purple'), ('Orange', 'orange'), ('Gris', 'gray'),
            ('Rose', 'pink'), ('Marron', 'brown'),]:
            Tk.Radiobutton(self.MenuConfig, text=c, variable=self.Color,
                           value=n).grid(row=col+1, column=2, padx=5, pady=5,
                                         sticky=W)
            col += 1
        Tk.Button(self.MenuConfig, fg='green', text='Quitter',
                  command=lambda: self._DelWidget(self.MenuConfig)
                  ).grid(row=14, column=1, pady=10)
        self.MenuConfig.bind('<Escape>', lambda e: 
                             self._DelWidget(self.MenuConfig))
 
if __name__ == "__main__":
    app = GUI(None)
    app.mainloop()

Ici c'est l'image de fond qui a l'index 1

26/05/2012, 16h51
PauseKawa
Citation:

Envoyé par Bear the french

for e in range(1,9):
traduction littérale --> Pour e qui prend les valeurs entières de 1 à 9.
En bref, cela va faire une boucle avec le paramètre e changeant de valeur à chaque tour... donc 9 fois ce qui est indenté (décalé au dessous), va se produire.

Pas vraiment:
Code:

1 2 3 4 5 6 7 8 9 10 11 >>> for e in range(1,9): ... print(e) ... 1 2 3 4 5 6 7 8
27/05/2012, 09h16
Bear the french
Bonjour,

Tout à fait d'accord avec la remarque précédente :oops:

Je corrige :
range(x,y) désigne la suite d'entiers entre les deux bornes données en paramètres, avec x compris mais y exclu.
Une erreur de débutant :oops:

Bertrand

Ps : Du coup, pour me faire pardonner, un petit rappel à nos lecteurs francophones des autres différents types de paramétrages de range() :

1. range(x) désigne la suite d'entiers à partir de zéro et avec x exclu. range(x) équivaut à range(0,x)
Code:

1 2 >>> range(10) [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
2. range(x,y,z) désigne la suite d'entiers à intervalles z entre les deux bornes données en paramètres, avec x en premier élément mais y exclu.
Code:

1 2 >>> range(0, 10, 3) [0, 3, 6, 9]
Ceci fonctionne aussi avec un paramètre z négatif :
Code:

1 2 >>> range(-10, -100, -30) [-10, -40, -70]
3. range(len(liste)) permet de passer en revu l'ensemble des éléments d'une liste. C'est la combinaison des deux fonctions range() et len().
Code:

1 2 3 4 5 6 7 8 9 >>> a = ['Mary', 'had', 'a', 'little', 'lamb'] >>> for i in range(len(a)): ... print i, a[i] ... 0 Mary 1 had 2 a 3 little 4 lamb

Bonjour,

Du coup je viens de me rendre compte que j'ai oublier de préciser le principal: tag_bind :oops:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 try: from tkinter import * except: from Tkinter import * def OnEvent(event): item = canvas.find_closest(event.x, event.y) label.config(text=item) root.after(120, lambda: label.config(text="")) root = Tk() canvas = Canvas(root, width=500, height=500, bg="white") canvas.pack() label = Label(root) label.pack() canvas.create_rectangle(200, 200, 300, 300, fill="white", tags="dessin") canvas.create_oval(10, 10, 50, 50, fill="red", tags="dessin") canvas.create_oval(450, 10, 490, 50, fill="blue", tags="dessin") canvas.create_oval(10, 450, 50, 490, fill="yellow", tags="dessin") canvas.create_oval(450, 450, 490, 490, fill="green", tags="dessin") canvas.tag_bind("dessin", "<ButtonRelease-1>", OnEvent) root.mainloop()
Ici le binding est fait sur le tag 'dessin' donc lorsque le callback OnEvent est appelé on a obligatoirement cliquer sur un élément ayant ce tag et find_closest fonctionne.
Mais bon: Je ne pense pas que Swinnen en parle et vous avez du rendre votre copie à l'heure qu'il est.

@+