Fonctionnement Pinceau() validé

lib/Pinceau.py

@@ -1,4 +1,6 @@
 """pinceau utilise pour la selection et la mise a jour des cases du plateau"""
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
 
 class Pinceau():
     def __init__(self, plateau):
@@ -15,9 +17,12 @@ class Pinceau():
 
         self._actif = False
 
+    def estActif(self):
+        return self._actif
+
     def majForme(self, forme):
         if forme in ["simple", "ligne", "frontiere", "pot", \
-                     "rectV", "rectP", "ecclipseV", "ecclipseP"]:
+                     "rectV", "rectP", "ellipseV", "ellipseP"]:
             self._forme = forme
 
     def majEpaisseur(self, val):
@@ -26,11 +31,11 @@ class Pinceau():
 
     def defOrigine(self, coord):
         if self.plateau.coordonneesValides(coord):
-            self._origine = self.cases[coord].centreGraphique
+            self._origine = self.plateau.cases[coord].centreGraphique
 
     def defPoint2(self, coord):
         if self.plateau.coordonneesValides(coord):
-            self._point2 = self.cases[coord].centreGraphique
+            self._point2 = self.plateau.cases[coord].centreGraphique
 
     def selection(self):
         return self._selection
@@ -38,99 +43,105 @@ class Pinceau():
     def demarrer(self, coord):
         """commence a peindre a partir de la case choisie comme origine"""
         if self.plateau.coordonneesValides(coord):
-            self._origine = self.cases[coord].centreGraphique
-            self._point2 = self.cases[coord].centreGraphique
+            self._origine = self.plateau.cases[coord].centreGraphique
+            self._point2 = self.plateau.cases[coord].centreGraphique
             self._actif = True
 
     def maj(self, coord):
         """on met a jour la selection en fonction de la case qui vient d'etre ajoutee"""
-        enPlus  = []  #cases a ajouter a la selection
-        enMoins = []  #cases a retirer de la selection 
-
-        if self._forme == "simple":
-            #pas de forme: on ajoute les cases survolees a la liste des cases
-            zone = self.plateau.zone(coord, self._epaisseur - 1)
-            for coord in zone:
-                if not coord in self._selection:
-                    enPlus.append(coord)
-
-        elif self._forme == "frontiere":
-            #droite qui selectionne toutes les cases situees au dessus d'elle
-            if self._objetGraphique == None:
-                pinceau = QPen()
-                pinceau.setColor(QColor("black"))
-                self._objetGraphique = QGraphicsLineItem()
-                self._objetGraphique.setPen(pinceau)
-                self.plateau.addItem(self._objetGraphique)
-                
-            self._point2 = self.plateau.cases[coord].centreGraphique    
-            ligne = QLineF(self._origine, self._point2)
-            orientation = int((1+int(ligne.angle()/22.5))/2)
-            ligne.setAngle(orientation*45)
-            self._objetGraphique.setLine(ligne)
-            select = self.selectionFrontiere()
-            #on met compare avec l'ancienne selection pour minimiser le nombre de cases a maj
-            for coord in self._selection:
-                if not coord in select:
-                    enMoins.append(coord)
-                select.remove(coord)
-            enPlus = select   #toutes les coord qui restent dans select sont a ajouter
-
-        else:    
-            if self._forme == "ligne":
-                #segment simple
+        if self._actif:
+            enPlus  = []  #cases a ajouter a la selection
+            enMoins = []  #cases a retirer de la selection
+            if self._origine == None: self._origine = self.plateau.cases[coord].centreGraphique
+
+            if self._forme == "simple":
+                #pas de forme: on ajoute les cases survolees a la liste des cases
+                zone = self.plateau.zone(coord, self._epaisseur - 1)
+                for coord in zone:
+                    if not coord in self._selection:
+                        enPlus.append(coord)
+
+            elif self._forme == "frontiere":
+                #droite qui selectionne toutes les cases situees au dessus d'elle
                 if self._objetGraphique == None:
                     pinceau = QPen()
