dmonde/lib/EcranEditionCombattant.py

#from __future__ import unicode_literals
# -*- coding: utf-8 -*-
from __future__ import division

from PyQt4.QtCore import *
from PyQt4.QtGui import *
from Combattant import Combattant
from ui.ecran_editionCombattant import Ui_edc_fenetre
from outilsSvg import *
from VueEditionForme import VueEditionForme
import regles
import Actions
import ui.dm as dm


class EcranEditionCombattant(QDialog):
    """interface de creation/edition de terrains"""
    def __init__(self, combattant=None, parent=None):
        """initialisation de la fenetre"""
        super (EcranEditionCombattant, self).__init__()
        self.pixGraphique = None
        self.createWidgets()
        
        if combattant == None:
            self.combattant = Combattant()
        else:
            self.combattant = combattant
        self.ouverture()

    def nouvelIdCombattant(self):
        """renvoie un identifiant pour un nouveau terrain"""
        dicoSvg = afficheSvg("lib\\biblio\\Combattant")
        nouvelId = 1
        while str(nouvelId) in dicoSvg.keys():
            nouvelId += 1
        return str(nouvelId)

    def formeCases(self):
        retour = ""
        if self.ui.edc_casesHexa.isChecked():
            retour = "H"
        else:
            retour = "C"
        return retour

    def createWidgets(self):
        """construction de l'interface"""
        #construction de l'interface
        self.ui = Ui_edc_fenetre()
        self.ui.setupUi(self)
        self.connect(self.ui.edc_nom, SIGNAL("textEdited(QString)"), self.majActivationEnregistrer)
        self.connect(self.ui.edc_nom, SIGNAL("textEdited(QString)"), self.majEtiquetteVueForme)

        self.connect(self.ui.edc_enregistrer, SIGNAL("clicked()"), self.enregistrer)
        self.connect(self.ui.edc_annuler, SIGNAL("clicked()"), self.annuler)

        self.connect(self.ui.edc_casesHexa, SIGNAL("clicked()"), self.majFormeCases)
        self.connect(self.ui.edc_casesCarrees, SIGNAL("clicked()"), self.majFormeCases)
        self.connect(self.ui.edc_couleur, SIGNAL("clicked()"), self.selectionCouleur)
        self.connect(self.ui.edc_image, SIGNAL("clicked()"), self.selectionImage)
##        self.connect(self.ui.edc_aideForme, SIGNAL("clicked()"), self.afficherAideForme)

        self.connect(self.ui.edc_logo, SIGNAL("imageModifiee()"), self.logoModifie)
        self.vueForme = VueEditionForme(self)
        
        self.ui.edc_listeAttributs.setColumnWidth(0, (0.4*self.ui.edc_listeAttributs.width())) 
        self.ui.edc_listeAttributs.setColumnWidth(1, (0.4*self.ui.edc_listeAttributs.width()))
        self.connect(self.ui.edc_listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee, Qt.UniqueConnection)


        self.connect(self.ui.edc_attaque_ajouter, SIGNAL("clicked()"), self.nouvelleAttaque)
        self.connect(self.ui.edc_attaque_supprimer, SIGNAL("clicked()"), self.supprimerAttaque)

