Refonte Edition de combattant: Modif image et etiquette fonctionnelles

lib/EcranEditionCombattant.py

@@ -18,7 +18,6 @@ class EcranEditionCombattant(QDialog):
         """initialisation de la fenetre"""
         super (EcranEditionCombattant, self).__init__()
         self.pixGraphique = None
-        self.id = None
         self.createWidgets()
         
         if combattant == None:
@@ -76,10 +75,7 @@ class EcranEditionCombattant(QDialog):
         
     def ouverture(self):
         """premier affichage: on met a jour les champs"""
-        #identifiant
-        if not self.id:
-            self.id = self.nouvelIdCombattant()
-        
+       
         #page_nom
         self.ui.edc_nom.majTexte(self.combattant.nom)
         if self.combattant.logo:
@@ -118,7 +114,10 @@ class EcranEditionCombattant(QDialog):
                 widget.majTexte(self.combattant.details[detail])
         self.ui.edc_notes.setText(self.combattant.notes)
 
-    def majActivationEnregistrer(self, txt):
+        #autre
+        self.majActivationEnregistrer()
+
+    def majActivationEnregistrer(self):
         """verifie la validite des saisies"""
         self.ui.edc_enregistrer.setEnabled(len(self.ui.edc_nom.texte()) > 0)
 
@@ -196,70 +195,29 @@ class EcranEditionCombattant(QDialog):
             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    
+            self.combattant.couleur = couleur
+            self.vueForme.majCouleur(couleur)
+
             
     def enregistrer(self):
         """enregistre le terrain cree/edite"""
+        #identifiant
+        if not self.combattant.id:
+            self.combattant.id = self.nouvelIdCombattant()
+
         #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.formeDef[self.vueForme.formeCases()] = self.vueForme.formeDef()
+        self.combattant.img = self.vueForme.imageDef()
+        self.combattant.etiquette = self.vueForme.etiquetteDef()
 
         #page dep
         self.combattant.taille = self.ui.edc_taille.value()
@@ -286,7 +244,7 @@ class EcranEditionCombattant(QDialog):
                 if len(txt) > 0:
                     self.combattant.details[detail] = txt
         
-        self.combattant.notes = str(self.ui.notesCombattant.toPlainText())
+        self.combattant.notes = str(self.ui.edc_notes.toPlainText())
 
         enregistrer(self.combattant.id, self.combattant, "lib\\biblio\\combattant")
         self.combattant = None

lib/Pion.py

@@ -211,11 +211,10 @@ class Pion(QGraphicsItem):
         """met a jour la taille, le format et l'orientation de l'etiquette"""
         self.etiquetteGraphique = QGraphicsSimpleTextItem("{}".format(self.txtId()))
         self.etiquetteGraphique.setPos(QPointF(self.etiquette.dx - 0.112*self.plateau.hCase, \
-                                                self.etiquette.dy - 0.275*self.plateau.hCase))
-        police = QFont("Georgia", self.etiquette.taille_police)
+                                                self.etiquette.dy - 0.5*self.plateau.hCase))
+        police = QFont("Verdana", self.etiquette.taille_police)
         police.setBold(self.etiquette.gras)
         self.etiquetteGraphique.setFont(police)
-        self.etiquetteGraphique.setRotation(self.etiquette.rotation)
         self.etiquetteGraphique.setParentItem(self)        
                 
     def majNbRotation(self, nbRotations):
@@ -306,7 +305,7 @@ class ImgPion():
 class EtiquettePion():
     def __init__(self):
         self.txt = ""
-        self.taille_police = 38     #taille de la police
+        self.taille_police = 28     #taille de la police
         self.gras = False           #en gras
         self.dx = 0                 #decalage horizontal
         self.dy = 0                 #decalage vertical

lib/Plateau.py

@@ -696,7 +696,7 @@ class Plateau(QGraphicsScene):
         """on a clique dans la liste d'ordre de jeu, le pion correspondant est selectionne et centre sur la carte"""
         numCombattant = int(self.fenetre.ui.inf_listeOrdreJeu.item(ligne, 0).text().toUtf8())  
         self.vue().centerOn(self.cases[self.combattants[numCombattant].position].centreGraphique)
-        self.pionSaisir(numCombattant)
+        self.modeActif.clic_combattant(numCombattant)
 
     def pionSuivant(self):
         """selection du pion suivant dans la liste d'ordre de jeu"""

lib/VueEditionForme.py

@@ -24,11 +24,14 @@ class VueEditionForme(QGraphicsScene):
         self._l0 = 0
         self._h0 = 0
         self._rotation = 0
+        self.selection = None
 
         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)
 
+    def setCursor(self, curseur):
+        self.fenetre.ui.edc_vueForme.setCursor(curseur)
 
     #acces aux donnees
     def chargerFormeDef(self, formeDef):