-                    pinceau.setColor(QColor("black"))                    
+                    pinceau.setColor(QColor("black"))
                     self._objetGraphique = QGraphicsLineItem()
                     self._objetGraphique.setPen(pinceau)
-                    self._objetGraphique.prepareGeometryChange()
                     self.plateau.addItem(self._objetGraphique)
-                self._point2 = self.plateau.cases[coord].centreGraphique        
+                    
+                self._point2 = self.plateau.cases[coord].centreGraphique    
                 ligne = QLineF(self._origine, self._point2)
-                self._objetGraphique.setLine(ligne)                                   
-            
-            elif self._forme == "rectV" or self.modeParam["typeFormeDessin"] == "rectP":
-                #rectangle
-                if self.modeParam["formeDessin"] == None:
-                    pinceau = QPen()
-                    pinceau.setColor(QColor("black"))
-                    self._objetGraphique = QGraphicsRectItem()
-                    self._objetGraphique.prepareGeometryChange()
-                    self._objetGraphique.setPen(pinceau)
-                    self.plateau.addItem(self._objetGraphique)            
-                rect = QRectF(QPointF(min(self._origine.x(), self._point2.x()), min(self._origine.y(), self._point2.y())), \
-                              QPointF(max(self._origine.x(), self._point2.x()), max(self._origine.y(), self._point2.y()))  )
-                self._objetGraphique.setRect(rect)
-            
-            elif self._forme == "ellipseV" or self.modeParam["typeFormeDessin"] == "ellipseP":
-                #ellipse
-                if self._objetGraphique == None:
-                    pinceau = QPen()
-                    pinceau.setColor(QColor("black"))
-                    self._objetGraphique = QGraphicsEllipseItem()
-                    self._objetGraphique.prepareGeometryChange()
-                    self._objetGraphique.setPen(pinceau)
-                    self.plateau.addItem(self._objetGraphique)
-                rect = QRectF(QPointF(min(self._origine.x(), self._point2.x()), min(self._origine.y(), self._point2.y())), \
-                              QPointF(max(self._origine.x(), self._point2.x()), max(self._origine.y(), self._point2.y()))  )
-                self._objetGraphique.setRect(rect)
+                orientation = int((1+int(ligne.angle()/22.5))/2)
+                ligne.setAngle(orientation*45)
+                self._objetGraphique.setLine(ligne)
+                select = self.selectionFrontiere()
+                #on met compare avec l'ancienne selection pour minimiser le nombre de cases a maj
+                for coord in self._selection:
+                    if not coord in select:
+                        enMoins.append(coord)
+                    else:    
+                        select.remove(coord)
+                enPlus = select   #toutes les coord qui restent dans select sont a ajouter
 