##        self.ui.listeInventaireCombattant.setColumnWidth(0, (0.2*self.ui.listeInventaireCombattant.width()))
##        self.ui.listeInventaireCombattant.setColumnWidth(1, (0.8*self.ui.listeInventaireCombattant.width()))
##        self.connect(self.ui.listeInventaireCombattant, SIGNAL("clicked()"), self.listeInventaireCelluleModifiee)
##        self.connect(self.ui.supprimerInventaireCombattant, SIGNAL("clicked()"), self.supprimerLigneListeInventaire)
##        self.connect(self.ui.ajouterInventaireCombattant, SIGNAL("clicked()"), self.ajouterLigneListeInventaire)
        
    def ouverture(self):
        """premier affichage: on met a jour les champs"""
       
        #page_nom
        self.ui.edc_nom.majTexte(self.combattant.nom)
        if self.combattant.logo:
            self.ui.edc_logo.chargerImage(self.combattant.logo)
        else:
            self.ui.edc_logo.majTexte("Choisissez \nun fichier\nimage")

        self.vueForme.creer(self.formeCases())
        self.vueForme.majCouleur(self.combattant.couleur)
        self.vueForme.chargerFormeDef(self.combattant.formeDef[self.formeCases()])
        self.vueForme.chargerImageDef(self.combattant.img)
        self.vueForme.chargerEtiquetteDef(self.combattant.etiquette)

        #page deplacements
        self.ui.edc_taille.setValue(self.combattant.taille)
        self.ui.edc_depMarche.setValue(self.combattant.depMarche)
        self.ui.edc_depNage.setValue(self.combattant.depNage)
        self.ui.edc_depEscalade.setValue(self.combattant.depEscalade)
        self.ui.edc_depVol.setValue(self.combattant.depVol)
        self.ui.edc_saut.setValue(self.combattant.saut)      

        #page attributs
        self.majListeAttributs()

        #page attaques
        print "charge", self.combattant.attaques
        self.ui.edc_attaque_panneau.construire(self)
        self.ui.edc_attaque_liste.charger(self, self.combattant.attaques)
        


        #page inventaire
        #self.majListeInventaire()

        #page_notes
        for detail in self.combattant.details:
            widget = self.ui.edc_pages.findChild(dm.DmLineEdit, "edc_detail_{}".format(detail))
            if widget:
                widget.majTexte(self.combattant.details[detail])
        self.ui.edc_notes.setText(QString.fromUtf8(self.combattant.notes))

        #autre
        self.majActivationEnregistrer()

    def majActivationEnregistrer(self):
        """verifie la validite des saisies"""
        self.ui.edc_enregistrer.setEnabled(len(self.ui.edc_nom.texte()) > 0)

    def majListeAttributs(self):
        """met a jour la liste des attributs de la Combattant"""
        self.disconnect(self.ui.edc_listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee)
        
        #on vide la liste
        while self.ui.edc_listeAttributs.rowCount() > 0:
            self.ui.edc_listeAttributs.removeRow(0)
        
        #attributs issus des regles utilisees    
        ordre = regles.ordreAttributs()
        for elt in ordre:
            ligne = ordre.index(elt)
            self.ui.edc_listeAttributs.insertRow(ligne)
            if regles.attribut(elt).combatSeulement == True: self.ui.edc_listeAttributs.setRowHidden(ligne, True)
            item = QTableWidgetItem(QString.fromUtf8(elt))
            item.setFlags(Qt.NoItemFlags)
            self.ui.edc_listeAttributs.setItem(ligne, 0, item)
            self.ui.edc_listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.combattant.listeAttributs[elt]))))
            
        self.connect(self.ui.edc_listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee)

    def listeAttributCelluleModifiee(self, ligne, colonne):
        """une cellule de la liste des attributs a ete modifiee"""
        if colonne != 1:
            pass
        else:
            attribut = regles.ordreAttributs()[(ligne)]
            nouvelleVal = str(self.ui.edc_listeAttributs.item(ligne, 1).text().toUtf8())
            valVerifiee = regles.listeControle()[attribut].controler(nouvelleVal)
            if valVerifiee != None:
                self.combattant.listeAttributs[attribut] = valVerifiee
            else:    
                self.ui.edc_listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.combattant.listeAttributs[attribut]))))

    def majFormeCases(self):
        if self.vueForme.formeCases() != self.formeCases():
            #on enregistre la def de forme, d'image et d'etiquette en cours
            self.combattant.formeDef[self.vueForme.formeCases()] = self.vueForme.formeDef()
            self.combattant.img = self.vueForme.imageDef()
            self.combattant.etiquette = self.vueForme.etiquetteDef()

            #on recree la scene avec la nouvelle forme de cases
            self.vueForme.vider()
            self.vueForme.creer(self.formeCases())

            #on charge les def correspondantes a la nouvelle forme
            self.vueForme.chargerFormeDef(self.combattant.formeDef[self.formeCases()])
            self.vueForme.chargerImageDef(self.combattant.img)
            self.vueForme.chargerEtiquetteDef(self.combattant.etiquette)

    def majEtiquetteVueForme(self):
        self.combattant.etiquette.txt = self.ui.edc_nom.texte()
        self.vueForme.chargerEtiquetteDef(self.combattant.etiquette)

    def logoModifie(self):
        if not len(self.combattant.img.nomFichier) > 0:
            #si pas d'image attribuee au pion, on utilise le logo pour le pion
            self.vueForme.nouvelleImageDef(self.ui.edc_logo.image())

    def selectionImage(self):
        """selectionne le fichier image dans la boite de dialogue dediee"""
        fichier = QFileDialog.getOpenFileName(self, 
                                              "Selectionnez une image", 
                                              "\\img", 
                                              "Images (*.png *.jpg)")
        if len(fichier) > 0:
            pix = QPixmap(fichier)
            if not pix.isNull():
                self.vueForme.nouvelleImageDef(fichier)
            else:    
                dial = QMessageBox(self)
                dial.setText("Format non reconnu")
                dial.setWindowTitle("Erreur")
                dial.setStandardButtons(QMessageBox.Ok)
                dial.exec_()

    def selectionCouleur(self):
        """selectionne la couleur dans la boite de dialogue dediee"""
        couleur = QColorDialog(self).getColor(QColor("white"), self)
        if couleur.isValid():
            nomCouleur = couleur.name()
            self.combattant.couleur = couleur
            self.vueForme.majCouleur(couleur)

    def nouvelleAttaque(self):
        """ajoute une nouvelle ligne a la liste des attaques"""
        self.ui.edc_attaque_liste.nouvelle()

    def supprimerAttaque(self):
        """supprime la ligne selectionnee de la liste des attaques"""
        if self.ui.edc_attaque_liste.ligneSelectionnee():
            self.ui.edc_attaque_panneau.reinit()
            self.ui.edc_attaque_liste.supprimer()

    def enregistrer(self):
        """enregistre le terrain cree/edite"""
        #identifiant
        if not self.combattant.id:
            self.combattant.id = self.nouvelIdCombattant()

        #page nom
        self.combattant.nom = self.ui.edc_nom.texte()
        self.combattant.logo = self.ui.edc_logo.image()
        
        self.combattant.formeDef[self.vueForme.formeCases()] = self.vueForme.formeDef()
        self.combattant.img = self.vueForme.imageDef()
        self.combattant.etiquette = self.vueForme.etiquetteDef()

        #page dep
        self.combattant.taille = self.ui.edc_taille.value()
        self.combattant.depMarche = self.ui.edc_depMarche.value()
        self.combattant.depNage = self.ui.edc_depNage.value()
        self.combattant.depEscalade = self.ui.edc_depEscalade.value()
        self.combattant.depVol = self.ui.edc_depVol.value()
        self.combattant.saut = self.ui.edc_saut.value()

        #page attributs
        #dans listeAttributCelluleModifiee

        #page attaque
        print "svg", self.ui.edc_attaque_liste.listeAttaques()
        self.combattant.attaques = self.ui.edc_attaque_liste.listeAttaques()

        #page inventaire
        #a voir...

        #page notes
        listeWidget = self.ui.edc_pages.findChildren(dm.DmLineEdit)
        for widget in listeWidget:
            detail = str(widget.objectName()).replace("edc_detail_","")
            txt = widget.texte()
            if len(txt) > 0:
                self.combattant.details[detail] = txt
        
        self.combattant.notes = str(self.ui.edc_notes.toPlainText().toUtf8())

        enregistrer(self.combattant.id, self.combattant, "lib\\biblio\\combattant")
        self.combattant = None
        self.done(1)

