dmonde/lib/Modes.py

"""modes d'interaction avec le plateau"""
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from EntreeSortie import EntreeSortie

class ModeBase(object):
    """mode de base: tous les modes heritent de cette classe"""
    def __init__(self, plateau):
        self.plateau = plateau
        #le mode est il active
        self._actif = False
        #le dragmode est il active sur la QGraphicsView
        self._activerDragMode = 0
        #curseur de la QGraphicsView
        self._sourceCurseur = ""
        #met le focus sur la QGraphicsView a l'activation
        self._focus = False 

    def activer(self, param = None):
        """active le mode"""
        self.activerCurseur()
        if self._focus:
            self.plateau.fenetre.ui.cbt_vue.setFocus()
        self._actif = True    

    def desactiver(self):
        """desactive le mode"""
        self.desactiverCurseur()
        self.plateau.fenetre.ui.cbt_vue.setDragMode(1)
        self._actif = False

    def reinit(self):
        """remet les variables a 0 et reactive le mode"""
        pass

    def activerCurseur(self):
        self.plateau.fenetre.ui.cbt_vue.setDragMode(self._activerDragMode)
        curseurPix = QPixmap(self._sourceCurseur)
        curseurPinceau = QCursor(curseurPix, 0, curseurPix.height())
        self.plateau.fenetre.ui.cbt_vue.setCursor(curseurPinceau)

    def desactiverCurseur(self):
        self.plateau.fenetre.ui.cbt_vue.setCursor(QCursor(Qt.ArrowCursor))

    ### gestion des evenements souris
    # clic gauche
    def clic_combattant(self, num):
        pass

    def clic_decor(self, num):
        pass

    def clic_case(self, coord):
        pass

    #double clic gauche
    def doubleClic_combattant(self, num):
        pass

    def doubleClic_decor(self, num):
        pass

    def doubleClic_case(self, coord):
        pass

    #survol de la souris (entree)   
    def survol_combattant(self, num):
        pass

    def survol_decor(self, num):
        pass

    def survol_case(self, coord):
        pass

    #survol de la souris (sortie)  
    def finSurvol_combattant(self, num):
        pass

    def finSurvol_decor(self, num):
        pass

    def finSurvol_case(self, coord):
        pass

    #survol de la souris avec clic gauche enfonce (entree)   
    def survolClic_combattant(self, event):
        pass

    def survolClic_decor(self, event):
        pass

    def survolClic_case(self, coord):
        pass

    #autre
    def clicGauche(self, event):
        pass

    def finClicGauche(self, event):
        pass
    
    def mouvementSouris(self, event):
        pass
    
    def toucheClavier(self, event):
        pass
  

### --------------------------------------- ####


class Standard(ModeBase):
    """mode standard"""
    def __init__(self, plateau):
        super(Standard, self).__init__(plateau)
        self._sourceCurseur = ""
        self._focus = False
        self.activerDragMode = True

    def clic_pion(self, num):
        pass
        #doit selectionner le pion

class MajCases(ModeBase):
    """mode de mise a jour des cases (terrain, couleur, effet special)"""
    def __init__(self, plateau):
        super(MajCases, self).__init__(plateau)
        self._sourceCurseur = "img\\curseurPinceau.png"
        self._focus = True
        self._param = None   #parametre avec lequel on mettra a jour la case

    def activer(self, param):
        """active le mode"""
        self.majParam(param)
        super(MajCases, self).activer()

    def desactiver(self):
        """desactive le mode"""
        self.plateau.pinceau.reinit()
        super(MajCases, self).desactiver()

    def majParam(self, param):
        self._param = param

    def param(self):
        return self._param

    def clic_case(self, coord):
        #demarre une operation de peinture des cases
        self.plateau.pinceau.demarrer(coord)

    def survolClic_case(self, coord):
        self.plateau.pinceau.maj(coord)

    def finClicGauche(self, event):
        if self.plateau.pinceau.estActif():
            for coord in self.plateau.pinceau.selection():
                if self._param.__class__.__name__ == "Terrain":
                    self.plateau.cases[coord].majTerrain(self._param)
                elif self._param.__class__.__name__ == "QColor":
                    if self._param.isValid():
                         self.plateau.cases[coord].majTerrain(None)
                         self.plateau.cases[coord].majCouleur(self._param)
                elif self._param.__class__.__name__ == "EffetCase":
                    self.plateau.cases[coord].majEffet(self._param)
                self.plateau.pinceau.reinit()
            self.reinit()

    def toucheClavier(self, event):
        if event.key() == Qt.Key_Up:
            self.plateau.fenetre.ui.epaisseurPinceau.setValue(self.plateau.fenetre.ui.epaisseurPinceau.value()+1)
        elif event.key() == Qt.Key_Down:
            self.plateau.fenetre.ui.epaisseurPinceau.setValue(self.plateau.fenetre.ui.epaisseurPinceau.value()-1)

