créer fenêtre Tkinter

Version imprimable

Bonjour, j'aurais besoin de conseil et d'aide pour continuer mon projet. J'ai un code qui marche bien mais je veux que l'utilisateur rentre ces paramétres avant le début du jeu. Donc je veux qu'une fenêtre apparaisse au début avec pour commencer juste un bouton "jouer" qui lancera le jeu. Je mets mon 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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
# -*- coding: cp1252 -*-
# ==============================================================================
# Slidings rows : jeu de puissance 4 améliorer 
# ==============================================================================
"""Slidings Rows """
__author__  = 
__version__ = "1.0"
__date__    = "14/05/2010"
# ------------------------------------------------------------------------------
from Tkinter import *
 
 
class TextGrid(Frame):
  """grille rectangulaire de widget avec la possibilité d'ajouter un texte"""
 
  config = {'border':1, 'widget':Label, 'text':'' , 'size':(2,2), 'command':''}
 
  def __init__(self, master, **keys):
    """initialise la grille de widget"""
    for key in self.config:
      if key not in keys: keys[key] = self.config[key]
    self.grid, self.size, self.init = {}, keys['size'], keys['text']
    widget, command, (cols,rows) = keys['widget'], keys['command'], keys['size']
    del keys['widget'], keys['command'], keys['size']
    Frame.__init__(self, master, border=keys['border'], relief=SOLID) 
    for col in range(cols):
      for row in range(rows):
        if command:
            keys['command'] = lambda cell=(col,row): command(cell)
        self.grid[col,row] = widget(self, keys) 
        self.grid[col,row].grid(column=col, row=row, sticky=N+S+W+E)
    for n in range(cols): self.columnconfigure(n, weight=1)
    for n in range(rows): self.rowconfigure(n, weight=1)
 
 
  def __getitem__(self, key):
    if isinstance(key, str): 
      return Frame.__getitem__(self, key)
    col, row = key[:2]; prop = key[2] if len(key) == 3 else 'text'
    return self.grid[col,row][prop] 
 
 
  def __setitem__(self, key, val):
    if isinstance(key, str):
      Frame.__setitem__(self, key, val); return
    col, row = key[:2]; prop = key[2] if len(key) == 3 else 'text'
    self.grid[col,row][prop] = val
 
 
class Initiation(Tk):
 """initialise le jeu"""
 
 def __init__(self,parent):
      """initialise les différentes variables et crée les widgets"""
      Tk.__init__(self,parent)
      self.parent = parent
      self.size, self.fnt = (7,7), "Arial 14" #initialise les variables de taille et d'écriture
      self.colors = ('RED','RED','RED','RED','RED','RED','RED') #texte pour initialiser gridB
      self.color1 = 'RED' #définie une couleur associée à un joueur
      self.color2 = 'BLUE'
      self.joueur1 = 0 #initialise le nombre de combinaisons gagnantes à 0
      self.joueur2 = 0
 
      self.gridB = TextGrid(self, widget=Button, size=(7,1), font=self.fnt, width=9,
              command=Calcul().paint)                                          # création des boutons permettant de commander où         
      for p, color in enumerate(self.colors):                                  # placer une pièce et quelle couleur doit jouer  
          self.gridB[p,0] = 'RED'
          self.gridB[p,0,'bg'] = 'GREY'
      self.gridB.pack(side=TOP, fill=BOTH, padx=5, pady=5)  
 
      self.gridA = TextGrid(self, size=self.size, font=self.fnt, width=4, height=2, relief=SOLID) # création de la grille de jeu
      for p in range(7):                                                                          # cette grille est de taille 7x7  
          for k in range(7):                                                                      # comme le puissance 4 "classique"   
              self.gridA[p,k,'bg'] = 'GREY'
      self.gridA.pack(side=TOP, fill=BOTH, expand=YES, padx=5, pady=5)
 
 
