dmonde/lib/old/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 EcranEditionMateriel(QDialog):
    """interface de creation/edition de terrains"""
    def __init__(self, mat, mode = "creation", parent=None):
        """initialisation de la fenetre"""
        super (EcranEditionMateriel, self).__init__()
        self._mat = mat
        self._mode = mode
        self._sections = []

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

    def mode(self):
        return self._mode

    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_enregistrer, SIGNAL("clicked()"), self.valider)
        self.connect(self.ui.edc_annuler, SIGNAL("clicked()"), self.annuler)

    def toutesLesSections(self):
        return [EdEnTete, EdPageCreation, EdPageCombat, EdPageDeplacement, EdPageAttributs, \
                EdPageAttaques, EdPageInventaire, EdPageNotes]

    def section(self, nom):
        for section in self._sections:
            if section.__class__.__name__ == nom: return section
        return None

    def afficher(self, pageInitiale = 0, formeCases = "H"):
        """affiche la fenetre"""
        self.createWidgets()
        
        #on instancie et on construit les sections necessaires
        for section in self.toutesLesSections():
            instance = section(self)
            if self.mat().__class__.__name__ in instance.filtre() \
            and self._mode in instance.modes():
                self._sections.append(instance)
                instance.construire()
                if section == EdPageCreation:
                    if formeCases == "C": self.ui.edc_casesCarrees.setChecked(True)
                instance.charger()
            else:
                self.ui.edc_menu.setRowHidden((self.toutesLesSections().index(section) - 1), True)

        self.allerAPage(pageInitiale)
        self.majAffichage()
        self.show()

    def allerAPage(self, index, sens = "+"):
        while self.ui.edc_menu.isRowHidden(index): 
            index += 1 if sens == "+" else -1
            if index > self.ui.edc_menu.rowCount(): return
        self.ui.edc_menu.setCurrentCell(index, 0)
        self.ui.edc_menu.setCurrentCell(index, 1)
        self.ui.edc_pages.setCurrentIndex(index)        

    def pageSuivante(self):
        index = self.ui.edc_menu.currentRow() + 1
        if index > (self.ui.edc_menu.rowCount() - 1): index = 0
        print index
        self.allerAPage(index)

    def pagePrecedente(self):
        index = self.ui.edc_menu.currentRow() - 1
        if index < 0: index = self.ui.edc_menu.rowCount() - 1
        print index
        self.allerAPage(index, "-")        

    def nomModifie(self):
        """le nom du pion a ete modifie"""
        self.majAffichage()
        sectionForme = self.section("EdPageCreation")
        if sectionForme: sectionForme.majEtiquetteVueForme()

    def logoModifie(self):
        """le logo du pion a ete modifie"""
        sectionForme = self.section("EdPageCreation")
        if sectionForme: sectionForme.logoModifie()

    #### barre d'outils
    def majAffichage(self):
        """verifie la validite des saisies"""
        self.ui.edc_enregistrer.setEnabled(len(self.ui.edc_nom.texte()) > 0) 
        
    def valider(self):
        """enregistre le materiel cree/edite"""
        for section in self._sections:
            section.enregistrer()
        self.done(1)

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

    def wheelEvent(self, event):
        if event.delta() < 0:
            self.pageSuivante()
            return
        elif event.delta() > 0:
            self.pagePrecedente()
            return
        return QDialog.wheelEvent(self, event)


class EdSectionBase(object):
    """classe de base pour les differentes sections de l'ecran d'edition des pions"""
    def __init__(self, ecran):
        self.ecran = ecran
        self._filtre = []
        self._modes = ["creation", "combat"]
        
    def filtre(self):
        """liste des classes de materiel concernees par cette section"""
        return self._filtre

    def modes(self):
        return self._modes

    def ui(self):
        return self.ecran.ui

    def mat(self):
        return self.ecran.mat()

    def construire(self):
        """construit et met en forme"""
        pass
    
    def charger(self):
        """charge les donnees du materiel dans la section"""
        pass
    
    def enregistrer(self):
        """met a jour le materiel en fonction des donnees saisies"""
        pass

