dmonde/lib/gM.py

'''gestion des materiels pour le plateau'''
from PyQt4.QtCore import SIGNAL, Qt

from lib.EcranEditionMateriel import EcranEditionMateriel, nouveauCombattant, nouveauDecor
from lib.EcranEditionTerrain import EcranEditionTerrain
from lib.explorateurMat import importerMateriel
from lib.mat import chargerMat


class GestionMateriel(object):
    '''gestion du materiel'''
    def __init__(self):
        self._m = []    #liste des idM des materiels utilisees par le plateau

    def __getstate__(self):
        state = {key:value for key, value in self.__dict__.items() if not key in ["prog"]}
        return (state)

    def __setstate__(self, state):
        self.__dict__ = state

    def initialiser(self, prog):
        """charge les tables de materiel avec les mat enregistres"""
        self.prog = prog
        for typMat in ["tr", "dc", "cb"]:
            self.table(typMat).charger(self.chargerMateriels(typMat))
            
        self.prog.connect(self.prog.ui.cp_importTerrain, SIGNAL("clicked()"), self.importerTr, Qt.UniqueConnection)
        self.prog.connect(self.prog.ui.cp_importDecor, SIGNAL("clicked()"), self.importerDc, Qt.UniqueConnection)
        self.prog.connect(self.prog.ui.cp_importCombattant, SIGNAL("clicked()"), self.importerCb, Qt.UniqueConnection)
        
        self.prog.connect(self.prog.ui.cp_editerTerrain, SIGNAL("clicked()"), self.terrainEdit, Qt.UniqueConnection)
        self.prog.connect(self.prog.ui.cp_nouveauTerrain, SIGNAL("clicked()"), self.terrainNouveau, Qt.UniqueConnection)
        self.prog.connect(self.prog.ui.cp_retirerTerrain, SIGNAL("clicked()"), self.terrainRetirer, Qt.UniqueConnection)
        
        self.prog.connect(self.prog.ui.cp_editerCombattant, SIGNAL("clicked()"), self.creatureEdit, Qt.UniqueConnection)
        self.prog.connect(self.prog.ui.cp_nouveauCombattant, SIGNAL("clicked()"), self.creatureNouveau, Qt.UniqueConnection)
        self.prog.connect(self.prog.ui.cp_retirerCombattant, SIGNAL("clicked()"), self.creatureRetirer, Qt.UniqueConnection)
        
        self.prog.connect(self.prog.ui.cp_editerDecor, SIGNAL("clicked()"), self.decorEdit, Qt.UniqueConnection)
        self.prog.connect(self.prog.ui.cp_nouveauDecor, SIGNAL("clicked()"), self.decorNouveau, Qt.UniqueConnection)
        self.prog.connect(self.prog.ui.cp_retirerDecor, SIGNAL("clicked()"), self.decorRetirer, Qt.UniqueConnection)

    def vider(self):
        pass
       
    def ajouterMat(self, idR):
        if not idR in self._m: self._m.append(idR)
    
    def materiels(self, filtre=""):     
        return [m for m in self._m if (m[:2] == filtre or len(filtre) == 0)]

    def chargerMateriels(self, filtre = ""):
        listeMat = []
        for idM in self.materiels(filtre):
            listeMat.append(chargerMat(idM))     
        return listeMat   

    def table(self, typ):
        """renvoie le nom de la table correspondant au type de mat demande"""
        tables = {"tr": self.prog.ui.cp_listeTerrains, \
                  "dc": self.prog.ui.cp_listeDecors, \
                  "cb":self.prog.ui.cp_listeCreatures}
        return tables[typ]


    def reinitModePlateau(self):
        """ramene le mode du plateau au mode creation standard"""
        if self.prog.plateau:
            self.prog.plateau.plateauModeCreation()

    def importerTr(self):
        self.importer(0)
        
    def importerDc(self):
        self.importer(1)
        
    def importerCb(self):
        self.importer(2)

    def importer(self, ongletInit = 0):
        listeMat = importerMateriel(ongletInit)
        for idMat in listeMat:
            self.ajouterMat(idMat)
        
        self.majTables()
    
    def majTables(self):
        self.majListeTerrains()
        self.majListeDecors()
        self.majListeCreatures()
                 
    ### TERRAINS
    
    def majListeTerrains(self):
        """mise a jour de la liste des terrains depuis la sauvegarde"""
        self.prog.ui.cp_listeTerrains.vider()
        self.prog.ui.cp_listeTerrains.charger(self.chargerMateriels("tr"))
    
    def terrainEdit(self):
        """ouvre la fenetre 'terrains' en mode edition"""
        mat = chargerMat(self.prog.ui.cp_listeTerrains.selection())
        self.afficheEcranEditionTerrains(mat)
        self.reinitModePlateau()
        
    def terrainNouveau(self):
        """ouvre la fenetre 'terrains' en mode edition"""
        self.afficheEcranEditionTerrains()
        self.reinitModePlateau()
        
    def afficheEcranEditionTerrains(self, terrain = None):
        """affiche l'ecran d'edition/creation de terrains"""
        fen = EcranEditionTerrain(terrain)     
        r = fen.exec_()
        if r == 1:
            terrain = fen.terrain
            if terrain: terrain.enregistrer()
            self.ajouterMat(terrain.idM())
            self.majListeTerrains()
            self.reinitModePlateau()
        del fen
        
    def terrainRetirer(self):
        """retire le terrain selectionne de la table"""
        idM = self.prog.ui.cp_listeTerrains.selection()
        if idM:
            self._m.remove(idM)
            self.majListeTerrains()
            
    ### CREATURES    
    def majListeCreatures(self):
        """mise a jour de la liste des creatures depuis la sauvegarde"""
        self.prog.ui.cp_listeCreatures.vider()
        self.prog.ui.cp_listeCreatures.charger(self.chargerMateriels("cb"))

    def creatureEdit(self):
        """ouvre la fenetre 'creatures' en mode edition"""
        mat = chargerMat(self.prog.ui.cp_listeCreatures.selection())
        self.afficheEcranEditionCombattants(mat)
        self.reinitModePlateau()
        
    def creatureNouveau(self):
        """ouvre la fenetre 'creatures' en mode edition"""
        combattant = nouveauCombattant()
        self.afficheEcranEditionCombattants(combattant)
        self.reinitModePlateau()
        
    def afficheEcranEditionCombattants(self, combattant):
        """affiche l'ecran d'edition/creation de creatures"""
        fen = EcranEditionMateriel(combattant)
        fen.afficher()
        r = fen.exec_()
        if r == 1:
            combattant = fen.mat()
            if combattant: combattant.enregistrer()
            self.ajouterMat(combattant.idM())
            self.majListeCreatures()
            self.reinitModePlateau()
        del fen

    def creatureRetirer(self):
        """retire la creature selectionne de la table"""
        idM = self.prog.ui.cp_listeCreatures.selection()
        if idM:
            self._m.remove(idM)
            self.majListeCreatures()
        
    ### DECORS 
    def majListeDecors(self):
        """mise a jour de la liste des decors depuis la sauvegarde"""   
        self.prog.ui.cp_listeDecors.vider()
        self.prog.ui.cp_listeDecors.charger(self.chargerMateriels("dc"))  
         
    def decorEdit(self):
        """ouvre la fenetre 'decors' en mode edition"""
        mat = chargerMat(self.prog.ui.cp_listeDecors.selection())
        self.afficheEcranEditionDecors(mat)
        self.reinitModePlateau()
        
    def decorNouveau(self):
        """ouvre la fenetre 'decors' en mode edition"""
        decor = nouveauDecor()
        self.afficheEcranEditionDecors(decor)
        self.reinitModePlateau()
        
    def afficheEcranEditionDecors(self, decor):
        """affiche l'ecran d'edition/creation de decors"""
        fen = EcranEditionMateriel(decor)
        fen.afficher()
        r = fen.exec_()
        if r == 1:
            decor = fen.mat()
            if decor: decor.enregistrer()
            self.ajouterMat(decor.idM())
            self.majListeDecors()
            self.reinitModePlateau()
        del fen
            
    def decorRetirer(self):
        """retire le decor selectionne de la table"""
        idM = self.prog.ui.cp_listeDecors.selection()
        if idM:
            self._m.remove(idM)
            self.majListeDecors()