Comment récupérer un objet d'une liste?

Version imprimable

Bonjour,
Je suis débutante en Python. Je travaille avec python 3.2
Dans mon code ci-bas, je dessine un labyrinthe à partir d’un fichier texte "fichier.lab" dont le contenu est une série de 0 et de 1.

111111111E
10000000011
1111000110
10001110001
0110101111
10011001001
1100011000
10011001111
1100110000
10110010111
0001101110
11110110001
0000000111
11111100001
0000011111
11011000001
0110111110
10001000101
1111001010
00000101001
1111111111

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
 
#!/usr/local/bin/python
 
from tkinter import *
import tkinter
 
def FindCellule(grille, x, y):
	for i in range(0,len(grille)-1,1):
		if(grille[i].GetXCoord == x and grille[i].GetYCoord == y):
			return grille[i]
 
class Cellule():
	def __init__(self,x = 100, y = 100, nord='0', sud='0', est='0', ouest='0'):
		self.xP = x
		self.yP = y
		self.nord = nord
		self.sud = sud
		self.est = est
		self.ouest = ouest
	def setCoordonnees (self, x, y):
		self.xP = x
		self.Yp = y
	def GetXCoord (self):
		return self.xP
	def GetYCoord (self):
		return self.yP
	def setNord (self, nord):
		self.nord = nord
	def setSud (self, sud):
		self.sud = sud
	def setEst (self, est):
		self.est = est
	def setOuest (self, ouest):
		self.ouest = ouest
	def getNord (self):
		return self.nord
	def getSud (self):
		return self.sud
	def getEst (self):
		return self.est
	def getOuest (self):
		return self.ouest
 
class Labyrinthe():
	def __init__(self, x=0, y=0):
		self.xM = x
		self.yM = y
		self.grille = []
	def traceLignePaire(x,y,a):
		if(a == '1'):
			w.create_line( x, y, x, y - 3*pas, width=epaisseurLigne)
	def traceLigneImPaire(x,y,a):
		if(a == '1'):
			w.create_line( x -ep+1, y, x + 3*pas + ep, y, width=epaisseurLigne)			
	def XentreLab(x):
		return x		
	def YentreLab(y):
		return y
 
	def tracerLabyrinthe(self):
		cellule = Cellule()
		contenu = open('fichier.lab', 'r+')
		x_pos = PointDep
		y_pos = PointDep
 
		#Nr de la ligne
		c = 1
		ligneAvant =''
		for ligne in contenu:
			for j in range(0,len(ligne)-1,1):				
				if(ligne[j] == 'E'):
					self.xM = x_pos + (3*pas/2)
					self.yM = y_pos - (3*pas/2)
					cellule.setCoordonnees(self.xM,self.yM)
					cellule.setOuest = '1'
					cellule.setNord = '1'
					cellule.setEst = '1'
				if(ligne[j] == '0'):
					if(c %2 ==0 and j < (len(ligne)-2)):
						w.create_oval(x_pos + (3*pas/2) -r,y_pos - (3*pas/2) -r,x_pos + (3*pas/2) +r,y_pos - (3*pas/2) +r,width=2,outline='black',fill='yellow')
						cellule.setCoordonnees(x_pos + (3*pas/2),y_pos - (3*pas/2))
						cellule.setOuest = ligne[j]
						cellule.setNord = ligneAvant[j]
					x_pos = x_pos + 3*pas	
				elif(c %2 ==0 ):
					Labyrinthe.traceLignePaire(x_pos,y_pos,ligne[j])
					if(j < (len(ligne)-2)):
						w.create_oval(x_pos + (3*pas/2) -r,y_pos - (3*pas/2) -r,x_pos + (3*pas/2) +r,y_pos - (3*pas/2) +r,width=2,outline='black',fill='yellow')
						cellule.setCoordonnees(x_pos + (3*pas/2),y_pos - (3*pas/2))
						cellule.setOuest = ligne[j]
						cellule.setNord = ligneAvant[j]
					x_pos = x_pos + 3*pas	
				else:
					Labyrinthe.traceLigneImPaire(x_pos,y_pos,ligne[j])
					x_pos = x_pos + 3*pas
			x_pos = PointDep
			if(c%2 != 0):
				y_pos = y_pos + 3*pas
			c = c + 1
			ligneAvant = ligne
			self.grille.append(cellule)
		contenu.close()	
 