-            #on liste les cases intersectant la forme
-            select = self.casesSousForme(self._objetGraphique, (self._forme[-1:] == "P"), self._epaisseur - 1)
-            
-            for coord in self._selection:
-                if not coord in select:
-                    enMoins.append(coord)
-                select.remove(coord)
-            enPlus = select
-            
-        for coord in enPlus:
-            self.afficherCase(coord, True)
-            self._selection.append(coord)
-        for coord in enMoins:
-            self.afficherCase(coord, False)
-            self._selection.remove(coord)
+            else:    
+                if self._forme == "ligne":
+                    #segment simple
+                    if self._objetGraphique == None:
+                        pinceau = QPen()
+                        pinceau.setColor(QColor("black"))                    
+                        self._objetGraphique = QGraphicsLineItem()
+                        self._objetGraphique.setPen(pinceau)
+                        self._objetGraphique.prepareGeometryChange()
+                        self.plateau.addItem(self._objetGraphique)
+                    self._point2 = self.plateau.cases[coord].centreGraphique        
+                    ligne = QLineF(self._origine, self._point2)
+                    self._objetGraphique.setLine(ligne)                                   
+                
+                elif self._forme == "rectV" or self._forme == "rectP":
+                    #rectangle
+                    if self._objetGraphique == None:
+                        pinceau = QPen()
+                        pinceau.setColor(QColor("black"))
+                        self._objetGraphique = QGraphicsRectItem()
+                        self._objetGraphique.prepareGeometryChange()
+                        self._objetGraphique.setPen(pinceau)
+                        self.plateau.addItem(self._objetGraphique)
+                    self._point2 = self.plateau.cases[coord].centreGraphique  
+                    rect = QRectF(QPointF(min(self._origine.x(), self._point2.x()), min(self._origine.y(), self._point2.y())), \
+                                  QPointF(max(self._origine.x(), self._point2.x()), max(self._origine.y(), self._point2.y()))  )
+                    self._objetGraphique.setRect(rect)
+                
+                elif self._forme == "ellipseV" or self._forme == "ellipseP":
+                    #ellipse
+                    if self._objetGraphique == None:
+                        pinceau = QPen()
+                        pinceau.setColor(QColor("black"))
+                        self._objetGraphique = QGraphicsEllipseItem()
+                        self._objetGraphique.prepareGeometryChange()
+                        self._objetGraphique.setPen(pinceau)
+                        self.plateau.addItem(self._objetGraphique)
+                    self._point2 = self.plateau.cases[coord].centreGraphique  
+                    rect = QRectF(QPointF(min(self._origine.x(), self._point2.x()), min(self._origine.y(), self._point2.y())), \
+                                  QPointF(max(self._origine.x(), self._point2.x()), max(self._origine.y(), self._point2.y()))  )
+                    self._objetGraphique.setRect(rect)
+
+                #on liste les cases intersectant la forme
+                select = self.casesSousForme(self._objetGraphique, (self._forme[-1:] == "P"))
+                
+                for coord in self._selection:
+                    if not coord in select:
+                        enMoins.append(coord)
+                    else:    
+                        select.remove(coord)
+                enPlus = select
+                
+            for coord in enPlus:
+                self.afficherCase(coord, True)
+                self._selection.append(coord)
+            for coord in enMoins:
+                self.afficherCase(coord, False)
+                self._selection.remove(coord)
             
     def annuler(self):
         self.reinit()
@@ -139,17 +150,19 @@ class Pinceau():
         return self._selection
 
     def reinit(self):
-        for coord in self_selection:
+        for coord in self._selection:
             self.afficherCase(coord, False)
-        self._origine = (-1, -1)
-        self._point2 = (-1, -1)
+        if self._objetGraphique:
+            self.plateau.removeItem(self._objetGraphique)
+            self._objetGraphique = None
+        self._origine = None
+        self._point2 = None
         self._selection = []
         self._actif = False
 
     def afficherCase(self, coord, actif):
         self.plateau.cases[coord].majEstCibleCurseur(actif)
 
-
     def selectionFrontiere(self):
         """retourne les cases selectionnees lors de l'utilisation de la forme 'frontiere'"""
         listeCases = []
@@ -157,7 +170,7 @@ class Pinceau():
             ligne = self._objetGraphique.line()
             normale = ligne.normalVector()
             normale = normale.unitVector()
-            coordOrigine = self.coordonneesAuPoint(self.modeParam["origineFormeDessin"])
+            coordOrigine = self.plateau.coordonneesAuPoint(self._origine)
             dx = normale.p2().x() - normale.p1().x()
             dy = normale.p2().y() - normale.p1().y()
             for coord in self.plateau.cases:
@@ -188,7 +201,7 @@ class Pinceau():
         return listeCases
 
 
-    def casesSousForme(self, forme, plein = True, epaisseur = 0):
+    def casesSousForme(self, forme, plein = True):
         """renvoie la liste des cases en collision avec un QGraphicsItem en parametre
             plein = False: pas le contenu de la forme
             epaisseur = renvoie aussi les cases voisines jusqu'a la distance demandee"""
@@ -207,31 +220,42 @@ class Pinceau():
             point1 = forme.boundingRect().topLeft()
             point2 = forme.boundingRect().bottomRight()            
  
-        #preselection des cases (meilleures perf)    
+        #preselection des cases (meilleures perf)
+        preSelection = []
         if point1 != None and point2 != None and point1 != point2:
-            preSelection = self.preSelectionCollision(point1, point2)
+            coord1 = self.plateau.coordonneesAuPoint(point1)  
+            coord2 = self.plateau.coordonneesAuPoint(point2)
+            if coord1 != None and coord2 != None:
+                minX = min(coord1[0], coord2[0]) - 1
+                maxX = max(coord1[0], coord2[0]) + 1
+                minY = min(coord1[1], coord2[1]) - 1
+                maxY = max(coord1[1], coord2[1]) + 1
+                for coord in self.plateau.cases:
+                    if coord[0] >= minX and coord[0] <= maxX and coord[1] >= minY and coord[1] <= maxY :
+                        preSelection.append(coord)
+            else:
+                preSelection = self.cases       
         else:
-            preSelection = []
-            for coord in self.cases:
+            for coord in self.plateau.cases:
                 preSelection.append(coord)
        
         #on liste les cases en collision avec la forme 
         for coord in preSelection:
-            if self.cases[coord].collidesWithItem(forme, Qt.IntersectsItemShape):
+            if self.plateau.cases[coord].collidesWithItem(forme, Qt.IntersectsItemShape):
                 if plein:
                     tmp.append(coord) 
                 else:
                     contenu = True
-                    for i in range(0,len(self.cases[coord].polygon())):
-                        if not forme.contains(self.cases[coord].polygon().at(i)):
+                    for i in range(0,len(self.plateau.cases[coord].polygon())):
+                        if not forme.contains(self.plateau.cases[coord].polygon().at(i)):
                             contenu = False
                             break
                     if contenu == False:
                          tmp.append(coord)    
         #on applique l'epaisseur du pinceau (lignes ou formes vides seulement) si necessaire
-        if not plein and epaisseur > 0:
+        if not plein and self._epaisseur > 0:
             for coord in tmp:
-                zone = self.zone(coord, epaisseur)
+                zone = self.plateau.zone(coord, self._epaisseur - 1)
                 for coord2 in zone:
                     if not coord2 in listeCases:
                         listeCases.append(coord2)
@@ -239,7 +263,7 @@ class Pinceau():
             listeCases = tmp
         #si la liste est vide, on ajoute l'origine de la forme
         if len(listeCases) == 0:
-            listeCases = [self.coordonneesAuPoint(point1)]    
+            listeCases = [self.plateau.coordonneesAuPoint(point1)]    
         return listeCases                
 
 

lib/Plateau.py

@@ -16,6 +16,7 @@ from Case import Case
 from Combattant import Combattant
 from Decor import Decor
 from Forme import Forme
+from Pinceau import Pinceau
 
 from Cache import Cache
 from EntreeSortie import EntreeSortie
@@ -82,7 +83,9 @@ class Plateau(QGraphicsScene):
             self.polygonesCaches[i] = None
         self.listeCasesZonePlacement = []
         self.polygoneZonePlacement = None
-        self.entreesSorties = []    
+        self.entreesSorties = []
+
+        self.pinceau = Pinceau(self)
             
         #infos combat
         self.numCombattantEnCours = 0
@@ -183,7 +186,6 @@ class Plateau(QGraphicsScene):
         peintre.end()
         img.scaledToHeight(128, Qt.FastTransformation)
         
-
     def connexions(self):
         """connecte le plateau aux differents widgets de la fenetre principale"""
         #modes d'interaction
@@ -601,7 +603,8 @@ class Plateau(QGraphicsScene):
     def majEpaisseurPinceau(self, epaisseur):
         """met a jour l'epaisseur du pinceau (en cases)"""
         self.fenetre.ui.cp_valeurEpaisseurPinceau.setText(QString.fromUtf8(str(epaisseur)))
-        self.epaisseurPinceau = int(epaisseur)
+##        self.epaisseurPinceau = int(epaisseur)
+        self.pinceau.majEpaisseur(int(epaisseur))
 
     def modeMajAltitudeCase(self):
         self.majMode("caseMajAltitude")
@@ -615,7 +618,8 @@ class Plateau(QGraphicsScene):
                   "cp_formeEllipsePlein": "ellipseP", \
                   "cp_formeRectVide": "rectV", \
                   "cp_formeRectPlein": "rectP"}
