dmonde/lib/ui/dmtableattaques.py

#from __future__ import unicode_literals
# -*- coding: utf-8 -*-
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from lib.Actions import *
import lib.regles as regles
from lib.ui.dm import *

#dans une DmTableAttaques, les 10 premieres colonnes sont reservees aux donnees de base
#le reste des colonnes sert aux donnees complementaires issues des regles
colonnesBase= ["Type", "Nom", "Portee", "Forme", "Rayon"]
largeurColonnesBase = {"Type": 70, "Nom": 100, "Portee": 60, "Forme": 80,"Rayon": 60}
        
class DmTableAttaques(DmTableWidget):
    """interface d'edition des attaques du combattant"""
    def __init__(self, parent=None):
        super (DmTableAttaques, self).__init__(parent)
            
    def construire(self):
        """cree les colonnes de la table"""
        #colonnes de base: celles qui ne dependent pas des regles utilisees
        for i in range(0, 10):
            self.insertColumn(i)
            
            #on cache les colonnes qui ne seront pas utilisees
            self.setColumnHidden(i, (i >= len(colonnesBase)))
            if i < len(colonnesBase):
                #la largeur est geree par une variable globale
                self.setHorizontalHeaderItem(i, QTableWidgetItem(colonnesBase[i]))

                if colonnesBase[i] in largeurColonnesBase:
                    largeur = largeurColonnesBase[colonnesBase[i]]
                else:
                    largeur = 60
                if largeur > 0:    
                    self.setColumnWidth(i, largeur)
                else:
                    self.setColumnHidden(i, True)
                    
        #on ajoute maintenant les colonnes issues des regles            
        ordre = regles.ordreAttributsAttaques()
        for elt in ordre:
            numCol = 10 + ordre.index(elt)
            self.insertColumn(numCol)
            self.setHorizontalHeaderItem(numCol, QTableWidgetItem(QString.fromUtf8(elt)))
            self.setColumnWidth(numCol, 45)
            self.setColumnHidden(numCol, False)

        self.connect(self, SIGNAL("cellChanged(int, int)"), self.celluleModifiee)

    def posColonne(self, nom):
        """renvoie la position de la colonne demandee"""
        retour = None
        if nom in colonnesBase:
            retour = colonnesBase.index(nom)
        elif nom in regles.ordreAttributsAttaques():
            retour = 10 + regles.ordreAttributsAttaques().index(nom)
        return retour

    def listeAttaques(self):
        """retourne la liste des attaques de la liste"""
        liste = []
        for ligne in self.lignes():
            attaque = None
            typeAttaque = str(self.cellWidget(ligne, self.posColonne("Type")).valeurActuelle().toString())
            if typeAttaque == "cac":
                attaque = Cac()
            elif typeAttaque == "dist":
                attaque = Distance()
            elif typeAttaque == "zone":
                formeAttaque = str(self.cellWidget(ligne, self.posColonne("Forme")).valeurActuelle().toString())
                if formeAttaque == "ligne":
                    attaque = Ligne()
                elif formeAttaque == "disque":
                    attaque = Disque()
                elif formeAttaque == "cone":
                    attaque = Cone()
                    
            if attaque:
                attaque.majNom(self.texte(ligne, self.posColonne("Nom")))
                attaque.majPortee(self.data(ligne, self.posColonne("Portee")))
                if typeAttaque == "zone" and formeAttaque == "disque":
                    attaque.majRayon(self.data(ligne, self.posColonne("Rayon")))
                for col in range(10, self.columnCount()):
                    attr = regles.ordreAttributsAttaques()[(col-10)]
                    val = str(self.data(ligne, col-10))
                    if regles.attributAttaque(attr).controler(val):
                        attaque.majAttribut(attr, val)
                liste.append(attaque)
        return liste

    def charger(self, listeAttaques):
        """charge et affiche une liste d'attaques"""
        self.vider()
        self.majEnCours = True
        ligne = 0
        for attaque in listeAttaques:
            #controle du type d'attaque
            if isinstance(attaque, Attaque):
                if attaque.__class__.__name__ in ["ligne", "disque", "cone"]:
                    typeAtt = "zone"
                    formeAtt = attaque.typeAtt()
                else:
                    typeAtt = attaque.typeAtt()  
                    formeAtt = ""
                    
                self.nouvelleLigneFin()
                #donnees generales
                donneesAttaque = {"Nom": attaque.nom(), "Portee": attaque.portee(), "Rayon": attaque.rayon()}
                self.majLigne(ligne, donneesAttaque)

                #met a jour le type d'attaque
                widget = self.listeTypesAttaques(ligne)
                widget.allerA(typeAtt)
                self.setCellWidget(ligne, self.posColonne("Type"), widget)
                self.afficherDonneesAttaqueZone(ligne, (typeAtt == "zone"))

                #maj des attributs de regles
                self.majLigne(ligne, attaque.attributs())

            ligne += 1

        self.majEnCours = False

    def nouvelle(self):
        """ajoute une ligne a la table et maj avec les valeurs par defaut"""
        ligne = self.nouvelleLigneFin()
        modeleAttaque = Attaque()
        #donnees generales
        donneesAttaque = {"Nom": modeleAttaque.nom(), "Portee": modeleAttaque.portee(), "Rayon": modeleAttaque.rayon()}
        self.majLigne(ligne, donneesAttaque)

        #liste types attaque
        widget = self.listeTypesAttaques(ligne)
        widget.allerA("cac")
        self.setCellWidget(ligne, self.posColonne("Type"), widget)

        #des regles
        attributs = regles.listeAttributsAttaques()
        self.majLigne(ligne, attributs)

        self.afficherDonneesAttaqueZone(ligne, False)
    
    def supprimer(self):
        """supprime l'attaque selectionnee de la liste des attaques du pion"""
        select = self.ligneSelectionnee()
        if select:
            numAttaque = int(self.data(sel,0))
            reponse = QMessageBox.question(self, 'Message',
                           "Etes vous sûr de vouloir supprimer cette attaque?", QMessageBox.Yes | 
                           QMessageBox.No, QMessageBox.No)
            if reponse == QMessageBox.Yes:   
                self.removeRow(select)

    def celluleModifiee(self, ligne, colonne):
        """une cellule de la table a ete modifiee par l'utilisateur,
            on controle sa validite via la classe Attaque et
            on retourne la valeur acceptee, ou l'ancienne valeur sinon"""
        
        if not self.majEnCours:
            modeleAttaque = Attaque()
            
            if colonne < len(colonnesBase):
                if colonne == self.posColonne("Nom"):
                    #maj du nom de l'attaque
                    nouveauNom = self.texte(ligne, colonne)
                    modeleAttaque.majNom(nouveauNom)
                    if modeleAttaque.nom() != nouveauNom:
                        self.majTexte(ligne, colonne, modeleAttaque.nom())
                
                elif colonne == self.posColonne("Type"):
                    #maj du type de l'attaque (ici, on ne controle pas, mais on met a jour tout l'affichage si besoin)
                    nouveauType = str(self.cellWidget(ligne, colonne).valeurActuelle().toString())
                    self.afficherDonneesAttaqueZone(ligne, (nouveauType == "zone"))
                    
                elif colonne == self.posColonne("Portee"):
                    #maj de la portee de l'attaque
                    nouvellePortee = self.data(ligne, colonne) #! QVariant
                    modeleAttaque.majPortee(nouvellePortee)
                    if modeleAttaque.portee() != nouvellePortee:
                        self.majEnt(ligne, colonne, modeleAttaque.portee())

                elif colonne == self.posColonne("Rayon"):
                    #maj du rayon de l'attaque
                    nouveauRayon = self.data(ligne, colonne) #! QVariant
                    modeleAttaque.majRayon(nouveauRayon)
                    if modeleAttaque.rayon() != nouveauRayon:
                        self.majEnt(ligne, colonne, modeleAttaque.rayon())
    
            elif colonne >= 10:
                #colonnes issues des regles
                index = colonne - 10
                attribut = regles.ordreAttributsAttaques()[index]
                valeurAttribut = regles.listeControleAttaques()[attribut].controler(str(self.data(ligne, colonne).toString()))
                if valeurAttribut == None:
                    self.majData(ligne, colonne, regles.listeControleAttaques()[attribut].defaut)

    def afficherDonneesAttaqueZone(self, ligne, afficher):
        """rend modifiables ou non les donnees de base liees aux attaques de zone et modifie l'affichage en consequence"""
        self.majEnCours = True
        
        if afficher:
            modeleAttaque = Attaque()
            if self.cellWidget(ligne, self.posColonne("Forme")) == None:
                self.setCellWidget(ligne, self.posColonne("Forme"), self.listeFormesZone(ligne))
            item = QTableWidgetItem()
            item.setData(0, modeleAttaque.rayon())
            item.setBackgroundColor(QColor("white"))
            self.setItem(ligne, self.posColonne("Rayon"), item)
            
        else:
            if self.cellWidget(ligne, self.posColonne("Forme")) != None:
                self.removeCellWidget(ligne, self.posColonne("Forme"))
                
            item = QTableWidgetItem(QString.fromUtf8(""))
            item.setFlags(Qt.NoItemFlags)
            item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
            item.setBackgroundColor(QColor(200,200,200))
            self.setItem(ligne, self.posColonne("Forme"), item)
            
            item = QTableWidgetItem(QString.fromUtf8(""))
            item.setFlags(Qt.NoItemFlags)
            item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
            item.setBackgroundColor(QColor(200,200,200))
            self.setItem(ligne, self.posColonne("Rayon"), item)

        self.majEnCours = False

    def typeAttaqueModifie(self):
        emetteur = self.sender().objectName()
        ligne = int(emetteur.replace("cbType_",""))
        colonne = self.posColonne("Type")
        self.celluleModifiee(ligne, colonne)

    def formeAttaqueModifiee(self):
        emetteur = self.sender().objectName()
        ligne = int(emetteur.replace("cbForme_",""))
        colonne = self.posColonne("Type")
        self.celluleModifiee(ligne, colonne)
  
    def listeTypesAttaques(self, ligne):
        """retourne la DmComboBox qui apparait dans la colonne Type d'attaque"""
        liste = DmComboBox()
        liste.setObjectName(QString("cbType_{}".format(ligne)))   #sert a reconnaitre l'emetteur du signal apres une modif
        liste.addItem(QIcon("img\\curseurEpee.png"), QString.fromUtf8("C.à.C"), "cac")
        liste.addItem(QIcon("img\\arc.png"), QString.fromUtf8("Dist."), "dist")
        liste.addItem(QIcon("img\\baguette.png"), QString.fromUtf8("Zone"), "zone")
        self.connect(liste, SIGNAL("currentIndexChanged(int)"), self.typeAttaqueModifie)
        return liste
    
    def listeFormesZone(self, ligne):
        """retourne la DmComboBox qui apparait dans la colonne forme de zone"""
        liste = DmComboBox()
        liste.setObjectName(QString("cbForme_{}".format(ligne)))
        liste.addItem(QIcon("img\\formeLigne.png"), QString.fromUtf8("Ligne"), "ligne")
        liste.addItem(QIcon("img\\formeEllipsePlein.png"), QString.fromUtf8("Disque"), "disque")
        liste.addItem(QIcon("img\\cone.png"), QString.fromUtf8("Cone"), "cone")
        self.connect(liste, SIGNAL("currentIndexChanged(int)"), self.formeAttaqueModifiee)
        return liste