@@ -98,6 +101,15 @@ class VueEditionForme(QGraphicsScene):
                     self._cases[coord].selectionner(True)
                     self._cases[coord].setBrush(self._couleur)
 
+    def _majCouleurGraphique(self):
+        for coord in self._cases:
+            if self._cases[coord].estSelectionnee():
+                if coord == (0,0):
+                    c = self._couleur.darker(150)
+                    self._cases[coord].setBrush(c)
+                else:
+                    self._cases[coord].setBrush(self._couleur)
+
     def majSelection(self, coord):
          """met a jour l'affichage des cases selectionnees pour l'affichage de la forme"""
          if self._cases[coord].estSelectionnee():
@@ -118,8 +130,7 @@ class VueEditionForme(QGraphicsScene):
                          valide = False
                          break
              if valide:
-                 self._cases[coord].selectionner(False)           
-
+                 self._cases[coord].selectionner(False)
          else:
              #on s'assure que la case est bien adjacente a une case selectionnee
              valide = False
@@ -130,10 +141,51 @@ class VueEditionForme(QGraphicsScene):
                         break
              if valide:
                  self._cases[coord].selectionner(True)
+                 
+         self._majCouleurGraphique()
+
 
     def afficherMsg(self, msg):
         print msg
 
+
+##    def mousePressEvent(self, event):
+##        self.selection = None
+##        for item in self.fenetre.ui.edc_vueForme.scene().items(event.scenePos()):
+##            if item.__class__.__name__ == "VefImage":
+##                self.selection = item
+##                self.setCursor(Qt.SizeAllCursor)
+##                break
+##        super(VueEditionForme, self).mousePressEvent(event)
+##
+##    def mouseMoveEvent(self, event):
+##        if self.selection and event.buttons() == Qt.NoButton:
+##            item = self.selection
+##            position = event.scenePos()
+##            if ((position.x() - item.scenePos().x()) + (position.y() - item.scenePos().y()))**2 < 5:
+##                #coin superieur gauche
+##                self.setCursor(Qt.SizeFDiagCursor)
+##            elif ((position.x() - (item.scenePos().x() + item.width())) + (position.y() - item.scenePos().y()))**2 < 5:
+##                #coin sup droit
+##                self.setCursor(Qt.SizeBDiagCursor)
+##            elif ((position.x() - (item.scenePos().x() + item.width())) + (position.y() - (item.scenePos().y() + item.height())))**2 < 5:
+##                #coin inf droit
+##                self.setCursor(Qt.SizeFDiagCursor)
+##            elif ((position.x() - item.scenePos().x()) + (position.y() - (item.scenePos().y() + item.height())))**2 < 5:
+##                #coin inf gauche
+##                self.setCursor(Qt.SizeBDiagCursor)
+##            else:
+##                if position.x() > item.scenePos().x() and \
+##                   position.x() < (item.scenePos().x() + item.width()) and \
+##                   position.y() > item.scenePos().y() and \
+##                   position.y() < (item.scenePos().y() + item.height()):
+##                     #au milieu de l'item
+##                     self.setCursor(Qt.SizeAllCursor)               
+##                else:
+##                     self.setCursor(Qt.ArrowCursor)
+##        super(VueEditionForme, self).mouseMoveEvent(event)    
+
+
 class VefCase(QGraphicsPolygonItem):
     """case utilisee dans une VueEditionForme()"""
     def __init__(self, scene, parent=None):
@@ -231,7 +283,6 @@ class VefCase(QGraphicsPolygonItem):
 
 
 
-
 class VefImage(QGraphicsPixmapItem):
     """etiquette utilisee dans une VueEditionForme()"""
     def __init__(self, scene, parent=None):
@@ -241,8 +292,9 @@ class VefImage(QGraphicsPixmapItem):
         self._pix = None
         self._l0 = 0
         self._h0 = 0
-        self.setFlags(QGraphicsItem.ItemIsMovable | QGraphicsItem.ItemIsSelectable | \
-                      QGraphicsItem.ItemSendsGeometryChanges | QGraphicsItem.ItemIsFocusable)
+        self.setAcceptDrops(True)
+        self.setAcceptHoverEvents(True)
+        self.setFlags(QGraphicsItem.ItemIsMovable | QGraphicsItem.ItemIsSelectable | QGraphicsItem.ItemIsFocusable)
         self.scene.addItem(self)
         self.setZValue(10)
         
@@ -265,16 +317,16 @@ class VefImage(QGraphicsPixmapItem):
                         self._pix = self._pix.scaledToHeight(120*0.9, Qt.SmoothTransformation)
                     else:
                         self._pix = self._pix.scaledToWidth(120*0.9, Qt.SmoothTransformation)