def Deplacement(event):
	global PosX,PosY, nord, sud, ouest, est
	cellule
	touche = event.char
	if touche == 'h' and cellule.getNord() == '0':
		PosY -= 3*pas
	if touche == 'b' and cellule.getSud() == '0':
		PosY += 3*pas
	if touche == 'd' and cellule.getEst() == '0':
		PosX += 3*pas
	if touche == 'g' and cellule.getOuest() == '0':
		PosX -= 3*pas
	w.coords(Pion,PosX -Ray, PosY -Ray, PosX +Ray, PosY +Ray)
global pas, ep, r, PointDep, Pion, cellule
pas = 15
ep = 3
r = 5
Ray = 10
PointDep = 100
Largeur = 650
Hauteur = 600
epaisseurLigne = 5
fenetre = Tk()
fenetre.title('Labyrinthe')
 
w = Canvas(fenetre, width = Largeur, height = Hauteur, bg ='green')
cellule = Cellule()
lab = Labyrinthe()
lab.tracerLabyrinthe()	
PosX = lab.xM
PosY = lab.yM
cellule = FindCellule(lab.grille, PosX, PosY) 
Pion = w.create_oval(PosX-10,PosY-10,PosX+10,PosY+10,width=2,outline='black',fill='red')
 
w.focus_set()
w.bind('<Key>',Deplacement)
w.pack(padx =20, pady =20)
fenetre.mainloop()

Je trace le labyrinthe sans soucis.

Pour déplacer un pion dans le labyrinthe, je considère que mon labyrinthe est constitué d’une grille de cellules.
Je défini une cellule comme un objet ayant des coordonnées x, y et des variables nord, sud, est et ouest.
Ma classe Labyrinthe a donc une liste "grille" dans laquelle j’ajoute les cellules que je crée au cours du parcours du fichier "fichier.lab".
J’ai défini une fonction "FindCellule" qui prend en paramètre une liste et les coordonnées (x et y) et doit retourner la cellule dont les coordonnées correspondent à celles des paramètres. Mais l’objet retourné n’est apparemment pas un objet de type Cellule, car ne reconnaît pas les méthodes de la classe Cellule.
Comment récupérer entièrement un objet d’une liste ? Peut-on "caster" un objet en Python comme dans d’autres langages?
Merci d'avance.
Maren

02/05/2013, 11h39
Alliaël
Bonjour,

pour vérifier le type de ta cellule tu peux utiliser la fonction type en Python. Cela t'aidera peut être à voir ou sa coince. Un problème de cast en Python ca me parait très étrange.

http://docs.python.org/2/library/types.html

Ensuite quitte à y être, quelques conseils :
Code:

1 2 3 4 def FindCellule(grille, x, y): for i in range(0,len(grille)-1,1): if(grille[i].GetXCoord == x and grille[i].GetYCoord == y): return grille[i]
peut être remplacé par
Code:

1 2 3 4 5 def FindCellule(grille, x, y): for cellule in grille : if(cellule.GetXCoord == x and cellule.GetYCoord == y): return cellule
Qui est un peu plus joli à lire.

Ensuite, en Python tous tes attributs sont public à la base, donc tu n'as pas besoin de créer des accesseurs pour chaque (ou alors déclare les en private en ajoutant un _ devant).

Si tu n'y arrives toujours pas en regardant le type, tu peux sans doute nous indiquer le type renvoyer par Python ainsi que donner la ligne qui coince.

Bonne journée.

Citation:

Envoyé par Maren00