##    def supprimer(self):
##        """supprimer l'enregistrement de ce terrain"""
##        supprSvg("lib\\biblio\\combattant", self.combattant.id)
##        self.done(1)

    def annuler(self):
        """annule la creation/edition"""
        self.combattant = None
        self.done(0)



##    def majListeInventaire(self):
##        """met a jour la liste de l'inventaire de la Combattant"""
##        self.disconnect(self.ui.listeInventaireCombattant, SIGNAL("cellChanged(int,int)"), self.listeInventaireCelluleModifiee)
##        
##        #on vide la liste
##        while self.ui.listeInventaireCombattant.rowCount() > 0:
##            self.ui.listeInventaireCombattant.removeRow(0)
##        ligne = 0
##        #attributs issus des regles utilisees
##        for objet in self.combattant.inventaire:
##            self.ui.listeInventaireCombattant.insertRow(ligne)
##            self.ui.listeInventaireCombattant.setItem(ligne, 0, QTableWidgetItem(QString.fromUtf8(self.combattant.inventaire[objet])))
##            self.ui.listeInventaireCombattant.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(objet)))
##            ligne += 1
##        self.connect(self.ui.listeInventaireCombattant, SIGNAL("cellChanged(int,int)"), self.listeInventaireCelluleModifiee)
##
##    def listeInventaireCelluleModifiee(self, ligne, colonne):
##        """une cellule de la liste des attributs a ete modifiee"""
##        nouvelleVal = str(self.ui.listeInventaireCombattant.item(ligne, colonne).text().toUtf8())
##        val = None
##        if colonne == 0:
##            try:
##                nbre = int(nouvelleVal)
##            except:
##                nbre = -1
##            if nbre >= 0: val = str(nbre)
##        else:
##            val = str(nouvelleVal)
##            if val in self.combattant.inventaire or len(val) == 0:
##                print("cet objet existe deja ou a un nom invalide")
##                val = None
##
##        if colonne == 0:    
##            if val != None:
##                self.combattant.inventaire[str(self.ui.listeInventaireCombattant.item(ligne, 1).text().toUtf8())] = val
##            else:
##                self.ui.listeInventaireCombattant.setItem(ligne, 0, QTableWidgetItem(QString.fromUtf8(\
##                                                        str(self.combattant.inventaire[str(self.ui.listeInventaireCombattant.item(ligne, 1).text().toUtf8())]))))
##        else:
##            txt = str(self.ui.listeInventaireCombattant.item(ligne, 1).text().toUtf8())
##            if txt in self.combattant.inventaire:
##                del self.combattant.inventaire[txt]
##            if val != None:
##                self.combattant.inventaire[val] = txt
##            else:    
##                self.ui.listeInventaireCombattant.removeRow(ligne)
##
##    def ajouterLigneListeInventaire(self, objet=""):
##        num = -1
##        for i in range(0, self.ui.listeInventaireCombattant.rowCount()):   #si un objet de la liste a deja un nom vide, on ne cree pas de nouvelle ligne
##            if len(str(self.ui.listeInventaireCombattant.item(i, 0).text().toUtf8())) == 0:
##                num = i
##                break 
##        if num < 0:           
##            self.disconnect(self.ui.listeInventaireCombattant, SIGNAL("cellChanged(int,int)"), self.listeInventaireCelluleModifiee)
##            ligne = self.ui.listeInventaireCombattant.rowCount()
##            self.ui.listeInventaireCombattant.insertRow(ligne)
##            self.ui.listeInventaireCombattant.setItem(ligne, 0, QTableWidgetItem(QString.fromUtf8("0")))
##            self.ui.listeInventaireCombattant.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(objet)))
##            self.connect(self.ui.listeInventaireCombattant, SIGNAL("cellChanged(int,int)"), self.listeInventaireCelluleModifiee)
##        else:
##            self.ui.listeInventaireCombattant.setCurrentRow(num)
##            
##    def supprimerLigneListeInventaire(self):
##        self.disconnect(self.ui.listeInventaireCombattant, SIGNAL("cellChanged(int,int)"), self.listeInventaireCelluleModifiee)
##        ligne = self.ui.listeInventaireCombattant.currentRow()
##        del self.combattant.inventaire[str(self.ui.listeInventaireCombattant.item(ligne, 1).text().toUtf8())]
##        self.ui.listeInventaireCombattant.removeRow(ligne)
##        self.connect(self.ui.listeInventaireCombattant, SIGNAL("cellChanged(int,int)"), self.listeInventaireCelluleModifiee)