Création de la classe Partie

Création des classes DmTableBiblio et DmTableWidget

PJ.txt

@@ -0,0 +1,7 @@
+PJ:
+
+Combattant()
+
+estPJ = True
+
+

creation.txt

@@ -0,0 +1,42 @@
+3 types d'objets: terrains, décors, créatures
+
+3 origines (4?): Commun, Perso, Ce plateau seulement (, règles?)
+
+Parties:
+
+Général:
+  Id
+  Nom
+  notes
+
+Pion:
+  logo
+  hauteur
+  Forme
+  couleur
+  image et format image
+  texte et format texte
+
+Terrain:
+  couleur
+  imgTexture
+  franchissable
+  franchissableNage
+  franchissableEscalade
+  modDeplacement  
+  visibilite
+
+Décor:
+  escalade
+  franchissable
+  brule
+
+Créature:
+  Deplacement
+  Deplacement (nage)
+  Deplacement (vol)
+  Attaques
+  Inventaire
+  Attributs
+
+

lib/Partie.py

@@ -0,0 +1,23 @@
+#from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+"""partie de DMonde, caracterisee par un groupe de joueurs, des personnages, 
+un MJ (interchangeable), une carte du monde, un journal de quêtes
+une liste de plateaux, et un ensemble de règles"""
+
+
+class Partie():
+    def __init__(self):
+        self.id = ""
+        self.nom = "Partie"
+
+        self.joueurs = []
+        self.mj = 0
+
+        self.regles = ""
+
+        self.personnages = []          #liste de Combattant()
+        self.carteMonde = CarteMonde()
+        self.journal = Journal()
+        self.plateaux = []
+
+        

lib/Pion.py

@@ -57,6 +57,10 @@ class Pion(QGraphicsItem):
         """renvoie le nom et le numero complementaire du pion"""
         return "{} {}".format(self.nom, self.numComplementaire)
 
+    def logo(self):
+        """renvoie l'image a afficher dans les listes"""
+        return self.logo
+
     ###attributs du pion
     def position(self):
         """retourne la position actuelle du pion"""

lib/PionDecor_ancien.py