-        self.modeParam["typeFormeDessin"] = formes[str(self.sender().objectName())]
+##        self.modeParam["typeFormeDessin"] = formes[str(self.sender().objectName())]
+        self.pinceau.majForme(formes[str(self.sender().objectName())])
 
         if self.modeActif[0:7] != "caseMaj":    
             self.majMode("caseMajTerrain", self.modeParam["terrain"])
@@ -677,15 +681,15 @@ class Plateau(QGraphicsScene):
             self.modeParam["nbRotations"] = 0
                 
         if self.modeActif[0:7] == "caseMaj" or self.modeActif == "cachePlacer" or self.modeActif == "majZonePlacement":
-            if self.modeParam["formeDessin"] != None:
-                self.modeParam["formeDessin"].prepareGeometryChange()
-                self.removeItem(self.modeParam["formeDessin"])    
-            self.modeParam["formeDessin"] = None
-            self.modeParam["origineFormeDessin"] = None
-            self.modeParam["point2FormeDessin"] = None
-            
-            self.afficherListeCases(self.modeParam["listeCasesFormeDessin"], False)
-            self.modeParam["listeCasesFormeDessin"] = []
+##            if self.modeParam["formeDessin"] != None:
+##                self.modeParam["formeDessin"].prepareGeometryChange()
+##                self.removeItem(self.modeParam["formeDessin"])    
+##            self.modeParam["formeDessin"] = None
+##            self.modeParam["origineFormeDessin"] = None
+##            self.modeParam["point2FormeDessin"] = None
+            self.pinceau.reinit()
+##            self.afficherListeCases(self.modeParam["listeCasesFormeDessin"], False)
+##            self.modeParam["listeCasesFormeDessin"] = []
 
         if self.modeActif == "placementEntreeSortie":            
             if self.modeParam["entreeSortie"] != None:
@@ -702,7 +706,7 @@ class Plateau(QGraphicsScene):
                 if param != None:
                     self.curseurPinceau()
                     self.fenetre.ui.cbt_vue.setDragMode(0)
-                    self.modeParam["terrain"] = param                
+                    self.modeParam["terrain"] = param
                     
             elif mode == "caseCopie":
                 #curseur seringue, on 'preleve' le terrain sur la case cliquee, avant de passer en mode majTerrain
@@ -793,6 +797,7 @@ class Plateau(QGraphicsScene):
         if reinit:
             #mode standard : pas d'interaction avec les cases, on deplace le plateau en le saisissant ou les pions en cliquant dessus
             self.modeActif = "standard"
+
             self.majAffichagePionSelectionne()
             self.majInfosPion()
             self.majInfosDecor()
@@ -1313,77 +1318,77 @@ class Plateau(QGraphicsScene):
                         break       
         return coord            
 
