Refonte de l'acces aux sauvegardes materiels (creatures, decors,

terrains) ok

lib/Case.py

@@ -48,7 +48,7 @@ class Case(QGraphicsPolygonItem):
     def __getstate__(self):
         """selectionne les attributs qui seront sauvegardes"""
         state = {key:value for key, value in self.__dict__.items() if key in ["x", "y", "altitude","terrain","bordure","couleur", \
-                                                                              "ombre", "effetActif", "cachesActifs", "cachesInactifs"]}
+                                                                              "ombre", "effetActif", "caches"]}
 
         return (state)
 
@@ -246,7 +246,7 @@ class Case(QGraphicsPolygonItem):
         """met a jour le terrain de la case"""
         self.terrain = terrain
         if self.terrain.imgTexture.estValide():
-            self.setBrush(QBrush(QImage(self.terrain.imgTexture.chemin())))
+            self.setBrush(QBrush(self.terrain.imgTexture.pix()))
         else:
             if self.terrain.couleur.isValid():
                 self.setBrush(QBrush(self.terrain.couleur))

lib/Combattant.py

@@ -1,18 +1,15 @@
 #from __future__ import unicode_literals
 # -*- coding: utf-8 -*-
-from __future__ import division
 from Pion import Pion
 import regles
-import dmF
-import uid
+from mat import Materiel
 
-class Combattant(Pion):
+class Combattant(Pion, Materiel):
     """combattant sur un plateau de combat"""
     def __init__(self, parent=None):
         super(Combattant, self).__init__()
-        #caracs
-        self.id = uid.uid("cb")
-
+        self._type = "cb"
+        
         self.taille = 2
         self.depMarche = regles.valeurDefaut("depMarche")
         self.depNage = regles.valeurDefaut("depNage")

lib/Decor.py

@@ -1,17 +1,15 @@
 #from __future__ import unicode_literals
 # -*- coding: utf-8 -*-
-from __future__ import division
-import os
-
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
 from Pion import Pion
+from mat import Materiel
 
-class Decor(Pion):
+class Decor(Pion, Materiel):
     """decor a placer sur le plateau"""
-    def __init__(self, parent=None):
+    def __init__(self):
         super(Decor, self).__init__()
-        self.id = ""
+        self._type = "dc"
+
+        self.numero = -1
         self.escalade = False            #peut etre escalade
         self.brule = False               #peut prendre feu
         self.inventaire = []

lib/EcranEditionCombattant.py

@@ -14,50 +14,36 @@ from EcranEditionObjet import EcranEditionObjet
 from Objet import Objet
 from VueEditionForme import VueEditionForme
 from frameAttaque import FrameAttaque
-from lib.outilsSvg import afficheSvg
 import regles
-from rsc import selectionImage
+from rsc import selectionImage, RImage
 import ui.dm as dm
 from ui.ecran_editionCombattant import Ui_edc_fenetre
-from commun import sessionEnCours
+
 
 class EcranEditionCombattant(QDialog):
     """interface de creation/edition de terrains"""
-    def __init__(self, combattant=None, pageInitiale = 0, formeCases = "H", parent=None):
+    def __init__(self, combattant = None, pageInitiale = 0, formeCases = "H", parent=None):
         """initialisation de la fenetre"""
         super (EcranEditionCombattant, self).__init__()
-        self.pixGraphique = None
+        self._combattant = Combattant() if combattant == None else combattant
+        
+        #param de fonctionnement
+        self._modeCreation = True
         self._compteurAttaque = 0
+        
         self.createWidgets()
-        if combattant == None:
-            self.combattant = Combattant()
-        else:
-            self.combattant = combattant
-            
-        self.modeCreation = True
         self.ouverture()
-        self.ui.edc_menu.setCurrentCell(pageInitiale, 0)
-        self.ui.edc_pages.setCurrentIndex(pageInitiale)
+        self.allerAPage(pageInitiale)
+
         if formeCases == "C":
             self.ui.edc_casesCarrees.setChecked(True)
             self.majFormeCases()
-            
 
-    def nouvelIdCombattant(self):
-        """renvoie un identifiant pour un nouveau terrain"""
-        dicoSvg = afficheSvg("lib\\biblio\\Combattant")
-        nouvelId = 1
-        while str(nouvelId) in dicoSvg.keys():
-            nouvelId += 1
-        return str(nouvelId)
+    def combattant(self):
+        return self._combattant
 
     def formeCases(self):
-        retour = ""
-        if self.ui.edc_casesHexa.isChecked():
-            retour = "H"
-        else:
-            retour = "C"
-        return retour
+        return "H" if self.ui.edc_casesHexa.isChecked() else "C"
 
     def createWidgets(self):
         """construction de l'interface"""
@@ -67,26 +53,20 @@ class EcranEditionCombattant(QDialog):
         
         self.connect(self.ui.edc_nom, SIGNAL("textEdited(QString)"), self.majActivationEnregistrer)
         self.connect(self.ui.edc_nom, SIGNAL("textEdited(QString)"), self.majEtiquetteVueForme)
-
         self.connect(self.ui.edc_enregistrer, SIGNAL("clicked()"), self.enregistrer)
         self.connect(self.ui.edc_annuler, SIGNAL("clicked()"), self.annuler)
-
         self.connect(self.ui.edc_casesHexa, SIGNAL("clicked()"), self.majFormeCases)
         self.connect(self.ui.edc_casesCarrees, SIGNAL("clicked()"), self.majFormeCases)
         self.connect(self.ui.edc_couleur, SIGNAL("clicked()"), self.selectionCouleur)
         self.connect(self.ui.edc_image, SIGNAL("clicked()"), self.selectionImage)
-
         self.connect(self.ui.edc_logo, SIGNAL("clicked()"), self.selectionnerLogo)
+        
         self.vueForme = VueEditionForme(self)
-
         self.construireListeAttributs()
-
         self.construireInventaire()
         self.connect(self.ui.edc_filtreTypeObjet, SIGNAL("currentChanged(int)"), self.filtrerInventaire)
         self.ui.edc_filtreTypeObjet.stackUnder(self.ui.edc_listeInventaire)
-    
-        s = sessionEnCours()
-        print s.util()
+
 
     def layoutAtt(self):
         """retourne le layout des attaques"""
@@ -99,75 +79,77 @@ class EcranEditionCombattant(QDialog):
     def vueGraphique(self):
         return self.ui.edc_vueForme
 
+    def allerAPage(self, index):
+        self.ui.edc_menu.setCurrentCell(index, 0)
+        self.ui.edc_pages.setCurrentIndex(index)        
+
     def ouverture(self):
         """premier affichage: on met a jour les champs"""
-       
         #page_nom
-        self.ui.edc_nom.majTexte(self.combattant.nom)
-        if self.combattant.logo:
-            self.ui.edc_logo.chargerImage(self.combattant.logo)
+        self.ui.edc_nom.majTexte(self._combattant.nom())
+        if self._combattant.logo.estValide():
+            self.ui.edc_logo.chargerImage(self._combattant.logo)
         else:
             self.ui.edc_logo.majTexte("Choisissez \nun fichier\nimage")
 
         self.vueForme.creer(self.formeCases())
-        self.vueForme.autoriserModifForme(self.modeCreation)
-        self.vueForme.majCouleur(self.combattant.couleur)
-        self.vueForme.chargerFormeDef(self.combattant.formeDef[self.formeCases()])
-        self.vueForme.chargerImageDef(self.combattant.img)
-        self.vueForme.chargerEtiquetteDef(self.combattant.etiquette)
+        self.vueForme.autoriserModifForme(self._modeCreation)
+        self.vueForme.majCouleur(self._combattant.couleur)
+        self.vueForme.chargerFormeDef(self._combattant.formeDef[self.formeCases()])
+        self.vueForme.chargerImageDef(self._combattant.img)
+        self.vueForme.chargerEtiquetteDef(self._combattant.etiquette)
 
         #page deplacements