J’ai défini une fonction "FindCellule" qui prend en paramètre une liste et les coordonnées (x et y) et doit retourner la cellule dont les coordonnées correspondent à celles des paramètres. Mais l’objet retourné n’est apparemment pas un objet de type Cellule, car ne reconnaît pas les méthodes de la classe Cellule.

L'objet retourné est None, car FindCellule ne trouvera jamais de cellule à l'endroit correspondant.
Code:

1 2 3 4 def FindCellule(grille, x, y): for i in range(0,len(grille)-1,1): if(grille[i].GetXCoord == x and grille[i].GetYCoord == y): return grille[i]
"Jamais" parce que grille[i].GetXCoord est l'adresse de la méthode .GetXCoord de l'objet grille[i]. Il faudrait écrire grille[i].GetXCoord() pour avoir le "x".
Ceci dit, modifiez votre code pour afficher les coordonnées des différentes cellules:
Code:

1 2 3 4 5 6 def FindCellule(grille, x, y): for i in range(0,len(grille)-1,1): print (i, grille[i].GetXCoord(), grille[i].GetYCoord()) if(grille[i].GetXCoord() == x and grille[i].GetYCoord() == y): return grille[i] print (x, y, 'not found')
Et réfléchissez un peu a votre algo. de construction.
Bon courage,
- W

Salut,

Il y a plusieurs choses incorrectes, dans l'ordre d'exécution:

Toutes les cellules créées ne sont pas enregistrées dans la liste, la ligne de code est mal placée:

Code:

1
2
3
4
5
6
7
8
9
10
 
					x_pos = x_pos + 3*pas
				self.grille.append(cellule)		# Ici
			x_pos = PointDep
			if(c%2 != 0):
				y_pos = y_pos + 3*pas
			c = c + 1
			ligneAvant = ligne
			#self.grille.append(cellule)		# Pas la
		contenu.close()

Tu ne mémorise pas la cellule courante, ce serait plus sur que de vérifier la position du pion avec FindCellule() qui par ailleurs est erroné au niveau de la coordonnée y.

D'autre part, dans ton code, on trouve ligne 106 :

Code:

1
2
 
	cellule

Ce qui entraîne forcément l'erreur que tu décris

et ligne 130:

Code:

1
2
 
cellule = Cellule()

qui ne sert à rien.

Donc en actualisant la position du pion au fur et à mesure de ses déplacements ton code fonctionne plus ou moins bien. Faudra encore voir pourquoi le pion traverse les murs ...

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
 
#!/usr/local/bin/python
 
from tkinter import *
import tkinter
 
class Cellule():
	def __init__(self,x = 100, y = 100, nord='0', sud='0', est='0', ouest='0'):
		self.xP = x
		self.yP = y
		self.nord = nord
		self.sud = sud
		self.est = est
		self.ouest = ouest
	def setCoordonnees (self, x, y):
		self.xP = x
		self.Yp = y
	def GetXCoord (self):
		return self.xP
	def GetYCoord (self):
		return self.yP
	def setNord (self, nord):
		self.nord = nord
	def setSud (self, sud):
		self.sud = sud
	def setEst (self, est):
		self.est = est
	def setOuest (self, ouest):
		self.ouest = ouest
	def getNord (self):
		return self.nord
	def getSud (self):
		return self.sud
	def getEst (self):
		return self.est
	def getOuest (self):
		return self.ouest
 