-    def creerOrigineFormeDessin(self, coord):
-        """place le point d'origine de la forme de selection"""
-        self.modeParam["listeCasesFormeDessin"] = []
-        self.modeParam["origineFormeDessin"] = self.cases[coord].centreGraphique
-        self.modeParam["point2FormeDessin"] = self.cases[coord].centreGraphique
-        self.modeParam["listeCasesFormeDessin"] = [coord]
-        self.afficherListeCases(self.modeParam["listeCasesFormeDessin"], True)
-        
-    def majFormeDessin(self):
-        """cree/maj la forme utilisee pour selectionner les cases et met a jour la liste des cases selectionnes"""
-        self.afficherListeCases(self.modeParam["listeCasesFormeDessin"], False)
-        
-        pinceau = QPen()
-        pinceau.setColor(QColor("black"))
-        point2 = self.modeParam["point2FormeDessin"]
-        
-        if self.modeParam["typeFormeDessin"] == "simple":
-            #pas de forme: on ajoute les cases survolees a la liste des cases
-            coordPoint2 = self.coordonneesAuPoint(point2)
-            zone = self.zone(coordPoint2, self.epaisseurPinceau-1)
-            for coord in zone:
-                if not coord in self.modeParam["listeCasesFormeDessin"]:
-                    self.modeParam["listeCasesFormeDessin"].append(coord)
-
-        elif self.modeParam["typeFormeDessin"] == "frontiere":
-            #droite qui selectionne toutes les cases situees au dessus d'elle
-            if self.modeParam["formeDessin"] == None:
-                self.modeParam["formeDessin"] = QGraphicsLineItem()
-                self.modeParam["formeDessin"].setPen(pinceau)
-                self.addItem(self.modeParam["formeDessin"])    
-            ligne = QLineF(self.modeParam["origineFormeDessin"], point2)
-            orientation = int((1+int(ligne.angle()/22.5))/2)
-            ligne.setAngle(orientation*45)
-            self.modeParam["formeDessin"].setLine(ligne)
-            self.modeParam["listeCasesFormeDessin"] = self.selectionFrontiere()
-
-        else:    
-            if self.modeParam["typeFormeDessin"] == "ligne":
-                #segment simple
-                if self.modeParam["formeDessin"] == None:
-                    self.modeParam["formeDessin"] = QGraphicsLineItem()
-                    self.modeParam["formeDessin"].setPen(pinceau)
-                    self.modeParam["formeDessin"].prepareGeometryChange()
-                    self.addItem(self.modeParam["formeDessin"])
-                ligne = QLineF(self.modeParam["origineFormeDessin"], point2)
-                self.modeParam["formeDessin"].setLine(ligne)
-            
-            elif self.modeParam["typeFormeDessin"] == "rectV" or self.modeParam["typeFormeDessin"] == "rectP":
-                #rectangle
-                if self.modeParam["formeDessin"] == None:
-                    self.modeParam["formeDessin"] = QGraphicsRectItem()
-                    self.modeParam["formeDessin"].prepareGeometryChange()
-                    self.modeParam["formeDessin"].setPen(pinceau)
-                    self.addItem(self.modeParam["formeDessin"])
-                rect = self.rectFormeDessin(self.modeParam["origineFormeDessin"], point2)
-                self.modeParam["formeDessin"].setRect(rect)
-            
-            elif self.modeParam["typeFormeDessin"] == "ellipseV" or self.modeParam["typeFormeDessin"] == "ellipseP":
-                #ellipse
-                if self.modeParam["formeDessin"] == None:
-                    self.modeParam["formeDessin"] = QGraphicsEllipseItem()
-                    self.modeParam["formeDessin"].prepareGeometryChange()
-                    self.modeParam["formeDessin"].setPen(pinceau)
-                    self.addItem(self.modeParam["formeDessin"])
-                rect = self.rectFormeDessin(self.modeParam["origineFormeDessin"], point2)
-                self.modeParam["formeDessin"].setRect(rect)
-
-            #on liste les cases intersectant la forme
-            plein = (self.modeParam["typeFormeDessin"][len(self.modeParam["typeFormeDessin"])-1:] == "P")
-            self.modeParam["listeCasesFormeDessin"] = self.casesSousForme(self.modeParam["formeDessin"], plein, self.epaisseurPinceau - 1)
-        self.afficherListeCases(self.modeParam["listeCasesFormeDessin"], True)
+##    def creerOrigineFormeDessin(self, coord):
+##        """place le point d'origine de la forme de selection"""
+##        self.modeParam["listeCasesFormeDessin"] = []
+##        self.modeParam["origineFormeDessin"] = self.cases[coord].centreGraphique
+##        self.modeParam["point2FormeDessin"] = self.cases[coord].centreGraphique
+##        self.modeParam["listeCasesFormeDessin"] = [coord]
+##        self.afficherListeCases(self.modeParam["listeCasesFormeDessin"], True)
+##        
+##    def majFormeDessin(self):
+##        """cree/maj la forme utilisee pour selectionner les cases et met a jour la liste des cases selectionnes"""
+##        self.afficherListeCases(self.modeParam["listeCasesFormeDessin"], False)
+##        
+##        pinceau = QPen()
+##        pinceau.setColor(QColor("black"))
+##        point2 = self.modeParam["point2FormeDessin"]
+##        
+##        if self.modeParam["typeFormeDessin"] == "simple":
+##            #pas de forme: on ajoute les cases survolees a la liste des cases
+##            coordPoint2 = self.coordonneesAuPoint(point2)
+##            zone = self.zone(coordPoint2, self.epaisseurPinceau-1)
+##            for coord in zone:
+##                if not coord in self.modeParam["listeCasesFormeDessin"]:
+##                    self.modeParam["listeCasesFormeDessin"].append(coord)
+##
+##        elif self.modeParam["typeFormeDessin"] == "frontiere":
+##            #droite qui selectionne toutes les cases situees au dessus d'elle
+##            if self.modeParam["formeDessin"] == None:
+##                self.modeParam["formeDessin"] = QGraphicsLineItem()
+##                self.modeParam["formeDessin"].setPen(pinceau)
+##                self.addItem(self.modeParam["formeDessin"])    
+##            ligne = QLineF(self.modeParam["origineFormeDessin"], point2)
+##            orientation = int((1+int(ligne.angle()/22.5))/2)
+##            ligne.setAngle(orientation*45)
+##            self.modeParam["formeDessin"].setLine(ligne)
+##            self.modeParam["listeCasesFormeDessin"] = self.selectionFrontiere()
+##
+##        else:    
+##            if self.modeParam["typeFormeDessin"] == "ligne":
+##                #segment simple
+##                if self.modeParam["formeDessin"] == None:
+##                    self.modeParam["formeDessin"] = QGraphicsLineItem()
+##                    self.modeParam["formeDessin"].setPen(pinceau)
+##                    self.modeParam["formeDessin"].prepareGeometryChange()
+##                    self.addItem(self.modeParam["formeDessin"])
+##                ligne = QLineF(self.modeParam["origineFormeDessin"], point2)
+##                self.modeParam["formeDessin"].setLine(ligne)
+##            
+##            elif self.modeParam["typeFormeDessin"] == "rectV" or self.modeParam["typeFormeDessin"] == "rectP":
+##                #rectangle
+##                if self.modeParam["formeDessin"] == None:
+##                    self.modeParam["formeDessin"] = QGraphicsRectItem()
+##                    self.modeParam["formeDessin"].prepareGeometryChange()
+##                    self.modeParam["formeDessin"].setPen(pinceau)
+##                    self.addItem(self.modeParam["formeDessin"])
+##                rect = self.rectFormeDessin(self.modeParam["origineFormeDessin"], point2)
+##                self.modeParam["formeDessin"].setRect(rect)
+##            
+##            elif self.modeParam["typeFormeDessin"] == "ellipseV" or self.modeParam["typeFormeDessin"] == "ellipseP":
+##                #ellipse
+##                if self.modeParam["formeDessin"] == None:
+##                    self.modeParam["formeDessin"] = QGraphicsEllipseItem()
+##                    self.modeParam["formeDessin"].prepareGeometryChange()
+##                    self.modeParam["formeDessin"].setPen(pinceau)
+##                    self.addItem(self.modeParam["formeDessin"])
+##                rect = self.rectFormeDessin(self.modeParam["origineFormeDessin"], point2)
+##                self.modeParam["formeDessin"].setRect(rect)
+##
+##            #on liste les cases intersectant la forme
+##            plein = (self.modeParam["typeFormeDessin"][len(self.modeParam["typeFormeDessin"])-1:] == "P")
+##            self.modeParam["listeCasesFormeDessin"] = self.casesSousForme(self.modeParam["formeDessin"], plein, self.epaisseurPinceau - 1)
+##        self.afficherListeCases(self.modeParam["listeCasesFormeDessin"], True)
 
     def casesSousForme(self, forme, plein = True, epaisseur = 0):
         """renvoie la liste des cases en collision avec un QGraphicsItem en parametre
@@ -1493,19 +1498,19 @@ class Plateau(QGraphicsScene):
                     listeCases.append(coord)
         return listeCases
         
-    def validerFormeDessin(self):
-        """la projection des cases a peindre a ete acceptee, on peint ces cases"""
-        if self.modeActif[0:7] == "caseMaj" or self.modeActif == "caseCopie" or self.modeActif == "cachePlacer" or self.modeActif == "majZonePlacement":
-            self.majListeCases(self.modeParam["listeCasesFormeDessin"])
-        self.majMode(self.modeActif)  
+##    def validerFormeDessin(self):
+##        """la projection des cases a peindre a ete acceptee, on peint ces cases"""
+##        if self.modeActif[0:7] == "caseMaj" or self.modeActif == "caseCopie" or self.modeActif == "cachePlacer" or self.modeActif == "majZonePlacement":
+##            self.majListeCases(self.modeParam["listeCasesFormeDessin"])
+##        self.majMode(self.modeActif)  
             
-    def rectFormeDessin(self, point1, point2):
-        """retourne le rectangle repesentant la forme de selection
-           determine pour ce faire les points A et B, cad le point haut-droit et le point bas-gauche"""
-        pointA = QPointF(min(point1.x(), point2.x()), min(point1.y(), point2.y()))
-        pointB = QPointF(max(point1.x(), point2.x()), max(point1.y(), point2.y()))             
-        rect = QRectF(pointA, pointB)
-        return rect
+##    def rectFormeDessin(self, point1, point2):
+##        """retourne le rectangle repesentant la forme de selection
+##           determine pour ce faire les points A et B, cad le point haut-droit et le point bas-gauche"""
+##        pointA = QPointF(min(point1.x(), point2.x()), min(point1.y(), point2.y()))
+##        pointB = QPointF(max(point1.x(), point2.x()), max(point1.y(), point2.y()))             
+##        rect = QRectF(pointA, pointB)
+##        return rect
 
     def majLigneMireAttaqueDist(self, coordCible = None):
         """met a jour la ligne de mire representant l'attaque a distance"""
