Refonte de l'interface d'édition des combattants (partie 2)

lib/EcranEditionCombattant.py

@@ -5,7 +5,7 @@ from __future__ import division
 from PyQt4.QtCore import *
 from PyQt4.QtGui import *
 from Combattant import Combattant
-from ui.ecran_editionCombattant import Ui_editionCombattant
+from ui.ecran_editionCombattant import Ui_edc_fenetre
 from outilsSvg import *
 from VueEditionForme import VueEditionForme
 from EcranEditionAttaques import EcranEditionAttaques
@@ -46,32 +46,33 @@ class EcranEditionCombattant(QDialog):
     def createWidgets(self):
         """construction de l'interface"""
         #construction de l'interface
-        self.ui = Ui_editionCombattant()
+        self.ui = Ui_edc_fenetre()
         self.ui.setupUi(self)
-        self.connect(self.ui.edp_nom, SIGNAL("textEdited(QString)"), self.majActivationEnregistrer)
-        self.connect(self.ui.edp_nom, SIGNAL("textEdited(QString)"), self.majApercuTexte)
+        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.edp_enregistrer, SIGNAL("clicked()"), self.enregistrer)
-        self.connect(self.ui.edp_annuler, SIGNAL("clicked()"), self.annuler)
+        self.connect(self.ui.edc_enregistrer, SIGNAL("clicked()"), self.enregistrer)
+        self.connect(self.ui.edc_annuler, SIGNAL("clicked()"), self.annuler)
 
-        self.connect(self.ui.edp_couleur, SIGNAL("clicked()"), self.selectionCouleur)
-        self.connect(self.ui.edp_image, SIGNAL("clicked()"), self.selectionImage)
-        self.connect(self.ui.edp_aideForme, SIGNAL("clicked()"), self.afficherAideForme)
+        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_aideForme, SIGNAL("clicked()"), self.afficherAideForme)
 
-        self.vueForme = VueEditionForme(self, self.formeCases)
-        self.vueForme.creer()
+        self.connect(self.ui.edc_logo, SIGNAL("imageModifiee()"), self.logoModifie)
+        self.vueForme = VueEditionForme(self)
+        
 
-        self.ui.listeAttributs.setColumnWidth(0, (0.4*self.ui.listeAttributs.width())) 
-        self.ui.listeAttributs.setColumnWidth(1, (0.4*self.ui.listeAttributs.width()))
-        self.connect(self.ui.listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee, Qt.UniqueConnection)
+        self.ui.edc_listeAttributs.setColumnWidth(0, (0.4*self.ui.edc_listeAttributs.width())) 
+        self.ui.edc_listeAttributs.setColumnWidth(1, (0.4*self.ui.edc_listeAttributs.width()))
+        self.connect(self.ui.edc_listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee, Qt.UniqueConnection)
 
 ##        self.ui.listeInventaireCombattant.setColumnWidth(0, (0.2*self.ui.listeInventaireCombattant.width()))
 ##        self.ui.listeInventaireCombattant.setColumnWidth(1, (0.8*self.ui.listeInventaireCombattant.width()))
 ##        self.connect(self.ui.listeInventaireCombattant, SIGNAL("clicked()"), self.listeInventaireCelluleModifiee)
 ##        self.connect(self.ui.supprimerInventaireCombattant, SIGNAL("clicked()"), self.supprimerLigneListeInventaire)
 ##        self.connect(self.ui.ajouterInventaireCombattant, SIGNAL("clicked()"), self.ajouterLigneListeInventaire)
-
-
         
     def ouverture(self):
         """premier affichage: on met a jour les champs"""
@@ -81,10 +82,15 @@ class EcranEditionCombattant(QDialog):
         
         #page_nom
         self.ui.edc_nom.majTexte(self.combattant.nom)
-        self.ui.edc_logo.chargerImage(self.combattant.logo)
-        self.vueForme.majForme(self.combattant.formeDef[self.formeCases()])
-        self.majApercuImage()
-        self.majApercuTexte()
+        if self.combattant.logo:
+            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.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.taille)
@@ -98,7 +104,7 @@ class EcranEditionCombattant(QDialog):
         self.majListeAttributs()
 
         #page attaques
-        tabAttaques = self.ui.pages.widget(3)
+        tabAttaques = self.ui.edc_pages.widget(3)
         editionAttaques = EcranEditionAttaques(self.combattant)
         editionAttaques.setParent(tabAttaques)
 
@@ -118,24 +124,24 @@ class EcranEditionCombattant(QDialog):
 
     def majListeAttributs(self):
         """met a jour la liste des attributs de la Combattant"""
-        self.disconnect(self.ui.listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee)
+        self.disconnect(self.ui.edc_listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee)
         
         #on vide la liste
-        while self.ui.listeAttributs.rowCount() > 0:
-            self.ui.listeAttributs.removeRow(0)
+        while self.ui.edc_listeAttributs.rowCount() > 0:
+            self.ui.edc_listeAttributs.removeRow(0)
         
         #attributs issus des regles utilisees    
         ordre = regles.ordreAttributs()
         for elt in ordre:
             ligne = ordre.index(elt)
-            self.ui.listeAttributs.insertRow(ligne)
-            if regles.attribut(elt).combatSeulement == True: self.ui.listeAttributs.setRowHidden(ligne, True)
+            self.ui.edc_listeAttributs.insertRow(ligne)
+            if regles.attribut(elt).combatSeulement == True: self.ui.edc_listeAttributs.setRowHidden(ligne, True)
             item = QTableWidgetItem(QString.fromUtf8(elt))
             item.setFlags(Qt.NoItemFlags)
-            self.ui.listeAttributs.setItem(ligne, 0, item)
-            self.ui.listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.combattant.listeAttributs[elt]))))
+            self.ui.edc_listeAttributs.setItem(ligne, 0, item)
+            self.ui.edc_listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.combattant.listeAttributs[elt]))))
             
-        self.connect(self.ui.listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee)
+        self.connect(self.ui.edc_listeAttributs, SIGNAL("cellChanged(int,int)"), self.listeAttributCelluleModifiee)
 
     def listeAttributCelluleModifiee(self, ligne, colonne):
         """une cellule de la liste des attributs a ete modifiee"""
@@ -143,12 +149,160 @@ class EcranEditionCombattant(QDialog):
             pass
         else:
             attribut = regles.ordreAttributs()[(ligne)]
-            nouvelleVal = str(self.ui.listeAttributs.item(ligne, 1).text().toUtf8())
+            nouvelleVal = str(self.ui.edc_listeAttributs.item(ligne, 1).text().toUtf8())
             valVerifiee = regles.listeControle()[attribut].controler(nouvelleVal)
             if valVerifiee != None:
                 self.combattant.listeAttributs[attribut] = valVerifiee
             else:    