class Labyrinthe():
	def __init__(self, x=0, y=0):
		self.xM = x
		self.yM = y
		self.grille = []
		self.current_cell = -1
 
	def traceLignePaire(x,y,a):
		if(a == '1'):
			w.create_line( x, y, x, y - 3*pas, width=epaisseurLigne)
	def traceLigneImPaire(x,y,a):
		if(a == '1'):
			w.create_line( x -ep+1, y, x + 3*pas + ep, y, width=epaisseurLigne)			
	def XentreLab(x):
		return x		
	def YentreLab(y):
		return y
 
	def tracerLabyrinthe(self):
		cellule = Cellule()
		contenu = open('fichier.lab', 'r+')
		x_pos = PointDep
		y_pos = PointDep
 
		#Nr de la ligne
		c = 1
		ligneAvant =''
		for ligne in contenu:
			for j in range(0,len(ligne)-1,1):				
				if(ligne[j] == 'E'):
					self.xM = x_pos + (3*pas/2)
					self.yM = y_pos - (3*pas/2)
					cellule.setCoordonnees(self.xM,self.yM)
					cellule.setOuest = '1'
					cellule.setNord = '1'
					cellule.setEst = '1'
				if(ligne[j] == '0'):
					if(c %2 ==0 and j < (len(ligne)-2)):
						w.create_oval(x_pos + (3*pas/2) -r,y_pos - (3*pas/2) -r,x_pos + (3*pas/2) +r,y_pos - (3*pas/2) +r,width=2,outline='black',fill='yellow')
						cellule.setCoordonnees(x_pos + (3*pas/2),y_pos - (3*pas/2))
						cellule.setOuest = ligne[j]
						cellule.setNord = ligneAvant[j]
					x_pos = x_pos + 3*pas	
				elif(c %2 ==0 ):
					Labyrinthe.traceLignePaire(x_pos,y_pos,ligne[j])
					if(j < (len(ligne)-2)):
						w.create_oval(x_pos + (3*pas/2) -r,y_pos - (3*pas/2) -r,x_pos + (3*pas/2) +r,y_pos - (3*pas/2) +r,width=2,outline='black',fill='yellow')
						cellule.setCoordonnees(x_pos + (3*pas/2),y_pos - (3*pas/2))
						cellule.setOuest = ligne[j]
						cellule.setNord = ligneAvant[j]
					x_pos = x_pos + 3*pas	
				else:
					Labyrinthe.traceLigneImPaire(x_pos,y_pos,ligne[j])
					x_pos = x_pos + 3*pas
				self.grille.append(cellule)
			x_pos = PointDep
			if(c%2 != 0):
				y_pos = y_pos + 3*pas
			c = c + 1
			ligneAvant = ligne
		contenu.close()	
 
def Deplacement(event):
	global PosX,PosY, nord, sud, ouest, est
	touche = event.char
 
	if lab.current_cell == -1:
		# Position de départ du jeu
		if touche == 'b':
			PosY += 3*pas
			lab.current_cell = 9
	else:
		cellule = lab.grille[lab.current_cell]
		if touche == 'h' and cellule.getNord() == '0':
			PosY -= 3*pas
			lab.current_cell -= 10
		if touche == 'b' and cellule.getSud() == '0':
			PosY += 3*pas
			lab.current_cell += 10
		if touche == 'd' and cellule.getEst() == '0':
			PosX += 3*pas
			lab.current_cell += 1
		if touche == 'g' and cellule.getOuest() == '0':
			PosX -= 3*pas
			lab.current_cell -= 1
 
	w.coords(Pion,PosX -Ray, PosY -Ray, PosX +Ray, PosY +Ray)
 
 
global pas, ep, r, PointDep, Pion, cellule
pas = 15
ep = 3
r = 5
Ray = 10
PointDep = 100
Largeur = 650
Hauteur = 600
epaisseurLigne = 5
fenetre = Tk()
fenetre.title('Labyrinthe')
 
w = Canvas(fenetre, width = Largeur, height = Hauteur, bg ='green')
 
lab = Labyrinthe()
lab.tracerLabyrinthe()	
PosX = lab.xM
PosY = lab.yM
Pion = w.create_oval(PosX-10,PosY-10,PosX+10,PosY+10,width=2,outline='black',fill='red')
 
w.focus_set()
w.bind('<Key>',Deplacement)
w.pack(padx =20, pady =20)
fenetre.mainloop()

Remarque: Les tabulations au lieu des espaces c'est une plaie.

02/05/2013, 14h13
Maren00

Merci à vous tous (@Alliaël,@wiztricks,@VinsS) pour vos réponses.