-        self.ui.edc_taille.setValue(self.combattant.hauteur)
-        self.ui.edc_depMarche.setValue(self.combattant.depMarche)
-        self.ui.edc_depNage.setValue(self.combattant.depNage)
-        self.ui.edc_depEscalade.setValue(self.combattant.depEscalade)
-        self.ui.edc_depVol.setValue(self.combattant.depVol)
-        self.ui.edc_saut.setValue(self.combattant.saut)      
+        self.ui.edc_taille.setValue(self._combattant.hauteur)
+        self.ui.edc_depMarche.setValue(self._combattant.depMarche)
+        self.ui.edc_depNage.setValue(self._combattant.depNage)
+        self.ui.edc_depEscalade.setValue(self._combattant.depEscalade)
+        self.ui.edc_depVol.setValue(self._combattant.depVol)
+        self.ui.edc_saut.setValue(self._combattant.saut)      
 
         #page attributs
         self.majListeAttributs()        
 
         #page attaques: chargement des attaques du combattant, puis panneau 'nouvelle attaque'
         self.layoutAtt().setAlignment(Qt.AlignTop)
-        for attaque in self.combattant.attaques:
+        for attaque in self._combattant.attaques:
             self.attaqueNouvelle(attaque)
         self.attaqueNouvelle()
 
         #page inventaire
-        self.ui.edc_listeInventaire.charger(self.combattant.inventaire)
+        self.ui.edc_listeInventaire.charger(self._combattant.inventaire)
         self.majTotauxInventaire()
 
         #page_notes
-        for detail in self.combattant.details:
+        for detail in self._combattant.details:
             widget = self.ui.edc_pages.findChild(dm.DmLineEdit, "edc_detail_{}".format(detail))
             if widget:
-                widget.majTexte(self.combattant.details[detail])
-        self.ui.edc_notes.setText(QString.fromUtf8(self.combattant.notes))
+                widget.majTexte(self._combattant.details[detail])
+        self.ui.edc_notes.setText(QString.fromUtf8(self._combattant.notes))
 
         #autre
         self.majActivationEnregistrer()
-        
 
     ### page apparence
     def majFormeCases(self):
         if self.vueForme.formeCases() != self.formeCases():
             #on enregistre la def de forme, d'image et d'etiquette en cours
-            self.combattant.formeDef[self.vueForme.formeCases()] = self.vueForme.formeDef()
-            self.combattant.img = self.vueForme.imageDef()
-            self.combattant.etiquette = self.vueForme.etiquetteDef()
+            self._combattant.formeDef[self.vueForme.formeCases()] = self.vueForme.formeDef()
+            self._combattant.img = self.vueForme.imageDef()
+            self._combattant.etiquette = self.vueForme.etiquetteDef()
 
             #on recree la scene avec la nouvelle forme de cases
             self.vueForme.vider()
             self.vueForme.creer(self.formeCases())
 
             #on charge les def correspondantes a la nouvelle forme
-            self.vueForme.chargerFormeDef(self.combattant.formeDef[self.formeCases()])
-            self.vueForme.chargerImageDef(self.combattant.img)
-            self.vueForme.chargerEtiquetteDef(self.combattant.etiquette)
+            self.vueForme.chargerFormeDef(self._combattant.formeDef[self.formeCases()])
+            self.vueForme.chargerImageDef(self._combattant.img)
+            self.vueForme.chargerEtiquetteDef(self._combattant.etiquette)
 
     def majEtiquetteVueForme(self):
-        self.combattant.etiquette.txt = self.ui.edc_nom.texte()
-        self.vueForme.chargerEtiquetteDef(self.combattant.etiquette)
+        self._combattant.etiquette.txt = self.ui.edc_nom.texte()
+        self.vueForme.chargerEtiquetteDef(self._combattant.etiquette)
 
     def selectionnerLogo(self):
         img = selectionImage()
@@ -185,7 +167,7 @@ class EcranEditionCombattant(QDialog):
         """selectionne la couleur dans la boite de dialogue dediee"""
         couleur = QColorDialog(self).getColor(QColor("white"), self)
         if couleur.isValid():
-            self.combattant.couleur = couleur
+            self._combattant.couleur = couleur
             self.vueForme.majCouleur(couleur)
 
     #### page attributs
@@ -238,7 +220,7 @@ class EcranEditionCombattant(QDialog):
             if widget != 0:
                 if str(widget.objectName()[-6:]) == "_champ":
                     attr = str(widget.objectName()[:-6])