class Calcul():
    """'coeur' du jeu où sont disposées les méthodes permettant le bon fonctionnement"""
 
    def paint(self, button):
        """vérifie si le joueur peut jouer dans une colonne"""
        temp,root.temp_gridB=[],[]                         #initialise des listes 
        val = button[0] 
        if root.gridB[val,0] == 'Stop':             #si sur le bouton de gridB il est écrit 'Stop', on ne peut pas jouer dans cette colonne 
            p = [7] 
        for v in range(7):
            if root.gridB[v,0] != 'Stop':           #si on peut jouer ( bouton différent de 'Stop')
                root.temp_gridB.append(root.gridB[v,0])    #on enregistre la couleur courante ds temp_gridB
        if len(root.temp_gridB) != 0:               #cette condition permet de jouer si toutes les boutons de gridB n'affiche pas 'Stop'
          self.color = root.temp_gridB[0]           #on définit la couleur courante permettant de connaitre la couleur pour toutes les méthodes
          if len(temp) == 0:
              if root.temp_gridB[0] == root.color1:          #on définit le joueur courant permettant de connaitre le joueur pour toutes les méthodes
                  self.joueur=root.joueur1
              else:
                  self.joueur=root.joueur2
              self.remplir(button)                    #on appelle les méthodes remplir et gagner
              self.gagner(button)
 
    def remplir(self, button):        
        """place une pièce dans la grille de jeu en respectant la gravité"""
        val = button[0]
        k = 6
        while k:
            if root.gridA[val,k,'bg'] == 'GREY':     #on vérifie si on peut placer une pièce dans une colonne 
                root.gridA[val,k,'bg'] = self.color  #et si on peut, on l'ajoute avec la couleur courante
                self.change()
                break
            else:
                k -= 1
            if (k == 0) and (root.gridA[val,k,'bg'] == 'GREY'):
                root.gridA[val,k,'bg'] = self.color  #si la pièce ajoutée est la dernière de la colonne 
                root.gridB[val,0,'bg'] = 'yellow'    #alors on bloque la colonne pour la suite du jeu
                root.gridB[val,0] = 'Stop'           #en la colorant en jaune et en écrivant 'Stop' 
                self.change()                        #et on change de joueur
 
    def change(self):
        """permet de passer d'un joueur à l'autre après une action de jeu"""
        if root.temp_gridB[0] == root.color1:               #on regarde la couleur courante et 
            self.color='BLUE'                        #on la change pour le joueur suivant
        else:
            self.color='RED'
        cols, rows = root.size
        for p in range(rows):                        #on applique le changement sur gridB 
            if root.gridB[p,0] != 'Stop':            #en modifiant le texte des boutons 
                root.gridB[p,0] = self.color         #mais on vérifie avant que les boutons ne soient pas des 'Stop'
 
 
 
# ==============================================================================
if __name__ == "__main__":                                  #on crée notre root
 
 
    root=Initiation(None)
    root.withdraw()
    root.title("Sliding Rows")
    root.minsize(root.winfo_width(), root.winfo_height())
    root.resizable(1,1)
    root.deiconify()
    root.mainloop()

J'ai essayé plein de trucs mais je n'y arrive pas du tout. Je suis sur que c'est pas compliqué mais je débute donc je bloque sur des détails.

J'arrive à ça:

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
# -*- coding: cp1252 -*-
# ==============================================================================
# Slidings rows : jeu de puissance 4 améliorer 
# ==============================================================================
"""Slidings Rows """
__author__  = " "
__version__ = "1.0"
__date__    = "14/05/2010"
# ------------------------------------------------------------------------------
from Tkinter import *
 
 
class TextGrid(Frame):
  """grille rectangulaire de widget avec la possibilité d'ajouter un texte"""
 
  config = {'border':1, 'widget':Label, 'text':'' , 'size':(2,2), 'command':''}
 
  def __init__(self, master, **keys):
    """initialise la grille de widget"""
    for key in self.config:
      if key not in keys: keys[key] = self.config[key]
    self.grid, self.size, self.init = {}, keys['size'], keys['text']
    widget, command, (cols,rows) = keys['widget'], keys['command'], keys['size']
    del keys['widget'], keys['command'], keys['size']
    Frame.__init__(self, master, border=keys['border'], relief=SOLID) 
    for col in range(cols):
      for row in range(rows):
        if command:
            keys['command'] = lambda cell=(col,row): command(cell)
        self.grid[col,row] = widget(self, keys) 
        self.grid[col,row].grid(column=col, row=row, sticky=N+S+W+E)
    for n in range(cols): self.columnconfigure(n, weight=1)
    for n in range(rows): self.rowconfigure(n, weight=1)
 
 
  def __getitem__(self, key):
    if isinstance(key, str): 
      return Frame.__getitem__(self, key)
    col, row = key[:2]; prop = key[2] if len(key) == 3 else 'text'
    return self.grid[col,row][prop] 
 
 
  def __setitem__(self, key, val):
    if isinstance(key, str):
      Frame.__setitem__(self, key, val); return
    col, row = key[:2]; prop = key[2] if len(key) == 3 else 'text'
    self.grid[col,row][prop] = val
 
 
