dmonde/lib/ui/dm.py

#from __future__ import unicode_literals
# -*- coding: utf-8 -*-
"""ensemble des widgets surchargés"""
from PyQt4.QtCore import *
from PyQt4.QtGui import *
from lib.outilsSvg import *
import lib.regles as regles
from lib.Actions import *

class DmLabel(QLabel):
    """surcharge de QLabel"""
    def __init__(self, parent = None):
        super(DmLabel, self).__init__(parent)    

    def majTexte(self, txt):
        self.clear()
        self.setText(QString.fromUtf8(txt))

    def chargerImage(self, chemin):
        self.clear()
        if len(chemin) > 0:
            pix = QPixmap(QString.fromUtf8(chemin))
            pix = pix.scaled(self.width(), self.height(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
        else:
            pix = QPixmap()
        self.setPixmap(pix)         

    def texte(self):
        return str(self.text().toUtf8())

class DmLabelChoixImage(DmLabel):
    """surcharge de DmLabel,
        affiche une fenetre de selection de fichier, recupere une image,
        et l'affiche."""
    def __init__(self, parent = None):
        super(DmLabelChoixImage, self).__init__(parent)
        self.setStyleSheet("QLabel { padding: 3px; }")
        self._sourceImage = ""

    def mousePressEvent(self, event):
        if event.button() == 1:
            self.selectionImage()
            
    def selectionImage(self):
        fichier = QFileDialog.getOpenFileName(self, 
                                              "Selectionnez une image", 
                                              "\\img", 
                                              "Images (*.png *.jpg)")
        if len(fichier) > 0:
            pix = QPixmap(fichier)
            if not pix.isNull():
                self._sourceImage = fichier
                self.clear()
                pix = pix.scaled(self.width(), self.height(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
                self.setPixmap(pix)
                self.emit(SIGNAL("imageModifiee()"))
            else:
                dial = QMessageBox(self)
                dial.setText("Format non reconnu")
                dial.setWindowTitle("Erreur")
                dial.setStandardButtons(QMessageBox.Ok)
                dial.exec_()

    def image(self):
        """retourne le chemin de l'image chargee"""
        return self._sourceImage

    def chargerImage(self, chemin):
        self._sourceImage = chemin
        super(DmLabelChoixImage, self).chargerImage(chemin)

class DmTextEdit(QTextEdit):
    def __init__(self, parent = None):
        super(DmTextEdit, self).__init__(parent)    

    def majTexte(self, txt):
        self.clear()
        self.setText(QString.fromUtf8(str(txt)))    

    def texte(self):
        return str(self.toPlainText().toUtf8())

class DmLineEdit(QLineEdit):
    def __init__(self, parent = None):
        super(DmLineEdit, self).__init__(parent)    

    def majTexte(self, txt):
        self.clear()
        self.setText(QString.fromUtf8(str(txt)))    

    def texte(self):
        return str(self.text().toUtf8())

class DmGraphicsView(QGraphicsView):
    """surcharge de QGraphicsView"""
    def __init__(self, parent = None):
        super(DmGraphicsView, self).__init__(parent)
        self.nbZoomActuel = 0

    def resizeEvent(self, event):
        super(DmGraphicsView, self).resizeEvent(event)
        self.emit(SIGNAL("resizeEvent()"))

    def wheelEvent(self, event):
        """zoom/dezoom avec la molette de la souris"""
        #on zoom/dezoom et on recentre sur la position du curseur
        zoom = 1.00
        if event.delta() > 0:
            if self.nbZoomActuel <= 10:
                self.nbZoomActuel += 1
                zoom = 1.25
        elif event.delta() < 0:
            if self.nbZoomActuel >= -10:
                zoom = 0.8
                self.nbZoomActuel -= 1 
        if zoom != 0.00:
           self.scale(zoom, zoom)
           self.centerOn(self.mapToScene(event.pos()))
        event.accept() #pour considerer l'evenement comme resolu, sans ca les barres de defilement reagissent aussi      


class DmComboBox(QComboBox):
    """surcharge de QComboBox"""
    def __init__(self, parent = None):
        super(DmComboBox, self).__init__(parent)

    def allerA(self, donnee):
        """cherche la donnee demandee et affiche la ligne"""
        index = self.findData(QVariant(donnee))
        self.setCurrentIndex(index)

    def valeurActuelle(self):
        """renvoie sous forme de QVariant la valeur en cours"""
        return self.itemData(self.currentIndex())
    
class DmTableWidget(QTableWidget):
    """surcharge de QTableWidget"""
    def __init__(self, parent = None):
        super(DmTableWidget, self).__init__(parent)
        self.majEnCours = False

    def vider(self):
        """supprime toutes les lignes"""
        self.majEnCours = True
        while self.rowCount() > 0:
            self.removeRow(0)
        self.majEnCours = False    

    def nouvelleLigneFin(self):
        """ajoute une ligne en derniere position"""
        pos = self.rowCount()
        self.insertRow(pos)
        return pos

    def lignes(self):
        """retourne la liste des index de lignes de la table"""
        return range(0, self.rowCount())

    def colonnes(self):
        """retourne la liste des index de lignes de la table"""
        return range(0, self.columnCount())

    def masquerColonneId(self):
        """masque la colonne en position 0 qui contient les identifiants"""
        self.setColumnWidth(0, 0)

    def majData(self, ligne, colonne, var):
        """met a jour la cellule avec une donnee de type QVariant"""
        var = QVariant(var)
        self.item(ligne, colonne).setData(0, var)
        return True
    
    def majTexte(self, ligne, colonne, texte):
        """met a jour la cellule avec du texte"""
        if not self.item(ligne, colonne):
            self.setItem(ligne, colonne, QTableWidgetItem(QString.fromUtf8(str(texte))))
        else:
            self.item(ligne, colonne).setText(QString.fromUtf8(str(texte)))
        return True

    def majEnt(self, ligne, colonne, valeur):
        """met a jour la cellule avec une valeur numerique entiere
           si valeur ne peut etre converti en numerique, on retourne Faux"""
        retour = False
        try:
            entier = QVariant(long(valeur))
            self.item(ligne, colonne).setData(0, entier)
            retour = True
        except:
            pass
        return retour
                
    def chercherLigne(self, colonne, valeur):
        """cherche la valeur dans la colonne demandee
           renvoie la ligne correspondante """
        ligne = None
        for i in range(0, self.rowCount()):
            if str(self.item(i, colonne).text().toUtf8()) == str(valeur):
                ligne = i
                break           
        return ligne

    def majLigne(self, ligne, dico, flags = []):
        """rempli la ligne avec les donnees trouvees dans le dictionnaire"""
        for colonne in range(0, self.columnCount()):
            nomChamp = ""
            item = self.horizontalHeaderItem(colonne)
            if item:
                nomChamp = str(item.text())
            if nomChamp in dico:
                item = QTableWidgetItem()
                for f in flags:
                    item.setFlag(f)
                var = QVariant(dico[nomChamp])
                item.setData(0, var)
                self.setItem(ligne, colonne, item)

    def texte(self, ligne, colonne):
        return str(self.item(ligne, colonne).text().toUtf8())

    def data(self, ligne, colonne):
        retour = None
        item = self.item(ligne, colonne)
        if item:
            retour = item.data(0)
        return retour

    def ligneSelectionnee(self):
        """renvoie la ligne selectionnee (la premiere si plusieurs le sont)"""
        return self.currentRow()

    def selectionner(self, ligne, colonne):
        self.setCurrentCell(ligne, colonne, QItemSelectionModel.Select)

class DmTableBiblio(DmTableWidget):
    """table utilisee pour afficher les bibliotheques d'objets:
        terrains, decors, creatures"""
    def __init__(self, parent = None):
        super(DmTableBiblio, self).__init__(parent)
        self.fichier = ""
        self.masquerColonneId()

    def defFichier(self, fichier):
        """definit le fichier de sauvegarde qui la source des donnees de la table"""
        self.fichier = fichier

    def initAffichage(self):
        """fait les differents reglages relatifs a l'apparence"""
        self.setColumnWidth(0, 0)
        self.setIconSize(QSize(30,20))   
        self.horizontalHeader().setStretchLastSection(True)
        
    def remplir(self):
        """remplit la table avec les donnees contenues dans le dictionnaire de la savuvegarde"""
        dico = afficheSvg(self.fichier)
        self.majEnCours = True
        self.setSortingEnabled(False)
        index = 0
        for elt in dico:
            objet = dico[elt]
            self.insertRow(int(index))
            
            #code de l'objet
            self.setItem(int(index),0,QTableWidgetItem(QString.fromUtf8(elt)))
            #icone et nom
            icon = QIcon(objet.icone())
            item = QTableWidgetItem(icon,QString.fromUtf8(objet.nom))
            self.setItem(int(index),1,item)
            
            index += 1        
        self.sizeHintForColumn(1)
        self.setSortingEnabled(True)
        self.sortItems(1)
        self.majEnCours = False

    def maj(self):
        self.vider()
        self.remplir()

    def actuel(self):
        """renvoie l'objet actuellement selectionne"""
        objet = None
        index = self.item(self.currentRow(), 0)
        if index > 0:
            objet = charger(self.fichier, str(index.text().toUtf8()))
        return objet
    

class DmTableAttributsPi(DmTableWidget):
    """table utilisee pour afficher les attributs d'un pion dans le panneau Pi"""
    def __init__(self, parent = None):
        super(DmTableBiblio, self).__init__(parent)
        self.fichier = ""
        self.masquerColonneId()

    def defFichier(self, fichier):
        """definit le fichier de sauvegarde qui la source des donnees de la table"""
        self.fichier = fichier

    def initAffichage(self):
        """fait les differents reglages relatifs a l'apparence"""
        self.setColumnWidth(0, 0)
        self.setIconSize(QSize(30,20))   
        self.horizontalHeader().setStretchLastSection(True)
        
    def remplir(self):
        """remplit la table avec les donnees contenues dans le dictionnaire de la savuvegarde"""
        dico = afficheSvg(self.fichier)
        self.majEnCours = True
        self.setSortingEnabled(False)
        index = 0
        for elt in dico:
            objet = dico[elt]
            self.insertRow(int(index))
            
            #code de l'objet
            self.setItem(int(index),0,QTableWidgetItem(QString.fromUtf8(elt)))
            #icone et nom
            icon = QIcon("img\\"+objet.icone())
            item = QTableWidgetItem(icon,QString.fromUtf8(objet.nom))
            self.setItem(int(index),1,item)
            
            index += 1        
        self.sizeHintForColumn(1)
        self.setSortingEnabled(True)
        self.sortItems(1)
        self.majEnCours = False

    def maj(self):
        self.vider()
        self.remplir()

    def actuel(self):
        """renvoie l'objet actuellement selectionne"""
        objet = None
        index = self.item(self.currentRow(), 0)
        if index > 0:
            objet = charger(self.fichier, str(index.text().toUtf8()))
        return objet


class DmTableListeAttaques(DmTableWidget):
    """liste des attaques du combattant"""
    def __init__(self, parent = None):
        super(DmTableListeAttaques, self).__init__(parent)
        self.panneau = None
        self._listeAttaques = []
        self.connect(self, SIGNAL("currentCellChanged(int, int, int, int)"), self.selectionChangee)

    def listeAttaques(self):
        #on recupere les donnees de l'attaque en cours avant d'exporter la liste
        self.enregistrerPanneau(self.ligneSelectionnee())
        return self._listeAttaques

    def attaqueSelectionnee(self):
        """renvoie l'attaque selectionnee"""
        retour = None
        if len(self._listeAttaques) > 0 and self.ligneSelectionnee() != None:
            retour = self._listeAttaques[self.ligneSelectionnee()]
        return retour

    def majAttaque(self, index, nouvelle):
        """met a jour les donnees de l'attaque en position x"""
        self._listeAttaques[index] = nouvelle

    def charger(self, fenetre, listeAttaques):
        self.panneau = fenetre.ui.edc_attaque_panneau
        self._listeAttaques = listeAttaques
        self.peupler()
        self.selectionner(0, 0)
        self.majPanneau()
        
    def peupler(self):
        self.vider()
        for attaque in self._listeAttaques:
            ligne = self.nouvelleLigneFin()
            self.setItem(ligne, 0, QTableWidgetItem(attaque.icone(), QString.fromUtf8(attaque.nom())))      

    def majPanneau(self):
        """met a jour les donnees du panneau"""
        self.panneau.chargerAttaque(self.attaqueSelectionnee())

    def enregistrerPanneau(self, ligne):
        """enregistre les donnees du panneau sur l'attaque de la ligne"""
        attaque = self.panneau.attaque()
        if attaque:
            self._listeAttaques[ligne] = attaque
        self.peupler()

    def nouvelle(self):
        attaque = Cac()
        self._listeAttaques.append(attaque)
        self.peupler()
        self.selectionner(self.rowCount(), 0)
        
    def supprimer(self):
        """supprime l'attaque actuellement selectionnee"""
##        ligne = self.ligneSelectionnee()
        self._listeAttaques.remove(self.attaqueSelectionnee())
        self.peupler()
##        self.selectionner(ligne, 0)
##        self.removeRow(self.ligneSelectionnee())

    def selectionChangee(self, ancienneLigne, ancienneColonne, ligne, colonne):
        self.enregistrerPanneau(ancienneLigne)
        self.panneau.chargerAttaque(None)
        self.majPanneau()
##        self.emit(SIGNAL("selectionChangee(int, int)"), ancienneLigne, ligne)
        


class DmTableAttributsAttaque(DmTableWidget):
    """table contenant les attributs (selon regles) d'une attaque"""
    def __init__(self, parent = None):
        super(DmTableAttributsAttaque, self).__init__(parent)
        self._constr = False

    def attributs(self):
        """retourne un dictionnaire contenant les attributs"""
        dico = {}
        for ligne in self.lignes():
            nomAttr = regles.ordreAttributsAttaques()[ligne]
            dico[nomAttr] = regles.attributAttaque(nomAttr).controler(self.texte(ligne, 1))
        return dico

    def construire(self):
        """cree les lignes et remplit la colonne des noms d'attributs"""
        for nomAttribut in regles.ordreAttributsAttaques():
            attribut = regles.attributAttaque(nomAttribut)
            ligne = self.nouvelleLigneFin()
            self.majTexte(ligne, 0, attribut.nom)
            self.majTexte(ligne, 1, "")
        self._constr = True
            
    def charger(self, attributs):
        """charge les attributs d'une attaque"""
        self.decharger()
        for ligne in self.lignes():
            attr = regles.ordreAttributsAttaques()[ligne]
            valeur = attributs[attr]
            self.majTexte(ligne, 1, valeur)

    def decharger(self):
        """efface les valeurs de la colonne des valeurs,
            mais laisse intacte la colonne des noms d'attributs"""
        if not self._constr:
            self.contruire()
        else:
            for ligne in self.lignes():
                self.majTexte(ligne, 1, "")
        


class DmTableMenu(QTableWidget):
    """table utilisee comme barre d'onglets verticale"""
    def __init__(self, parent = None):
        super(DmTableMenu, self).__init__(parent)
      
    def setItem(self, ligne, colonne, item):
        super(DmTableMenu, self).setItem(ligne, colonne, item)
        if ligne == 0:
            self.setItemSelected(item, True)
            

class DmFrameInf_Combattant(QGroupBox):
    """frame d'information (combattant)"""
    def __init__(self, parent = None):
        super(DmFrameInf_Combattant, self).__init__(parent)

    def maj(self, combattant):
        self.setVisible((combattant != None))
        if combattant:
            self.findChild(DmLabel, "inf_pionNom").majTexte(combattant.nom)
            self.findChild(DmLabel, "inf_pionImage").chargerImage("img\\"+combattant.img.nomFichier)
            self.findChild(DmLabel, "inf_pionEffet").setVisible(False)
            

class DmFrameInf_Decor(QGroupBox):
    """frame d'information (decor)"""
    def __init__(self, parent = None):
        super(DmFrameInf_Decor, self).__init__(parent)

    def maj(self, decor):
        self.setVisible((decor != None))
        if decor:
            self.findChild(DmLabel, "inf_decorNom").majTexte(decor.nom)
            self.findChild(DmLabel, "inf_decorImage").chargerImage("img\\"+decor.img.nomFichier)

class DmFrameInf_Case(QGroupBox):
    """frame d'information (case)"""
    def __init__(self, parent = None):
        super(DmFrameInf_Case, self).__init__(parent)

    def maj(self, case):
        self.setVisible((case != None))
        if len(case.terrain.nom) > 0:
            self.findChild(DmLabel, "inf_caseTerrain").majTexte(case.terrain.nom)
        else:
            self.findChild(DmLabel, "inf_caseTerrain").majTexte("Case")
            
        self.findChild(DmLabel, "inf_caseCoord").majTexte("X: {}  Y: {}".format(case.x, case.y))
        self.findChild(DmLabel, "inf_caseAltitude").majTexte("Alt.: {}".format(case.altitude))
        
        if case.effetActif != "":
            self.findChild(DmLabel, "inf_caseEffet").chargerImage("img\\"+case.imgEffet[case.effetActif])          
        else:
            self.findChild(DmLabel, "inf_caseEffet").clear()      

class DmFrame(QFrame):
    """surcharge de QFrame"""
    def __init__(self, parent = None):
        super(DmFrame, self).__init__(parent)

class DmEdcPanneauAttaque(DmFrame):
    """frame contenant les donnees de l'attaque actuellement
        affichee lors de la creation de combattant"""
    def __init__(self, parent = None):
        super(DmEdcPanneauAttaque, self).__init__(parent)
        self.fenetre = None

    def construire(self, fenetre):
        self.fenetre = fenetre
        self.fenetre.ui.edc_attaque_attributs.vider()
        self.fenetre.ui.edc_attaque_attributs.construire()
        self.chargerAttaque(None)
##        self.connect(self.fenetre.ui.edc_attaque_liste, SIGNAL("selectionChangee(int, int)"), self.listeSelectionChangee)

    def chargerAttaque(self, attaque = None):
        """met a jour le contenu avec les donnees de l'attaque en param"""
        if attaque:
            self.setEnabled(True)
            if isinstance(attaque, Cac):
                self.fenetre.ui.edc_attaque_type.setCurrentIndex(0)
            elif isinstance(attaque, Distance):
                self.fenetre.ui.edc_attaque_type.setCurrentIndex(1)
            elif isinstance(attaque, Zone):
                self.fenetre.ui.edc_attaque_type.setCurrentIndex(2)
                self.fenetre.ui.edc_attaque_forme.setVisible(True)
                self.fenetre.ui.edc_attaque_forme_e.setVisible(True)
                if isinstance(attaque, Ligne):
                    self.fenetre.ui.edc_attaque_forme.setCurrentIndex(0)
                elif isinstance(attaque, Disque):
                    self.fenetre.ui.edc_attaque_forme.setCurrentIndex(1)
                    self.fenetre.ui.edc_attaque_rayon.setValue(attaque.rayon())
                    self.fenetre.ui.edc_attaque_rayon.setVisible(True)
                    self.fenetre.ui.edc_attaque_rayon_e.setVisible(True)
                elif isinstance(attaque, Cone):
                    self.fenetre.ui.edc_attaque_forme.setCurrentIndex(2)
                    
            self.fenetre.ui.edc_attaque_nom.majTexte(attaque.nom())
            self.fenetre.ui.edc_attaque_portee.setValue(attaque.portee())
            self.fenetre.ui.edc_attaque_attributs.charger(attaque.attributs())
            self.fenetre.ui.edc_attaque_notes.majTexte(attaque.notes())
        else:
            self.fenetre.ui.edc_attaque_type.setCurrentIndex(0)
            self.fenetre.ui.edc_attaque_nom.majTexte("")
            self.fenetre.ui.edc_attaque_portee.setValue(1)
            self.fenetre.ui.edc_attaque_forme.setCurrentIndex(0)
            self.fenetre.ui.edc_attaque_forme.setVisible(False)
            self.fenetre.ui.edc_attaque_forme_e.setVisible(False)
            self.fenetre.ui.edc_attaque_rayon.setValue(1)
            self.fenetre.ui.edc_attaque_rayon.setVisible(False)
            self.fenetre.ui.edc_attaque_rayon_e.setVisible(False)
            self.fenetre.ui.edc_attaque_attributs.decharger()
            self.fenetre.ui.edc_attaque_notes.majTexte("")
            self.setEnabled(False)

    def attaque(self):
        """retourne l'attaque en cours"""
        attaque = None
        if self.isEnabled():
            if self.fenetre.ui.edc_attaque_type.currentIndex() == 0:
                attaque = Cac()
            elif self.fenetre.ui.edc_attaque_type.currentIndex() == 1:
                attaque = Distance()
            elif self.fenetre.ui.edc_attaque_type.currentIndex() == 2:
                if self.fenetre.ui.edc_attaque_forme.currentIndex() == 0:
                    attaque = Ligne()
                elif self.fenetre.ui.edc_attaque_forme.currentIndex() == 1:
                    attaque = Disque()
                    attaque.majRayon(self.fenetre.ui.edc_attaque_rayon.value())
                elif self.fenetre.ui.edc_attaque_forme.currentIndex() == 2:
                    attaque = Cone()

            nom = self.fenetre.ui.edc_attaque_nom.texte()
            if len(nom) == 0: nom = "Attaque"
            attaque.majNom(nom)
            attaque.majPortee(self.fenetre.ui.edc_attaque_portee.value())
            attaque.majAttributs(self.fenetre.ui.edc_attaque_attributs.attributs())
            attaque.majNotes(self.fenetre.ui.edc_attaque_notes.texte())
        return attaque