-                self.ui.listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.combattant.listeAttributs[attribut]))))
+                self.ui.edc_listeAttributs.setItem(ligne, 1, QTableWidgetItem(QString.fromUtf8(str(self.combattant.listeAttributs[attribut]))))
+
+    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()
+
+            #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)
+
+    def majEtiquetteVueForme(self):
+        self.combattant.etiquette.txt = self.ui.edc_nom.texte()
+        self.vueForme.chargerEtiquetteDef(self.combattant.etiquette)
+
+    def logoModifie(self):
+        if not len(self.combattant.img.nomFichier) > 0:
+            #si pas d'image attribuee au pion, on utilise le logo pour le pion
+            self.vueForme.nouvelleImageDef(self.ui.edc_logo.image())
+
+    def selectionImage(self):
+        """selectionne le fichier image dans la boite de dialogue dediee"""
+        fichier = QFileDialog.getOpenFileName(self, 
+                                              "Selectionnez une image", 
+                                              "\\img", 
+                                              "Images (*.png *.jpg)")
+        pix = QPixmap(fichier)
+        if not pix.isNull():
+            self.vueForme.nouvelleImageDef(fichier)
+        else:    
+            dial = QMessageBox(self)
+            dial.setText("Format non reconnu")
+            dial.setWindowTitle("Erreur")
+            dial.setStandardButtons(QMessageBox.Ok)
+            dial.exec_()
+            
+##    def majApercuImage(self):
+##        """met a jour l'image sur l'apercu du pion"""
+##        if self.ui.imgAfficherCombattant.isChecked():
+##            if len(str(self.ui.imgTextureCombattant.text().toUtf8())) > 0:
+##                img = str(self.ui.imgTextureCombattant.text().toUtf8())
+##                self.vueForme.majImage(img, self.ui.imgTailleXCombattant.value() \
+##                                          , self.ui.imgTailleYCombattant.value() \
+##                                          , self.ui.imgPosXCombattant.value() \
+##                                          , self.ui.imgPosYCombattant.value() \
+##                                          , self.ui.imgRotationCombattant.value() \
+##                                          , self.ui.imgPivoteCombattant.isChecked() \
+##                                          , self.ui.imgMasqueCombattant.isChecked() )
+##            else:
+##                img = str(self.ui.imgLogoCombattant.text().toUtf8())
+##                self.vueForme.majImage(img)
+##        else:
+##            img = ""
+##            self.vueForme.majImage(img)
+
+##    def majApercuTexte(self):
+##        """met a jour l'etiquette sur l'apercu du pion"""
+##        if self.ui.txtAfficherCombattant.isChecked():
+##            txt = str(self.ui.nomCombattant.text().toUtf8())
+##        else:
+##            txt = "Pion"   
+##        self.vueForme.majTexte(txt, self.ui.txtTaillePoliceCombattant.value() \
+##                                  , self.ui.txtGrasCombattant.isChecked() \
+##                                  , self.ui.txtPosXCombattant.value() \
+##                                  , self.ui.txtPosYCombattant.value() \
+##                                  , self.ui.txtRotationCombattant.value())
+
+##    def reinitImage(self):
+##        self.ui.imgTailleXCombattant.setValue(10)
+##        self.ui.imgTailleYCombattant.setValue(10)
+##        self.ui.imgPosXCombattant.setValue(0)
+##        self.ui.imgPosYCombattant.setValue(0)
+##        self.ui.imgRotationCombattant.setValue(0)
+##        self.ui.imgPivoteCombattant.setChecked(False)
+##        self.ui.imgMasqueCombattant.setChecked(False)
+##        self.majApercuImage()
+##
+##    def reinitTexte(self):
+##        self.ui.txtTaillePoliceCombattant.setValue(21)
+##        self.ui.txtGrasCombattant.setCheckState(0)
+##        self.ui.txtPosXCombattant.setValue(0)
+##        self.ui.txtPosYCombattant.setValue(0)
+##        self.ui.txtRotationCombattant.setValue(0)
+##        self.majApercuTexte()        
+
+    def selectionCouleur(self):
+        """selectionne la couleur dans la boite de dialogue dediee"""
+        couleur = QColorDialog(self).getColor(QColor("white"), self)
+        if couleur.isValid():
+            nomCouleur = couleur.name()
+            self.combattant.couleur = couleur    
+            
+    def enregistrer(self):
+        """enregistre le terrain cree/edite"""
+        #page nom
+        self.combattant.id = self.id
+        self.combattant.nom = self.ui.edc_nom.texte()
+        self.combattant.logo = self.ui.edc_logo.image()
+
+
+        #page dep
+        self.combattant.taille = 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
+        #dans listeAttributCelluleModifiee
+
+        #page attaque
+        #dans EcranEditionAttaque
+
+        #page inventaire
+        #a voir...
+
+        #page notes
+        for detail in self.combattant.details:
+            widget = self.ui.findchild(DmLineEdit, "edc_detail_{}".format(detail))
+            if widget:
+                txt = widget.texte()
+                if len(txt) > 0:
+                    self.combattant.details[detail] = txt
+        
+        self.combattant.notes = str(self.ui.notesCombattant.toPlainText())
+
+        enregistrer(self.combattant.id, self.combattant, "lib\\biblio\\combattant")
+        self.combattant = None
+        self.done(1)
+
+##    def supprimer(self):
+##        """supprimer l'enregistrement de ce terrain"""
+##        supprSvg("lib\\biblio\\combattant", self.combattant.id)
+##        self.done(1)
+
+    def annuler(self):
+        """annule la creation/edition"""
+        self.combattant = None
+        self.done(0)
+
+
 
 ##    def majListeInventaire(self):
 ##        """met a jour la liste de l'inventaire de la Combattant"""
@@ -219,111 +373,3 @@ class EcranEditionCombattant(QDialog):
 ##        del self.combattant.inventaire[str(self.ui.listeInventaireCombattant.item(ligne, 1).text().toUtf8())]
 ##        self.ui.listeInventaireCombattant.removeRow(ligne)
 ##        self.connect(self.ui.listeInventaireCombattant, SIGNAL("cellChanged(int,int)"), self.listeInventaireCelluleModifiee)        
-
-    def majApercuImage(self):
-        """met a jour l'image sur l'apercu du pion"""
-        if self.ui.imgAfficherCombattant.isChecked():
-            if len(str(self.ui.imgTextureCombattant.text().toUtf8())) > 0:
-                img = str(self.ui.imgTextureCombattant.text().toUtf8())
-                self.vueForme.majImage(img, self.ui.imgTailleXCombattant.value() \
-                                          , self.ui.imgTailleYCombattant.value() \
-                                          , self.ui.imgPosXCombattant.value() \
-                                          , self.ui.imgPosYCombattant.value() \
-                                          , self.ui.imgRotationCombattant.value() \
-                                          , self.ui.imgPivoteCombattant.isChecked() \
-                                          , self.ui.imgMasqueCombattant.isChecked() )
-            else:
-                img = str(self.ui.imgLogoCombattant.text().toUtf8())
-                self.vueForme.majImage(img)
-        else:
-            img = ""
-            self.vueForme.majImage(img)
-
-    def majApercuTexte(self):
-        """met a jour l'etiquette sur l'apercu du pion"""
-        if self.ui.txtAfficherCombattant.isChecked():
-            txt = str(self.ui.nomCombattant.text().toUtf8())
-        else:
-            txt = "Pion"   
-        self.vueForme.majTexte(txt, self.ui.txtTaillePoliceCombattant.value() \
-                                  , self.ui.txtGrasCombattant.isChecked() \
-                                  , self.ui.txtPosXCombattant.value() \
-                                  , self.ui.txtPosYCombattant.value() \
-                                  , self.ui.txtRotationCombattant.value())
-
-    def reinitImage(self):
-        self.ui.imgTailleXCombattant.setValue(10)
-        self.ui.imgTailleYCombattant.setValue(10)
-        self.ui.imgPosXCombattant.setValue(0)
-        self.ui.imgPosYCombattant.setValue(0)
-        self.ui.imgRotationCombattant.setValue(0)
-        self.ui.imgPivoteCombattant.setChecked(False)
-        self.ui.imgMasqueCombattant.setChecked(False)
-        self.majApercuImage()
-
-    def reinitTexte(self):
-        self.ui.txtTaillePoliceCombattant.setValue(21)
-        self.ui.txtGrasCombattant.setCheckState(0)
-        self.ui.txtPosXCombattant.setValue(0)
-        self.ui.txtPosYCombattant.setValue(0)
-        self.ui.txtRotationCombattant.setValue(0)
-        self.majApercuTexte()        
-
-    def selectionCouleur(self):
-        """selectionne la couleur dans la boite de dialogue dediee"""
-        couleur = QColorDialog(self).getColor(QColor("white"), self)
-        if couleur.isValid():
-            nomCouleur = couleur.name()
-            self.combattant.couleur = couleur    
-            
-    def enregistrer(self):
-        """enregistre le terrain cree/edite"""
-        #page nom
-        self.combattant.id = self.id
-        self.combattant.nom = self.ui.edc_nom.texte()
-        self.combattant.logo = self.ui.edc_logo.image()
-        self.combattant.img = self.vueForme.image()
-        self.combattant.etiquette = self.vueForme.etiquette()
-        self.combattant.formeDef["H"] = self.vueForme.formeDef("H")
-        self.combattant.formeDef["C"] = self.vueForme.formeDef("C")
-
-        #page dep
-        self.combattant.taille = 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
-        #dans listeAttributCelluleModifiee
-
-        #page attaque
-        #dans EcranEditionAttaque
-
-        #page inventaire
-        #a voir...
-
-        #page notes
-        for detail in self.combattant.details:
-        widget = self.ui.findchild(DmLineEdit, "edc_detail_{}".format(detail))
-        if widget:
-            txt = widget.texte()
-            if len(txt) > 0:
-                self.combattant.details[detail] = txt
-        
-        self.combattant.notes = str(self.ui.notesCombattant.toPlainText())
-
-        enregistrer(self.combattant.id, self.combattant, "lib\\biblio\\combattant")
-        self.combattant = None
-        self.done(1)
-
-##    def supprimer(self):
-##        """supprimer l'enregistrement de ce terrain"""
-##        supprSvg("lib\\biblio\\combattant", self.combattant.id)
-##        self.done(1)
-
-    def annuler(self):
-        """annule la creation/edition"""
-        self.combattant = None
-        self.done(0)