class Initiation(Tk):
 """initialise le jeu"""
 
 def __init__(self,parent):
      """initialise les différentes variables et crée les widgets"""
      Tk.__init__(self,parent)
      self.parent = parent
      self.size, self.fnt = (7,7), "Arial 14" #initialise les variables de taille et d'écriture
      self.colors = ('RED','RED','RED','RED','RED','RED','RED') #texte pour initialiser gridB
      self.color1 = 'RED' #définie une couleur associée à un joueur
      self.color2 = 'BLUE'
      self.joueur1 = 0 #initialise le nombre de combinaisons gagnantes à 0
      self.joueur2 = 0
      self.col = 7
 
 
      self.t1=Toplevel()
      self.t1.title("Nouvelle fenetre")
      self.ferme=Button(self.t1,text="Fermer",command=self.grille())
      self.ferme.pack()
      self.ferme1=Label(self.t1,text="nb")
      self.ferme1.pack(side=LEFT,fill=BOTH)
      self.ferme11 = Entry(self.ferme1,textvar = self.col,width=4)
      self.ferme11.pack(side=RIGHT,fill=BOTH)
      print self.col
 
 def grille(self):
 
 
     self.gridB = TextGrid(self, widget=Button, size=(7,1), font=self.fnt, width=9,
             command=Calcul().paint)                                          # création des boutons permettant de commander où         
     for p, color in enumerate(self.colors):                                  # placer une pièce et quelle couleur doit jouer  
         self.gridB[p,0] = 'RED'
         self.gridB[p,0,'bg'] = 'GREY'
     self.gridB.pack(side=TOP, fill=BOTH, padx=5, pady=5)  
 
     self.gridA = TextGrid(self, size=self.size, font=self.fnt, width=4, height=2, relief=SOLID) # création de la grille de jeu
     for p in range(7):                                                                          # cette grille est de taille 7x7  
         for k in range(7):                                                                      # comme le puissance 4 "classique"   
             self.gridA[p,k,'bg'] = 'GREY'
     self.gridA.pack(side=TOP, fill=BOTH, expand=YES, padx=5, pady=5)
 
 