-                    widget.majTexte(self.combattant.listeAttributs[attr])            
+                    widget.majTexte(self._combattant.listeAttributs[attr])            
 
     def listeAttributs(self):
         """renvoie la liste des attributs tels qu'ils
@@ -317,31 +299,27 @@ class EcranEditionCombattant(QDialog):
     def majActivationEnregistrer(self):
         """verifie la validite des saisies"""
         self.ui.edc_enregistrer.setEnabled(len(self.ui.edc_nom.texte()) > 0) 
-    
+        
     def enregistrer(self):
         """enregistre le terrain cree/edite"""
-        #identifiant
-        if not self.combattant.id:
-            self.combattant.id = self.nouvelIdCombattant()
-
         #page nom
-        self.combattant.nom = self.ui.edc_nom.texte()
-        self.combattant.logo = self.ui.edc_logo.image()
+        self._combattant.majNom(self.ui.edc_nom.texte())
+        self._combattant.logo = self.ui.edc_logo.image() if self.ui.edc_logo.image() else RImage()
         
-        self.combattant.formeDef[self.vueForme.formeCases()] = self.vueForme.formeDef()
-        self.combattant.img = self.vueForme.imageDef()
-        self.combattant.etiquette = self.vueForme.etiquetteDef()
+        self._combattant.formeDef[self.vueForme.formeCases()] = self.vueForme.formeDef()
+        self._combattant.img = self.vueForme.imageDef()
+        self._combattant.etiquette = self.vueForme.etiquetteDef()
 
         #page dep
-        self.combattant.hauteur = self.ui.edc_taille.value()
-        self.combattant.depMarche = self.ui.edc_depMarche.value()
-        self.combattant.depNage = self.ui.edc_depNage.value()
-        self.combattant.depEscalade = self.ui.edc_depEscalade.value()
-        self.combattant.depVol = self.ui.edc_depVol.value()
-        self.combattant.saut = self.ui.edc_saut.value()
+        self._combattant.hauteur = self.ui.edc_taille.value()
+        self._combattant.depMarche = self.ui.edc_depMarche.value()
+        self._combattant.depNage = self.ui.edc_depNage.value()
+        self._combattant.depEscalade = self.ui.edc_depEscalade.value()
+        self._combattant.depVol = self.ui.edc_depVol.value()
+        self._combattant.saut = self.ui.edc_saut.value()
 
         #page attributs
-        self.combattant.listeAttributs = self.listeAttributs()
+        self._combattant.listeAttributs = self.listeAttributs()
 
         #page attaque
         listeAttaques = []
@@ -351,10 +329,10 @@ class EcranEditionCombattant(QDialog):
                 attaque = panneau.attaque()
                 if attaque:
                     listeAttaques.append(attaque)
-        self.combattant.attaques = listeAttaques
+        self._combattant.attaques = listeAttaques
 
         #page inventaire
-        self.combattant.inventaire = self.ui.edc_listeInventaire.inventaire()
+        self._combattant.inventaire = self.ui.edc_listeInventaire.inventaire()
 
         #page notes
         listeWidget = self.ui.edc_pages.findChildren(dm.DmLineEdit)
@@ -362,17 +340,14 @@ class EcranEditionCombattant(QDialog):
             detail = str(widget.objectName()).replace("edc_detail_","")
             txt = widget.texte()
             if len(txt) > 0:
-                self.combattant.details[detail] = txt
+                self._combattant.details[detail] = txt
         
-        self.combattant.notes = str(self.ui.edc_notes.toPlainText().toUtf8())
-
-#         enregistrer(self.combattant.id, self.combattant, "lib\\biblio\\combattant")
-#        self.combattant = None
+        self._combattant.notes = str(self.ui.edc_notes.toPlainText().toUtf8())
         self.done(1)
 
     def annuler(self):
         """annule la creation/edition"""
-        self.combattant = None
+        self._combattant = None
         self.done(0)
 
 if __name__ == "__main__":
@@ -380,6 +355,7 @@ if __name__ == "__main__":
     ecran = EcranEditionCombattant()
     ecran.show()
     r = app.exec_()
+    ecran.combattant().enregistrer()
     exit(r)      
 
 

lib/EcranEditionDecor.py

@@ -1,52 +1,38 @@
 #from __future__ import unicode_literals
 # -*- coding: utf-8 -*-
 from __future__ import division
+
 import sys
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
+
+from PyQt4.QtCore import SIGNAL, QString
+from PyQt4.QtGui import QDialog, QColorDialog, QColor, QApplication
+
 from Decor import Decor
-from ui.ecran_editionDecor import Ui_edd_fenetre
 from EcranEditionObjet import EcranEditionObjet
-from outilsSvg import *
-from VueEditionForme import VueEditionForme
 from Objet import Objet
+from VueEditionForme import VueEditionForme
 import rsc
+from ui.ecran_editionDecor import Ui_edd_fenetre
+
 
 class EcranEditionDecor(QDialog):
     """interface de creation/edition de decors"""
     def __init__(self, decor=None, pageInitiale = 0, formeCases = "H", parent=None):
         """initialisation de la fenetre"""
         super (EcranEditionDecor, self).__init__()
-        self.pixGraphique = None
         self.createWidgets()
         
-        if decor == None:
-            self.decor = Decor()
-        else:
-            self.decor = decor
+        self.decor = Decor() if not decor else decor
         self.modeCreation = (decor == None)
         self.ouverture()
-        self.ui.edd_menu.setCurrentCell(pageInitiale, 0)
-        self.ui.edd_pages.setCurrentIndex(pageInitiale)
+        self.allerAPage(pageInitiale)
+
         if formeCases == "C":
             self.ui.edd_casesCarrees.setChecked(True)
             self.majFormeCases()
-            
-    def nouvelIdDecor(self):
-        """renvoie un identifiant pour un nouveau terrain"""
-        dicoSvg = afficheSvg("lib\\biblio\\Decor")
-        nouvelId = 1
-        while str(nouvelId) in dicoSvg.keys():
-            nouvelId += 1
-        return str(nouvelId)
 
     def formeCases(self):
-        retour = ""
-        if self.ui.edd_casesHexa.isChecked():
-            retour = "H"
-        else:
-            retour = "C"
-        return retour
+        return "H" if self.ui.edd_casesHexa.isChecked() else "C"
     
     def createWidgets(self):
         """construction de l'interface"""
@@ -55,18 +41,15 @@ class EcranEditionDecor(QDialog):
         self.ui.setupUi(self)
         
         self.connect(self.ui.edd_nom, SIGNAL("textEdited(QString)"), self.majActivationEnregistrer)
-
         self.connect(self.ui.edd_enregistrer, SIGNAL("clicked()"), self.enregistrer)
         self.connect(self.ui.edd_annuler, SIGNAL("clicked()"), self.annuler)
-
         self.connect(self.ui.edd_casesHexa, SIGNAL("clicked()"), self.majFormeCases)
         self.connect(self.ui.edd_casesCarrees, SIGNAL("clicked()"), self.majFormeCases)
         self.connect(self.ui.edd_couleur, SIGNAL("clicked()"), self.selectionCouleur)
         self.connect(self.ui.edd_image, SIGNAL("clicked()"), self.selectionImage)
-
         self.connect(self.ui.edd_logo, SIGNAL("clicked()"), self.selectionnerLogo)
+        
         self.vueForme = VueEditionForme(self)
-
         self.construireInventaire()
         self.connect(self.ui.edd_filtreTypeObjet, SIGNAL("currentChanged(int)"), self.filtrerInventaire)
         self.ui.edd_filtreTypeObjet.stackUnder(self.ui.edd_listeInventaire)
@@ -74,11 +57,15 @@ class EcranEditionDecor(QDialog):
     def vueGraphique(self):
         return self.ui.edd_vueForme
 
+    def allerAPage(self, index):
+        self.ui.edd_menu.setCurrentCell(index, 0)
+        self.ui.edd_pages.setCurrentIndex(index)
+
     def ouverture(self):
         """premier affichage: on met a jour les champs"""
         #page_nom
-        self.ui.edd_nom.majTexte(self.decor.nom)
-        if self.decor.logo:
+        self.ui.edd_nom.majTexte(self.decor.nom())
+        if self.decor.logo.estValide():
             self.ui.edd_logo.chargerImage(self.decor.logo)
         else:
             self.ui.edd_logo.majTexte("Choisissez \nun fichier\nimage")
@@ -191,12 +178,8 @@ class EcranEditionDecor(QDialog):
     
     def enregistrer(self):
         """enregistre le terrain cree/edite"""
-        #identifiant
-        if not self.decor.id:
-            self.decor.id = self.nouvelIdDecor()
-
         #page nom
-        self.decor.nom = self.ui.edd_nom.texte()
+        self.decor.majNom(self.ui.edd_nom.texte())
         self.decor.logo = self.ui.edd_logo.image()
         
         self.decor.formeDef[self.vueForme.formeCases()] = self.vueForme.formeDef()

lib/EcranEditionTerrain.py

@@ -2,30 +2,25 @@
 # -*- coding: utf-8 -*-
 from __future__ import division
 
-import os
 import sys
 
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
+from PyQt4.QtCore import SIGNAL, QString
+from PyQt4.QtGui import QDialog, QColorDialog, QColor, QApplication
 
 from Terrain import Terrain
-from outilsSvg import *
-import rsc, uid
+import rsc
 from ui.ecran_editionTerrain import Ui_et_fenetre
 
 
 class EcranEditionTerrain(QDialog):
     """interface de creation/edition de terrains"""
-    def __init__(self, terrain=None, parent=None):
+    def __init__(self, terrain = None, parent=None):
         """initialisation de la fenetre"""
         super (EcranEditionTerrain, self).__init__()
         self.createWidgets()
-        self.terrain = terrain
-        if terrain == None:
-            self.terrain = Terrain()
-        else:
-            self.accesEdition()
-        self.majAffichage("")    
+        self.terrain = Terrain() if not terrain else terrain
+        if terrain: self.accesEdition()
+        self.majAffichage()    
         
     def createWidgets(self):
         """construction de l'interface"""
@@ -34,14 +29,13 @@ class EcranEditionTerrain(QDialog):
         self.ui.setupUi(self)
         self.connect(self.ui.et_enregistrer, SIGNAL("clicked()"), self.enregistrer)
         self.connect(self.ui.et_annuler, SIGNAL("clicked()"), self.annuler)
-        self.connect(self.ui.et_supprimer, SIGNAL("clicked()"), self.supprimer)
         self.connect(self.ui.et_nom, SIGNAL("textEdited(QString)"), self.majAffichage)
         self.connect(self.ui.et_selectionCouleur, SIGNAL("clicked()"), self.selectionCouleur)
         self.connect(self.ui.et_selectionFichier, SIGNAL("clicked()"), self.selectionFichier)
         
     def accesEdition(self):
         """ouverture en mode edition"""