@@ -1,241 +0,0 @@
-#from __future__ import unicode_literals
-# -*- coding: utf-8 -*-
-from __future__ import division
-
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-
-from Decor import Decor
-from Forme import Forme
-
-
-
-class PionDecor(QGraphicsItem):
-    """pion du plateau de combat representant un decor"""
-    def __init__(self, plateau, numero, parent=None):
-        super(PionDecor, self).__init__(parent)
-        #plateau
-        self.plateau = plateau    
-
-        #attributs
-        self.nom = "decor"
-        self.numero = numero
-        self.decor = Decor()
-        self.position = (-1, -1)
-        self.forme = Forme(self.plateau.formeCases)
-        self.z = 0
-        self.hauteur = 1   #hauteur de l'objet en cases
-        self.pixGraphique = None
-        self.largeurOriginale = 0
-        self.hauteurOriginale = 0
-        self.polygoneGraphique = None
-        self.nbRotations = 0
-
-    def __getstate__(self):
-        state = {key:value for key, value in self.__dict__.items() if not key in ["plateau", "forme", "polygoneGraphique", "pixGraphique", "shadow"]}
-        return (state)
-
-    def __setstate__(self, state):
-        self.__dict__ = state
-
-    def paint(self, painter, option, widget = None):
-        """reimplemente de QGraphicsItem"""
-        pass
-
-    def surbrillance(self, active):
-        """active/desactive la surbrillance"""
-        pass
-
-    def txtId(self):
-        return self.nom
-
-    ########### fonctions graphiques et geometriques   ##############
-    def creer(self, posX, posY, decor, nbRotations):
-        """place le pion decor sur le plateau"""        
-        self.decor = decor
-        self.setFlag(QGraphicsItem.ItemHasNoContents) #inutile de peindre l'item
-        self.setHandlesChildEvents(True)
-        
-        if len(self.decor.formeDef[self.plateau.formeCases]) > 0:
-            self.forme.definirForme(self.decor.formeDef[self.plateau.formeCases])
-        self.hauteur = self.decor.hauteur
-        
-        self.position = (posX, posY)
-        self.majNbRotations(nbRotations)
-
-        #aspect graphique
-        self.majAspectGraphique()
-
-        #ajout de l'objet graphique et placement
-        self.plateau.addItem(self)
-
-    def recreer(self, plateau):
-        """recree l'objet graphique apres un chargement"""
-        self.plateau = plateau
-        super(PionDecor, self).__init__()
-        self.setFlag(QGraphicsItem.ItemHasNoContents) #inutile de peindre l'item
-        self.setHandlesChildEvents(True)
-        self.polygoneGraphique = None
-        self.pixGraphique = None
-        self.forme = Forme(self.plateau.formeCases)
-        if len(self.decor.formeDef[self.plateau.formeCases]) > 0:
-            self.forme.definirForme(self.decor.formeDef[self.plateau.formeCases])        
-        #aspect graphique
-        self.majAspectGraphique()
-        #ajout de l'objet graphique et placement
-        self.plateau.addItem(self)
-             
-    def majAspectGraphique(self):
-        """met a jour l'aspect graphique du pion"""
-        #creation de la forme
-        if not self.polygoneGraphique:
-            polygone = self.plateau.polygoneAgglo(self.forme.listeCases((0,0)))
-            self.polygoneGraphique = QGraphicsPolygonItem()
-            self.polygoneGraphique.setPolygon(polygone)
-            self.polygoneGraphique.setAcceptHoverEvents(True)
-            self.polygoneGraphique.setFlag(QGraphicsItem.ItemIsFocusable)   #l'item peut recevoir des commandes souris/clavier
-            self.polygoneGraphique.setParentItem(self)
-            self.polygoneGraphique.setPos(QPointF(0,0))
-            if self.plateau.formeCases == "H":
-                self.polygoneGraphique.setTransformOriginPoint(QPointF(2*0.2886*self.plateau.hCase,0.5*self.plateau.hCase))
-            else:
-                self.polygoneGraphique.setTransformOriginPoint(QPointF(0.5*self.plateau.hCase,0.5*self.plateau.hCase))
-                
-        if self.plateau.formeCases == "H":
-            angleRotation = 60
-            positionGraphique = QPointF(self.position[0] * 0.866 * self.plateau.hCase, self.position[1] * self.plateau.hCase)
-        else:
-            angleRotation = 90
-            positionGraphique = QPointF(self.position[0] * self.plateau.hCase, self.position[1] * self.plateau.hCase)
-            
-        self.polygoneGraphique.setRotation(self.nbRotations*angleRotation)    
-        self.setPos(positionGraphique)
-        self.setZValue(10)    #place au dessus des cases
-        
-        #interactions
-        self.setFlag(QGraphicsItem.ItemIsFocusable)
-        self.setAcceptHoverEvents(True)   #accepte les evenements survol souris
-
-        #bordure
-        pinceau = QPen()
-        #pinceau.setColor(self.decor.couleur.darker(130))
-        pinceau.setColor(self.decor.couleur)
-        pinceau.setWidth(10)
-        self.polygoneGraphique.setPen(pinceau)
-
-        #ombre
-        self.shadow = QGraphicsDropShadowEffect()
-        self.shadow.setColor(QColor(50, 50, 50)) 
-        self.shadow.setXOffset(1) 
-        self.shadow.setYOffset(2) 
-        self.shadow.setBlurRadius(3)  
-        self.shadow.setEnabled(True)
-        self.polygoneGraphique.setGraphicsEffect(self.shadow)
-
-        #maj de l'image
-        self.majImage()
-
-        #fond 
-        if self.decor.couleur.isValid():
-            self.polygoneGraphique.setBrush(self.decor.couleur)
-        else:
-            self.polygoneGraphique.setBrush(QColor(255, 0, 0, 100))
-
-        #on met a jour l'occupation des cases
-        for coord in self.forme.listeCases((self.position[0],self.position[1]), self.nbRotations):
-            self.plateau.cases[coord].majOccupation(self, self.z)
-
-    def majImage(self):
-        """met a jour la taille, la position et l'orientation de l'image"""
-        if len(self.decor.img["nom"]) > 0:
-            pix = QPixmap(QString.fromUtf8("img\\"+self.decor.img["nom"]))
-            if self.decor.img["masqueAuto"]:
-                pix.setMask(pix.createHeuristicMask())
-            if not pix.isNull():
-                if not self.pixGraphique:
-                    self.pixGraphique = QGraphicsPixmapItem()
-                    self.pixGraphique.setZValue(10) 
-                    if pix.height() >= pix.width():
-                        pix = pix.scaledToHeight(self.plateau.hCase*0.9, Qt.SmoothTransformation)
-                    else:
-                        pix = pix.scaledToWidth(self.plateau.hCase*0.9, Qt.SmoothTransformation)
-                    self.largeurOriginale = pix.width()
-                    self.hauteurOriginale = pix.height()
-                    pix = pix.scaled((self.decor.img["kx"]/10)*pix.width(), \
-                                     (self.decor.img["ky"]/10)*pix.height(), \
-                                      Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
-                    self.pixGraphique.setPixmap(pix)
-
-                deltaX = self.decor.img["dx"] + 0.5*(self.plateau.hCase*1.1544 - self.largeurOriginale)
-                deltaY = self.decor.img["dy"] + 0.5*(self.plateau.hCase - self.hauteurOriginale)
-                if self.decor.img["nom"] != self.decor.logo and self.decor.img["pivote"] == True:
-                    self.pixGraphique.setParentItem(self.polygoneGraphique)
-                else:
-                    self.pixGraphique.setParentItem(self)
-                self.pixGraphique.setRotation(self.decor.img["rotation"])
-                self.pixGraphique.setPos(QPointF(deltaX, deltaY))            
-
-    def majNbRotations(self, nbRotations):
-        self.nbRotations = nbRotations
-        if self.plateau.formeCases == "H":
-            rotationsTour = 6
-        else:
-            rotationsTour = 4
-            
-        if self.nbRotations >= 0:
-            self.nbRotations = self.nbRotations % rotationsTour
-        else:
-            self.nbRotations = self.nbRotations % (-rotationsTour)
-
-    def majPosition(self, position, nbRotations = 0):
-        for coord in self.forme.listeCases((self.position[0],self.position[1]), self.nbRotations):
-            self.plateau.cases[coord].majOccupation(self)
-        self.position = position
-        self.majNbRotations(nbRotations)
-        self.majAspectGraphique()
-        
-    def afficheOmbreSelection(self, actif = False):
-        if actif:
-            self.shadow.setXOffset(3) 
-            self.shadow.setYOffset(3)
-        else:
-            self.shadow.setXOffset(1) 
-            self.shadow.setYOffset(2)  
-
-    def supprimer(self):
-        """'deconnecte' les items enfants avant de supprimer du pion"""
-        if self.pixGraphique != None:
-            self.pixGraphique.prepareGeometryChange()
-            self.pixGraphique.setParentItem(None)
-        self.polygoneGraphique.prepareGeometryChange()
-        self.polygoneGraphique.setParentItem(None)
-        self.plateau.removeItem(self)
-        self.plateau = None
-
-    ##################
-
-    ###############   evenements clavier et souris    ##############         
-    def boundingRect(self):
-        return QRectF()
-
-    def hoverEnterEvent(self, event):
-        """evenement lors du survol de la souris (en entree)""" 
-        self.plateau.caseSurvol(self.position[0], self.position[1])
-        self.plateau.pionDecorSurvol(self.numero)
-
-    def hoverLeaveEvent(self, event):
-        """evenement lors du survol de la souris (en sortie)"""
-        self.plateau.pionDecorSurvol(None)
-
-    def mousePressEvent(self, event):
-        """evenement lors du clic souris"""
-        if event.button() == 1: #sur clic gauche  
-            #en mode creation, on peut selectionner le decor pour le deplacer ou le supprimer
-            if self.plateau.modePrincipal == "creation":
-                 self.plateau.pionDecorSaisir(self.numero)
-                 event.accept()
-        else:
-            event.ignore()            
-            
-    
-    #######################

lib/Pion_ancien.py

@@ -1,343 +0,0 @@
-#from __future__ import unicode_literals
-# -*- coding: utf-8 -*-
-from __future__ import division
-import os
-
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-
-from Creature import Creature
-from Forme import Forme
-from outilsSvg import *
-
-class Pion(QGraphicsItem):
-    """pion du plateau de combat"""
-    def __init__(self, plateau, numero, parent=None):
-        super(Pion, self).__init__()
-        #plateau
-        self.plateau = plateau
-
-        #attributs
-        self.numero = numero
-        self.creature = Creature()
-        self.nom = "pion"
-        self.numTxt = ""
-        self.lstCarac = self.creature.listeCarac()   #caracteristiques par defaut issues des regles utilisees
-        self.position = (-1, -1)
-        self.forme = Forme(self.plateau.formeCases)
-        self.champDeplacement = {}   #dictionnaire des cases jusqu'auquelles le pion peut se deplacer (coordonnees : distance)
-        self.deplacementRestant = 0
-        self.z = 0         #hauteur z par rapport a l'altitude de la case occupee
-        self.hauteur = 1   #nombre de cases occupees en hauteur
-        self.pixGraphique = None
-        self.largeurOriginale = 0
-        self.hauteurOriginale = 0
-        self.polygoneGraphique = None
-        self.nbRotations = 0
-        self.etat = ""
-        self.attaques = []   #liste des attaques pre-parametrees du pion
-        self.notes = ""
-
-
-    def __getstate__(self):
-        self.idCreature = self.creature.id
-        state = {key:value for key, value in self.__dict__.items() if not key in ["plateau", "brillance", "shadow", "creature", \
-                                                                                  "polygonesForme", "pixGraphique"]}
-        return (state)
-
-    def __setstate__(self, state):
-        self.__dict__ = state
-        self.creature = charger("lib\\biblio\\creature", self.idCreature)
-        if self.creature == None:
-            self.creature = Creature()
-
-    def paint(self, painter, option, widget = None):
-        """reimplemente de QGraphicsItem"""
-        pass
-
-    def txtId(self):
-        """renvoie le nom et le numero complementaire du pion"""
-        return "{} {}".format(self.nom, self.numTxt)
-    
-    ########### fonctions graphiques et geometriques   ##############
-    def creer(self, posX, posY, nom, numTxt = "", creature = None, couleur = None, nbRotations = 0):
-        """place le pion sur le plateau"""        
-        #definition de la forme  
-        if creature != None:
-            self.creature = creature  
-            if len(self.creature.formeDef[self.plateau.formeCases]) > 0:
-                self.forme.definirForme(self.creature.formeDef[self.plateau.formeCases])
-            self.attaques = self.creature.listeAttaques()
-            self.lstCarac = self.creature.listeCarac()
-        else:
-            if couleur != None:
-                if couleur.isValid():
-                    self.creature.couleur = couleur
-                    
-        self.creerPolygone()
-        self.deplacementRestant = self.creature.deplacement
-        
-        self.nom = nom
-        self.numTxt = numTxt
-        
-        #aspect graphique
-        self.majAspectGraphique()
-
-        #ajout de l'objet graphique
-        self.plateau.addItem(self)
-
-        #enregistrement et maj de la position
-        self.majPosition((posX, posY), nbRotations)
-
-    def recreer(self, plateau):
-        """recree le pion (apres un chargement du plateau par ex)"""
-        self.plateau = plateau  
-        super(Pion, self).__init__()
-        self.pixGraphique = None
-        self.polygoneGraphique = None
-        self.creerPolygone()
-        self.majAspectGraphique()
-        self.plateau.addItem(self)
-        self.majPosition(self.position, self.nbRotations)
-
-    def creerPolygone(self):
-        """cree le polygone representant le pion (doit etre cree avant toute rotation)"""
-        polygone = self.plateau.polygoneAgglo(self.forme.listeCases((0,0)))
-        self.polygoneGraphique = QGraphicsPolygonItem()
-        self.polygoneGraphique.setPolygon(polygone)
-        self.polygoneGraphique.setAcceptHoverEvents(True)
-        self.polygoneGraphique.setFlag(QGraphicsItem.ItemIsFocusable)   #l'item peut recevoir des commandes souris/clavier
-        self.polygoneGraphique.setParentItem(self)
-        self.polygoneGraphique.setPos(QPointF(0,0))
-        if self.plateau.formeCases == "H":
-            self.polygoneGraphique.setTransformOriginPoint(QPointF(2*0.2886*self.plateau.hCase,0.5*self.plateau.hCase))
-        else:
-            self.polygoneGraphique.setTransformOriginPoint(QPointF(0.5*self.plateau.hCase,0.5*self.plateau.hCase))
-
-    def majAspectGraphique(self):
-        """met a jour l'aspect graphique du pion
-          (seulement les parametres independants de la position et de la forme de l'objet)"""
-        self.setZValue(10)
-           
-        #interactions graphiques
-##        self.setFlag(QGraphicsItem.ItemIsFocusable)   #l'item peut recevoir des commandes souris/clavier
-        self.setFlag(QGraphicsItem.ItemHasNoContents) #inutile de peindre l'item
-##        self.setAcceptHoverEvents(True)   #accepte les evenements survol souris
-        self.setHandlesChildEvents(True)
-
-        #classes graphiques
-        self.brillance = QGraphicsColorizeEffect()
-        self.shadow = QGraphicsDropShadowEffect()
-         
-        #etiquette         
-        self.text = QGraphicsSimpleTextItem("{}. {}".format(self.numero, self.txtId()))
-        self.text.setPos(QPointF(self.creature.txt["dx"]-0.112*self.plateau.hCase, self.creature.txt["dy"]-0.275*self.plateau.hCase))
-        police = QFont("Georgia", self.creature.txt["taille_police"])
-        police.setBold(self.creature.txt["gras"])
-        self.text.setFont(police)
-        self.text.setRotation(self.creature.txt["rotation"])
-        self.text.setParentItem(self)
-
-        #bordure
-        pinceau = QPen()
-        pinceau.setColor(self.creature.couleur.darker(130))
-        pinceau.setWidth(10)
-        self.polygoneGraphique.setPen(pinceau)
-            
-        #couleur de fond 
-        if self.creature.couleur.isValid():
-             self.polygoneGraphique.setBrush(self.creature.couleur)
-        else:
-             self.polygoneGraphique.setBrush(QColor(255, 0, 0, 150))
-        
-        #ombre
-        self.shadow.setColor(QColor(50, 50, 50)) 
-        self.shadow.setXOffset(1) 
-        self.shadow.setYOffset(2) 
-        self.shadow.setBlurRadius(3)  
-        self.shadow.setEnabled(True)
-        self.polygoneGraphique.setGraphicsEffect(self.shadow)
-
-        #brillance (invisible par defaut, est un polygone semi transparent superpose au pion)
-        self.polygoneBrillance = QGraphicsPolygonItem()
-        self.polygoneBrillance.setPolygon(self.polygoneGraphique.polygon())
-        self.polygoneBrillance.setVisible(False)
-        self.polygoneGraphique.setFlag(QGraphicsItem.ItemIsFocusable)
-        self.setAcceptHoverEvents(True)   #accepte les evenements survol souris
-        self.polygoneBrillance.setParentItem(self.polygoneGraphique)
-
-    def majPosition(self, nouvellePosition, nbRotations = 0):
-        """met a jour la position de l'objet graphique et de sa forme en fonction de sa position enregistree"""
-        valide = True  
-        if nouvellePosition in self.champDeplacement and self.plateau.modePrincipal == "combat":
-            distanceParcourue = self.champDeplacement[nouvellePosition]
-            if distanceParcourue <= self.deplacementRestant:
-                self.deplacementRestant -= distanceParcourue
-            else:
-                print ("pas assez de points de deplacement")
-                valide = False
-
-        if valide:
-            #on met a jour l'occupation des cases
-            if self.position != (-1,-1):
-                for coord in self.forme.listeCases((self.position[0],self.position[1]), self.nbRotations):
-                    self.plateau.cases[coord].majOccupation(self)
-
-            #on met a jour la position du pion        
-            self.position = nouvellePosition
-            self.majNbRotation(nbRotations)
-
-            #on replace
-            if self.plateau.formeCases == "H":
-                angleRotation = 60
-                positionGraphique = QPointF(self.position[0] * 0.866 * self.plateau.hCase, self.position[1] * self.plateau.hCase)
-            else:
-                angleRotation = 90
-                positionGraphique = QPointF(self.position[0] * self.plateau.hCase, self.position[1] * self.plateau.hCase)
-            self.prepareGeometryChange()
-            self.setPos(positionGraphique)
-            self.polygoneGraphique.setRotation(self.nbRotations*angleRotation)
-            
-            #maj de l'image
-            self.majImage()
-            
-            #on met a jour l'occupation des cases
-            for coord in self.forme.listeCases((self.position[0],self.position[1]), self.nbRotations):
-                 self.plateau.cases[coord].majOccupation(self, self.z)
-   
-    def majImage(self):
-        """met a jour la taille, la position et l'orientation de l'image"""
-        if len(self.creature.img["nom"]) > 0:
-            pix = QPixmap(QString.fromUtf8("img\\"+self.creature.img["nom"]))
-            if self.creature.img["masqueAuto"]:
-                pix.setMask(pix.createHeuristicMask())
-            if not pix.isNull():
-                if not self.pixGraphique:
-                    self.pixGraphique = QGraphicsPixmapItem()
-                    self.pixGraphique.setZValue(10) 
-                    if pix.height() >= pix.width():
-                        pix = pix.scaledToHeight(self.plateau.hCase*0.9, Qt.SmoothTransformation)
-                    else:
-                        pix = pix.scaledToWidth(self.plateau.hCase*0.9, Qt.SmoothTransformation)
-                    self.largeurOriginale = pix.width()
-                    self.hauteurOriginale = pix.height()
-                    pix = pix.scaled((self.creature.img["kx"]/10)*pix.width(), \
-                                     (self.creature.img["ky"]/10)*pix.height(), \
-                                      Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
-                    self.pixGraphique.setPixmap(pix)
-
-                deltaX = self.creature.img["dx"] + 0.5*(self.plateau.hCase*1.1544 - self.largeurOriginale)
-                deltaY = self.creature.img["dy"] + 0.5*(self.plateau.hCase - self.hauteurOriginale)
-                if self.creature.img["nom"] != self.creature.logo and self.creature.img["pivote"] == True:
-                    self.pixGraphique.setParentItem(self.polygoneGraphique)
-                else:
-                    self.pixGraphique.setParentItem(self)
-                self.pixGraphique.setRotation(self.creature.img["rotation"])
-                self.pixGraphique.setPos(QPointF(deltaX, deltaY))
-
-    def majNbRotation(self, nbRotations):
-        self.nbRotations = nbRotations
-        if self.plateau.formeCases == "H":
-            rotationsTour = 6
-        else:
-            rotationsTour = 4
-            
-        if self.nbRotations >= 0:
-            self.nbRotations = self.nbRotations % rotationsTour
-        else:
-            self.nbRotations = self.nbRotations % (-rotationsTour)
-
-    def afficheOmbreSelection(self, actif = False):
-        if actif:
-            self.shadow.setXOffset(3) 
-            self.shadow.setYOffset(3)
-        else:
-            self.shadow.setXOffset(1) 
-            self.shadow.setYOffset(2)            
-        
-    def surbrillance(self, active, opacite = 0.7, couleur = "white"):
-        """active/desactive la surbrillance"""
-        if active:
-            self.polygoneBrillance.setOpacity(opacite)
-            couleur = self.couleurSurbrillance(couleur)
-            pinceau = self.polygoneGraphique.pen()
-            self.polygoneBrillance.setBrush(couleur)
-            self.polygoneBrillance.setPen(pinceau)
-        self.polygoneBrillance.setVisible(active) 
-
-    def estCibleAttaque(self, estCible, possible = True):
-        """le pion s'affiche comme etant cible d'une attaque"""
-        if not possible:
-            couleur = "red"
-        else:
-            couleur = "white"
-        self.surbrillance(estCible, 0.8, couleur)
-        
-    def majZ(self, valeur):
-        """met a jour l'altitude Z du pion"""
-        if valeur != self.z:
-            self.z = valeur            
-
-    def couleurSurbrillance(self, couleur = "white"):
-        """renvoie une QColor visible pour la surbrillance, selon la couleur du pion"""
-        retour = QColor(couleur)
-        if self.polygoneGraphique.brush().color().lightness() > 220:
-            retour = retour.darker(140)
-        elif self.polygoneGraphique.brush().color().lightness() < 80:
-            retour = retour.lighter(140)
-        return retour
-
-    def supprimer(self):
-        """'deconnecte' les items enfants avant de supprimer du pion"""
-        self.polygoneBrillance.prepareGeometryChange()
-        self.polygoneBrillance.setParentItem(None)
-        if self.pixGraphique != None:
-            self.pixGraphique.prepareGeometryChange()
-            self.pixGraphique.setParentItem(None)
-        self.polygoneGraphique.prepareGeometryChange()
-        self.polygoneGraphique.setParentItem(None)
-        self.text.prepareGeometryChange()
-        self.text.setParentItem(None)
-        self.plateau.removeItem(self)
-        self.plateau = None
- 
-    ##################
-
-    ###############   evenements clavier et souris    ##############
-    #*EP
-    def boundingRect(self):
-        return QRectF()
-    
-    def hoverEnterEvent(self, event):
-        """evenement lors du survol de la souris (en entree)"""
-        #super(Pion, self).hoverEnterEvent(event)
-        if (self.plateau.pionSelectionne() == None and self.plateau.modeActif == "standard") or self.plateau.modeActif == "pionSupprimer":
-            self.surbrillance(True, 0.4)    
-        self.plateau.pionSurvol(self.numero)
-        event.ignore()
-
-    def hoverLeaveEvent(self, event):
-        """evenement lors du survol de la souris (en entree)"""
-        #super(Pion, self).hoverLeaveEvent(event)
-        self.surbrillance(False)
-        self.plateau.pionSurvol(None)
-
-    def mousePressEvent(self, event):
-        """evenement lors du clic souris"""
-        super(Pion, self).mousePressEvent(event)
-        if event.button() == 1: #sur clic gauche
-           accepte = self.plateau.pionClique(self.numero)
-           if accepte: event.accept()
-        else:
-           event.ignore()
-
-    def mouseDoubleClickEvent(self, event):
-        """evenement lors du clic souris"""
-        super(Pion, self).mouseDoubleClickEvent(event)
-        if event.button() == 1: #sur clic gauche
-           accepte = self.plateau.pionDoubleClic(self.numero)
-           if accepte: event.accept()
-        else:
-           event.ignore()
-
-     #######################

lib/Terrain.py

@@ -15,3 +15,6 @@ class Terrain():
         self.visibilite = True       #peut on voir au travers 
         self.modDeplacement = 1.00   #modificateur a appliquer au deplacement
 
+    def logo(self):
+        """renvoie l'image a afficher dans les listes"""
+        return self.imgTexture

lib/ui/dm.py

@@ -12,3 +12,68 @@ class DmGraphicsView(QGraphicsView):
         super(DmGraphicsView, self).resizeEvent(event)
         self.emit(SIGNAL("resizeEvent()"))
     
+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 masquerColonneId(self):
+        """masque la colonne en position 0 qui contient les identifiants"""
+        self.fenetre.ui.cp_listeTerrains.hideColumn(0)
+        
+
+class DmTableBiblio(DmTableWidget):
+    """table utilisee pour afficher les bibliotheques d'objets:
+        terrains, decors, creatures"""
+    def __init__(self, fichier, parent = None):
+        """prend en parametre le fichier de sauvegarde contenant les objets"""
+        super(DmTableBiblio, self).__init__(parent)
+        self.fichier = fichier
+        self.masquerColonneId()
+
+    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)
+        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.logo())
+            item = QTableWidgetItem(icon,QString.fromUtf8(objet.nom))
+            self.setItem(int(index),1,item)
+            
+            index += 1        
+        self.setIconSize(QSize(30,20))   
+        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
+    
+
+
+