class Calcul():
    """'coeur' du jeu où sont disposées les méthodes permettant le bon fonctionnement"""
 
    def paint(self, button):
        """vérifie si le joueur peut jouer dans une colonne"""
        temp,root.temp_gridB=[],[]                         #initialise des listes 
        val = button[0] 
        if root.gridB[val,0] == 'Stop':             #si sur le bouton de gridB il est écrit 'Stop', on ne peut pas jouer dans cette colonne 
            p = [7] 
        for v in range(7):
            if root.gridB[v,0] != 'Stop':           #si on peut jouer ( bouton différent de 'Stop')
                root.temp_gridB.append(root.gridB[v,0])    #on enregistre la couleur courante ds temp_gridB
        if len(root.temp_gridB) != 0:               #cette condition permet de jouer si toutes les boutons de gridB n'affiche pas 'Stop'
          self.color = root.temp_gridB[0]           #on définit la couleur courante permettant de connaitre la couleur pour toutes les méthodes
          if len(temp) == 0:
              if root.temp_gridB[0] == root.color1:          #on définit le joueur courant permettant de connaitre le joueur pour toutes les méthodes
                  self.joueur=root.joueur1
              else:
                  self.joueur=root.joueur2
              self.remplir(button)                    #on appelle les méthodes remplir et gagner
 
 
    def remplir(self, button):        
        """place une pièce dans la grille de jeu en respectant la gravité"""
        val = button[0]
        k = 6
        while k:
            if root.gridA[val,k,'bg'] == 'GREY':     #on vérifie si on peut placer une pièce dans une colonne 
                root.gridA[val,k,'bg'] = self.color  #et si on peut, on l'ajoute avec la couleur courante
                self.change()
                break
            else:
                k -= 1
            if (k == 0) and (root.gridA[val,k,'bg'] == 'GREY'):
                root.gridA[val,k,'bg'] = self.color  #si la pièce ajoutée est la dernière de la colonne 
                root.gridB[val,0,'bg'] = 'yellow'    #alors on bloque la colonne pour la suite du jeu
                root.gridB[val,0] = 'Stop'           #en la colorant en jaune et en écrivant 'Stop' 
                self.change()                        #et on change de joueur
 
    def change(self):
        """permet de passer d'un joueur à l'autre après une action de jeu"""
        if root.temp_gridB[0] == root.color1:               #on regarde la couleur courante et 
            self.color='BLUE'                        #on la change pour le joueur suivant
        else:
            self.color='RED'
        cols, rows = root.size
        for p in range(rows):                        #on applique le changement sur gridB 
            if root.gridB[p,0] != 'Stop':            #en modifiant le texte des boutons 
                root.gridB[p,0] = self.color         #mais on vérifie avant que les boutons ne soient pas des 'Stop'
 
 
 
# ==============================================================================
if __name__ == "__main__":                                  #on crée notre root
 
 
    root=Initiation(None)
    root.withdraw()
    root.title("Sliding Rows")
    root.minsize(root.winfo_width(), root.winfo_height())
    root.resizable(1,1)
    root.deiconify()
    root.mainloop()

Mais, je n'arrive pas à récupérer la valeur entrer dans ferme1. Je veux que cette valeur définisse le nombre de lignes et de colonnes de la grille.
Je continue d'essayer mais j'ai vraiment du mal.
J'ai essayé de créer une classe qui ouvre cette fenêtre et enregistre les paramétres mais ça ne marche pas... pourtant je trouvais ça bien.
Je dois essayer comment?

Merci de vos réponses.

Bonjour hyuga33,

Sans trop toucher au 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
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
# -*- coding: cp1252 -*-
# ==============================================================================
# Slidings rows : jeu de puissance 4 améliorer 
# ==============================================================================
"""Slidings Rows """
__author__  = " "
__version__ = "1.0"
__date__    = "14/05/2010"
# ------------------------------------------------------------------------------
from Tkinter import *
 
 
class TextGrid(Frame):
  """grille rectangulaire de widget avec la possibilité d'ajouter un texte"""
 
  config = {'border':1, 'widget':Label, 'text':'' , 'size':(2,2), 'command':''}
 
  def __init__(self, master, **keys):
    """initialise la grille de widget"""
    for key in self.config:
      if key not in keys: keys[key] = self.config[key]
    self.grid, self.size, self.init = {}, keys['size'], keys['text']
    widget, command, (cols,rows) = keys['widget'], keys['command'], keys['size']
    del keys['widget'], keys['command'], keys['size']
    Frame.__init__(self, master, border=keys['border'], relief=SOLID) 
    for col in range(cols):
      for row in range(rows):
        if command:
            keys['command'] = lambda cell=(col,row): command(cell)
        self.grid[col,row] = widget(self, keys) 
        self.grid[col,row].grid(column=col, row=row, sticky=N+S+W+E)
    for n in range(cols): self.columnconfigure(n, weight=1)
    for n in range(rows): self.rowconfigure(n, weight=1)
 
 
  def __getitem__(self, key):
    if isinstance(key, str): 
      return Frame.__getitem__(self, key)
    col, row = key[:2]; prop = key[2] if len(key) == 3 else 'text'
    return self.grid[col,row][prop] 
 
 
  def __setitem__(self, key, val):
    if isinstance(key, str):
      Frame.__setitem__(self, key, val); return
    col, row = key[:2]; prop = key[2] if len(key) == 3 else 'text'
    self.grid[col,row][prop] = val
 
 