class EdEnTete(EdSectionBase):
    def __init__(self, ecran):
        super(EdEnTete, self).__init__(ecran)
        self._filtre = ["Combattant", "Decor"]
        
    def construire(self):
        self.ecran.connect(self.ui().edc_nom, SIGNAL("textEdited(QString)"), self.ecran.nomModifie)
        self.ecran.connect(self.ui().edc_logo, SIGNAL("clicked()"), self.selectionnerLogo)
#         couleur = "rgb(250,100,50)" if self.ecran.mode() == "combat" else "rgb(20,100,250)"
#         self.ui().edc_enTete.setStyleSheet(QString("#edc_enTete {border-bottom: 3px solid "+couleur+";}"))
#         self.ui().edc_enTete.setStyleSheet(QString("#edc_enTete {background-color: "+couleur+";}"))

    def selectionnerLogo(self):
        img = selectionImage()
        if img:
            self.ui().edc_logo.chargerImage(img)
            self.ecran.logoModifie()
        
    def charger(self):
        self.ui().edc_nom.majTexte(self.mat().nom())
        if self.mat().logo.estValide():
            self.ui().edc_logo.chargerImage(self.mat().logo)
        else:
            self.ui().edc_logo.majTexte("Choisissez \nun fichier\nimage")
    
    def enregistrer(self):
        self.mat().majNom(self.ui().edc_nom.texte())
        self.mat().logo = self.ui().edc_logo.image() if self.ui().edc_logo.image() else RImage()
           


class EdPageCreation(EdSectionBase):
    def __init__(self, ecran):
        super(EdPageCreation, self).__init__(ecran)
        self._filtre = ["Combattant", "Decor"]
        self._modes = ["creation"]

    def construire(self):
        self.vueForme = VueEditionForme(self.ui().edc_vueForme)
        self.ecran.connect(self.ui().edc_aideForme, SIGNAL("clicked()"), self.afficherAideForme)
        self.ecran.connect(self.ui().edc_casesHexa, SIGNAL("clicked()"), self.majFormeCases)
        self.ecran.connect(self.ui().edc_casesCarrees, SIGNAL("clicked()"), self.majFormeCases)
        self.ecran.connect(self.ui().edc_couleur, SIGNAL("clicked()"), self.selectionCouleur)
        self.ecran.connect(self.ui().edc_image, SIGNAL("clicked()"), self.selectionImage)

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

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

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

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

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

    def logoModifie(self):
        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.mat().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)   

    def charger(self):
        self.vueForme.creer(self.formeCases())
        self.vueForme.autoriserModifForme(True)
        self.vueForme.majCouleur(self.mat().couleur)
        self.vueForme.chargerFormeDef(self.mat().formeDef[self.formeCases()])
        self.vueForme.chargerImageDef(self.mat().img)
        self.vueForme.chargerEtiquetteDef(self.mat().etiquette)
    
    def enregistrer(self):
        self.mat().formeDef[self.vueForme.formeCases()] = self.vueForme.formeDef()
        self.mat().img = self.vueForme.imageDef()
        self.mat().etiquette = self.vueForme.etiquetteDef()
    
    
class EdPageCombat(EdSectionBase):
    def __init__(self, ecran):
        super(EdPageCombat, self).__init__(ecran)
        self._filtre = ["Combattant", "Decor"]
        self._modes = ["combat"]
        
    def charger(self):
        pass
    
    def enregistrer(self):
        pass
            
        
class EdPageDeplacement(EdSectionBase):
    def __init__(self, ecran):
        super(EdPageDeplacement, self).__init__(ecran)
        self._filtre = ["Combattant", "Decor"]
        
    def charger(self):
        self.ui().edc_taille.setValue(self.mat().hauteur)
        self.ui().edc_depMarche.setValue(self.mat().depMarche)
        self.ui().edc_depNage.setValue(self.mat().depNage)
        self.ui().edc_depEscalade.setValue(self.mat().depEscalade)
        self.ui().edc_depVol.setValue(self.mat().depVol)
        self.ui().edc_saut.setValue(self.mat().saut)      
    
    def enregistrer(self):
        self.mat().hauteur = self.ui().edc_taille.value()
        self.mat().depMarche = self.ui().edc_depMarche.value()
        self.mat().depNage = self.ui().edc_depNage.value()
        self.mat().depEscalade = self.ui().edc_depEscalade.value()
        self.mat().depVol = self.ui().edc_depVol.value()
        self.mat().saut = self.ui().edc_saut.value()
              