-        self.ui.et_nom.setText(QString.fromUtf8(str(self.terrain.nom)))
+        self.ui.et_nom.majTexte(self.terrain.nom())
         if self.terrain.imgTexture.estValide():
             self.ui.et_apercu.chargerImage(self.terrain.imgTexture)
         else:    
@@ -52,19 +46,10 @@ class EcranEditionTerrain(QDialog):
             self.ui.et_depNage.setChecked(True)
         elif not self.terrain.franchissable:
             self.ui.et_depAucun.setChecked(True)
-        self.ui.et_supprimer.setEnabled(True)
 
-    def majAffichage(self, txt):
+    def majAffichage(self):
         """verifie la validite des saisies"""
-        self.ui.et_enregistrer.setEnabled(len(self.ui.et_nom.text().toUtf8()) > 0)
-
-    def nouvelIdTerrain(self):
-        """renvoie un identifiant pour un nouveau terrain"""
-        dicoSvg = afficheSvg("lib\\biblio\\terrain")
-        nouvelId = 1
-        while str(nouvelId) in dicoSvg.keys():
-            nouvelId += 1
-        return str(nouvelId)
+        self.ui.et_enregistrer.setEnabled(len(self.ui.et_nom.texte()) > 0)
 
     def selectionCouleur(self):
         """selectionne la couleur dans la boite de dialogue dediee"""
@@ -83,20 +68,11 @@ class EcranEditionTerrain(QDialog):
            
     def enregistrer(self):
         """enregistre le terrain cree/edite"""
-        if not self.terrain.id:
-            self.terrain.id = self.nouvelIdTerrain()
-        self.terrain.nom = str(self.ui.et_nom.text().toUtf8())
+        self.terrain.majNom(self.ui.et_nom.texte())
         if self.ui.et_apercu.image():
             self.terrain.imgTexture = self.ui.et_apercu.image()
         self.terrain.franchissable = (not self.ui.et_depAucun.isChecked())
         self.terrain.nage = self.ui.et_depNage.isChecked()
-        enregistrer(self.terrain.id, self.terrain, "lib\\biblio\\terrain")
-        self.terrain = None
-        self.done(1)
-
-    def supprimer(self):
-        """supprimer l'enregistrement de ce terrain"""
-        supprSvg("terrain", self.terrain.id)
         self.done(1)
 
     def annuler(self):

lib/Pinceau.py

@@ -242,9 +242,9 @@ class Pinceau():
         return retour    
 
     def ontTerrainsSimilaires(self, coord1, coord2):
-        return (self.plateau.cases[coord1].terrain.nom == self.plateau.cases[coord2].terrain.nom and \
+        return (self.plateau.cases[coord1].terrain.nom() == self.plateau.cases[coord2].terrain.nom() and \
                 self.plateau.cases[coord1].terrain.couleur.rgb() == self.plateau.cases[coord2].terrain.couleur.rgb() and \
-                self.plateau.cases[coord1].terrain.imgTexture.definition() == self.plateau.cases[coord1].terrain.imgTexture.definition())
+                self.plateau.cases[coord1].terrain.imgTexture.idR() == self.plateau.cases[coord1].terrain.imgTexture.idR())
 
 
 

lib/Pion.py

@@ -1,25 +1,23 @@
 #from __future__ import unicode_literals
 # -*- coding: utf-8 -*-
-from __future__ import division
-import os
 
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
+from PyQt4.QtCore import QPointF, Qt, QRectF
+from PyQt4.QtGui import QGraphicsItem, QColor, QGraphicsPolygonItem, QPen, \
+    QGraphicsDropShadowEffect, QGraphicsPixmapItem, QGraphicsSimpleTextItem, \
+    QFont, QGraphicsObject
 
 from Forme import Forme
-from outilsSvg import *
-from rsc import *
-import dmK
+from lib.rsc import RImage
 
-class Pion(QGraphicsItem):
+
+class Pion(QGraphicsObject):
     """pion du plateau de combat"""
     def __init__(self, parent=None):
         super(Pion, self).__init__()
         #caracteristiques du pion
-        self.numero = 0
-        self.nom = ""
+        self.numero = -1
         self.couleur = QColor()
-        self.logo = ""
+        self.logo = RImage()
         self.img = ImgPion()
         self.etiquette = EtiquettePion()
 
@@ -41,7 +39,7 @@ class Pion(QGraphicsItem):
         self.polygoneGraphique = None
         self.nbRotations = 0
 
-        
+
     def __getstate__(self):
         nePasSvg = ["plateau", "brillance", "shadow", "creature", "polygonesForme", "pixGraphique", "etiquetteGraphique"]
         state = {key:value for key, value in self.__dict__.items() if not key in nePasSvg}
@@ -51,7 +49,7 @@ class Pion(QGraphicsItem):
         self.__dict__ = state
         self.pixGraphique = None
         self.etiquetteGraphique = None
-        super(Pion, self).__init__()
+#         super(Pion, self).__init__()
 
     def paint(self, painter, option, widget = None):
         """reimplemente de QGraphicsItem: on ne peint pas cet item, seulement ses items enfants"""
@@ -59,7 +57,7 @@ class Pion(QGraphicsItem):
 
     def txtId(self):
         """renvoie le nom et le numero complementaire du pion"""
-        return "{} {}".format(self.nom, self.numComplementaire)
+        return "{} {}".format(self._nom, self.numComplementaire)
 
     def icone(self):
         """renvoie l'image a afficher dans les listes"""
@@ -303,7 +301,7 @@ class Pion(QGraphicsItem):
     def boundingRect(self):
         return QRectF()
         
-     #######################
+    #######################
 
 class ImgPion():
     def __init__(self):

lib/Plateau.py

@@ -2,37 +2,36 @@
 # -*- coding: utf-8 -*-
 from __future__ import division
 
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
+from math import sqrt
+from time import time
 
-##from ui.ecran_editionAttaques import Ui_editionAttaques
+from PyQt4.QtCore import Qt, SIGNAL, QPointF, QString, QSize, QLineF
+from PyQt4.QtGui import QGraphicsScene, QColor, QPixmap, QPainter, QIcon, \
+    QTableWidgetItem, QFont, QToolButton, QColorDialog, QMessageBox, \
+    QApplication, QPolygonF, QGraphicsPolygonItem, QPen, QGraphicsView
 
-import Modes
 import Actions
+from Cache import Cache
 from Case import Case
 from Combattant import Combattant
 from Decor import Decor
-from Pinceau import Pinceau
-from ProjectionDep import ProjectionDep
-from Cache import Cache
-from Terrain import Terrain
-
+from EcranAffichageTexte import EcranAffichageTexte
 from EcranCreerPlateau import EcranCreerPlateau
 from EcranEditionCombattant import EcranEditionCombattant
 from EcranEditionDecor import EcranEditionDecor
 from EcranEditionTerrain import EcranEditionTerrain
-from EcranAffichageTexte import EcranAffichageTexte
 from EcranGestionCombat import EcranGestionCombat
-from EcranSelectionPj import EcranSelectionPj
 from EcranVol import EcranVol
-
-import regles as regles
-from outilsSvg import enregistrer, charger, chargerUnique
-from time import time
+import Modes
+from Pinceau import Pinceau
+from ProjectionDep import ProjectionDep
+from Terrain import Terrain
 import br
+from outilsSvg import enregistrer, charger, chargerUnique
+import regles as regles
 
-from math import sqrt
 
+##from ui.ecran_editionAttaques import Ui_editionAttaques
 m_couleursRapides = [(255,255,255), (200,200,200), (130,130,130), (90,90,90), (15,15,15), \
                    (0,85,0), (170,255,0), (170,255,127), (85,85,0), (85,0,0), (170,85,0), (100,50,0), \
                    (255,255,127), (240,80,0), (85,170,255), (85,85,255), (85,0,255), (0,255,255)]