class Initiation(Tk):
 """initialise le jeu"""
 
 def __init__(self,parent):
      """initialise les différentes variables et crée les widgets"""
      Tk.__init__(self,parent)
      self.parent = parent
      self.size, self.fnt = (7,7), "Arial 14" #initialise les variables de taille et d'écriture
      self.colors = ('RED','RED','RED','RED','RED','RED','RED') #texte pour initialiser gridB
      self.color1 = 'RED' #définie une couleur associée à un joueur
      self.color2 = 'BLUE'
      self.joueur1 = 0 #initialise le nombre de combinaisons gagnantes à 0
      self.joueur2 = 0
      self.col = 7
      self.intro()
 
 def intro(self):
      self.t1=Toplevel()
      self.t1.protocol("WM_DELETE_WINDOW", self.lance) # En cas de fermeture de la fenetre
      self.t1.title("Nouvelle fenetre")
      Button(self.t1, text="Fermer", command=self.lance).pack()
      Label(self.t1,text="nb").pack(side=LEFT,fill=BOTH)
      self.ferme11=Entry(self.t1, text=self.col, width=4)
      self.ferme11.pack(side=RIGHT,fill=BOTH)
 
 def lance(self):
      if self.ferme11.get() and str(self.ferme11.get()) in ("123456789"):
          self.col=int(self.ferme11.get()) # Le get() retourne un string
      self.grille()
      self.deiconify()
      self.t1.destroy()
 
 def grille(self):
 
 
     self.gridB = TextGrid(self, widget=Button, size=(self.col,1), font=self.fnt, width=9,
             command=Calcul().paint)                                          # création des boutons permettant de commander où         
     for p, color in enumerate(self.colors):                                  # placer une pièce et quelle couleur doit jouer  
         self.gridB[p,0] = 'RED'
         self.gridB[p,0,'bg'] = 'GREY'
     self.gridB.pack(side=TOP, fill=BOTH, padx=5, pady=5)  
 
     self.gridA = TextGrid(self, size=self.size, font=self.fnt, width=4, height=2, relief=SOLID) # création de la grille de jeu
     for p in range(self.col):                                                                          # cette grille est de taille 7x7  
         for k in range(self.col):                                                                      # comme le puissance 4 "classique"   
             self.gridA[p,k,'bg'] = 'GREY'
     self.gridA.pack(side=TOP, fill=BOTH, expand=YES, padx=5, pady=5)
 
 
class Calcul():
    """'coeur' du jeu où sont disposées les méthodes permettant le bon fonctionnement"""
 
    def paint(self, button):
        """vérifie si le joueur peut jouer dans une colonne"""
        temp,root.temp_gridB=[],[]                         #initialise des listes 
        val = button[0] 
        if root.gridB[val,0] == 'Stop':             #si sur le bouton de gridB il est écrit 'Stop', on ne peut pas jouer dans cette colonne 
            p = [7] 
        for v in range(7):
            if root.gridB[v,0] != 'Stop':           #si on peut jouer ( bouton différent de 'Stop')
                root.temp_gridB.append(root.gridB[v,0])    #on enregistre la couleur courante ds temp_gridB
        if len(root.temp_gridB) != 0:               #cette condition permet de jouer si toutes les boutons de gridB n'affiche pas 'Stop'
          self.color = root.temp_gridB[0]           #on définit la couleur courante permettant de connaitre la couleur pour toutes les méthodes
          if len(temp) == 0:
              if root.temp_gridB[0] == root.color1:          #on définit le joueur courant permettant de connaitre le joueur pour toutes les méthodes
                  self.joueur=root.joueur1
              else:
                  self.joueur=root.joueur2
              self.remplir(button)                    #on appelle les méthodes remplir et gagner
 
 
    def remplir(self, button):        
        """place une pièce dans la grille de jeu en respectant la gravité"""
        val = button[0]
        k = 6
        while k:
            if root.gridA[val,k,'bg'] == 'GREY':     #on vérifie si on peut placer une pièce dans une colonne 
                root.gridA[val,k,'bg'] = self.color  #et si on peut, on l'ajoute avec la couleur courante
                self.change()
                break
            else:
                k -= 1
            if (k == 0) and (root.gridA[val,k,'bg'] == 'GREY'):
                root.gridA[val,k,'bg'] = self.color  #si la pièce ajoutée est la dernière de la colonne 
                root.gridB[val,0,'bg'] = 'yellow'    #alors on bloque la colonne pour la suite du jeu
                root.gridB[val,0] = 'Stop'           #en la colorant en jaune et en écrivant 'Stop' 
                self.change()                        #et on change de joueur
 
    def change(self):
        """permet de passer d'un joueur à l'autre après une action de jeu"""
        if root.temp_gridB[0] == root.color1:               #on regarde la couleur courante et 
            self.color='BLUE'                        #on la change pour le joueur suivant
        else:
            self.color='RED'
        cols, rows = root.size
        for p in range(rows):                        #on applique le changement sur gridB 
            if root.gridB[p,0] != 'Stop':            #en modifiant le texte des boutons 
                root.gridB[p,0] = self.color         #mais on vérifie avant que les boutons ne soient pas des 'Stop'
 
 
 
 
