dmonde/lib/ui/dm.py

#from __future__ import unicode_literals
# -*- coding: utf-8 -*-
"""ensemble des widgets surchargés"""
import os

from PyQt4.QtCore import QString, SIGNAL, QVariant, QSize, pyqtSignal, \
    QPersistentModelIndex, Qt, QEvent, QModelIndex
from PyQt4.QtGui import QLabel, QPixmap, QTextEdit, QLineEdit, QGraphicsView, \
    QComboBox, QSpinBox, QTabWidget, QTableWidget, QTableWidgetItem, \
    QItemSelectionModel, QIcon, QColor, QBrush, QGroupBox, QFrame

from lib.mat import chargerMat
from lib.outilsSvg import afficheSvg


try:
    from lib.commun import rep, charger
except:
    try:
        from commun import rep, charger
    except:
        print "dm: impossible de charger commun"

try:        
    import lib.regles as regles
except:
    try:
        import regles as regles
    except:
        print "dm: impossible de charger regles"

class Biblio():
    """cette classe fournit une liste spreciale"""
    def __init__(self):
        self.dico = {}
        self.ordre = []

    def trierPar(self, param):
        """trie en fonction du parametre des objets"""
        ordre = []
        return ordre

    def elt(self, index):
        return self.dict[index]

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

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

    def chargerImage(self, img = None):
        """prend une RImage en parametre"""
        self.clear()
        if img:
            self._image = img
            pix = img.pix(self.width(), self.height())
        else:
            pix = QPixmap()
        self.setPixmap(pix)         

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

    def image(self):
        return self._image

    def mousePressEvent(self, event):
        if event.button() == 1:
            self.emit(SIGNAL("clicked()"))

    def mouseDoubleClickEvent(self, event):
        if event.button() == 1:
            self.emit(SIGNAL("doubleClicked()"))

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()))
            self.emit(SIGNAL("zoomChange(int)"), self.nbZoomActuel)
        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 DmSpinBox(QSpinBox):
    """surcharge de QSpinBox"""
    def __init__(self, parent = None):
        super(DmSpinBox, self).__init__(parent)
    
    def focusInEvent(self, event):
        super(DmSpinBox, self).focusInEvent(event)
        self.selectAll()


class DmTabInventaire(QTabWidget):
    """surcharge de QTabWidget stylisee et
        utilisee pour filtrer les types d'objets affiches"""
    def __init__(self, parent = None):
        super(DmTabInventaire, self).__init__(parent)
        self.setStyleSheet(QString.fromUtf8("""
                                             QTabWidget::pane { border-top: 2px solid #C2C7CB; }
                                             QTabWidget::tab-bar { alignment: right; }
                                             QTabBar::tab {
                                                 background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                                                                             stop: 0 #E1E1E1, stop: 0.4 #DDDDDD,
                                                                             stop: 0.5 #D8D8D8, stop: 1.0 #D3D3D3);
                                                 border: 2px solid #C4C4C3;
                                                 border-bottom-color: #C2C7CB;                                                  border-top-left-radius: 4px;
                                                 border-top-right-radius: 8px;
                                                 border-top-left-radius: 8px;
                                                 padding-left: 15px; }
                                             QTabBar::tab:selected, QTabBar::tab:hover {
                                                 background: qlineargradient(x1: 0, y1: 0, x2: 0, y2: 1,
                                                                             stop: 0 #fafafa, stop: 0.4 #f4f4f4,
                                                                             stop: 0.5 #e7e7e7, stop: 1.0 #fafafa); }
                                             QTabBar::tab:selected { border-color: #9B9B9B;
                                                                     border-bottom-color: #C2C7CB; }
                                               """))

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)
        if not self.item(ligne, colonne):
            item = QTableWidgetItem()
            item.setData(0, var)
            self.setItem(ligne, colonne, item)
        else:
            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 DmTableMat(DmTableWidget):
    """table utilisee pour afficher les bibliotheques d'objets:
        terrains, decors, creatures"""
    def __init__(self, parent = None):
        super(DmTableMat, self).__init__(parent)
        
    def charger(self, filtre = ""):
        """remplit la table avec les donnees contenues dans les fichiers de materiel
           (filtre selon le prefixe)"""
        self.setIconSize(QSize(30,20))   
        self.horizontalHeader().setStretchLastSection(True)
        self.masquerColonneId()           
           
        self.majEnCours = True
        self.setSortingEnabled(False)
        
        for attributsFichier in os.walk(rep("jeu")):
            for f in attributsFichier[2]:
                if f[:2] == filtre or len(filtre) == 0:
                    ligne = self.nouvelleLigneFin()
                    mat = charger(os.path.join(attributsFichier[0], f))
                    self.majTexte(ligne, 0, mat.idM())
                    icon = QIcon() if not mat.icone() else QIcon(mat.icone().fichier())
                    item = QTableWidgetItem(icon, QString.fromUtf8(mat.nom()))
                    self.setItem(ligne, 1, item)
          
        self.sizeHintForColumn(1)
        self.sortItems(1)
        
        self.setSortingEnabled(True)
        self.majEnCours = False
        
    def maj(self):
        self.vider()
        self.remplir()

    def selection(self):
        """renvoie l'objet actuellement selectionne"""
        mat = chargerMat(self.texte(self.currentRow(), 0))
        return mat
    