lib/Pion.py

@@ -295,8 +295,8 @@ class Pion(QGraphicsItem):
 class ImgPion():
     def __init__(self):
         self.nomFichier = ""        #nom du fichier image source
-        self.kx = 1                 #coeff d'agrandissement horizontal
-        self.ky = 1                 #coeff d'agrandissement vertical
+        self.kx = 10                 #coeff d'agrandissement horizontal
+        self.ky = 10                 #coeff d'agrandissement vertical
         self.dx = 0                 #decalage horizontal
         self.dy = 0                 #decalage vertical
         self.rotation = 0           #rotation(en degres)
@@ -305,9 +305,9 @@ class ImgPion():
         
 class EtiquettePion():
     def __init__(self):
-        self.taille_police = 8     #taille de la police
+        self.txt = ""
+        self.taille_police = 38     #taille de la police
         self.gras = False           #en gras
         self.dx = 0                 #decalage horizontal
         self.dy = 0                 #decalage vertical
-        self.rotation = 0           #rotation(en degres)
 

lib/VueEditionForme.py

@@ -10,7 +10,7 @@ from Pion import ImgPion, EtiquettePion
 
 class VueEditionForme(QGraphicsScene):
     """vue graphique permettant d'afficher et de modifier la forme des creatures/decors"""
-    def __init__(self, fenetre, formeCases = "H", parent=None):   
+    def __init__(self, fenetre, parent=None):   
         super(VueEditionForme, self).__init__()
         self.fenetre = fenetre
         
@@ -19,18 +19,18 @@ class VueEditionForme(QGraphicsScene):
         self._couleur = QColor("grey")
 
         self._cases = {}
-        self._formeCases = formeCases
+        self._formeCases = "H"
        
         self._l0 = 0
         self._h0 = 0
         self._rotation = 0
 
-    #acces aux donnees
-        
-    def vue(self):
-        """retourne la ref de la QGraphicsView"""
-        return self.fenetre.ui.vueForme
+        self.fenetre.ui.edc_vueForme.setScene(self)    
+        self.fenetre.ui.edc_vueForme.centerOn(self.fenetre.ui.edc_vueForme.mapFromScene(QPointF(60,60)))   #centre la vue sur la case 0,0
+        self.fenetre.ui.edc_vueForme.scale(0.25, 0.25)
+
 
+    #acces aux donnees
     def chargerFormeDef(self, formeDef):
         self._formeDef = formeDef
         self._majFormeGraphique()
@@ -39,23 +39,26 @@ class VueEditionForme(QGraphicsScene):
         """renvoie la definition de forme (selon la forme des cases actuelle)"""
         retour = []
         for coord in self._cases:
-            if self._cases[coord].estSelectionnee and coord != (0,0):
+            if self._cases[coord].estSelectionnee() and coord != (0,0):
                 retour.append(coord)      
         return retour      
 
     def chargerEtiquetteDef(self, etiquetteDef):
-##        self._majEtiquette(txt)
         self._vefEtiquette.charger(etiquetteDef)
 
     def etiquetteDef(self):
-        return self._etiquette
+        return self._vefEtiquette.definition()
 
     def chargerImageDef(self, imgDef):
-##        self._majImage(sourceImg)
+        self._vefImage.charger(imgDef)
+
+    def nouvelleImageDef(self, cheminFichier):
+        imgDef = ImgPion()
+        imgDef.nomFichier = cheminFichier
         self._vefImage.charger(imgDef)
 
     def imageDef(self):
-        return self._img
+        return self._vefImage.definition()
     
     def majCouleur(self, couleur):
         """met a jour la couleur du pion"""
@@ -69,121 +72,77 @@ class VueEditionForme(QGraphicsScene):
         return self._formeCases
 
     #creation, suppression, mises a jour...
-    def creer(self):
+    def creer(self, formeCases = "H"):
+        self._formeCases = formeCases
+        
         for x in range(-5,6):
-            for y in range(-5,6):
+            for y in range(-5,5):
                 if self._formeCases == "H":
                      if 1 == (x % 2):
                           y += 0.5
-                c = CaseEditionForme(self)
-                c.creer(x, y, self._formeCases)
-                self.cases[(x,y)] = c
+                c = VefCase(self)
+                c.creer(x, y, self._couleur, self._formeCases)
+                self._cases[(x,y)] = c
                 
-        self.vue().setScene(self)    
-        self.vue().centerOn(self.vue().mapFromScene(QPointF(60,60)))   #centre la vue sur la case 0,0
-        self.vue().scale(0.25, 0.25)
 
     def vider(self):
         for coord in self._cases:
             self.removeItem(self._cases[coord])
+        self._cases = {}
 
     def _majFormeGraphique(self):
         """met a jour la forme affichee sur le graphique"""
         if self._formeDef:
             for coord in self._formeDef:
                 if coord in self._cases:
-                    self._cases[coord].estSelectionnee = True
+                    self._cases[coord].selectionner(True)
                     self._cases[coord].setBrush(self._couleur)
 
-##    def _majEtiquette(self, txt, taillePolice = 20, gras = False, dx = 0, dy = 0, rotation = 0):
-##        if len(txt) > 0:
-##            if not self._etiquette:
-##                self._etiquette = QGraphicsSimpleTextItem()
-##                self.addItem(self._etiquette)
-##            self._etiquette.setText(QString.fromUtf8("1."+txt))
-##            self._etiquette.setPos(QPointF(dx-0.112*120, dy-0.275*120))
-##            police = QFont("Georgia", taillePolice)
-##            police.setBold(gras)
-##            self._etiquette.setFont(police)
-##            self._etiquette.setRotation(rotation)
-##            
-##        else:
-##            if self._etiquette:
-##                self.removeItem(self._etiquette)
-
-##    def _majImage(self, img, kx = 10, ky = 10, dx = 0, dy = 0, rotation = 0):
-##
-##        if len(img) > 0:
-##            pix = QPixmap(QString.fromUtf8("img\\"+img))
-##            if not pix.isNull():
-##                    
-##                if not self._imgGraphique:
-##                    self._imgGraphique = QGraphicsPixmapItem()
-##                    self.addItem(self._imgGraphique)
-##                    self._imgGraphique.setZValue(10)
-##                    
-##                    if pix.height() >= pix.width():
-##                        pix = pix.scaledToHeight(120*0.9, Qt.SmoothTransformation)
-##                    else:
-##                        pix = pix.scaledToWidth(120*0.9, Qt.SmoothTransformation)
-##                    self.largeurOriginale = pix.width()
-##                    self.hauteurOriginale = pix.height()    
-##
-##                pix = pix.scaled((kx/10)*self.l0, (ky/10)*self.h0, Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
-##                deltaX = dx + 0.5*(120*1.1544 - self.l0)
-##                deltaY = dy + 0.5*(120 - self.h0)
-##      
-##                self._imgGraphique.setPixmap(pix)    
-##                self._imgGraphique.setPos(QPointF(deltaX, deltaY))
-##                self._imgGraphique.setRotation(rotation)
-##        else:
-##            if self._imgGraphique:
-##                self.removeItem(self._imgGraphique)
-
     def majSelection(self, coord):
          """met a jour l'affichage des cases selectionnees pour l'affichage de la forme"""
-         if self.cases[coord].estSelectionnee == True:
-             self.cases[coord].estSelectionnee = False
+         if self._cases[coord].estSelectionnee():
+             #on deselectionne la case
+##             self._cases[coord].selectionner(False)
              valide = True
-             for coordVerif in self.cases:
+             for coordVerif in self._cases:
                  #on parcourt les autres cases selectionnees
-                 if coordVerif != (0,0) and coordVerif != coord and self.cases[coordVerif].estSelectionnee == True:
+                 if coordVerif != (0,0) and coordVerif != coord and self._cases[coordVerif].estSelectionnee():
                      #on liste les cases connectees a cette case, de proche en proche
                      connectees = [coordVerif]
                      for coordVerif2 in connectees:
-                         for coordVoisin in self.cases[coordVerif2].voisins:
-                             if coordVoisin in self.cases and not coordVoisin in connectees:
-                                 if self.cases[coordVoisin].estSelectionnee:
+                         for coordVoisin in self._cases[coordVerif2].voisins():
+                             if coordVoisin in self._cases and not coordVoisin in connectees:
+                                 if self._cases[coordVoisin].estSelectionnee():
                                      connectees.append(coordVoisin)
                      if not (0,0) in connectees:
                          valide = False
                          break