# ==============================================================================
if __name__ == "__main__":                                  #on crée notre root
 
 
    root=Initiation(None)
    root.withdraw()
    root.title("Sliding Rows")
    root.minsize(root.winfo_width(), root.winfo_height())
    root.resizable(1,1)
    root.mainloop()

Je te laisse finir la mise en place de self.col

@+

15/05/2010, 13h42
hyuga33

Merci pausekawa!
J'ai donc mis en place self.col dans le reste du code pour ma version compléte du jeu et ça marche bien. J'ai même rajouter des boutons sur t1 pour afficher les régles, la version et d'autre truc. Tout ça marche vraiment bien. self.col me donne donc le nombre de ligne et de colonne. J'ai donc une grille carrée.
Je n'avais pas penser à créer plusieurs méthodes.
La j'essaie de faire pareil pour le nombre de ligne. J'ai rajouté un label et un widget Entry pour entrer self.lig mais ça ne le lis pas pour le moment. Je persévére!!!
15/05/2010, 19h16
hyuga33
J'essaie de mettre un widget check mais ça ne marche pas...Voila ce que j'ai ajouter dans la méthode intro.
Code:

1 2 3 4 val=1 chk=Checkbutton(self.t1,textvariable=val,variable=val) chk.grid()
Mon but est de pouvoir choisir une option si on coche la case. Aprés je ferai des "if (cachecoché=oui)" et mon bloc d'instruction de l'option.

P.S.:J'ai abondonné l'idée de pouvoir avoir un nombre de lignes et de colonnes différents. Je préfére rester avec un carrée.
15/05/2010, 20h29
PauseKawa

Bonsoir hyuga33,

C'est une question différente il me semble (Checkbutton).
Commence par lire une doc puis repose ta question dans un autre sujet svp.
C'est mieux pour la lecture sur le forum. Cela évite les 'dialogues', donc plus de réponses.

Bon code.

PS: Regarde à rectifier l'indentation de ton code > 4.
15/05/2010, 20h37
hyuga33

Merci pour la doc PauseKawa. Je regarde la doc et je vais essayer de résoudre mon problème avec. Si je n'y arrive pas je posterai un message à l'endroit qu'il faut. Si j'y arrive je le dirais ici.
Sinon, j'avais remarquer l'erreur d'indentation mais j'attends d'avoir fini mon code pour la rectifier. De même, je changerai certain nom de variable pour qu'ils soient pus appropriés à leur fonction.
J'arrive au bout de mon code, j'espére finir dans la soirée.
Bonne soirée et encore merci.
15/05/2010, 21h33
hyuga33

C'est fait!!!! J'ai fini mon code et il marche parfaitement. Sûrement qu'il est améliorable mais il restera comme ça.
Je te remercie beaucoup PauseKawa pour toute ton aide.