@@ -1841,7 +1846,8 @@ class Plateau(QGraphicsScene):
                      accepte = True
                  
             elif self.modeActif[0:7] == "caseMaj" or self.modeActif == "cachePlacer" or self.modeActif == "majZonePlacement":
-                self.creerOrigineFormeDessin(coord)
+                self.pinceau.demarrer((x, y))
+##                self.creerOrigineFormeDessin(coord)
                 accepte = True
                 
             elif self.modeActif == "pionDecorSelectionne":
@@ -1883,15 +1889,20 @@ class Plateau(QGraphicsScene):
     def caseSurvolClicEnfonce(self, coordCase):
         """une case est survolee par le curseur (le clic gauche est enfonce)"""
         if self.modeActif[0:7] == "caseMaj" or self.modeActif == "cachePlacer" or self.modeActif == "majZonePlacement":
-            if self.cases[coordCase].centreGraphique != self.modeParam["point2FormeDessin"]:
-                if self.modeParam["origineFormeDessin"] == None: self.modeParam["origineFormeDessin"] = self.cases[coordCase].centreGraphique
-                self.modeParam["point2FormeDessin"] = self.cases[coordCase].centreGraphique
-                self.majFormeDessin()
+            self.pinceau.maj(coordCase)
+##            if self.cases[coordCase].centreGraphique != self.modeParam["point2FormeDessin"]:
+##                if self.modeParam["origineFormeDessin"] == None: self.modeParam["origineFormeDessin"] = self.cases[coordCase].centreGraphique
+##                self.modeParam["point2FormeDessin"] = self.cases[coordCase].centreGraphique
+##                self.majFormeDessin()
 
     def clicGaucheRelache(self):
-       """si une forme de selection etait affichee, elle est validee""" 
-       if len(self.modeParam["listeCasesFormeDessin"]) > 0:
-            self.validerFormeDessin()
+        """si une forme de selection etait affichee, elle est validee""" 
+        if self.pinceau.estActif():
+            if len(self.pinceau.selection()) > 0:
+                self.majListeCases(self.pinceau.selection())
+                self.pinceau.reinit()
+            #on reinit le mode
+            self.majMode(self.modeActif)
 
     def caseSurvol(self, x, y):
         """une case est survole par le curseur, on affiche ses informations dans la zone prevue"""