lib/ui/mainwindow.ui

@@ -1852,7 +1852,7 @@
                   </size>
                  </property>
                  <property name="currentIndex">
-                  <number>2</number>
+                  <number>0</number>
                  </property>
                  <widget class="QWidget" name="cp_afficherTerrains">
                   <attribute name="icon">
@@ -1867,7 +1867,7 @@
                   </attribute>
                   <layout class="QVBoxLayout" name="verticalLayout_4">
                    <item>
-                    <widget class="QTableWidget" name="cp_listeTerrains">
+                    <widget class="DmTableBiblio" name="cp_listeTerrains">
                      <property name="minimumSize">
                       <size>
                        <width>81</width>
@@ -3991,6 +3991,11 @@ selectionné</string>
    <extends>QGraphicsView</extends>
    <header location="global">dm.h</header>
   </customwidget>
+  <customwidget>
+   <class>DmTableBiblio</class>
+   <extends>QTableWidget</extends>
+   <header location="global">dm.h</header>
+  </customwidget>
  </customwidgets>
  <resources/>
  <connections/>

lib/ui/notes nouvelle interfac.txt

@@ -1,12 +0,0 @@
-- redimensionner la largeur des onglets:
-self.tabWidget.setStyleSheet("QTabBar::tab { width: 38px; }")
-
-- couleurs rapides;
-blanc, gris clair, gris foncé, gris trés foncé, noir, 
-bleu clair, bleu foncé, 
-jaune pale, orange, bordeaux, 
-marron clair, marron foncé, 
-vert clair, vert foncé, vert trés foncé, 
-..., ...
-
-