dmonde/lib/explorateurMat.py

# -*- coding: utf-8 -*-
'''
Fenetre d'exploration des materiels du jeu

'''
from os.path import os

from PyQt4.QtCore import SIGNAL, QString, Qt
from PyQt4.QtGui import QDialog, QFrame, QColor, QPalette, QApplication

from lib.EcranEditionCombattant import EcranEditionCombattant
from lib.EcranEditionDecor import EcranEditionDecor
from lib.EcranEditionTerrain import EcranEditionTerrain
from lib.commun import rep, charger, Session
from lib.dialogues import dmConfirmer
from lib.mat import supprimerMat
from ui.ecran_explorateurMat import Ui_exm_fenetre
from ui.panneauMateriel import Ui_pem_panneau

def importerMateriel(ongletInit = 0):
    expl = ExplorateurMateriel(ongletInit)
    expl.charger()
    expl.exec_()
    listeMat = expl.selection()
    del expl    
    return listeMat

class ExplorateurMateriel(QDialog):
    def __init__(self, ongletInit = 0, parent=None):
        """initialisation de la fenetre"""
        super (ExplorateurMateriel, self).__init__(parent)
        self.createWidgets()
        self._selection = []
        self.ui.exm_onglets.setCurrentIndex(ongletInit)

    def createWidgets(self):
        """construction de l'interface"""
        self.ui = Ui_exm_fenetre()
        self.ui.setupUi(self)
        self.connect(self.ui.exm_ok, SIGNAL("clicked()"), self.valider)
        self.connect(self.ui.exm_annuler, SIGNAL("clicked()"), self.annuler)
        self.connect(self.ui.exm_filtreNom, SIGNAL("textEdited(QString)"), self.majFiltre)
        self.initLayout()

    def layout(self, typMat):
        dico = {"tr" : self.ui.exm_layout_tr, \
                "cb" : self.ui.exm_layout_cb, \
                "dc" : self.ui.exm_layout_dc}
        return dico[typMat]
    
    def charger(self):
        """charge les images disponibles dans l'explorateur"""
        listeMat = []
        for attributsFichier in os.walk(rep("jeu")):
            for f in attributsFichier[2]:
                if os.path.splitext(f)[1] == ".dm":
                    mat = charger(os.path.join(rep("jeu"), f))       
                    listeMat.append(mat)
        listeMat.sort(key=lambda x: x.nom)
        for mat in listeMat:
            self.ajouterMat(mat)
            
    def ajouterMat(self, mat):
        """ajoute un panneau materiel a la liste deroulante correspondante"""
        panneau = PanneauMateriel(self)
        panneau.chargerMat(mat)
        self.layout(mat.idM()[:2]).addWidget(panneau)

    def selection(self):
        return self._selection

    def majSelection(self, idMat):
        if idMat in self._selection:
            self._selection.remove(idMat)
        else:
            self._selection.append(idMat)
        self.majAffichage()

    def majAffichage(self):
        self.ui.exm_ok.setEnabled((len(self._selection) > 0))
        self.ui.exm_ok.setText(QString("Importer ({})".format(len(self._selection))))

    def retirerPanneau(self, panneau):
        idM = panneau.mat().idM()
        if idM in self._selection: self._selection.remove(idM)
        layout = self.layout(idM[:2])
        layout.removeWidget(panneau)
        panneau.setParent(None)
        layout.update()

    def majFiltre(self):
        filtreNom = self.ui.exm_filtreNom.text()
        self.emit(SIGNAL("majFiltre(QString)"), filtreNom)

    def initLayout(self):
        for layout in [self.ui.exm_layout_tr, self.ui.exm_layout_cb, self.ui.exm_layout_dc]:
            layout.setColumnMinimumWidth(0, 140)
            layout.setColumnStretch(0, 1)
            layout.setColumnMinimumWidth(1, 140)
            layout.setColumnStretch(1, 1)
            layout.setColumnMinimumWidth(2, 140)
            layout.setColumnStretch(2, 1)
            layout.setAlignment(Qt.AlignLeft | Qt.AlignTop)
        
    def valider(self):
        self.done(1)

    def annuler(self):
        self._selection = []
        self.done(0)

class PanneauMateriel(QFrame):
    def __init__(self, fenetre, parent=None):
        """initialisation de la fenetre"""
        self.fenetre = fenetre
        super (PanneauMateriel, self).__init__(parent)
        self.createWidgets()
        self._mat = None
        self._selectionnee = False

    def createWidgets(self):
        """construction de l'interface"""
        self.ui = Ui_pem_panneau()
        self.ui.setupUi(self)
        self.ui.pem_editer.setVisible(False)
        self.ui.pem_supprimer.setVisible(False)
        self.connect(self.fenetre, SIGNAL("majFiltre(QString)"), self.appliquerFiltre)
        self.connect(self.ui.pem_image, SIGNAL("clicked()"), self.clic)
        self.connect(self.ui.pem_nom, SIGNAL("clicked()"), self.clic)
        self.connect(self.ui.pem_editer, SIGNAL("clicked()"), self.editer)
        self.connect(self.ui.pem_supprimer, SIGNAL("clicked()"), self.supprimer)
        self.setMouseTracking(True)

    def selectionner(self, actif):
        self._selectionnee = actif
        if actif:
            couleur = QColor(250, 250, 250, 250)
        else:
            couleur = QColor(240, 240, 240, 240)
        palette = QPalette()
        palette.setColor(QPalette.Window, couleur)
        self.setPalette(palette)

    def mat(self):
        return self._mat
    
    def chargerMat(self, mat):
        self._mat = mat
        self.maj()

    def maj(self):
        self.ui.pem_image.chargerImage(self._mat.icone())
        self.ui.pem_nom.majTexte(self._mat.nom())
        
    def editer(self):
        if self._mat.typ() == "tr":
            fen = EcranEditionTerrain(self._mat)    
        elif self.mat().typ() == "cb":
            fen = EcranEditionCombattant(self._mat) 
        elif self.mat().typ() == "dc":
            fen = EcranEditionDecor(self._mat) 
        r = fen.exec_()
        if r == 1:
            mat = fen.mat()
            if mat: 
                mat.enregistrer()
                self._mat = mat
        del fen
    
    def supprimer(self):
        msg = "Êtes-vous sûr de vouloir supprimer définitivement: \n\n{}".format(self._mat.nom())
        if not dmConfirmer(msg): return
        supprimerMat(self._mat.idM())
        self.fenetre.retirerPanneau(self)

    def appliquerFiltre(self, filtreNom):
        self.setVisible(str(filtreNom.toUtf8()).lower() in self._mat.nom().lower())

    def clic(self):
        self.selectionner(not self._selectionnee)
        self.fenetre.majSelection(self.mat().idM()) 
        
    def mousePressEvent(self, event):
        if event.button() == 1:
            self.clic()

    def enterEvent(self, event):
        self.ui.pem_editer.setVisible(True)
        self.ui.pem_supprimer.setVisible(True)

    def leaveEvent(self, event):
        self.ui.pem_editer.setVisible(False)
        self.ui.pem_supprimer.setVisible(False)
        
        
if __name__ == "__main__":
    s = Session()
    print "exploMat"
    arg = ["DMonde", s.idS()]
    app = QApplication(arg)
    listeMat = importerMateriel()
    print listeMat
    s.fin()
    exit()