class EdPageAttributs(EdSectionBase):
    def __init__(self, ecran):
        super(EdPageAttributs, self).__init__(ecran)
        self._filtre = ["Combattant"]
        self._modes = ["creation", "combat"]

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

    def construire(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)
        
        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 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   
        
    def charger(self):
        """met a jour la liste des attributs du 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.ecran.mat().listeAttributs[attr])       
    
    def enregistrer(self):
        self.mat().attributs = self.listeAttributs()

            
class EdPageAttaques(EdSectionBase):
    def __init__(self, ecran):
        super(EdPageAttaques, self).__init__(ecran)
        self._filtre = ["Combattant"]
        self._compteurAttaque = 0
    
    def layoutAtt(self):
        """retourne le layout des attaques"""
        return self.ecran.ui.edc_deroulementAttaques_layout
    
    def construire(self):
        self.layoutAtt().setAlignment(Qt.AlignLeft)

    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.ecran.connect(panneau, SIGNAL("attaqueNouvelle()"), self.attaqueNouvelle)
        self.ecran.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)
    
    def charger(self):
        self.layoutAtt().setAlignment(Qt.AlignTop)
        for attaque in self.mat().attaques:
            self.attaqueNouvelle(attaque)
        self.attaqueNouvelle()
    
    def enregistrer(self):
        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.mat().attaques = listeAttaques
            
class EdPageInventaire(EdSectionBase):
    def __init__(self, ecran):
        super(EdPageInventaire, self).__init__(ecran)
        self._filtre = ["Combattant", "Decor"]
        
    def construire(self):
        self.ecran.ui.edc_listeInventaire.construire()
        self.ecran.connect(self.ecran.ui.edc_filtreTypeObjet, SIGNAL("currentChanged(int)"), self.filtrerInventaire)
        self.ecran.ui.edc_filtreTypeObjet.stackUnder(self.ecran.ui.edc_listeInventaire)
        self.ecran.connect(self.ecran.ui.edc_listeInventaire, SIGNAL("objetClique(int)"), self.editerObjet)

    def editerObjet(self, indexObjet):
        if indexObjet < len(self.ecran.ui.edc_listeInventaire.inventaire()):
            objet = self.ecran.ui.edc_listeInventaire.inventaire()[indexObjet]
        else:
            objet = None
        typeObjet = self.ecran.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.ecran.ui.edc_listeInventaire.majObjet(objet, resultat)
            else:
                self.ecran.ui.edc_listeInventaire.ajouterObjet(resultat)
        else:
            if objet:
                self.ecran.ui.edc_listeInventaire.supprimerObjet(objet)
        
        self.fenetreEO = None
        self.majTotauxInventaire()

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

    def filtrerInventaire(self, index):
        filtre = index - 1
        self.ecran.ui.edc_listeInventaire.filtrer(filtre)
        
    def charger(self):
        self.ui().edc_listeInventaire.charger(self.mat().inventaire)
        self.majTotauxInventaire()
    
    def enregistrer(self):
        self.mat().inventaire = self.ui.edc_listeInventaire.inventaire()
            
class EdPageNotes(EdSectionBase):
    def __init__(self, ecran):
        super(EdPageNotes, self).__init__(ecran)
        self._filtre = ["Combattant", "Decor"]

    def construire(self):
        pass
        
    def charger(self):
        for detail in self.mat().details:
            widget = self.ui().edc_pages.findChild(dm.DmLineEdit, "edc_detail_{}".format(detail))
            if widget:
                widget.majTexte(self.mat().details[detail])
        self.ui().edc_notes.setText(QString.fromUtf8(self.mat().notes))
    
    def enregistrer(self):
        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.mat().details[detail] = txt
        
        self.mat().notes = str(self.ui().edc_notes.toPlainText().toUtf8())
            

if __name__ == "__main__":
    app = QApplication(sys.argv)
    mat = Combattant()
    ecran = EcranEditionMateriel(mat, "creation")
    ecran.afficher()
    r = app.exec_()
    exit(r)