Je suis actuellement en train de travailler avec le code de @VinsS.
Avec ce code, je n'ai plus besoin de la fonction FindCellule.
Par contre, je ne comprends pas pourquoi le pion traverse les murs. Apparemment, les valeurs (nord, sud,...) des cellules dans la grille n'ont pas été mises à jour.
Je continue à regarder et vous tiens au courant si je trouve la solution.
Merci aussi d'avance si vous avez le temps de regarder
03/05/2013, 14h26
Maren00

Bonjour,
après multiples modifications, j'ai toujours pas pu empêcher au pion de traverser les lignes du labyrinthe. Alors que tout devrait à priori bien fonctionner.
Je désespère...
03/05/2013, 15h32
VinsS
Tu n'aimes pas les parenthèses aux appels de fonction, hein.

Ici:
Code:

1 2 cellule.setOuest = '1'
Ce doit être:
Code:

1 2 cellule.setOuest('1')
Pareil plus loin pour les suivantes, mais il me semble qu'il y a encore d'autres erreurs, entre autres le total de cellules dans la grille.

En regardant en détail, les imbrications de boucles semblaient être à l'origine des défauts.

Mais il fallait simplifier la construction de la grille pour que les choses deviennent plus claires.

Ça donne ceci:

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
 
# -*- coding: utf-8 -*-
#!/usr/local/bin/python
 
from tkinter import *
import tkinter
 
class Cellule():
	def __init__(self,x = 100, y = 100, nord='0', sud='0', est='0', ouest='0'):
		self.xP = x
		self.yP = y
		self.nord = nord
		self.sud = sud
		self.est = est
		self.ouest = ouest
	def setCoordonnees (self, x, y):
		self.xP = x
		self.Yp = y
	def GetXCoord (self):
		return self.xP
	def GetYCoord (self):
		return self.yP
	def setNord (self, nord):
		self.nord = nord
	def setSud (self, sud):
		self.sud = sud
	def setEst (self, est):
		self.est = est
	def setOuest (self, ouest):
		self.ouest = ouest
	def getNord (self):
		return self.nord
	def getSud (self):
		return self.sud
	def getEst (self):
		return self.est
	def getOuest (self):
		return self.ouest
 
class Labyrinthe():
	def __init__(self, x=0, y=0):
		self.xM = x
		self.yM = y
		self.grille = []
		self.current_cell = -1
 
	def tracerLabyrinthe(self):
		x_pos = PointDep
		y_pos = PointDep
		with open('fichier.lab', 'r+') as inf:
			lines = inf.readlines()
			for idx, line in enumerate(lines):
				line = line.strip()
				if idx % 2 == 0:
					self.draw_walls(x_pos, y_pos, line)
					x_pos = PointDep
					y_pos = y_pos + 3*pas
					continue
 
				for i, digit in enumerate(line[:-1]):
					cell = Cellule()
					cell.setOuest('0')
					if digit == '1':
						self.draw_border(x_pos, y_pos)
						cell.setOuest('1')
 
					self.draw_cell(x_pos, y_pos)
					cell.setNord(lines[idx-1][i])
					if i == len(line)-1:
						cell.setEst('1')
					else:
						cell.setEst(line[i+1])
					cell.setSud(lines[idx+1][i])
					self.grille.append(cell)
					x_pos += 3 * pas
 
				self.draw_border(x_pos, y_pos)
				x_pos = PointDep
 
	def draw_walls(self, x, y, walls):
		# Tracé de murs horizontaux, une ligne en une fois
		ep = 3
		pas = 15
		epaisseurLigne = 5
		for wall in walls:
			if wall == '1':
				w.create_line( x -ep+1, y, x + 3*pas + ep, y, width=epaisseurLigne)
			elif wall == 'E':
				self.xM, self.yM = x + (3*pas/2), y - (3*pas/2)
			x += 3*pas
 
	def draw_border(self, x, y):
		# Tracé d'un bord droit
		pas = 15
		epaisseurLigne = 5
		w.create_line( x, y, x, y - 3*pas, width=epaisseurLigne)
 
	def draw_cell(self, x, y):
		# Tracé d'une cellule
		pas = 15
		r = 5
		w.create_oval(x + (3*pas/2) -r, y - (3*pas/2) -r, 
						x + (3*pas/2) +r, y - (3*pas/2) +r,
						width=2, outline='black', fill='yellow')
 