@@ -79,10 +78,7 @@ class Plateau(QGraphicsScene):
         self.numCombattantEnCours = 0
         self.ordreJeu = {}  #numero du pion: ordre de jeu
             
-        #note: la hauteur Z (qui gere l'empilement des objets graphiques est distribuee de cette maniere:
-        #cases : 0 a 9
-        #pions : 10 et +
-        
+
     def __getstate__(self):
         self.dateSvg = time()
         state = {key:value for key, value in self.__dict__.items() if not key in ["fenetre", "modeActif", \
@@ -262,12 +258,6 @@ class Plateau(QGraphicsScene):
         self.fenetre.afficherPanneauxPlateau(True)
         self.majNomPlateau()
         self.majBoutonsCouleursPerso()
-        self.fenetre.ui.cp_listeTerrains.defFichier("lib\\biblio\\terrain")
-        self.fenetre.ui.cp_listeTerrains.initAffichage()
-        self.fenetre.ui.cp_listeCreatures.defFichier("lib\\biblio\\combattant")
-        self.fenetre.ui.cp_listeCreatures.initAffichage()
-        self.fenetre.ui.cp_listeDecors.defFichier("lib\\biblio\\decor")
-        self.fenetre.ui.cp_listeDecors.initAffichage()
         self.majListeTerrains()
         self.majListeCreatures()
         self.majListeDecors()
@@ -422,84 +412,65 @@ class Plateau(QGraphicsScene):
         self.notes = affichageTexte.recupererTexte()
         
     ##### affichage de la liste des terrains enregistres, et fonctions d'acces aux donnees""""     
+    def terrainEdit(self):
+        """ouvre la fenetre 'terrains' en mode edition"""
+        self.afficheEcranEditionTerrains(self.fenetre.ui.cp_listeTerrains.selection())
+        self.activerMode(Modes.StandardCp)
+        
+    def terrainNouveau(self):
+        """ouvre la fenetre 'terrains' en mode edition"""
+        self.afficheEcranEditionTerrains()
+        self.activerMode(Modes.StandardCp)
+        
     def afficheEcranEditionTerrains(self, terrain = None):
         """affiche l'ecran d'edition/creation de terrains"""
-        self.editionTerrain = EcranEditionTerrain(terrain)     
-        self.editionTerrain.setAttribute(Qt.WA_DeleteOnClose)
-        r = self.editionTerrain.exec_()
+        fen = EcranEditionTerrain(terrain)     
+        r = fen.exec_()
         if r == 1:
+            terrain = fen.terrain
+            if terrain: terrain.enregistrer()
             self.majListeTerrains()
             self.activerMode(Modes.StandardCp)
  
     def majListeTerrains(self):
         """mise a jour de la liste des terrains depuis la sauvegarde"""
-        self.fenetre.ui.cp_listeTerrains.maj()
-
-    def terrainEdit(self):
-        """ouvre la fenetre 'terrains' en mode edition"""
-        index = self.fenetre.ui.cp_listeTerrains.item(self.fenetre.ui.cp_listeTerrains.currentRow(), 0)
-        if index > 0:
-            terrain = charger("lib\\biblio\\terrain", str(index.text().toUtf8()))
-            self.afficheEcranEditionTerrains(terrain)
-            self.activerMode(Modes.StandardCp)
-        
-    def terrainNouveau(self):
-        """ouvre la fenetre 'terrains' en mode edition"""
-        self.afficheEcranEditionTerrains()
-        self.activerMode(Modes.StandardCp)
+        self.fenetre.ui.cp_listeTerrains.vider()
+        self.fenetre.ui.cp_listeTerrains.charger("tr")
     ###############
 
     ##### affichage de la liste des creatures enregistrees, et fonctions d'acces aux donnees""""     
-    def afficheEcranEditionCombattants(self, creature = None):
-        """affiche l'ecran d'edition/creation de creatures"""
-        self.editionCreature = EcranEditionCombattant(creature, 0, self.formeCases)
-        self.editionCreature.setAttribute(Qt.WA_DeleteOnClose)
-        r = self.editionCreature.exec_()
-        if r == 1:
-            combattant = self.editionCreature.combattant
-            enregistrer(combattant.id, combattant, "lib\\biblio\\combattant")
-            self.majListeCreatures()
-            self.activerMode(Modes.StandardCp)
-        self.editionCreature = None
-        
-    def majListeCreatures(self):
-        """mise a jour de la liste des creatures depuis la sauvegarde"""
-        self.fenetre.ui.cp_listeCreatures.maj()
-
     def creatureEdit(self):
         """ouvre la fenetre 'creatures' en mode edition"""
-        index = self.fenetre.ui.cp_listeCreatures.item(self.fenetre.ui.cp_listeCreatures.currentRow(), 0)
-        if index > 0:
-            creature = charger("lib\\biblio\\combattant", str(index.text().toUtf8()))
-            self.afficheEcranEditionCombattants(creature)
-            self.activerMode(Modes.StandardCp)
+        self.afficheEcranEditionCombattants(self.fenetre.ui.cp_listeCreatures.selection())
+        self.activerMode(Modes.StandardCp)
         
     def creatureNouveau(self):
         """ouvre la fenetre 'creatures' en mode edition"""
         self.afficheEcranEditionCombattants()
         self.activerMode(Modes.StandardCp)
         
-    ###############
-
-    ##### affichage de la liste des decors enregistrees, et fonctions d'acces aux donnees""""     
-    def afficheEcranEditionDecors(self, decor = None):
-        """affiche l'ecran d'edition/creation de decors"""
-        self.editionDecor = EcranEditionDecor(decor, 0, self.formeCases)
-        self.editionDecor.setAttribute(Qt.WA_DeleteOnClose)
-        r = self.editionDecor.exec_()
+    def afficheEcranEditionCombattants(self, combattant = None):
+        """affiche l'ecran d'edition/creation de creatures"""
+        fen = EcranEditionCombattant(combattant, 0, self.formeCases)
+        r = fen.exec_()
         if r == 1:
-            decor = self.editionDecor.decor
-            enregistrer(decor.id, decor, "lib\\biblio\\decor")
-            self.majListeDecors()
+            combattant = fen.combattant()
+            if combattant: combattant.enregistrer()
+            self.majListeCreatures()
             self.activerMode(Modes.StandardCp)
-            
-    def majListeDecors(self):
-        """mise a jour de la liste des decors depuis la sauvegarde"""
-        self.fenetre.ui.cp_listeDecors.maj()
+        del fen
+        
+    def majListeCreatures(self):
+        """mise a jour de la liste des creatures depuis la sauvegarde"""
+        self.fenetre.ui.cp_listeCreatures.vider()
+        self.fenetre.ui.cp_listeCreatures.charger("cb")
+        
+    ###############
 
+    ##### affichage de la liste des decors enregistrees, et fonctions d'acces aux donnees""""     
     def decorEdit(self):
         """ouvre la fenetre 'decors' en mode edition"""
-        self.afficheEcranEditionDecors(self.fenetre.ui.cp_listeDecors.actuel())
+        self.afficheEcranEditionDecors(self.fenetre.ui.cp_listeDecors.selection())
         self.activerMode(Modes.StandardCp)
         
     def decorNouveau(self):
@@ -507,6 +478,21 @@ class Plateau(QGraphicsScene):
         self.afficheEcranEditionDecors()
         self.activerMode(Modes.StandardCp)
         
+    def afficheEcranEditionDecors(self, decor = None):
+        """affiche l'ecran d'edition/creation de decors"""
+        fen = EcranEditionDecor(decor, 0, self.formeCases)
+        r = fen.exec_()
+        if r == 1:
+            decor = fen.decor
+            if decor: decor.enregistrer()
+            self.majListeDecors()
+            self.activerMode(Modes.StandardCp)
+        del fen
+            
+    def majListeDecors(self):
+        """mise a jour de la liste des decors depuis la sauvegarde"""
+        self.fenetre.ui.cp_listeDecors.vider()
+        self.fenetre.ui.cp_listeDecors.charger("dc")
     ###############
     
     ############### affichage des caches enregistres
@@ -531,7 +517,6 @@ class Plateau(QGraphicsScene):
             estCombattant = (self.pionSelectionne().numero < 10000)
             #affichage
             self.fenetre.ui.pi_actions.setEnabled(estCombattant)
-            self.fenetre.ui.pi_finTour.setEnabled(estCombattant)
             self.fenetre.ui.pi_ongletsListes.setTabEnabled(0, estCombattant)
             self.fenetre.ui.pi_ongletsListes.setTabEnabled(1, estCombattant)
             
@@ -566,7 +551,7 @@ class Plateau(QGraphicsScene):
                     self.fenetre.ui.pi_listeAttributs.setRowHidden(i, (i >= len(lignesBase)))
 
                 #maj des donnees de base    
-                self.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Nom"), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().nom))))
+                self.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Nom"), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().nom()))))
                 self.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Etat"), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().etat))))
                 self.fenetre.ui.pi_listeAttributs.setItem(lignesBase.index("Alt."), 1, QTableWidgetItem(QString.fromUtf8(str(self.pionSelectionne().z))))
                 
@@ -700,20 +685,17 @@ class Plateau(QGraphicsScene):
     
     def modeCreationDecor(self, ligne, col):
         """enclenche le mode de creation de decors depuis la liste des decors"""
-        index = self.fenetre.ui.cp_listeDecors.item(ligne, 0)
-        decor = charger("lib\\biblio\\decor", str(index.text().toUtf8()))
+        decor = self.fenetre.ui.cp_listeDecors.selection()
         self.activerMode(Modes.CreationPion, decor)
         
     def modeCreationCombattant(self, ligne, col):
         """enclenche le mode de creation de pions depuis la liste des creatures"""
-        index = self.fenetre.ui.cp_listeCreatures.item(ligne, 0)
-        creature = charger("lib\\biblio\\combattant", str(index.text().toUtf8()))
+        creature = self.fenetre.ui.cp_listeCreatures.selection()
         self.activerMode(Modes.CreationPion, creature)
 
     def modeMajTerrainCase(self, ligne, col):
         """enclenche le mode permettant la mise a jour du terrain des cases"""
-        index = self.fenetre.ui.cp_listeTerrains.item(ligne, 0)
-        terrain = charger("lib\\biblio\\terrain", str(index.text().toUtf8()))
+        terrain = self.fenetre.ui.cp_listeTerrains.selection()
         if terrain:
             self.activerMode(Modes.MajCases, terrain)
         else:
@@ -807,7 +789,7 @@ class Plateau(QGraphicsScene):
         for num in self.ordreJeu:
             self.fenetre.ui.inf_listeOrdreJeu.insertRow(int(index))
             self.fenetre.ui.inf_listeOrdreJeu.setItem(int(index), 0, QTableWidgetItem(QString.fromUtf8(str(num))))
-            icon = QIcon(self.combattants[num].logo.chemin())
+            icon = QIcon(self.combattants[num].icone().fichier())
             item = QTableWidgetItem(icon, QString.fromUtf8(self.combattants[num].txtId()))
             self.fenetre.ui.inf_listeOrdreJeu.setItem(int(index), 1, item)
             self.fenetre.ui.inf_listeOrdreJeu.setItem(int(index), 2, QTableWidgetItem(QString.fromUtf8(str(self.ordreJeu[num]))))

lib/Terrain.py

@@ -1,19 +1,27 @@
 #from __future__ import unicode_literals
 # -*- coding: utf-8 -*-
 from PyQt4.QtGui import QColor
+from lib.mat import Materiel
 import rsc
-        
-class Terrain():
+
+class Terrain(Materiel):
     """terrain a affecter a une case"""
     def __init__(self, parent=None):
-        self.id = rsc.uid("tr")
-        self.nom = ""                   #libelle a afficher dans la liste 
+        super(Terrain, self).__init__()
+        self._type = "tr"
+
         self.couleur = QColor("")       #couleur si pas de texture
         self.imgTexture = rsc.RImage()        #image source de la texture
         self.nage = False                   #cette case se franchit a la nage
         self.franchissable = True           #peut on franchir cette case
         self.visibilite = True              #peut on voir au travers 
-        self.modDeplacement = 1.00         #modificateur a appliquer au deplacement
+        self.modDeplacement = 1.00         #modificateur a appliquer au deplacement   
+
+    def __getstate__(self):
+        return (self.__dict__)
+    
+    def __setstate__(self, state):
+        self.__dict__ = state
 
     def icone(self):
         """renvoie l'image a afficher dans les listes"""

lib/rsc.py

@@ -32,6 +32,7 @@ class Ressource(object):
     """classe de base des ressources utilisees"""
     def __init__(self):
         """cette classe contient les infos relatives a une ressource importee"""
+        super(Ressource, self).__init__()
         self._type = "rs"
         self._idR = ""
         self._nom = ""

lib/test.py

@@ -1,15 +1,27 @@
-import os
-from sys import argv
+from PyQt4.QtGui import QGraphicsItem
 
-from PyQt4.QtGui import QApplication
+class A(QGraphicsItem):
+    def __init__(self):
+        super(A, self).__init__()
+        self.a = "a"
+    
+    def fa(self):
+        return self.a
 
-
-test = raw_input("test:")
-app = QApplication([argv, test])
-
-arg = app.argv()
-
-print str(arg[0])
-print str(arg[1])   
-
-os.system("pause")
+class B(object):
+    def __init__(self):
+        super(B, self).__init__()
+        self._b = "b"
+        
+    def fb(self):
+        return self._b
+            
+class C(A, B):
+    def __init__(self):
+        super(C, self).__init__()    
+        
+        
+c = C()
+print c.fa()
+print c.fb()
+    

lib/ui/dm.py

@@ -1,15 +1,26 @@
 #from __future__ import unicode_literals
 # -*- coding: utf-8 -*-
 """ensemble des widgets surchargés"""
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
+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.outilsSvg import *
+    from lib.commun import rep, charger
 except:
     try:
-        from outilsSvg import *
+        from commun import rep, charger
     except:
-        print "dm: impossible de charger outilsSvg"
+        print "dm: impossible de charger commun"
+
 try:        
     import lib.regles as regles
 except:
@@ -112,9 +123,9 @@ class DmGraphicsView(QGraphicsView):
                 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)
+            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      
 
 
@@ -272,67 +283,52 @@ class DmTableWidget(QTableWidget):
         self.setCurrentCell(ligne, colonne, QItemSelectionModel.Select)
 
 
-class DmTableBiblio(DmTableWidget):
+class DmTableMat(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)
+        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)
-        
-    def remplir(self):
-        """remplit la table avec les donnees contenues dans le dictionnaire de la savuvegarde"""
-        dico = afficheSvg(self.fichier)
+        self.masquerColonneId()           
+           
         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