class Pipette(ModeBase):
    """mode pipette: on preleve la couleur ou le terrain d'une case"""
    def __init__(self, plateau):
        super(ZonePlacement, self).__init__(plateau)
        self._sourceCurseur = "img\\curseurSeringue.png"

    def activerCurseur(self):
        super(Pipette, self).activerCurseur()
        
    def clic_case(self, coord):
        if len(case.terrain.nom) > 0:
             param = case.terrain
        else:
             param = case.couleur
        self.plateau.activerMode(Modes.CaseMaj, param)     
             

class ZonePlacement(ModeBase):
    """mode de definition de la/les zones de placement des joueurs"""
    def __init__(self, plateau):
        super(ZonePlacement, self).__init__(plateau)
        self._sourceCurseur = "img\\curseurPinceau.png"
        self._focus = True

    def activerCurseur(self):
        super(ZonePlacement, self).activerCurseur()

    def activer(self, param = None):
        self.plateau.pinceau.majForme("rectP")
        self.plateau.pinceau.verrouillerForme(True)
        super(ZonePlacement, self).activer()

    def desactiver(self):
        self.plateau.pinceau.reinit()
        super(ZonePlacement, self).desactiver()

    def clic_case(self, coord):
        #demarre une operation de peinture des cases
        self.plateau.pinceau.demarrer(coord)
        
    def survolClic_case(self, coord):
        self.plateau.pinceau.maj(coord)
    
    def finClicGauche(self, coord):
        if self.plateau.pinceau.estActif():
            if len(self.plateau.pinceau.selection()) > 0:
                self.plateau.majZonePlacement(self.plateau.pinceau.selection())
                

class EntreesSorties(ModeBase):
    """mode de definition deentrees et sorties du plateau"""
    def __init__(self, plateau):
        super(EntreesSorties, self).__init__(plateau)
        self._sourceCurseur = "img\\curseurPinceau.png"
        self._focus = True

    def activerCurseur(self):
        super(EntreesSorties, self).activerCurseur()

    def activer(self, param):
        self.es = param
        self.es.creerForme()
        super(EntreesSorties, self).activer()

    def desactiver(self):
        if not self.es.estPositionne:
            self.es.prepareGeometryChange()
            self.es.plateau = None
            self.plateau.removeItem(self.es)
        super(EntreesSorties, self).desactiver()
        
    def mouvementSouris(self, event):
        if event.buttons() != Qt.LeftButton:
            if not self.es.estPositionne:
                self.es.majProjection(event.scenePos())

    def clicGauche(self, event):
        if not event.isAccepted():
            self.es.positionner()
            self.plateau.entreesSorties.append(self.es)
            self.desactiver()

    def toucheClavier(self, event):
        if event.key() == Qt.Key_Delete:
            self.desactiver()
        elif event.key() == Qt.Key_Right:
            self.es.nbRotations += 1
            self.es.majProjection()   
        elif event.key() == Qt.Key_Left:
            self.es.nbRotations -= 1
            self.es.majProjection()