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 *
try:
    from lib.outilsSvg import *
    import lib.regles as regles
    from lib.Actions import *
except:
    try:
        from outilsSvg import *
        import regles as regles
        from Actions import *
    except:
        pass
        
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 DmTableInventaire(DmTableWidget):
    """table utilisee pour afficher l'inventaire d'un combattant"""
    itemExited = pyqtSignal(QTableWidgetItem)
    def __init__(self, parent = None):
        super(DmTableInventaire, self).__init__(parent)
        self._inventaire = []
        self._ligneSurvolee = None
        
        #pour la gestion des survols
        self.setMouseTracking(True)
        self._last_index = QPersistentModelIndex()
        self.viewport().installEventFilter(self)
        
        self.connect(self, SIGNAL("itemEntered(QTableWidgetItem*)"), self.itemSurvole)
        self.connect(self, SIGNAL("itemExited(QTableWidgetItem*)"), self.itemSurvoleFin)
        self.connect(self, SIGNAL("itemClicked(QTableWidgetItem*)"), self.itemClique)

    def construire(self):
        self.setColumnWidth(0, 40)
        self.setColumnWidth(1, 311)
        self.setColumnWidth(2, 60)
        self.setColumnWidth(3, 60)
        self.setColumnWidth(4, 20)
        
##        for col in self.colonnes():
##            item = QTableWidgetItem()
##            item.setFlags(Qt.NoItemFlags)
##            if col == 1:
##                item.setText(0, " ")
##                item.setData(0, " ")
##            self.setItem(ligne, col, item)
##        self._inventaire.append(objet)

    def ajouterObjet(self, objet):
        ligne = self.rowCount() - 1   #avant la ligne 'ajouter'
        self.insertRow(ligne)
        donnees = [objet.quantite, objet.nom, objet.valeurTotale(), objet.poidsTotal(), ""]
        for col in self.colonnes():
            item = QTableWidgetItem()
            item.setFlags(Qt.NoItemFlags)
            item.setData(0, donnees[col])
            self.setItem(ligne, col, item)
        self._inventaire.append(objet)

    def charger(self, inventaire):
        """charge l'inventaire en parametre"""
        self._inventaire = inventaire
        for objet in inventaire:
            self.ajouterObjet(objet)

    def majObjet(self, objet):
        """maj la ligne correspondant a l'objet"""
        pass    

    def supprimerObjet(self, objet):
        """ajoute la ligne correspondant a l'objet"""
        pass        

    def inventaire(self):
        """cree un inventaire a partir des donnees de la table"""
        return self._inventaire

    def itemSurvole(self, item):
        ligne = item.row()
        self.majCouleurLigne(ligne, QColor(150, 50, 50, 150))

    def itemSurvoleFin(self, item):
        ligne = item.row()
        self.majCouleurLigne(ligne, QColor(248, 248, 248, 150))

    def itemClique(self, item):
        ligne = item.row()
        self.emit(SIGNAL("objetClique(int)"), ligne)

    def majCouleurLigne(self, ligne, couleur):
        """modifie la couleur de fond des items de la lignes"""
        for col in self.colonnes():
            item = self.item(ligne, col)
            if item:
                item.setBackground(QBrush(couleur))

    def eventFilter(self, widget, event):
        if widget is self.viewport():
            index = self._last_index
            if event.type() == QEvent.MouseMove:
                index = self.indexAt(event.pos())
            elif event.type() == QEvent.Leave:
                index = QModelIndex()
            if index != self._last_index:
                row = self._last_index.row()
                column = self._last_index.column()
                item = self.item(row, column)
                if item is not None:
                    self.itemExited.emit(item)
                self._last_index = QPersistentModelIndex(index)
        return QTableWidget.eventFilter(self, widget, event)


            

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