dmonde/lib/EcranEditionCombattant.py

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

import sys

from PyQt4.QtCore import SIGNAL, Qt, QString, QSize
from PyQt4.QtGui import QDialog, QColorDialog, QColor, QHBoxLayout, QFrame, \
    QApplication

import Actions
from Combattant import Combattant
from EcranEditionObjet import EcranEditionObjet
from Objet import Objet
from VueEditionForme import VueEditionForme
from dialogues import dmMessage
from frameAttaque import FrameAttaque
import regles
from rsc import selectionImage, RImage
import ui.dm as dm
from ui.ecran_editionCombattant import Ui_edc_fenetre


class EcranEditionCombattant(QDialog):
    """interface de creation/edition de terrains"""
    def __init__(self, combattant = None, pageInitiale = 0, formeCases = "H", parent=None):
        """initialisation de la fenetre"""
        super (EcranEditionCombattant, self).__init__()
        self._combattant = Combattant() if combattant == None else combattant
        
        #param de fonctionnement
        self._modeCreation = True
        self._compteurAttaque = 0
        
        self.createWidgets()
        self.ouverture()
        self.allerAPage(pageInitiale)

        if formeCases == "C":
            self.ui.edc_casesCarrees.setChecked(True)
            self.majFormeCases()

    def combattant(self):
        return self._combattant

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

    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_aideForme, SIGNAL("clicked()"), self.afficherAideForme)
        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_logo, SIGNAL("clicked()"), self.selectionnerLogo)
        
        self.vueForme = VueEditionForme(self)
        self.construireListeAttributs()
        self.construireInventaire()
        self.connect(self.ui.edc_filtreTypeObjet, SIGNAL("currentChanged(int)"), self.filtrerInventaire)
        self.ui.edc_filtreTypeObjet.stackUnder(self.ui.edc_listeInventaire)

    def mat(self):
        """retourne le materiel de la fenetre"""
        return self.combattant()

    def layoutAtt(self):
        """retourne le layout des attaques"""
        return self.ui.edc_deroulementAttaques_layout

    def layoutCarac(self):
        """retourne le layout des attributs"""
        return self.ui.edc_deroulementAttributs_layout        

    def vueGraphique(self):
        return self.ui.edc_vueForme

    def allerAPage(self, index):
        self.ui.edc_menu.setCurrentCell(index, 0)
        self.ui.edc_menu.setCurrentCell(index, 1)
        self.ui.edc_pages.setCurrentIndex(index)        

    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.estValide():
            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.autoriserModifForme(self._modeCreation)
        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.hauteur)
        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: chargement des attaques du combattant, puis panneau 'nouvelle attaque'
        self.layoutAtt().setAlignment(Qt.AlignTop)
        for attaque in self._combattant.attaques:
            self.attaqueNouvelle(attaque)
        self.attaqueNouvelle()

        #page inventaire
        self.ui.edc_listeInventaire.charger(self._combattant.inventaire)
        self.majTotauxInventaire()

        #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()

    ### page apparence
    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 selectionnerLogo(self):
        img = selectionImage()
        if img:
            self.ui.edc_logo.chargerImage(img)
            self.vueForme.nouvelleImageDef(self.ui.edc_logo.image())

    def selectionImage(self):
        """selectionne le fichier image dans la boite de dialogue dediee"""
        img = selectionImage()
        if img:
            self.vueForme.nouvelleImageDef(img)
        
    def selectionCouleur(self):
        """selectionne la couleur dans la boite de dialogue dediee"""
        couleur = QColorDialog(self).getColor(QColor("white"), self)
        if couleur.isValid():
            self._combattant.couleur = couleur
            self.vueForme.majCouleur(couleur)

    def afficherAideForme(self):
        msg = "Sur l'écran ci-contre, vous pouvez éditer la forme et l'apparence de votre pion. Vous pouvez: \n\n" \
                 "Choisir la couleur du pion \n" \
                 "Choisir une image (qui remplacera alors le logo sur le pion) \n" \
                 "Deplacer l'etiquette et l'image sur le pion en cliquant dessus \n" \
                 "Faire pivoter l'image avec [FLECHE HAUT] et [FLECHE BAS] \n" \
                 "Modifier la taille de l'image avec [FLECHE GAUCHE] et [FLECHE DROITE] \n" \
                 "Activer desactiver l'etiquette en gras avec [G] \n" \
                 "Modifier la taille de la police avec [FLECHE HAUT] et [FLECHE BAS]"
        dmMessage(msg)         

    #### page attributs
    def construireListeAttributs(self):
        """construit les champs d'attributs"""
        """cree les champs dedies a la saisie des attributs dans la grille dediee"""
        self.layoutCarac().setSpacing(4)
        self.layoutCarac().setMargin(0)
        self.layoutAtt().setAlignment(Qt.AlignLeft)
        
        for nomAttribut in regles.ordreAttributsFichePerso():
            if len(nomAttribut) > 0:
                lay = QHBoxLayout()
                lay.setMargin(0)
                lay.setSpacing(2)

                etiquette = dm.DmLabel()
                etiquette.majTexte(regles.attribut(nomAttribut).nom)        
                etiquette.setObjectName("{}_etiquette".format(nomAttribut))
                etiquette.setAlignment(Qt.AlignLeft|Qt.AlignVCenter)
                etiquette.setMinimumSize(QSize(110, 24))
                etiquette.setMaximumSize(QSize(110, 24))
                lay.addWidget(etiquette)
                
                champ = dm.DmLineEdit()
                champ.setMinimumSize(QSize(80, 24))
                champ.setMaximumSize(QSize(80, 24))
                champ.setAlignment(Qt.AlignCenter)
                champ.majTexte(regles.listeAttributs()[nomAttribut])
                champ.setObjectName("{}_champ".format(nomAttribut))
                champ.setStyleSheet("background-color: rgb({},{},{});".format(248,248,248))
    ##            self.connect(champ, SIGNAL("textChanged()"), self.controlerAttribut)
                lay.addWidget(champ)

                self.layoutCarac().addLayout(lay)
            else:
                lay = QHBoxLayout()
                etiquetteVide = dm.DmLabel()
                etiquetteVide.setMinimumHeight(9)
                etiquetteVide.setMaximumHeight(9)
                lay.addWidget(etiquetteVide)
                lay.addWidget(etiquetteVide)
                self.layoutCarac().addLayout(lay)

    def majListeAttributs(self):
        """met a jour la liste des attributs de la Combattant"""
        for i in range(0, self.layoutCarac().count()):
            layout = self.layoutCarac().itemAt(i).layout()
            widget = layout.itemAt(1).widget()
            if widget != 0:
                if str(widget.objectName()[-6:]) == "_champ":
                    attr = str(widget.objectName()[:-6])
                    widget.majTexte(self._combattant.listeAttributs[attr])            

    def listeAttributs(self):
        """renvoie la liste des attributs tels qu'ils
           sont saisis dans la liste des attributs"""
        attributs = regles.listeAttributs()
        for i in range(0, self.layoutCarac().count()):
            layout = self.layoutCarac().itemAt(i).layout()
            widget = layout.itemAt(1).widget()
            if widget != 0 and widget != None:
                if str(widget.objectName()[-6:]) == "_champ":
                    attr = str(widget.objectName()[:-6])
                    attributs[attr] = widget.texte()
        return attributs   

    #### page attaques
    def attaqueNouvelle(self, attaque = None):
        """ajoute une nouvelle ligne a la liste des attaques"""
        #on ajoute de suite un panneau 'nouvelle attaque en dessous'
        self._compteurAttaque += 1
        panneau = FrameAttaque(self._compteurAttaque)
        if attaque:
            panneau.chargerAttaque(attaque)
        panneau.setObjectName(QString("att_frame_{}".format(self._compteurAttaque)))
        self.connect(panneau, SIGNAL("attaqueNouvelle()"), self.attaqueNouvelle)
        self.connect(panneau, SIGNAL("attaqueSupprimer(int)"), self.attaqueSupprimer)
        self.layoutAtt().addWidget(panneau)        

    def attaqueSupprimer(self, index):
        """supprime la ligne selectionnee de la liste des attaques"""
        panneau = self.findChild(QFrame, "att_frame_{}".format(index))
        self.layoutAtt().removeWidget(panneau)

    ### page inventaire
    def construireInventaire(self):
        """construction de la page inventaire"""
        self.ui.edc_listeInventaire.construire()
        self.connect(self.ui.edc_listeInventaire, SIGNAL("objetClique(int)"), self.editerObjet)

    def editerObjet(self, indexObjet):
        if indexObjet < len(self.ui.edc_listeInventaire.inventaire()):
            objet = self.ui.edc_listeInventaire.inventaire()[indexObjet]
        else:
            objet = None
        typeObjet = self.ui.edc_filtreTypeObjet.currentIndex() - 1
        
            
        self.fenetreEO = EcranEditionObjet(objet, typeObjet)
        self.fenetreEO.show()
        self.fenetreEO.exec_()
        resultat = self.fenetreEO.resultat()

        if resultat:
            if objet:
                self.ui.edc_listeInventaire.majObjet(objet, resultat)
            else:
                self.ui.edc_listeInventaire.ajouterObjet(resultat)
        else:
            if objet:
                self.ui.edc_listeInventaire.supprimerObjet(objet)
        
        self.fenetreEO = None
        self.majTotauxInventaire()

    def majTotauxInventaire(self):
        inv = self.ui.edc_listeInventaire.inventaire()
        poidsTotal = 0.00
        for obj in inv:
            poidsTotal += obj.poidsTotal()
        self.ui.edc_inventaire_poids.majTexte("{} kg".format(poidsTotal))

    def filtrerInventaire(self, index):
        filtre = index - 1
        self.ui.edc_listeInventaire.filtrer(filtre)

    #### barre d'outils
    def majActivationEnregistrer(self):
        """verifie la validite des saisies"""
        self.ui.edc_enregistrer.setEnabled(len(self.ui.edc_nom.texte()) > 0) 
        
    def enregistrer(self):
        """enregistre le terrain cree/edite"""
        #page nom
        self._combattant.majNom(self.ui.edc_nom.texte())
        self._combattant.logo = self.ui.edc_logo.image() if self.ui.edc_logo.image() else RImage()
        
        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.hauteur = 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
        self._combattant.listeAttributs = self.listeAttributs()

        #page attaque
        listeAttaques = []
        for i in range(0, self.layoutAtt().count()):
            panneau = self.layoutAtt().itemAt(i).widget()
            if panneau != 0:
                attaque = panneau.attaque()
                if attaque:
                    listeAttaques.append(attaque)
        self._combattant.attaques = listeAttaques

        #page inventaire
        self._combattant.inventaire = self.ui.edc_listeInventaire.inventaire()

        #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())
        self.done(1)

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

if __name__ == "__main__":
    app = QApplication(sys.argv)
    ecran = EcranEditionCombattant()
    ecran.show()
    r = app.exec_()
    exit(r)