-            if objet.icone():
-                icon = QIcon(objet.icone().chemin())
-            else:
-                icon = QIcon()
-            item = QTableWidgetItem(icon, QString.fromUtf8(objet.nom))
-            self.setItem(int(index),1,item)
-            
-            index += 1        
+        
+        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.setSortingEnabled(True)
         self.sortItems(1)
+        
+        self.setSortingEnabled(True)
         self.majEnCours = False
-
+        
     def maj(self):
         self.vider()
         self.remplir()
 
-    def actuel(self):
+    def selection(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
+        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(DmTableBiblio, self).__init__(parent)
+        super(DmTableMat, self).__init__(parent)
         self.fichier = ""
         self.masquerColonneId()
 
@@ -512,7 +508,7 @@ class DmFrameInf_Combattant(QGroupBox):
     def maj(self, combattant):
         self.setVisible((combattant != None))
         if combattant:
-            self.findChild(DmLabel, "inf_pionNom").majTexte(combattant.nom)
+            self.findChild(DmLabel, "inf_pionNom").majTexte(combattant.nom())
             self.findChild(DmLabel, "inf_pionImage").chargerImage(combattant.img.rimage)
             self.findChild(DmLabel, "inf_pionEffet").setVisible(False)
             
@@ -525,7 +521,7 @@ class DmFrameInf_Decor(QGroupBox):
     def maj(self, decor):
         self.setVisible((decor != None))
         if decor:
-            self.findChild(DmLabel, "inf_decorNom").majTexte(decor.nom)
+            self.findChild(DmLabel, "inf_decorNom").majTexte(decor.nom())
             self.findChild(DmLabel, "inf_decorImage").chargerImage(decor.img.rimage)
 
 class DmFrameInf_Case(QGroupBox):
@@ -535,8 +531,8 @@ class DmFrameInf_Case(QGroupBox):
 
     def maj(self, case):
         self.setVisible((case != None))
-        if len(case.terrain.nom) > 0:
-            self.findChild(DmLabel, "inf_caseTerrain").majTexte(case.terrain.nom)
+        if len(case.terrain.nom()) > 0:
+            self.findChild(DmLabel, "inf_caseTerrain").majTexte(case.terrain.nom())
         else:
             self.findChild(DmLabel, "inf_caseTerrain").majTexte("Case")
             

lib/ui/ecran_editionTerrain.py

@@ -2,7 +2,7 @@
 
 # Form implementation generated from reading ui file 'editionTerrain.ui'
 #
-# Created: Mon Jun 29 16:59:40 2015
+# Created: Tue Sep 08 11:44:01 2015
 #      by: PyQt4 UI code generator 4.10.4
 #
 # WARNING! All changes made in this file will be lost!
@@ -26,7 +26,9 @@ except AttributeError:
 class Ui_et_fenetre(object):
     def setupUi(self, et_fenetre):
         et_fenetre.setObjectName(_fromUtf8("et_fenetre"))
-        et_fenetre.resize(395, 252)
+        et_fenetre.resize(395, 243)
+        et_fenetre.setMinimumSize(QtCore.QSize(395, 243))
+        et_fenetre.setMaximumSize(QtCore.QSize(395, 243))
         icon = QtGui.QIcon()
         icon.addPixmap(QtGui.QPixmap(_fromUtf8("img/paysage.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
         et_fenetre.setWindowIcon(icon)
@@ -40,13 +42,6 @@ class Ui_et_fenetre(object):
         self.et_apercu.setFrameShadow(QtGui.QFrame.Sunken)
         self.et_apercu.setAlignment(QtCore.Qt.AlignCenter)
         self.et_apercu.setObjectName(_fromUtf8("et_apercu"))
-        self.et_supprimer = QtGui.QPushButton(et_fenetre)
-        self.et_supprimer.setEnabled(False)
-        self.et_supprimer.setGeometry(QtCore.QRect(20, 200, 75, 31))
-        font = QtGui.QFont()
-        font.setFamily(_fromUtf8("Verdana"))
-        self.et_supprimer.setFont(font)
-        self.et_supprimer.setObjectName(_fromUtf8("et_supprimer"))
         self.et_enregistrer = QtGui.QPushButton(et_fenetre)
         self.et_enregistrer.setEnabled(False)
         self.et_enregistrer.setGeometry(QtCore.QRect(280, 200, 91, 31))
@@ -55,12 +50,15 @@ class Ui_et_fenetre(object):
         font.setBold(True)
         font.setWeight(75)
         self.et_enregistrer.setFont(font)
+        self.et_enregistrer.setAutoDefault(False)
+        self.et_enregistrer.setDefault(True)
         self.et_enregistrer.setObjectName(_fromUtf8("et_enregistrer"))
         self.et_annuler = QtGui.QPushButton(et_fenetre)
-        self.et_annuler.setGeometry(QtCore.QRect(190, 200, 81, 31))
+        self.et_annuler.setGeometry(QtCore.QRect(20, 200, 81, 31))
         font = QtGui.QFont()
         font.setFamily(_fromUtf8("Verdana"))
         self.et_annuler.setFont(font)
+        self.et_annuler.setAutoDefault(False)
         self.et_annuler.setObjectName(_fromUtf8("et_annuler"))
         self.et_selectionCouleur = QtGui.QPushButton(et_fenetre)
         self.et_selectionCouleur.setGeometry(QtCore.QRect(20, 80, 31, 31))
@@ -76,7 +74,7 @@ class Ui_et_fenetre(object):
         font.setPointSize(8)
         self.label_4.setFont(font)
         self.label_4.setObjectName(_fromUtf8("label_4"))
-        self.et_nom = QtGui.QLineEdit(et_fenetre)
+        self.et_nom = DmLineEdit(et_fenetre)
         self.et_nom.setGeometry(QtCore.QRect(100, 30, 271, 31))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
@@ -96,7 +94,7 @@ class Ui_et_fenetre(object):
         icon2.addPixmap(QtGui.QPixmap(_fromUtf8(":/interface/32/ressource/loupe_32.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
         self.et_selectionFichier.setIcon(icon2)
         self.et_selectionFichier.setObjectName(_fromUtf8("et_selectionFichier"))
-        self.et_tags = QtGui.QLineEdit(et_fenetre)
+        self.et_tags = DmLineEdit(et_fenetre)
         self.et_tags.setGeometry(QtCore.QRect(170, 70, 201, 21))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
@@ -158,7 +156,6 @@ class Ui_et_fenetre(object):
 "et/ou un \n"
 "fichier\n"
 "texture", None))
-        self.et_supprimer.setText(_translate("et_fenetre", "Supprimer", None))
         self.et_enregistrer.setText(_translate("et_fenetre", "Enregistrer", None))
         self.et_annuler.setText(_translate("et_fenetre", "Annuler", None))
         self.label_4.setText(_translate("et_fenetre", "Nom du terrain : ", None))
@@ -166,7 +163,7 @@ class Ui_et_fenetre(object):
         self.label.setText(_translate("et_fenetre", "Tags : ", None))
         self.et_groupeDep.setTitle(_translate("et_fenetre", "Déplacement", None))
 
-from dm import DmLabel
+from dm import DmLineEdit, DmLabel
 import ressource_rc
 
 if __name__ == "__main__":

lib/ui/ecran_principal.py

@@ -2,7 +2,7 @@
 
 # Form implementation generated from reading ui file 'principal.ui'
 #
-# Created: Tue Sep 01 16:42:51 2015
+# Created: Mon Sep 07 21:37:46 2015
 #      by: PyQt4 UI code generator 4.10.4
 #
 # WARNING! All changes made in this file will be lost!
@@ -612,7 +612,7 @@ class Ui_principal(object):
         self.verticalLayout_4 = QtGui.QVBoxLayout(self.cp_afficherTerrains)
         self.verticalLayout_4.setSpacing(3)
         self.verticalLayout_4.setObjectName(_fromUtf8("verticalLayout_4"))
-        self.cp_listeTerrains = DmTableBiblio(self.cp_afficherTerrains)
+        self.cp_listeTerrains = DmTableMat(self.cp_afficherTerrains)
         self.cp_listeTerrains.setMinimumSize(QtCore.QSize(81, 0))
         self.cp_listeTerrains.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
         self.cp_listeTerrains.setEditTriggers(QtGui.QAbstractItemView.AnyKeyPressed|QtGui.QAbstractItemView.DoubleClicked)
@@ -659,7 +659,7 @@ class Ui_principal(object):
         self.verticalLayout_7 = QtGui.QVBoxLayout(self.cp_afficherDecors)
         self.verticalLayout_7.setSpacing(3)
         self.verticalLayout_7.setObjectName(_fromUtf8("verticalLayout_7"))
-        self.cp_listeDecors = DmTableBiblio(self.cp_afficherDecors)
+        self.cp_listeDecors = DmTableMat(self.cp_afficherDecors)
         self.cp_listeDecors.setMinimumSize(QtCore.QSize(81, 0))
         self.cp_listeDecors.setEditTriggers(QtGui.QAbstractItemView.AnyKeyPressed|QtGui.QAbstractItemView.DoubleClicked)
         self.cp_listeDecors.setIconSize(QtCore.QSize(2, 2))
@@ -707,7 +707,7 @@ class Ui_principal(object):
         self.verticalLayout_6 = QtGui.QVBoxLayout(self.cp_afficherCreatures)
         self.verticalLayout_6.setSpacing(3)
         self.verticalLayout_6.setObjectName(_fromUtf8("verticalLayout_6"))
-        self.cp_listeCreatures = DmTableBiblio(self.cp_afficherCreatures)
+        self.cp_listeCreatures = DmTableMat(self.cp_afficherCreatures)
         self.cp_listeCreatures.setMinimumSize(QtCore.QSize(81, 0))
         self.cp_listeCreatures.setEditTriggers(QtGui.QAbstractItemView.AnyKeyPressed|QtGui.QAbstractItemView.DoubleClicked)
         self.cp_listeCreatures.setIconSize(QtCore.QSize(2, 2))
@@ -756,8 +756,8 @@ class Ui_principal(object):
         self.creationPlateau_sousPanneauBas.setFrameShadow(QtGui.QFrame.Raised)
         self.creationPlateau_sousPanneauBas.setObjectName(_fromUtf8("creationPlateau_sousPanneauBas"))
         self.gridLayout_3 = QtGui.QGridLayout(self.creationPlateau_sousPanneauBas)
-        self.gridLayout_3.setSpacing(3)
         self.gridLayout_3.setMargin(3)
+        self.gridLayout_3.setSpacing(3)
         self.gridLayout_3.setObjectName(_fromUtf8("gridLayout_3"))
         self.cp_placerEntree = QtGui.QToolButton(self.creationPlateau_sousPanneauBas)
         self.cp_placerEntree.setMinimumSize(QtCore.QSize(41, 31))
@@ -1196,7 +1196,7 @@ class Ui_principal(object):
         self.grp_deroulement.setWidgetResizable(True)
         self.grp_deroulement.setObjectName(_fromUtf8("grp_deroulement"))
         self.grp_deroulement_contenu = QtGui.QWidget()
-        self.grp_deroulement_contenu.setGeometry(QtCore.QRect(0, 0, 100, 30))
+        self.grp_deroulement_contenu.setGeometry(QtCore.QRect(0, 0, 756, 588))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
         brush.setStyle(QtCore.Qt.SolidPattern)
@@ -1548,8 +1548,8 @@ class Ui_principal(object):
         self.cbt_panneauGauche.setCurrentIndex(1)
         self.cbt_panneauBas.setCurrentIndex(1)
         self.cbt_panneauDroite.setCurrentIndex(1)
-        self.cp_ongletsListes.setCurrentIndex(1)
-        self.pi_ongletsListes.setCurrentIndex(0)
+        self.cp_ongletsListes.setCurrentIndex(2)
+        self.pi_ongletsListes.setCurrentIndex(2)
         self.tabStatutAppli.setCurrentIndex(2)
         QtCore.QMetaObject.connectSlotsByName(principal)
 
@@ -1724,7 +1724,7 @@ class Ui_principal(object):
         self.actionParam_tres.setText(_translate("principal", "Paramètres", None))
         self.actionLexique.setText(_translate("principal", "Lexique", None))
 
-from dm import DmFrameInf_Decor, DmFrameInf_Case, DmTableBiblio, DmLabel, DmGraphicsView, DmFrameInf_Combattant, DmTextEdit, DmTableWidget
+from dm import DmFrameInf_Decor, DmFrameInf_Case, DmFrameInf_Combattant, DmLabel, DmGraphicsView, DmTableMat, DmTextEdit, DmTableWidget
 import ressource_rc
 
 if __name__ == "__main__":

lib/ui/editionTerrain.ui

@@ -7,9 +7,21 @@
     <x>0</x>
     <y>0</y>
     <width>395</width>
-    <height>252</height>
+    <height>243</height>
    </rect>
   </property>
+  <property name="minimumSize">
+   <size>
+    <width>395</width>
+    <height>243</height>
+   </size>
+  </property>
+  <property name="maximumSize">
+   <size>
+    <width>395</width>
+    <height>243</height>
+   </size>
+  </property>
   <property name="windowTitle">
    <string>Créer / Editer un terrain</string>
   </property>
@@ -49,27 +61,6 @@ texture</string>
     <set>Qt::AlignCenter</set>
    </property>
   </widget>
-  <widget class="QPushButton" name="et_supprimer">
-   <property name="enabled">
-    <bool>false</bool>
-   </property>
-   <property name="geometry">
-    <rect>
-     <x>20</x>
-     <y>200</y>
-     <width>75</width>
-     <height>31</height>
-    </rect>
-   </property>
-   <property name="font">
-    <font>
-     <family>Verdana</family>
-    </font>
-   </property>
-   <property name="text">
-    <string>Supprimer</string>
-   </property>
-  </widget>
   <widget class="QPushButton" name="et_enregistrer">
    <property name="enabled">
     <bool>false</bool>
@@ -92,11 +83,17 @@ texture</string>
    <property name="text">
     <string>Enregistrer</string>
    </property>
+   <property name="autoDefault">
+    <bool>false</bool>
+   </property>
+   <property name="default">
+    <bool>true</bool>
+   </property>
   </widget>
   <widget class="QPushButton" name="et_annuler">
    <property name="geometry">
     <rect>
-     <x>190</x>
+     <x>20</x>
      <y>200</y>
      <width>81</width>
      <height>31</height>
@@ -110,6 +107,9 @@ texture</string>
    <property name="text">
     <string>Annuler</string>
    </property>
+   <property name="autoDefault">
+    <bool>false</bool>
+   </property>
   </widget>
   <widget class="QPushButton" name="et_selectionCouleur">
    <property name="geometry">
@@ -147,7 +147,7 @@ texture</string>
     <string>Nom du terrain : </string>
    </property>
   </widget>
-  <widget class="QLineEdit" name="et_nom">
+  <widget class="DmLineEdit" name="et_nom">
    <property name="geometry">
     <rect>
      <x>100</x>
@@ -211,7 +211,7 @@ texture</string>
      <normaloff>:/interface/32/ressource/loupe_32.png</normaloff>:/interface/32/ressource/loupe_32.png</iconset>
    </property>
   </widget>
-  <widget class="QLineEdit" name="et_tags">
+  <widget class="DmLineEdit" name="et_tags">
    <property name="geometry">
     <rect>
      <x>170</x>
@@ -373,6 +373,11 @@ texture</string>
    <extends>QLabel</extends>
    <header location="global">dm.h</header>
   </customwidget>
+  <customwidget>
+   <class>DmLineEdit</class>
+   <extends>QLineEdit</extends>
+   <header location="global">dm.h</header>
+  </customwidget>
  </customwidgets>
  <resources>
   <include location="ressource.qrc"/>