dmonde/lib/Pinceau.py

"""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):
        self.plateau = plateau

        self._forme = "simple"
        self._epaisseur = 1
        self._formeVerrouillee = False
        
        self._origine = None
        self._point2 = None
        self._selection = []

        self._objetGraphique = None

        self._actif = False

    def estActif(self):
        return self._actif

    def majForme(self, forme):
        if forme in ["simple", "ligne", "frontiere", "pot", \
                     "rectV", "rectP", "ellipseV", "ellipseP"] and not self._formeVerrouillee:
            self._forme = forme

    def verrouillerForme(self, actif):
        self._formeVerrouillee = True

    def majEpaisseur(self, val):
        if val in range(1, 5):
            self._epaisseur = val

    def defOrigine(self, coord):
        if self.plateau.coordonneesValides(coord):
            self._origine = self.plateau.cases[coord].centreGraphique

    def defPoint2(self, coord):
        if self.plateau.coordonneesValides(coord):
            self._point2 = self.plateau.cases[coord].centreGraphique

    def selection(self):
        return self._selection

    def demarrer(self, coord):
        """commence a peindre a partir de la case choisie comme origine"""
        self._formeVerrouillee = False
        if self.plateau.coordonneesValides(coord):
            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"""
        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"))
                    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)
                    else:    
                        select.remove(coord)
                enPlus = select   #toutes les coord qui restent dans select sont a ajouter

            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.plateau.casesSousForme(self._objetGraphique, (self._forme[-1:] == "P"), self._epaisseur - 1)
                
                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 reinit(self): 
        for coord in self._selection:
            self.afficherCase(coord, False)
        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 = []
        if self._objetGraphique != None:
            ligne = self._objetGraphique.line()
            normale = ligne.normalVector()
            normale = normale.unitVector()
            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:
                if dx < 0 and dy == 0:  #normale pointe vers la gauche
                    if (coord[0] - coordOrigine[0]) <= 0:
                        listeCases.append(coord)
                if dx > 0 and dy == 0:  #normale pointe vers la droite
                    if (coord[0]  - coordOrigine[0]) >= 0:
                        listeCases.append(coord)   
                if dx == 0 and dy < 0:  #pointe vers le haut (rappel: axe y vers le bas)
                    if (coord[1] - coordOrigine[1]) <= 0:
                        listeCases.append(coord)
                elif dx == 0 and dy > 0:  #pointe vers le bas
                    if (coord[1] - coordOrigine[1]) >= 0:
                        listeCases.append(coord)
                if dx > 0 and dy < 0:  #pointe vers le haut droite
                    if (coord[0] - coordOrigine[0]) + -1*(coord[1] - coordOrigine[1]) >= 0:
                        listeCases.append(coord)
                elif dx > 0 and dy > 0:  #pointe vers le bas droite
                    if -1*(coord[0] - coordOrigine[0]) + -1*(coord[1] - coordOrigine[1]) <= 0:
                        listeCases.append(coord)
                if dx < 0 and dy < 0:  #pointe vers le haut gauche
                    if (coord[0] - coordOrigine[0]) + (coord[1] - coordOrigine[1]) <= 0:
                        listeCases.append(coord)
                elif dx < 0 and dy > 0:  #pointe vers le bas gauche
                    if -1*(coord[0] - coordOrigine[0]) + (coord[1] - coordOrigine[1]) >= 0:
                        listeCases.append(coord)
        return listeCases