-                    self.l0 = self._pix.width()
-                    self.h0 = self._pix.height()
+                    self._l0 = self._pix.width()
+                    self._h0 = self._pix.height()
                 else:
                     self._pix = None
         else:
             self_pix = None
             
         if self._pix:
-            self._pix.scaled((self._def.kx/10)*self._l0, (self._def.ky/10)*self._h0, \
-                                         Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
+            taille = QSize((self._def.kx/10)*self._l0, (self._def.ky/10)*self._h0)
+            self._pix = self._pix.scaled(taille, Qt.IgnoreAspectRatio, Qt.SmoothTransformation)
             k = 1
             if self.scene.formeCases() == "H": k = 1.1544
             deltaX = self._def.dx + 0.5*(120*k - self._pix.width())
@@ -283,33 +335,48 @@ class VefImage(QGraphicsPixmapItem):
             self.setPixmap(self._pix)
             self.setPos(QPointF(deltaX, deltaY))
             self.setRotation(self._def.rotation)
-     
+
+
+    def width(self):
+        return self.boundingRect().width()
+
+    def height(self):
+        return self.boundingRect().height()
+
+    def majPos(self, pos):
+        k = 1
+        if self.scene.formeCases() == "H": k = 1.1544
+        self._def.dx = pos.x() - 0.5*(120*k - self._pix.width())
+        self._def.dy = pos.y() - 0.5*(120 - self._pix.height())
+
     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")
+        self.scene.afficherMsg("Utilisez les touches Z, Q, S, D pour modifier la taille de l'image\n" \
+                               "Utilisez les touches W et X pour faire pivoter l'image")
 
     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())
+        super(VefImage, self).mouseReleaseEvent(event)
+        QApplication.processEvents()
+        self.majPos(self.scenePos())
 
     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()
+        if event.key() in [Qt.Key_Z, Qt.Key_Q, Qt.Key_S, Qt.Key_D, Qt.Key_W, Qt.Key_X]:
+            if event.key() == Qt.Key_Z:
+                self._def.ky += 2
+            elif event.key() == Qt.Key_Q:
+                self._def.kx -= 2
+            elif event.key() == Qt.Key_S:
+                self._def.ky -= 2
+            elif event.key() == Qt.Key_D:
+                self._def.kx += 2
+            elif event.key() == Qt.Key_W:
+                self._def.rotation -= 5
+            elif event.key() == Qt.Key_X:
+                self._def.rotation += 5
+
+            self.majPos(self.scenePos())
+            self._maj()
 
 
 class VefEtiquette(QGraphicsSimpleTextItem):
@@ -319,11 +386,9 @@ class VefEtiquette(QGraphicsSimpleTextItem):
         self.scene = scene
         self._def = EtiquettePion()
         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.setAcceptHoverEvents(True)
+        
         self.scene.addItem(self)
         self.setZValue(10)
         
@@ -343,15 +408,10 @@ class VefEtiquette(QGraphicsSimpleTextItem):
             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 majPos(self, pos):
+        self._def.dx = pos.x() - 0.112*120
+        self._def.dy = pos.y() - 0.5*120        
 
     def mousePressEvent(self, event):
         self.prepareGeometryChange()
@@ -360,22 +420,25 @@ class VefEtiquette(QGraphicsSimpleTextItem):
 
     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
+        super(VefEtiquette, self).mouseReleaseEvent(event)
+        QApplication.processEvents()
+        self.majPos(self.scenePos())
 
     def keyPressEvent(self, event):
         if event.key() == Qt.Key_Up:
             self._def.taille_police += 4
+            self.majPos(self.scenePos())
             self._maj()
         elif event.key() == Qt.Key_Down:
             self._def.taille_police -= 4
+            self.majPos(self.scenePos())
             self._maj()
         elif event.key() == Qt.Key_G:
             if not self._def.gras:
                 self._def.gras = True
             else:
                 self._def.gras = False
+            self.majPos(self.scenePos())
             self._maj()
         
              

lib/outilsSvg.py

@@ -27,7 +27,7 @@ def enregistrer(nomObj, obj, fichier = "", remplacer = True):
         while dico.has_key("{}{}".format(nomObj, k)):
             k += 1 
         dico["{}{}".format(nomObj,k)]=obj  
-     else:    
+     else:
         dico[nomObj]=obj   
           
      #on remet le dictionnaire dans le fichier
@@ -35,7 +35,6 @@ def enregistrer(nomObj, obj, fichier = "", remplacer = True):
          pickle.dump(dico, output, protocol=pickle.HIGHEST_PROTOCOL)
      output.close()
      chaine = "{} sauvegarde.".format(nomObj)
-     #print (time() - t0)
      return chaine
 
 def enregistrerUnique(obj, fichier = "", remplacer = True):