def Deplacement(event):
	global PosX,PosY, nord, sud, ouest, est
	touche = event.char
 
	if lab.current_cell == -1:
		# Position de départ du jeu
		if touche == 'b':
			PosY += 3*pas
			lab.current_cell = 9
	else:
		cellule = lab.grille[lab.current_cell]
 
		if touche == 'h' and cellule.getNord() == '0':
			PosY -= 3*pas
			lab.current_cell -= 10
		elif touche == 'b' and cellule.getSud() == '0':
			PosY += 3*pas
			lab.current_cell += 10
		elif touche == 'd' and cellule.getEst() == '0':
			PosX += 3*pas
			lab.current_cell += 1
		elif touche == 'g' and cellule.getOuest() == '0':
			PosX -= 3*pas
			lab.current_cell -= 1
 
	w.coords(Pion,PosX -Ray, PosY -Ray, PosX +Ray, PosY +Ray)
 
 
global pas, ep, r, PointDep, Pion, cellule
pas = 15
ep = 3
r = 5
Ray = 10
PointDep = 100
Largeur = 650
Hauteur = 600
epaisseurLigne = 5
fenetre = Tk()
fenetre.title('Labyrinthe')
 
w = Canvas(fenetre, width = Largeur, height = Hauteur, bg ='green')
 
lab = Labyrinthe()
lab.tracerLabyrinthe()	
PosX = lab.xM
PosY = lab.yM
Pion = w.create_oval(PosX-10,PosY-10,PosX+10,PosY+10,width=2,outline='black',fill='red')
 
w.focus_set()
w.bind('<Key>',Deplacement)
w.pack(padx =20, pady =20)
fenetre.mainloop()

Dans les fonctions de tracé j'ai remis les paramètres de dimensions (je n'aime pas de voir ces détails dans l'espace de nom global), tu changes en fonction de tes besoins. L'idéal serait d'avoir une saisie utilisateur des dimensions de la grille et de transmettre ces paramètres à la classe Labyrinthe comme attributs, puisque c'est le cas.

Citation:
Envoyé par Maren00
Code:

1 2 3 4 5 6 7 8 9 10 11 class Cellule(): ... def setNord (self, nord): self.nord = nord def setSud (self, sud): self.sud = sud def setEst (self, est): self.est = est def setOuest (self, ouest): self.ouest = ouest
Salut

Tant qu'on y est à tous optimiser par ci, par là, je vais y aller de ma petite contribution...
Code:

1 2 3 4 5 6 7 8 9 10 11 class Cellule(): ... def setDirection (self, *args, **kwargs): if "nord" in kwargs.iterkeys(): self.nord = kwargs["nord"] if "sud" in kwargs.iterkeys(): self.sud = kwargs["sud"] if "est" in kwargs.iterkeys(): self.est = kwargs["est"] if "ouest" in kwargs.iterkeys(): self.ouest = kwargs["ouest"]
Et ensuite tu remplaces tes cellule.setOuest(ligne[j]) par cellule.setDirection(ouest=ligne[j]) tu verras c'est magique. Et tu peux même cumuler par exemple cellule.setDirection(nord=xxx, sud=yyy, est=zzz, ouest=ttt).

Ceci dit cela ne change pas l'algo. Si celui-ci était foireux qq part, le pb reste le même...

15/05/2013, 16h27
Maren00

Merci à vous tous pour votre aide.
Ma santé ne m'a pas permis de répondre plus tôt.
J'ai finalement utilisé le code de "VinsS" (qui marche normalement) auquel j'ai apporté de petites modifications.
C'est parfait maintenant.
Merci beaucoup.
Maren