class DmTableAttributsPi(DmTableWidget):
    """table utilisee pour afficher les attributs d'un pion dans le panneau Pi"""
    def __init__(self, parent = None):
        super(DmTableMat, 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 = []
        
        #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, 20);self.setColumnWidth(1, 70)
        self.setColumnWidth(2, 241);self.setColumnWidth(4, 60)
        self.setColumnWidth(6, 20)

    def ajouterObjet(self, objet):
        ligne = self.rowCount() - 1   #avant la ligne 'ajouter'
        self.insertRow(ligne)
        self.remplirLigne(ligne, objet)
        self._inventaire.append(objet)

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

    def majObjet(self, ancien, nouveau):
        """maj la ligne correspondant a l'objet"""
        index = self._inventaire.index(ancien)
        self._inventaire[index] = nouveau
        self.remplirLigne(index, nouveau)
        
    def supprimerObjet(self, objet):
        """ajoute la ligne correspondant a l'objet"""
        index = self._inventaire.index(objet)  
        self._inventaire.remove(objet)
        self.removeRow(index)

    def remplirLigne(self, ligne, objet):
        """remplit les cellules de la ligne avec les donnees de l'objet"""
        imgType = ["pieces.png", "btn_ModeCombat.png", "chimie.png", "diamant.png", "boite_outils.png"]
        self.creerItem(ligne, 0, "", imgType[objet.typeObjet])
        self.creerItem(ligne, 1, objet.quantite)
        self.creerItem(ligne, 2, objet.nom)
        self.creerItem(ligne, 3, objet.poidsTotal())
        self.creerItem(ligne, 4, "")
                       
    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 creerItem(self, ligne, colonne, txt, img = None):
        item = QTableWidgetItem()
        item.setFlags(Qt.NoItemFlags)
        item.setText(QString().fromUtf8(" {}".format(txt)))
        if img:
            pix = QPixmap("img\\{}".format(img))
            item.setIcon(QIcon(pix))
        self.setItem(ligne, colonne, item)

    def filtrer(self, typeObjet):
        """filtre l'affichage des lignes par type d'objet"""
        for ligne in range(0, self.rowCount() - 1):
            self.setRowHidden(ligne, typeObjet >= 0 and typeObjet != self._inventaire[ligne].typeObjet )

    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 DmTableInventaireCombat(DmTableInventaire):
    """inventaire affiche dans le panneau de combat"""
    def __init__(self, parent = None):
        super(DmTableInventaireCombat, self).__init__(parent)    

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(combattant.img.rimage)
            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(decor.img.rimage)

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)