-             if valide == True:        
-                 self.cases[coord].setBrush(QColor("white"))
-             else:
-                 self.cases[coord].estSelectionnee = True
+             if valide:
+                 self._cases[coord].selectionner(False)           
+
          else:
              #on s'assure que la case est bien adjacente a une case selectionnee
              valide = False
-             for coordVerif in self.cases[coord].voisins:
-                if coordVerif in self.cases:
-                    if self.cases[coordVerif].estSelectionnee == True:
+             for coordVerif in self._cases[coord].voisins():
+                if coordVerif in self._cases:
+                    if self._cases[coordVerif].estSelectionnee():
                         valide = True
                         break
              if valide:
-                 self.cases[coord].estSelectionnee = True
-                 self.cases[coord].setBrush(QColor("red"))
-
+                 self._cases[coord].selectionner(True)
 
+    def afficherMsg(self, msg):
+        print msg
 
 class VefCase(QGraphicsPolygonItem):
     """case utilisee dans une VueEditionForme()"""
     def __init__(self, scene, parent=None):
-        super(CaseEditionForme, self).__init__()
+        super(VefCase, self).__init__()
         self.scene = scene
         self._position = (0,0)
         self._estSelectionnee = False
         self._voisins = []
+        self._couleur = None
         
         #interactions graphiques
         self.setFlag(QGraphicsItem.ItemIsFocusable)
@@ -192,11 +151,21 @@ class VefCase(QGraphicsPolygonItem):
     def estSelectionnee(self):
         return self._estSelectionnee
 
+    def selectionner(self, actif):
+        if actif:
+            self.setBrush(self._couleur)
+        else:
+            self.setBrush(QColor(255,255,255,50))
+        self._estSelectionnee = actif
+
+    def voisins(self):
+        return self._voisins
+
     def creer(self, x, y, couleur, formeCases="H"):
         """creation du polygone et enregistrement des donnees geometriques"""
         self._position = (x, y)
         polygone = QPolygonF()
-        if self.scene.formeCases == "H":
+        if formeCases == "H":
             polygone  << QPointF(((x*0.866)+0.2886)*120,  y*120) \
                       << QPointF(((x*0.866)+0.866)*120,   y*120) \
                       << QPointF(((x*0.866)+1.1547)*120, (y+0.5)*120) \
@@ -211,18 +180,18 @@ class VefCase(QGraphicsPolygonItem):
         self.setPolygon(polygone)
 
         #enregistrement des cases voisines:       
-        if self.scene.formeCases() == "H":
-            self.voisins.append((x, y+1))
-            self.voisins.append((x, y-1))
-            self.voisins.append((x-1, y+0.5))
-            self.voisins.append((x-1, y-0.5))
-            self.voisins.append((x+1, y+0.5))
-            self.voisins.append((x+1, y-0.5))
+        if formeCases == "H":
+            self._voisins.append((x, y+1))
+            self._voisins.append((x, y-1))
+            self._voisins.append((x-1, y+0.5))
+            self._voisins.append((x-1, y-0.5))
+            self._voisins.append((x+1, y+0.5))
+            self._voisins.append((x+1, y-0.5))
         else:
-            self.voisins.append((x,   y-1))
-            self.voisins.append((x,   y+1))
-            self.voisins.append((x-1, y))
-            self.voisins.append((x+1, y))
+            self._voisins.append((x,   y-1))
+            self._voisins.append((x,   y+1))
+            self._voisins.append((x-1, y))
+            self._voisins.append((x+1, y))
 
         #pour afficher les coordonnees des cases:        
         #text = QGraphicsSimpleTextItem("{}-{}".format(x,y), parent=self)
@@ -233,38 +202,40 @@ class VefCase(QGraphicsPolygonItem):
 
         #couleur de fond par defaut
         if couleur.__class__.__name__ == "QColor":
-            if not couleur.isValid():
-                couleur = QColor("grey")
+            if couleur.isValid():
+                self._couleur = couleur
+            else:
+                self._couleur = QColor("grey")
         else:
-            couleur = QColor("grey")
+            self._couleur = QColor("grey")
         
         if self._position == (0, 0):
-            couleur.darker(150)
+            couleur = self._couleur.darker(150)
             self.setBrush(couleur)
-            self.estSelectionnee = True
+            self._estSelectionnee = True
         else:    
-            self.setBrush(QColor(255,255,255,50))
+            self.selectionner(False)
         #creation de l'objet graphique sur le plateau
+        pinceau = QPen()
+        pinceau.setWidth(2)
+        pinceau.setColor(QColor(150,150,150,150))
+        self.setPen(pinceau)
         self.scene.addItem(self)
 
     def mousePressEvent(self, event):
         """evenement lors du clic souris"""
-        super(CaseEditionForme, self).mousePressEvent(event)
+        super(VefCase, self).mousePressEvent(event)
         if event.button() == 1: #sur clic gauche
             if self._position != (0, 0):
                 self.scene.majSelection(self._position)
 
 
 
-        
-
-
-
 
 class VefImage(QGraphicsPixmapItem):
     """etiquette utilisee dans une VueEditionForme()"""
     def __init__(self, scene, parent=None):
-        super(VefEtiquette, self).__init__()
+        super(VefImage, self).__init__()
         self.scene = scene
         self._def = ImgPion()
         self._pix = None
@@ -272,22 +243,22 @@ class VefImage(QGraphicsPixmapItem):
         self._h0 = 0
         self.setFlags(QGraphicsItem.ItemIsMovable | QGraphicsItem.ItemIsSelectable | \
                       QGraphicsItem.ItemSendsGeometryChanges | QGraphicsItem.ItemIsFocusable)
+        self.scene.addItem(self)
+        self.setZValue(10)
         
     def charger(self, definition):
         self._pix = None
         self._l0 = 0
         self._h0 = 0
         self._def = definition
-        self.scene.addItem(self)
-        self.setZValue(10)
-        self.maj()
+        self._maj()
 
     def definition(self):
         return self._def
 
     def _maj(self):
-        if self._pix == None:
-            if len(self._def.nomFichier) > 0:
+        if len(self._def.nomFichier) > 0:
+            if self._pix == None:
                 self._pix = QPixmap(QString.fromUtf8(self._def.nomFichier))
                 if not self._pix.isNull():
                     if self._pix.height() >= self._pix.width():
@@ -298,41 +269,68 @@ class VefImage(QGraphicsPixmapItem):
                     self.h0 = self._pix.height()
                 else:
                     self._pix = None
-
+        else:
+            self_pix = None
+            
         if self._pix:
-            self._pix = self._pix.scaled((self._def.kx/10)*self._l0, (self._def.ky/10)*self._h0, \
+            self._pix.scaled((self._def.kx/10)*self._l0, (self._def.ky/10)*self._h0, \
                                          Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
-            deltaX = self._def.dx + 0.5*(120*1.1544 - self._l0)
-            deltaY = self._def.dy + 0.5*(120 - self._h0)
-
-            self.setPixmap(self._pix)    
+            k = 1
+            if self.scene.formeCases() == "H": k = 1.1544
+            deltaX = self._def.dx + 0.5*(120*k - self._pix.width())
+            deltaY = self._def.dy + 0.5*(120 - self._pix.height())
+            
+            self.setPixmap(self._pix)
             self.setPos(QPointF(deltaX, deltaY))
             self.setRotation(self._def.rotation)
      
-
-##    def mousePressEvent(self, event):
-##        pass
-
-
-
-
-
-
-
-class VefEtiquette(QGraphicsTextItem):
+    def mousePressEvent(self, event):
+        self.prepareGeometryChange()
+        self.scene.afficherMsg("Utilisez les touches HAUT et BAS pour modifier la taille de l'image\n" \
+                               "Utilisez les touches GAUCHE et DROITE pour faire pivoter l'image\n" \
+                               "Utilisez la touche G pour activer/desactiver l'écriture en gras")
+
+    def mouseReleaseEvent(self, event):
+        self.scene.afficherMsg("")
+        nouvellePos = self.scenePos()
+        self._def.dx = nouvellePos.x()# - 0.5*(120*k - self._pix.width())
+        self._def.dy = nouvellePos.y()# - 0.5*(120 - self._pix.height())
+
+    def keyPressEvent(self, event):
+        pass
+##        if event.key() == Qt.Key_Up:
+##            self._def.taille_police += 4
+##            self._maj()
+##        elif event.key() == Qt.Key_Down:
+##            self._def.taille_police -= 4
+##            self._maj()
+##        elif event.key() == Qt.Key_G:
+##            if not self._def.gras:
+##                self._def.gras = True
+##            else:
+##                self._def.gras = False
+##            self._maj()
+
+
+class VefEtiquette(QGraphicsSimpleTextItem):
     """etiquette utilisee dans une VueEditionForme()"""
     def __init__(self, scene, parent=None):
         super(VefEtiquette, self).__init__()
         self.scene = scene
         self._def = EtiquettePion()
-        self.setFlags(QGraphicsItem.ItemIsMovable | QGraphicsItem.ItemIsSelectable | \
-                      QGraphicsItem.ItemSendsGeometryChanges | QGraphicsItem.ItemIsFocusable)
+        self.setFlags(QGraphicsItem.ItemIsMovable | QGraphicsItem.ItemIsSelectable | QGraphicsItem.ItemIsFocusable)
+##        self.setFlags(QGraphicsItem.ItemIsMovable | QGraphicsItem.ItemIsSelectable | \
+##                      QGraphicsItem.ItemSendsGeometryChanges | QGraphicsItem.ItemIsFocusable)
+##        self.setFlags(QGraphicsItem.ItemIsSelectable | \
+##                      QGraphicsItem.ItemSendsGeometryChanges | QGraphicsItem.ItemIsFocusable)
+        self.setAcceptDrops(True)
+        self.scene.addItem(self)
+        self.setZValue(10)
+        
         
     def charger(self, definition):
         self._def = definition
-        self.scene.addItem(self)
-        self.setZValue(10)
-        self.maj()
+        self._maj()
 
     def definition(self):
         return self._def
@@ -340,13 +338,48 @@ class VefEtiquette(QGraphicsTextItem):
     def _maj(self):
         if len(self._def.txt) > 0:
             self.setText(QString.fromUtf8(self._def.txt))
-            self.setPos(QPointF(self._def.dx-0.112*120, self._def.dy-0.275*120))
-            police = QFont("Georgia", self._def.taillePolice)
-            police.setBold(True)
+            self.setPos(QPointF(self._def.dx - 0.112*120, self._def.dy - 0.5*120))
+
+            police = QFont("Verdana", self._def.taille_police)
+            police.setBold(self._def.gras)
             self.setFont(police)
         
+##    def itemChange(self, changement, nouvelleValeur):
+##        """reimplementation de la fonction de QGraphicsItem"""
+##        if changement == QGraphicsItem.ItemPositionChange:
+##             nouvellePos = nouvelleValeur.toPointF()
+##             #maj de dx et dy (par rapport a la position initiale
+##             self._def.dx = nouvellePos.x() - 0.112*120
+##             self._def.dy = nouvellePos.y() - 0.5*120
+##        return super(VefEtiquette, self).itemChange(changement, nouvelleValeur)
 
-
+    def mousePressEvent(self, event):
+        self.prepareGeometryChange()
+        self.scene.afficherMsg("Utilisez les touches HAUT et BAS pour modifier la taille de la police\n" \
+                               "Utilisez la touche G pour activer/desactiver l'écriture en gras")
+
+    def mouseReleaseEvent(self, event):
+        self.scene.afficherMsg("")
+        nouvellePos = self.scenePos()
+        self._def.dx = nouvellePos.x() - 0.112*120
+        self._def.dy = nouvellePos.y() - 0.5*120
+
+    def keyPressEvent(self, event):
+        if event.key() == Qt.Key_Up:
+            self._def.taille_police += 4
+            self._maj()
+        elif event.key() == Qt.Key_Down:
+            self._def.taille_police -= 4
+            self._maj()
+        elif event.key() == Qt.Key_G:
+            if not self._def.gras:
+                self._def.gras = True
+            else:
+                self._def.gras = False
+            self._maj()
+        
+             
+                
 
 
 

lib/regles.py

@@ -90,9 +90,13 @@ def attributAttaque(nomCourt):
         retour = None
     return retour    
 
-def valeurDefaut(self, nom):
+def valeurDefaut(nom):
     """renvoie la valeur par defaut demandee"""
-    dico = {"depMarche": 9, "depNage": 6, "depEscalade" = 3, "depVol" = 0, "saut" = 6}
+    retour = None
+    dico = {"depMarche": 9, "depNage": 6, "depEscalade": 3, "depVol": 0, "saut": 6}
+    if nom in dico:
+        retour = dico[nom]
+    return retour
 
 class Attribut():
     """attribut des pions et personnages"""

lib/ui/dm.py

@@ -3,7 +3,7 @@
 """ensemble des widgets surchargés"""
 from PyQt4.QtCore import *
 from PyQt4.QtGui import *
-##from lib.outilsSvg import *
+from lib.outilsSvg import *
 
 class DmLabel(QLabel):
     """surcharge de QLabel"""
@@ -44,18 +44,20 @@ class DmLabelChoixImage(DmLabel):
                                               "Selectionnez une image", 
                                               "\\img", 
                                               "Images (*.png *.jpg)")
-        pix = QPixmap(fichier)
-        if not pix.isNull():
-            self._sourceImage = fichier
-            self.clear()
-            pix = pix.scaled(self.width(), self.height(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
-            self.setPixmap(pix)
-        else:    
-            dial = QMessageBox(self)
-            dial.setText("Format non reconnu")
-            dial.setWindowTitle("Erreur")
-            dial.setStandardButtons(QMessageBox.Ok)
-            dial.exec_()
+        if len(fichier) > 0:
+            pix = QPixmap(fichier)
+            if not pix.isNull():
+                self._sourceImage = fichier
+                self.clear()
+                pix = pix.scaled(self.width(), self.height(), Qt.KeepAspectRatio, Qt.SmoothTransformation)
+                self.setPixmap(pix)
+                self.emit(SIGNAL("imageModifiee()"))
+            else:
+                dial = QMessageBox(self)
+                dial.setText("Format non reconnu")
+                dial.setWindowTitle("Erreur")
+                dial.setStandardButtons(QMessageBox.Ok)
+                dial.exec_()
 
     def image(self):
         """retourne le chemin de l'image chargee"""

lib/ui/ecran_editionCombattant.py

@@ -2,7 +2,7 @@
 
 # Form implementation generated from reading ui file 'editionCombattant.ui'
 #
-# Created: Fri Jun 05 10:52:33 2015
+# Created: Fri Jun 05 16:46:13 2015
 #      by: PyQt4 UI code generator 4.10.4
 #
 # WARNING! All changes made in this file will be lost!
@@ -23,20 +23,20 @@ except AttributeError:
     def _translate(context, text, disambig):
         return QtGui.QApplication.translate(context, text, disambig)
 
-class Ui_ecran_creationPion(object):
-    def setupUi(self, ecran_creationPion):
-        ecran_creationPion.setObjectName(_fromUtf8("ecran_creationPion"))
-        ecran_creationPion.setWindowModality(QtCore.Qt.ApplicationModal)
-        ecran_creationPion.resize(618, 484)
-        ecran_creationPion.setMinimumSize(QtCore.QSize(0, 484))
-        ecran_creationPion.setMaximumSize(QtCore.QSize(16777215, 10000))
-        self.horizontalLayout_2 = QtGui.QHBoxLayout(ecran_creationPion)
+class Ui_edc_fenetre(object):
+    def setupUi(self, edc_fenetre):
+        edc_fenetre.setObjectName(_fromUtf8("edc_fenetre"))
+        edc_fenetre.setWindowModality(QtCore.Qt.ApplicationModal)
+        edc_fenetre.resize(667, 514)
+        edc_fenetre.setMinimumSize(QtCore.QSize(0, 484))
+        edc_fenetre.setMaximumSize(QtCore.QSize(16777215, 10000))
+        self.horizontalLayout_2 = QtGui.QHBoxLayout(edc_fenetre)
         self.horizontalLayout_2.setContentsMargins(0, 0, -1, 0)
         self.horizontalLayout_2.setObjectName(_fromUtf8("horizontalLayout_2"))
         self.horizontalLayout = QtGui.QHBoxLayout()
         self.horizontalLayout.setSpacing(3)
         self.horizontalLayout.setObjectName(_fromUtf8("horizontalLayout"))
-        self.edc_menu = DmTableMenu(ecran_creationPion)
+        self.edc_menu = DmTableMenu(edc_fenetre)
         sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Fixed, QtGui.QSizePolicy.Expanding)
         sizePolicy.setHorizontalStretch(0)
         sizePolicy.setVerticalStretch(0)
@@ -210,12 +210,12 @@ class Ui_ecran_creationPion(object):
         self.horizontalLayout.addWidget(self.edc_menu)
         self.verticalLayout = QtGui.QVBoxLayout()
         self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
-        self.edc_pages = QtGui.QStackedWidget(ecran_creationPion)
+        self.edc_pages = QtGui.QStackedWidget(edc_fenetre)
         self.edc_pages.setMinimumSize(QtCore.QSize(392, 0))
         self.edc_pages.setObjectName(_fromUtf8("edc_pages"))
         self.page_nom = QtGui.QWidget()
         self.page_nom.setObjectName(_fromUtf8("page_nom"))
-        self.edc_nom = QtGui.QLineEdit(self.page_nom)
+        self.edc_nom = DmLineEdit(self.page_nom)
         self.edc_nom.setGeometry(QtCore.QRect(110, 40, 271, 31))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
@@ -250,12 +250,12 @@ class Ui_ecran_creationPion(object):
         self.label_8.setFont(font)
         self.label_8.setObjectName(_fromUtf8("label_8"))
         self.frame_2 = QtGui.QFrame(self.page_nom)
-        self.frame_2.setGeometry(QtCore.QRect(30, 90, 341, 331))
+        self.frame_2.setGeometry(QtCore.QRect(30, 90, 371, 361))
         self.frame_2.setFrameShape(QtGui.QFrame.WinPanel)
         self.frame_2.setFrameShadow(QtGui.QFrame.Raised)
         self.frame_2.setObjectName(_fromUtf8("frame_2"))
         self.edc_vueForme = QtGui.QGraphicsView(self.frame_2)
-        self.edc_vueForme.setGeometry(QtCore.QRect(10, 10, 281, 291))
+        self.edc_vueForme.setGeometry(QtCore.QRect(10, 10, 311, 321))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(244, 244, 244))
         brush.setStyle(QtCore.Qt.SolidPattern)
@@ -272,31 +272,31 @@ class Ui_ecran_creationPion(object):
         self.edc_vueForme.setRenderHints(QtGui.QPainter.Antialiasing|QtGui.QPainter.HighQualityAntialiasing|QtGui.QPainter.TextAntialiasing)
         self.edc_vueForme.setObjectName(_fromUtf8("edc_vueForme"))
         self.edc_image = QtGui.QToolButton(self.frame_2)
-        self.edc_image.setGeometry(QtCore.QRect(300, 50, 31, 31))
+        self.edc_image.setGeometry(QtCore.QRect(330, 50, 31, 31))
         icon6 = QtGui.QIcon()
         icon6.addPixmap(QtGui.QPixmap(_fromUtf8("img/portrait.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
         self.edc_image.setIcon(icon6)
         self.edc_image.setIconSize(QtCore.QSize(22, 22))
         self.edc_image.setObjectName(_fromUtf8("edc_image"))
         self.edc_couleur = QtGui.QToolButton(self.frame_2)
-        self.edc_couleur.setGeometry(QtCore.QRect(300, 10, 31, 31))
+        self.edc_couleur.setGeometry(QtCore.QRect(330, 10, 31, 31))
         icon7 = QtGui.QIcon()
         icon7.addPixmap(QtGui.QPixmap(_fromUtf8("img/btnCouleurs.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
         self.edc_couleur.setIcon(icon7)
         self.edc_couleur.setObjectName(_fromUtf8("edc_couleur"))
         self.edc_aideForme = QtGui.QToolButton(self.frame_2)
-        self.edc_aideForme.setGeometry(QtCore.QRect(300, 270, 31, 31))
+        self.edc_aideForme.setGeometry(QtCore.QRect(330, 270, 31, 31))
         icon8 = QtGui.QIcon()
         icon8.addPixmap(QtGui.QPixmap(_fromUtf8("img/aide.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
         self.edc_aideForme.setIcon(icon8)
         self.edc_aideForme.setObjectName(_fromUtf8("edc_aideForme"))
-        self.edp_casesHexa = QtGui.QRadioButton(self.frame_2)
-        self.edp_casesHexa.setGeometry(QtCore.QRect(30, 300, 131, 31))
-        self.edp_casesHexa.setChecked(True)
-        self.edp_casesHexa.setObjectName(_fromUtf8("edp_casesHexa"))
-        self.edp_casesCarrees = QtGui.QRadioButton(self.frame_2)
-        self.edp_casesCarrees.setGeometry(QtCore.QRect(170, 300, 111, 31))
-        self.edp_casesCarrees.setObjectName(_fromUtf8("edp_casesCarrees"))
+        self.edc_casesHexa = QtGui.QRadioButton(self.frame_2)
+        self.edc_casesHexa.setGeometry(QtCore.QRect(30, 330, 131, 31))
+        self.edc_casesHexa.setChecked(True)
+        self.edc_casesHexa.setObjectName(_fromUtf8("edc_casesHexa"))
+        self.edc_casesCarrees = QtGui.QRadioButton(self.frame_2)
+        self.edc_casesCarrees.setGeometry(QtCore.QRect(170, 330, 111, 31))
+        self.edc_casesCarrees.setObjectName(_fromUtf8("edc_casesCarrees"))
         self.edc_pages.addWidget(self.page_nom)
         self.page_dep = QtGui.QWidget()
         self.page_dep.setObjectName(_fromUtf8("page_dep"))
@@ -612,7 +612,7 @@ class Ui_ecran_creationPion(object):
         font.setFamily(_fromUtf8("Verdana"))
         self.edc_notes.setFont(font)
         self.edc_notes.setObjectName(_fromUtf8("edc_notes"))
-        self.edc_detail_age = QtGui.QLineEdit(self.page_notes)
+        self.edc_detail_age = DmLineEdit(self.page_notes)
         self.edc_detail_age.setGeometry(QtCore.QRect(340, 21, 61, 20))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
@@ -643,7 +643,7 @@ class Ui_ecran_creationPion(object):
         font.setPointSize(8)
         self.label_17.setFont(font)
         self.label_17.setObjectName(_fromUtf8("label_17"))
-        self.edc_detail_sexe = QtGui.QLineEdit(self.page_notes)
+        self.edc_detail_sexe = DmLineEdit(self.page_notes)
         self.edc_detail_sexe.setGeometry(QtCore.QRect(340, 50, 61, 20))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
@@ -660,7 +660,7 @@ class Ui_ecran_creationPion(object):
         font.setFamily(_fromUtf8("Verdana"))
         self.edc_detail_sexe.setFont(font)
         self.edc_detail_sexe.setObjectName(_fromUtf8("edc_detail_sexe"))
-        self.edc_detail_yeux = QtGui.QLineEdit(self.page_notes)
+        self.edc_detail_yeux = DmLineEdit(self.page_notes)
         self.edc_detail_yeux.setGeometry(QtCore.QRect(100, 140, 91, 20))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
@@ -685,7 +685,7 @@ class Ui_ecran_creationPion(object):
         font.setPointSize(8)
         self.label_37.setFont(font)
         self.label_37.setObjectName(_fromUtf8("label_37"))
-        self.edc_detail_peau = QtGui.QLineEdit(self.page_notes)
+        self.edc_detail_peau = DmLineEdit(self.page_notes)
         self.edc_detail_peau.setGeometry(QtCore.QRect(100, 170, 91, 20))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
@@ -717,7 +717,7 @@ class Ui_ecran_creationPion(object):
         font.setPointSize(8)
         self.label_39.setFont(font)
         self.label_39.setObjectName(_fromUtf8("label_39"))
-        self.edc_detail_cheveux = QtGui.QLineEdit(self.page_notes)
+        self.edc_detail_cheveux = DmLineEdit(self.page_notes)
         self.edc_detail_cheveux.setGeometry(QtCore.QRect(100, 200, 91, 20))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
@@ -735,7 +735,7 @@ class Ui_ecran_creationPion(object):
         self.edc_detail_cheveux.setFont(font)
         self.edc_detail_cheveux.setText(_fromUtf8(""))
         self.edc_detail_cheveux.setObjectName(_fromUtf8("edc_detail_cheveux"))
-        self.edc_detail_lieuNaissance = QtGui.QLineEdit(self.page_notes)
+        self.edc_detail_lieuNaissance = DmLineEdit(self.page_notes)
         self.edc_detail_lieuNaissance.setGeometry(QtCore.QRect(100, 110, 171, 20))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
@@ -767,7 +767,7 @@ class Ui_ecran_creationPion(object):
         font.setPointSize(8)
         self.label_41.setFont(font)
         self.label_41.setObjectName(_fromUtf8("label_41"))
-        self.edc_detail_poids = QtGui.QLineEdit(self.page_notes)
+        self.edc_detail_poids = DmLineEdit(self.page_notes)
         self.edc_detail_poids.setGeometry(QtCore.QRect(340, 81, 61, 20))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
@@ -791,7 +791,7 @@ class Ui_ecran_creationPion(object):
         font.setPointSize(8)
         self.label_43.setFont(font)
         self.label_43.setObjectName(_fromUtf8("label_43"))
-        self.edc_detail_espece = QtGui.QLineEdit(self.page_notes)
+        self.edc_detail_espece = DmLineEdit(self.page_notes)
         self.edc_detail_espece.setGeometry(QtCore.QRect(100, 21, 171, 20))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
@@ -816,7 +816,7 @@ class Ui_ecran_creationPion(object):
         font.setPointSize(8)
         self.label_44.setFont(font)
         self.label_44.setObjectName(_fromUtf8("label_44"))
-        self.edc_detail_profession = QtGui.QLineEdit(self.page_notes)
+        self.edc_detail_profession = DmLineEdit(self.page_notes)
         self.edc_detail_profession.setGeometry(QtCore.QRect(100, 50, 171, 20))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
@@ -841,7 +841,7 @@ class Ui_ecran_creationPion(object):
         font.setPointSize(8)
         self.label_45.setFont(font)
         self.label_45.setObjectName(_fromUtf8("label_45"))
-        self.edc_detail_taille = QtGui.QLineEdit(self.page_notes)
+        self.edc_detail_taille = DmLineEdit(self.page_notes)
         self.edc_detail_taille.setGeometry(QtCore.QRect(340, 110, 61, 21))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
@@ -859,7 +859,7 @@ class Ui_ecran_creationPion(object):
         self.edc_detail_taille.setFont(font)
         self.edc_detail_taille.setText(_fromUtf8(""))
         self.edc_detail_taille.setObjectName(_fromUtf8("edc_detail_taille"))
-        self.edc_detail_religion = QtGui.QLineEdit(self.page_notes)
+        self.edc_detail_religion = DmLineEdit(self.page_notes)
         self.edc_detail_religion.setGeometry(QtCore.QRect(100, 80, 171, 21))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
@@ -884,7 +884,7 @@ class Ui_ecran_creationPion(object):
         font.setPointSize(8)
         self.label_42.setFont(font)
         self.label_42.setObjectName(_fromUtf8("label_42"))
-        self.edc_detail_langues = QtGui.QLineEdit(self.page_notes)
+        self.edc_detail_langues = DmLineEdit(self.page_notes)
         self.edc_detail_langues.setGeometry(QtCore.QRect(210, 170, 191, 51))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(248, 248, 248))
@@ -911,7 +911,7 @@ class Ui_ecran_creationPion(object):
         self.label_46.setObjectName(_fromUtf8("label_46"))
         self.edc_pages.addWidget(self.page_notes)
         self.verticalLayout.addWidget(self.edc_pages)
-        self.frame = QtGui.QFrame(ecran_creationPion)
+        self.frame = QtGui.QFrame(edc_fenetre)
         self.frame.setMinimumSize(QtCore.QSize(392, 50))
         self.frame.setMaximumSize(QtCore.QSize(16777215, 50))
         self.frame.setFrameShape(QtGui.QFrame.StyledPanel)
@@ -937,99 +937,99 @@ class Ui_ecran_creationPion(object):
         self.horizontalLayout.setStretch(1, 1)
         self.horizontalLayout_2.addLayout(self.horizontalLayout)
 
-        self.retranslateUi(ecran_creationPion)
+        self.retranslateUi(edc_fenetre)
         self.edc_pages.setCurrentIndex(0)
         QtCore.QObject.connect(self.edc_menu, QtCore.SIGNAL(_fromUtf8("cellClicked(int,int)")), self.edc_pages.setCurrentIndex)
-        QtCore.QMetaObject.connectSlotsByName(ecran_creationPion)
+        QtCore.QMetaObject.connectSlotsByName(edc_fenetre)
 
-    def retranslateUi(self, ecran_creationPion):
-        ecran_creationPion.setWindowTitle(_translate("ecran_creationPion", "Creation / Edition de combattant", None))
+    def retranslateUi(self, edc_fenetre):
+        edc_fenetre.setWindowTitle(_translate("edc_fenetre", "Creation / Edition de combattant", None))
         item = self.edc_menu.verticalHeaderItem(0)
-        item.setText(_translate("ecran_creationPion", "1", None))
+        item.setText(_translate("edc_fenetre", "1", None))
         item = self.edc_menu.verticalHeaderItem(1)
-        item.setText(_translate("ecran_creationPion", "2", None))
+        item.setText(_translate("edc_fenetre", "2", None))
         item = self.edc_menu.verticalHeaderItem(2)
-        item.setText(_translate("ecran_creationPion", "3", None))
+        item.setText(_translate("edc_fenetre", "3", None))
         item = self.edc_menu.verticalHeaderItem(3)
-        item.setText(_translate("ecran_creationPion", "4", None))
+        item.setText(_translate("edc_fenetre", "4", None))
         item = self.edc_menu.verticalHeaderItem(4)
-        item.setText(_translate("ecran_creationPion", "5", None))
+        item.setText(_translate("edc_fenetre", "5", None))
         item = self.edc_menu.verticalHeaderItem(5)
-        item.setText(_translate("ecran_creationPion", "6", None))
+        item.setText(_translate("edc_fenetre", "6", None))
         item = self.edc_menu.horizontalHeaderItem(0)
-        item.setText(_translate("ecran_creationPion", "inutile", None))
+        item.setText(_translate("edc_fenetre", "inutile", None))
         item = self.edc_menu.horizontalHeaderItem(1)
-        item.setText(_translate("ecran_creationPion", "menus", None))
+        item.setText(_translate("edc_fenetre", "menus", None))
         __sortingEnabled = self.edc_menu.isSortingEnabled()
         self.edc_menu.setSortingEnabled(False)
         item = self.edc_menu.item(0, 1)
-        item.setText(_translate("ecran_creationPion", " NOM ET APPARENCE ", None))
+        item.setText(_translate("edc_fenetre", " NOM ET APPARENCE ", None))
         item = self.edc_menu.item(1, 1)
-        item.setText(_translate("ecran_creationPion", " TAILLE ET DEPLACEMENT ", None))
+        item.setText(_translate("edc_fenetre", " TAILLE ET DEPLACEMENT ", None))
         item = self.edc_menu.item(2, 1)
-        item.setText(_translate("ecran_creationPion", " ATTRIBUTS ET CAPACITES", None))
+        item.setText(_translate("edc_fenetre", " ATTRIBUTS ET CAPACITES", None))
         item = self.edc_menu.item(3, 1)
-        item.setText(_translate("ecran_creationPion", " ATTAQUES ", None))
+        item.setText(_translate("edc_fenetre", " ATTAQUES ", None))
         item = self.edc_menu.item(4, 1)
-        item.setText(_translate("ecran_creationPion", " INVENTAIRE ", None))
+        item.setText(_translate("edc_fenetre", " INVENTAIRE ", None))
         item = self.edc_menu.item(5, 1)
-        item.setText(_translate("ecran_creationPion", " NOTES ", None))
+        item.setText(_translate("edc_fenetre", " NOTES ", None))
         self.edc_menu.setSortingEnabled(__sortingEnabled)
-        self.edc_logo.setText(_translate("ecran_creationPion", "Choisissez \n"
+        self.edc_logo.setText(_translate("edc_fenetre", "Choisissez \n"
 "un fichier\n"
 "image", None))
-        self.label_8.setText(_translate("ecran_creationPion", "Nom : ", None))
-        self.edc_image.setText(_translate("ecran_creationPion", "...", None))
-        self.edc_couleur.setText(_translate("ecran_creationPion", "...", None))
-        self.edc_aideForme.setText(_translate("ecran_creationPion", "...", None))
-        self.edp_casesHexa.setText(_translate("ecran_creationPion", "Cases hexagonales", None))
-        self.edp_casesCarrees.setText(_translate("ecran_creationPion", "Cases carrées", None))
-        self.label_9.setText(_translate("ecran_creationPion", "Nombre de cases que la créature peut parcourir en un tour : ", None))
-        self.label_10.setText(_translate("ecran_creationPion", "Marche / Course", None))
-        self.label_11.setText(_translate("ecran_creationPion", "Nage    ", None))
-        self.label_12.setText(_translate("ecran_creationPion", "Escalade ", None))
-        self.label_13.setText(_translate("ecran_creationPion", "Vol      ", None))
-        self.label_14.setText(_translate("ecran_creationPion", "Hauteur maximum pour les sauts : ", None))
-        self.label_15.setText(_translate("ecran_creationPion", "Taille de la créature (en cases) : ", None))
+        self.label_8.setText(_translate("edc_fenetre", "Nom : ", None))
+        self.edc_image.setText(_translate("edc_fenetre", "...", None))
+        self.edc_couleur.setText(_translate("edc_fenetre", "...", None))
+        self.edc_aideForme.setText(_translate("edc_fenetre", "...", None))
+        self.edc_casesHexa.setText(_translate("edc_fenetre", "Cases hexagonales", None))
+        self.edc_casesCarrees.setText(_translate("edc_fenetre", "Cases carrées", None))
+        self.label_9.setText(_translate("edc_fenetre", "Nombre de cases que la créature peut parcourir en un tour : ", None))
+        self.label_10.setText(_translate("edc_fenetre", "Marche / Course", None))
+        self.label_11.setText(_translate("edc_fenetre", "Nage    ", None))
+        self.label_12.setText(_translate("edc_fenetre", "Escalade ", None))
+        self.label_13.setText(_translate("edc_fenetre", "Vol      ", None))
+        self.label_14.setText(_translate("edc_fenetre", "Hauteur maximum pour les sauts : ", None))
+        self.label_15.setText(_translate("edc_fenetre", "Taille de la créature (en cases) : ", None))
         item = self.edc_listeAttributs.horizontalHeaderItem(0)
-        item.setText(_translate("ecran_creationPion", "Nouvelle colonne", None))
+        item.setText(_translate("edc_fenetre", "Nouvelle colonne", None))
         item = self.edc_listeAttributs.horizontalHeaderItem(1)
-        item.setText(_translate("ecran_creationPion", "Valeur", None))
-        self.label_18.setText(_translate("ecran_creationPion", "Attributs / caractéristiques :  ", None))
+        item.setText(_translate("edc_fenetre", "Valeur", None))
+        self.label_18.setText(_translate("edc_fenetre", "Attributs / caractéristiques :  ", None))
         item = self.edc_listeInventaire.horizontalHeaderItem(0)
-        item.setText(_translate("ecran_creationPion", "nombre", None))
+        item.setText(_translate("edc_fenetre", "nombre", None))
         item = self.edc_listeInventaire.horizontalHeaderItem(1)
-        item.setText(_translate("ecran_creationPion", "objet", None))
-        self.edc_inventaire_supprimer.setText(_translate("ecran_creationPion", "...", None))
-        self.label_24.setText(_translate("ecran_creationPion", "Inventaire :", None))
-        self.edc_inventaire_nouveau.setText(_translate("ecran_creationPion", "...", None))
-        self.label_23.setText(_translate("ecran_creationPion", "Notes :", None))
-        self.label_16.setText(_translate("ecran_creationPion", "Age : ", None))
-        self.label_17.setText(_translate("ecran_creationPion", "Sexe : ", None))
-        self.label_37.setText(_translate("ecran_creationPion", "Yeux :", None))
-        self.label_38.setText(_translate("ecran_creationPion", "Peau :", None))
-        self.label_39.setText(_translate("ecran_creationPion", "Poils /\n"
+        item.setText(_translate("edc_fenetre", "objet", None))
+        self.edc_inventaire_supprimer.setText(_translate("edc_fenetre", "...", None))
+        self.label_24.setText(_translate("edc_fenetre", "Inventaire :", None))
+        self.edc_inventaire_nouveau.setText(_translate("edc_fenetre", "...", None))
+        self.label_23.setText(_translate("edc_fenetre", "Notes :", None))
+        self.label_16.setText(_translate("edc_fenetre", "Age : ", None))
+        self.label_17.setText(_translate("edc_fenetre", "Sexe : ", None))
+        self.label_37.setText(_translate("edc_fenetre", "Yeux :", None))
+        self.label_38.setText(_translate("edc_fenetre", "Peau :", None))
+        self.label_39.setText(_translate("edc_fenetre", "Poils /\n"
 "Cheveux :", None))
-        self.label_40.setText(_translate("ecran_creationPion", "Lieu de\n"
+        self.label_40.setText(_translate("edc_fenetre", "Lieu de\n"
 "naissance :", None))
-        self.label_41.setText(_translate("ecran_creationPion", "Poids : ", None))
-        self.label_43.setText(_translate("ecran_creationPion", "Espèce : ", None))
-        self.label_44.setText(_translate("ecran_creationPion", "Profession : ", None))
-        self.label_45.setText(_translate("ecran_creationPion", "Taille : ", None))
-        self.label_42.setText(_translate("ecran_creationPion", "Religion /\n"
+        self.label_41.setText(_translate("edc_fenetre", "Poids : ", None))
+        self.label_43.setText(_translate("edc_fenetre", "Espèce : ", None))
+        self.label_44.setText(_translate("edc_fenetre", "Profession : ", None))
+        self.label_45.setText(_translate("edc_fenetre", "Taille : ", None))
+        self.label_42.setText(_translate("edc_fenetre", "Religion /\n"
 "Croyances :", None))
-        self.label_46.setText(_translate("ecran_creationPion", "Langues parlées :", None))
-        self.edc_enregistrer.setText(_translate("ecran_creationPion", "Enregistrer", None))
-        self.edc_annuler.setText(_translate("ecran_creationPion", "Annuler", None))
+        self.label_46.setText(_translate("edc_fenetre", "Langues parlées :", None))
+        self.edc_enregistrer.setText(_translate("edc_fenetre", "Enregistrer", None))
+        self.edc_annuler.setText(_translate("edc_fenetre", "Annuler", None))
 
-from dm import DmLabelChoixImage, DmTableMenu
+from dm import DmLabelChoixImage, DmTableMenu, DmLineEdit
 
 if __name__ == "__main__":
     import sys
     app = QtGui.QApplication(sys.argv)
-    ecran_creationPion = QtGui.QDialog()
-    ui = Ui_ecran_creationPion()
-    ui.setupUi(ecran_creationPion)
-    ecran_creationPion.show()
+    edc_fenetre = QtGui.QDialog()
+    ui = Ui_edc_fenetre()
+    ui.setupUi(edc_fenetre)
+    edc_fenetre.show()
     sys.exit(app.exec_())
 

lib/ui/editionCombattant.ui

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
- <class>ecran_creationPion</class>
- <widget class="QDialog" name="ecran_creationPion">
+ <class>edc_fenetre</class>
+ <widget class="QDialog" name="edc_fenetre">
   <property name="windowModality">
    <enum>Qt::ApplicationModal</enum>
   </property>
@@ -9,8 +9,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>618</width>
-    <height>484</height>
+    <width>667</width>
+    <height>514</height>
    </rect>
   </property>
   <property name="minimumSize">
@@ -612,8 +612,8 @@ image</string>
             <rect>
              <x>30</x>
              <y>90</y>
-             <width>341</width>
-             <height>331</height>
+             <width>371</width>
+             <height>361</height>
             </rect>
            </property>
            <property name="frameShape">
@@ -627,8 +627,8 @@ image</string>
              <rect>
               <x>10</x>
               <y>10</y>
-              <width>281</width>
-              <height>291</height>
+              <width>311</width>
+              <height>321</height>
              </rect>
             </property>
             <property name="palette">
@@ -681,7 +681,7 @@ image</string>
            <widget class="QToolButton" name="edc_image">
             <property name="geometry">
              <rect>
-              <x>300</x>
+              <x>330</x>
               <y>50</y>
               <width>31</width>
               <height>31</height>
@@ -704,7 +704,7 @@ image</string>
            <widget class="QToolButton" name="edc_couleur">
             <property name="geometry">
              <rect>
-              <x>300</x>
+              <x>330</x>
               <y>10</y>
               <width>31</width>
               <height>31</height>
@@ -721,7 +721,7 @@ image</string>
            <widget class="QToolButton" name="edc_aideForme">
             <property name="geometry">
              <rect>
-              <x>300</x>
+              <x>330</x>
               <y>270</y>
               <width>31</width>
               <height>31</height>
@@ -739,7 +739,7 @@ image</string>
             <property name="geometry">
              <rect>
               <x>30</x>
-              <y>300</y>
+              <y>330</y>
               <width>131</width>
               <height>31</height>
              </rect>
@@ -755,7 +755,7 @@ image</string>
             <property name="geometry">
              <rect>
               <x>170</x>
-              <y>300</y>
+              <y>330</y>
               <width>111</width>
               <height>31</height>
              </rect>