Manipulation des ressources repensee, lib 'rsc' creee

Creation de la lib 'commun'

.settings/org.eclipse.core.resources.prefs

@@ -9,16 +9,22 @@ encoding//lib/EcranAltitude.py=utf-8
 encoding//lib/EcranChargerPlateau.py=utf-8
 encoding//lib/EcranCreerPlateau.py=utf-8
 encoding//lib/EcranEditionCombattant.py=utf-8
+encoding//lib/EcranEditionDecor.py=utf-8
 encoding//lib/EcranEditionTerrain.py=utf-8
 encoding//lib/EcranFondPlateau.py=utf-8
 encoding//lib/EcranGestionCombat.py=utf-8
+encoding//lib/EcranSelectionPj.py=utf-8
 encoding//lib/Modes.py=utf-8
+encoding//lib/Partie.py=utf-8
 encoding//lib/Pion.py=utf-8
 encoding//lib/Plateau.py=utf-8
 encoding//lib/Terrain.py=utf-8
 encoding//lib/framePj.py=utf-8
 encoding//lib/outilsSvg.py=latin1
+encoding//lib/rsc.py=utf-8
 encoding//lib/ui/dm.py=utf-8
 encoding//lib/ui/ecran_altitude.py=utf-8
 encoding//lib/ui/ecran_creerPlateau.py=utf-8
+encoding//lib/ui/ecran_explorateur.py=utf-8
+encoding//lib/ui/ecran_saisie.py=utf-8
 encoding/DMonde.py=utf-8

DMonde.py

@@ -17,7 +17,7 @@ from lib.framePj import FramePj
 from lib.outilsSvg import *
 from lib.ui.ecran_principal import Ui_principal
 from lib.Actions import Ligne
-
+from lib.rsc import repApp
 
 class DMonde(QMainWindow):
     """interface comprenant: chat ecrit, fenetre d'infos, lancer de des, echange de fichiers, lancement du chat vocal"""
@@ -25,7 +25,9 @@ class DMonde(QMainWindow):
         """initialisation de la fenetre"""
         super (DMonde, self).__init__()
         self.plateau = None
-        self.partie = "partie1"
+        self.profil = "Joueur"
+        self.partie = ""
+        self.regles = ""
         self.idPlateauEnCours = ""
         self.plateauConnecte = False
         self._compteurPj = 0
@@ -38,15 +40,29 @@ class DMonde(QMainWindow):
         self.afficherPanneauxPlateau(False)
         self.connect(self.ui.cbt_sauver, SIGNAL("clicked()"), self.sauverPlateau)   
         self.connect(self.ui.cbt_fermer, SIGNAL("clicked()"), self.fermerPlateau)
+        self.connect(self.ui.grp_nouveauPj, SIGNAL("clicked()"), self.nouveauPj)
         self.ui.cbt_vue.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)
         self.ui.cp_ongletsListes.setStyleSheet("QTabBar::tab { width: 38px; }")
         self.ui.pi_ongletsListes.setStyleSheet("QTabBar::tab { width: 38px; }")
+        self.creerEcranFondPlateau()
+        
+        self.chargerPartie("")
+        
+#         self.showMaximized()
 
+    def chargerPartie(self, idPartie):
+        """charge la partie"""
+        self.profil = "olivier"
+        self.partie = "partie1"
+        self.regles = "dd35"
+        
+        tmp = {"profil": self.profil, "partie": self.partie, "regles": self.regles}
+        enregistrerUnique(tmp, os.path.join(repApp(), "dm.tmp"), True)
+        
         self.majFichierInfosSvg()
-        self.creerEcranFondPlateau()
         self.chargerListePj()
-        self.connect(self.ui.grp_nouveauPj, SIGNAL("clicked()"), self.nouveauPj)
-##        self.showMaximized()
+        
+        
 
 
     ########## onglet plateau

lib/Cache.py

@@ -1,15 +1,121 @@
 #from __future__ import unicode_literals
 # -*- coding: utf-8 -*-
+from PyQt4.QtCore import QString, QPointF, Qt
+from PyQt4.QtGui import QGraphicsTextItem, QFont, QColor, QCursor
+
+from EcranConfirmation import dmConfirmer
+
 
 class Cache():
     """cache place sur le plateau"""
-    def __init__(self, numero, parent=None):
-        self.numero = numero
-        self.nom = ""
-        self._actif = False
+    def __init__(self, plateau, idCache, parent=None):
+        self.plateau = plateau
+        self._idCache = idCache
+        self._nom = ""
+        self.etiquette = None
+        self._listeCases = []
+
+    def nom(self):
+        return self._nom
+
+    def listeCases(self):
+        return self._listeCases
+
+    def creer(self, listeCases, nom):
+        self._nom = nom
+        self._listeCases = listeCases
+
+        self.plateau.caches[self._idCache] = self
+        
+        for coord in self._listeCases:
+            self.plateau.cases[coord].ajouterCache(self._idCache)  
+        
+        for idCombattant in self.plateau.combattants:
+            if self.plateau.combattants[idCombattant].position in self._listeCases:
+                self.plateau.combattants[idCombattant].cacher(self._idCache)
+            
+        self.etiquette = EtiquetteCache(self)
+        self.etiquette.creer()
+                    
+
+    def retirer(self):
+        """retire le cache du plateau apres confirmation"""
+        #demande de confirmation
+        if not dmConfirmer("Retirer le cache du plateau?"): 
+            return
+        
+        for coord in self._listeCases:
+            self.plateau.cases[coord].retirerCache(self._idCache)
+
+        for idCombattant in self.plateau.combattants:
+            if self.plateau.combattants[idCombattant].position in self._listeCases:
+                self.plateau.combattants[idCombattant].reveler(self._idCache)
+
+        self.plateau.removeItem(self.etiquette)
+
+        del self.plateau.caches[self._idCache]         
+        
+ 
+        
+class EtiquetteCache(QGraphicsTextItem):
+    def __init__(self, cache, parent=None):
+        self.cache = cache
+        super(EtiquetteCache, self).__init__(parent)
+        
+    def creer(self):
+        """cree et place l'etiquette avec le texte et a la position demandee"""
+        self._txt = self.cache.nom()
+        self.setPos(self.position())
+        self.cache.plateau.addItem(self)  
+        self.setZValue(100)   
+        curseur = QCursor(Qt.ArrowCursor)
+        self.setCursor(curseur)   
+        self.maj()     
 
-    def activer(self, actif):
-        self._actif = actif
+    def position(self):
+        """calcule la position de l'etiquette:
+           on cherche la case la plus proche du barycentre"""
+        liste = self.cache.listeCases()
+        
+        totalX = 0 ; totalY = 0
+        for x, y in liste:
+            totalX += x ; totalY += y
+        xc = totalX / len(liste) ; yc = totalY / len(liste)
+        
+        plusProche = None
+        for x, y in liste:
+            d2 = (x - xc)**2 + (y - yc)**2
+            if not plusProche: 
+                plusProche = (d2, (x, y))
+            else:
+                if d2 < plusProche[0]: plusProche = (d2, (x, y))
+        
+        coord = plusProche[1]
+        pos = self.cache.plateau.cases[coord].centreGraphique
+        return pos             
 
-    def actif(self):
-        return self._actif
+    def maj(self, survol = False):
+        """met a jour l'apparence de l'etiquette slon qu'elle soit survolee ou non"""
+        txt = self._txt
+        if survol: txt += "  [X]"
+        self.setPlainText(QString.fromUtf8(txt))
+        
+        police = QFont("Verdana", 20)
+        police.setBold(survol)
+        self.setFont(police)   
+        
+        self.setDefaultTextColor(QColor(249, 249, 249) if not survol else QColor(255, 50, 50)) 
+            
+    def hoverEnterEvent(self, event):
+        self.maj(True)
+         
+    def hoverLeaveEvent(self, event):
+        self.maj(False)            
+        
+    def mousePressEvent(self, event):
+        self.cache.retirer()
+        
+        
+        
+    
+        

lib/Case.py

@@ -33,8 +33,7 @@ class Case(QGraphicsPolygonItem):
         self.centreGraphique = None
 
         self.occupation = {}    #z: num pion
-        self.cachesActifs = []       #liste des caches places par le MJ (cache le terrain, les decors, les pions aux joueurs...)
-        self.cachesInactifs = []
+        self.caches = []       #liste des caches places par le MJ sur la case (cache le terrain, les decors, les pions aux joueurs...)
 
         #effet sur la case 
         self.effetActif = "" 
@@ -113,7 +112,6 @@ class Case(QGraphicsPolygonItem):
         #cache
         self.polygoneCache = PolygoneCache(self)
         self.polygoneCache.creer()
-        self.majCache()
 
     def recreer(self, plateau):
 ##        self.plateau = plateau  #refPlateau
@@ -360,44 +358,24 @@ class Case(QGraphicsPolygonItem):
 
 
     #caches
-    def ajouterCache(self, idCache, actif = True):
-        if actif:
-            if not idCache in self.cachesActifs:
-                self.cachesActifs.append(idCache)
-                self.majCache() 
-        else:
-            if not idCache in self.cachesInactifs:
-                self.cachesInactifs.append(idCache)
+    def ajouterCache(self, idCache):
+        if not idCache in self.caches:
+            self.caches.append(idCache)
+        self.majCache()
         
-    def supprimerCache(self, idCache):
-        if idCache in self.cachesActifs:
-            self.cachesActifs.remove(idCache) 
-            self.majCache() 
-        elif idCache in self.cachesInactifs:
-            self.cachesInactifs.remove(idCache)     
-
-    def activerCache(self, idCache, actif = True):
-        if actif:
-            if idCache in self.cachesInactifs:
-                self.cachesInactifs.remove(idCache)
-                self.cachesActifs.append(idCache)
-                self.majCache()
-        else:
-            if idCache in self.cachesActifs:
-                self.cachesActifs.remove(idCache)
-                self.cachesInactifs.append(idCache)
-                self.majCache()
-                                    
+    def retirerCache(self, idCache):
+        if idCache in self.caches:
+            self.caches.remove(idCache) 
+        self.majCache()
+    
     def majCache(self):
-        self.polygoneCache.setVisible((len(self.cachesActifs) > 0))
-        if len(self.cachesActifs) > 0:
-            self.polygoneCache.majTransparence() 
-
+        """met a jour l'aspect de la case selon la situation"""
+        self.polygoneCache.afficher((len(self.caches) > 0))
+        self.polygoneCache.majTransparence()
+                                
     def estCachee(self):
         """une case cachee ne recoit plus aucun evenement souris ou clavier"""
-        retour = (len(self.cachesActifs) > 0 and \
-                not issubclass(self.plateau.modeActif.__class__, Modes.ModeBaseCp))
-        return retour
+        return (len(self.caches) > 0 and not issubclass(self.plateau.modeActif.__class__, Modes.ModeBaseCp))
 
     #fonctions secondaires
     def couleurDep(self):

lib/Combattant.py

@@ -4,13 +4,14 @@ from __future__ import division
 from Pion import Pion
 import regles
 import dmF
+import uid
 
 class Combattant(Pion):
     """combattant sur un plateau de combat"""
     def __init__(self, parent=None):
         super(Combattant, self).__init__()
         #caracs
-        self.id = None
+        self.id = uid.uid("cb")
 
         self.taille = 2
         self.depMarche = regles.valeurDefaut("depMarche")
@@ -28,6 +29,7 @@ class Combattant(Pion):
         #caracs liees au combat:
         self.etat = ""
         self.deplacementRestant = 0        
+        self.caches = []   #liste des id des caches qui couvrent le combattant
 
     def pM(self):
         """les points de mouvement"""
@@ -53,6 +55,18 @@ class Combattant(Pion):
         super(Combattant, self).ajouterAuPlateau(self.plateau)
         self.majEtiquette()
         
+    def cacher(self, idCache):
+        """on a place le combattant sous un cache"""
+        self.caches.append(idCache)
+        
+    def reveler(self, idCache):
+        """on a retire le cache qui couvrait ce combattant"""
+        self.caches.remove(idCache)
+
+    def estCache(self):
+        """met a jour le combattant selon qu'il est cache ou non"""
+        return (len(self.caches) > 0)
+
     def hoverEnterEvent(self, event):
         """evenement lors du survol de la souris (en entree)"""
         self.plateau.combattantSurvol(self.numero)

lib/Decor.py

@@ -11,7 +11,7 @@ class Decor(Pion):
     """decor a placer sur le plateau"""
     def __init__(self, parent=None):
         super(Decor, self).__init__()
-        self.id = "00"
+        self.id = ""
         self.escalade = False            #peut etre escalade
         self.brule = False               #peut prendre feu
         self.inventaire = []

lib/EcranEditionCombattant.py

@@ -163,14 +163,14 @@ class EcranEditionCombattant(QDialog):
         self.vueForme.chargerEtiquetteDef(self.combattant.etiquette)
 
     def selectionnerLogo(self):
-        img = rsc.selectionImage()
+        img = rsc.selectionImage("cb")
         if img:
             self.ui.edc_logo.chargerImage(img)
             self.vueForme.nouvelleImageDef(self.ui.edc_logo.image())
 
     def selectionImage(self):
         """selectionne le fichier image dans la boite de dialogue dediee"""
-        img = rsc.selectionImage()
+        img = rsc.selectionImage("cb")
         if img:
             self.vueForme.nouvelleImageDef(img)
         
@@ -369,11 +369,11 @@ class EcranEditionCombattant(QDialog):
         self.done(0)
 
 if __name__ == "__main__":
-	app = QApplication(sys.argv)
-	ecran = EcranEditionCombattant()
-	ecran.show()
-	r = app.exec_()
-	exit(r)      
+    app = QApplication(sys.argv)
+    ecran = EcranEditionCombattant()
+    ecran.show()
+    r = app.exec_()
+    exit(r)      
 
 
 

lib/EcranEditionDecor.py

@@ -126,14 +126,14 @@ class EcranEditionDecor(QDialog):
             self.vueForme.nouvelleImageDef(self.ui.edd_logo.image())
 
     def selectionnerLogo(self):
-        img = rsc.selectionImage()
+        img = rsc.selectionImage("dc")
         if img:
             self.ui.edd_logo.chargerImage(img)
             self.vueForme.nouvelleImageDef(self.ui.edd_logo.image())
 
     def selectionImage(self):
         """selectionne le fichier image dans la boite de dialogue dediee"""
-        img = rsc.selectionImage()
+        img = rsc.selectionImage("dc")
         if img:
             self.vueForme.nouvelleImageDef(img)
 
@@ -141,7 +141,6 @@ class EcranEditionDecor(QDialog):
         """selectionne la couleur dans la boite de dialogue dediee"""
         couleur = QColorDialog(self).getColor(QColor("white"), self)
         if couleur.isValid():
-            nomCouleur = couleur.name()
             self.decor.couleur = couleur
             self.vueForme.majCouleur(couleur)
 
@@ -223,10 +222,10 @@ class EcranEditionDecor(QDialog):
         self.done(0)
 
 if __name__ == "__main__":
-   app = QApplication(sys.argv)
-   ecran = EcranEditionDecor()
-   ecran.show()
-   r = app.exec_()
-   exit(r)      
+    app = QApplication(sys.argv)
+    ecran = EcranEditionDecor()
+    ecran.show()
+    r = app.exec_()
+    exit(r)      
 
 

lib/EcranEditionTerrain.py

@@ -1,13 +1,18 @@
 #from __future__ import unicode_literals
 # -*- coding: utf-8 -*-
 from __future__ import division
+
 import os
+import sys
+
 from PyQt4.QtCore import *
 from PyQt4.QtGui import *
+
 from Terrain import Terrain
-from ui.ecran_editionTerrain import Ui_et_fenetre
 from outilsSvg import *
-import rsc
+import rsc, uid
+from ui.ecran_editionTerrain import Ui_et_fenetre
+
 
 class EcranEditionTerrain(QDialog):
     """interface de creation/edition de terrains"""
@@ -72,7 +77,7 @@ class EcranEditionTerrain(QDialog):
 
     def selectionFichier(self):
         """selectionne le fichier de texture dans la boite de dialogue dediee"""
-        img = rsc.selectionImage()
+        img = rsc.selectionImage("tr")
         if img:
             self.ui.et_apercu.chargerImage(img)
            
@@ -85,7 +90,8 @@ class EcranEditionTerrain(QDialog):
             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")
+#         enregistrer(self.terrain.id, self.terrain, "lib\\biblio\\terrain")
+        rsc.enregistrerMat(self.terrain)
         self.terrain = None
         self.done(1)
 
@@ -98,3 +104,12 @@ class EcranEditionTerrain(QDialog):
         """annule la creation/edition"""
         self.terrain = None
         self.done(0)
+
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+    ecran = EcranEditionTerrain()
+    ecran.show()
+    r = app.exec_()
+    exit(r)      
+    

lib/Modes.py

@@ -15,6 +15,8 @@ from Combattant import Combattant
 from Decor import Decor
 import dmK
 from lib.EcranAltitude import EcranAltitude
+from Cache import Cache
+from EcranSaisie import dmSaisie
 
 class ModeBase(object):
     """mode de base: tous les modes heritent de cette classe"""
@@ -181,9 +183,7 @@ class StandardCp(ModeBaseCp):
     def activer(self, param):
         """active le mode"""
         self.plateau.fenetre.ui.cbt_panneauDroite.setCurrentIndex(1)
-        if len(self.plateau.caches) > 0:
-            for coord in self.plateau.cases:
-                self.plateau.cases[coord].majCache()
+        self.plateau.majCaches()
         super(StandardCp, self).activer()
 
     def clic_combattant(self, num):
@@ -330,10 +330,10 @@ class ZonePlacement(ModeBaseCp):
                 self.plateau.majZonePlacement(self.plateau.pinceau.selection())
         return True        
 
-class EditerCaches(ModeBaseCp):
+class PlacerCaches(ModeBaseCp):
     """mode de creation/ edition des caches"""
     def __init__(self, plateau):
-        super(EditerCaches, self).__init__(plateau)
+        super(PlacerCaches, self).__init__(plateau)
         self._sourceCurseur = ":/interface/16/ressource/pinceau_16.png"
         self._focus = True
         self._numCache = None
@@ -341,13 +341,27 @@ class EditerCaches(ModeBaseCp):
     def activer(self, param = None):
         self._numCache = param
         self.plateau.pinceau.majForme("rectP")
-        super(EditerCaches, self).activer()
+        super(PlacerCaches, self).activer()
 
     def desactiver(self):
         self.plateau.pinceau.reinit()
-        super(EditerCaches, self).desactiver()        
+        super(PlacerCaches, self).desactiver()        
+
+    def creerCache(self, listeCases, nom):
+        """cree le cache avec le nom et la liste des cases en parametre"""
+        #determination d'un nouvel id pour le cache
+        idCache = 0
+        if len(self.plateau.caches) > 0:
+            idCache = max(self.plateau.caches) + 1
+        #nom par defaut si besoin
+        if not len(nom) >0:
+            nom = "Cache {}".format(idCache + 1)
+        #creation du cache    
+        cache = Cache(self.plateau, idCache)
+        cache.creer(listeCases, nom)
 
     def clic_case(self, coord):
+        #on peint la liste des cases qui sera cachee
         self.plateau.pinceau.demarrer(coord)
         return True
         
@@ -356,13 +370,12 @@ class EditerCaches(ModeBaseCp):
         return True
     
     def finClicGauche(self, coord):
+        #si la liste de cases peintes est valide, on demande le nom du cache et on le cree
         accepte = False
         if self.plateau.pinceau.estActif():
             if len(self.plateau.pinceau.selection()) > 0:
-                if self._numCache != None:
-                    self.plateau.editerFormeCache(self._numCache, self.plateau.pinceau.selection())
-                else:
-                    self.plateau.nouveauCache(self.plateau.pinceau.selection())
+                nom = dmSaisie("Entrez le nom du cache à créer:")
+                self.creerCache(self.plateau.pinceau.selection(), nom)
                 self.plateau.activerMode(StandardCp)
             accepte = True
         return accepte
@@ -493,6 +506,24 @@ class CreationPion(ModeBaseCp):
                 accepte = True
         return accepte
 
+class CreationPJ(CreationPion):
+    """mode de creation de pions de joueurs"""
+    def __init__(self, plateau):
+        super(CreationPJ, self).__init__(plateau)
+
+    def clic_case(self, coord):
+        accepte = False
+        if self._pion:
+            if not self.plateau.cases[coord].estOccupee():
+                if isinstance(self._pion, Combattant) and dmK.touchesEnfoncees() == ["maj"]:
+                    nouveauZ = self.plateau.dialogueVol(self._pion.z)
+                    self._pion.majZ(nouveauZ)
+                self.plateau.creerPion(self._pion)
+                self.plateau.majListePJ()
+                accepte = True
+        return accepte    
+
+
 class SuppressionPion(ModeBaseCp):
     """mode de suppression de pions (combattant ou decor)"""
     def __init__(self, plateau):
@@ -634,9 +665,7 @@ class StandardPi(ModeBasePi):
 
     def activer(self, num):
         self.plateau.fenetre.ui.cbt_panneauDroite.setCurrentIndex(3)
-        if len(self.plateau.caches) > 0:
-            for coord in self.plateau.cases:
-                self.plateau.cases[coord].majCache()
+        self.plateau.majCaches()
         super(StandardPi, self).activer()
 
     def clic_combattant(self, num):

lib/Partie.py

@@ -16,8 +16,5 @@ class Partie():
         self.regles = ""
 
         self.personnages = []          #liste de Combattant()
-        self.carteMonde = CarteMonde()
-        self.journal = Journal()
-        self.plateaux = []
-
-        
+#         self.carteMonde = CarteMonde()
+#         self.journal = Journal()

lib/Pion.py

@@ -68,9 +68,9 @@ class Pion(QGraphicsItem):
     def yReel(self):
         """renvoie le y reel (pour les contructions graphiques"""
         if 1 == (self.position[0] % 2):
-             y = self.position[1] + 0.5
+            y = self.position[1] + 0.5
         else:
-             y = self.position[1]
+            y = self.position[1]
         return y
     
     ###attributs du pion

lib/Plateau.py

@@ -213,6 +213,7 @@ class Plateau(QGraphicsScene):
 
         #autres:
         self.fenetre.connect(self.fenetre.ui.cp_placerEntree, SIGNAL("clicked()"), self.majModeDefinirEntree, Qt.UniqueConnection)
+        self.fenetre.connect(self.fenetre.ui.cp_placerCache, SIGNAL("clicked()"), self.majModePlacerCache, Qt.UniqueConnection)
         self.fenetre.connect(self.fenetre.ui.cp_placerSortie, SIGNAL("clicked()"), self.majModeDefinirSortie, Qt.UniqueConnection)
         self.fenetre.connect(self.fenetre.ui.cp_defPlacement, SIGNAL("clicked()"), self.majModeZonePlacement, Qt.UniqueConnection)
         self.fenetre.connect(self.fenetre.ui.pi_notes, SIGNAL("textChanged()"), self.majNotesCombattant, Qt.UniqueConnection)
@@ -270,7 +271,7 @@ class Plateau(QGraphicsScene):
         self.majListeTerrains()
         self.majListeCreatures()
         self.majListeDecors()
-        self.initListeCaches()
+        self.majCaches()
         
         self.initListeOrdreJeu()
         self.initListeAttaques()
@@ -335,12 +336,45 @@ class Plateau(QGraphicsScene):
 
     def publier(self):
         self.public = True
+        self.majListePJ()
         self.majBoutonEtape()
     
     def demarrer(self):
         self.tour = 1
         self.majBoutonEtape()    
 
+    def majListePJ(self):
+        """met a jour la liste des pj qui peuvent etre ajoutes au plateau"""
+        self.fenetre.ui.pc_listePJ.setColumnWidth(0,0)
+        self.fenetre.ui.pc_listePJ.setColumnWidth(1,40)
+        self.connect(self.fenetre.ui.pc_listePJ, SIGNAL("cellClicked(int, int)"), self.ajouterPj)
+        listePj = chargerUnique("parties\\{}\\groupe".format(self.fenetre.partie))
+        idPj = 0
+        for pj in listePj:
+            self.fenetre.ui.pc_listePJ.nouvelleLigneFin()
+            self.fenetre.ui.pc_listePJ.majTexte("j{}".format(idPj), 0, idPj)
+            
+            if pj.logo:
+                icone = QIcon(pj.logo.chemin())
+                item = QTableWidgetItem(QString(""))
+                item.setIcon(icone)
+                self.fenetre.ui.pc_listePJ.setItem(idPj, 1, item)
+
+            item = QTableWidgetItem()
+            item.setText(QString().fromUtf8(pj.nom))
+            police = QFont(QString("Verdana"))
+            police.setBold(True)
+            item.setFont(police)
+            self.fenetre.ui.pc_listePJ.setItem(idPj, 2, item)
+            idPj += 1
+            
+    def ajouterPj(self, ligne, col):
+        listePj = chargerUnique("parties\\{}\\groupe".format(self.fenetre.partie))
+        idPj = int(self.fenetre.ui.pc_listePJ.texte(ligne, 0))
+        if idPj != None:
+            pj = listePj[idPj]
+            self.activerMode(Modes.CreationPJ, pj)
+
     def majBoutonsCouleursPerso(self):
         """met a jour l'affichage des couleurs customisees dans la boite de dialogue de selection de couleur"""
         for i in range(0,18):
@@ -366,19 +400,19 @@ class Plateau(QGraphicsScene):
 ##        QApplication.processEvents()
         pass
 
-    def ajouterPj(self):
-        """affiche la fenetre de selection des pj, et recupere l'eventuel pj selectionne"""
-        self.ecranSelPj = EcranSelectionPj(self.fenetre)
-        self.ecranSelPj.setAttribute(Qt.WA_DeleteOnClose)
-        listePj = chargerUnique("parties\\{}\\groupe".format(self.fenetre.partie))
-        self.ecranSelPj.charger(listePj)
-        r = self.ecranSelPj.exec_()
-        if r == 1:
-            idPj = int(self.ecranSelPj.selection())
-            if idPj != None:
-                pj = listePj[idPj]
-                self.activerMode(Modes.CreationPion, pj)
-        self.ecranSelPj = None
+#     def ajouterPj(self):
+#         """affiche la fenetre de selection des pj, et recupere l'eventuel pj selectionne"""
+#         self.ecranSelPj = EcranSelectionPj(self.fenetre)
+#         self.ecranSelPj.setAttribute(Qt.WA_DeleteOnClose)
+#         listePj = chargerUnique("parties\\{}\\groupe".format(self.fenetre.partie))
+#         self.ecranSelPj.charger(listePj)
+#         r = self.ecranSelPj.exec_()
+#         if r == 1:
+#             idPj = int(self.ecranSelPj.selection())
+#             if idPj != None:
+#                 pj = listePj[idPj]
+#                 self.activerMode(Modes.CreationPion, pj)
+#         self.ecranSelPj = None
 
     def agrandirNotesMjPlateau(self):
         """affiche les notes du plateau dans une QDialog, puis recupere les donnees qui y sont saisies"""
@@ -474,6 +508,19 @@ class Plateau(QGraphicsScene):
         self.activerMode(Modes.StandardCp)
         
     ###############
+    
+    ############### affichage des caches enregistres
+    
+    def majCaches(self):
+        """charge la liste des caches avec les donnees en memoire"""
+        traite = []
+        for idCache in self.caches:
+            for coord in self.caches[idCache].listeCases():
+                if not coord in traite:
+                    self.cases[coord].majCache()
+                    traite.append(coord)
+
+
 
     ############### maj des infos du panneau Pi a la selection/deselection d'un pion
         #voir a balancer tout ca dans une classe a part
@@ -689,6 +736,15 @@ class Plateau(QGraphicsScene):
                   "cp_formeRectPlein": "rectP"}
         self.pinceau.majForme(formes[str(self.sender().objectName())])
 
+    def majModePlacerCache(self):
+        """active le mode de creation des caches"""
+        if self.public:
+            dial = QMessageBox()
+            dial.setText(QString().fromUtf8("Vous ne pouvez pas placer de caches une fois le plateau publié"))
+            dial.exec_()
+            return
+        self.activerMode(Modes.PlacerCaches)
+
     def majModeCombatDeplacement(self):
         """active le mode de combat 'deplacement' (mode standard)"""
         self.modeActif.nouvelleAction(Actions.Deplacement)
@@ -1512,17 +1568,6 @@ class Plateau(QGraphicsScene):
     ###############
 
     ######### caches ###############
-    def activerModeCreationCache(self):
-        self.activerMode(Modes.EditerCaches)
-
-    def activerModeEditionCache(self):
-        idCache = int(self.fenetre.ui.cp_listeCaches.texte(self.fenetre.ui.cp_listeCaches.currentRow(), 0))
-        self.activerMode(Modes.EditerCaches, idCache)
-
-    def initListeCaches(self):
-        """charge la liste des caches avec les donnees en memoire"""
-        for idCache in self.caches:
-            self.ajouterCacheATable(self.caches[idCache])
 
     def nouveauCache(self, listeCases):
         nouvelId = 0
@@ -1536,33 +1581,6 @@ class Plateau(QGraphicsScene):
         for coord in listeCases:
             self.cases[coord].ajouterCache(nouvelId)        
 
-    def editerFormeCache(self, idCache, listeCases):
-        """edite le cache avec la liste des cases en param"""
-        actif = self.caches[idCache].actif()
-        for coord in self.cases:
-            if coord in listeCases:
-                self.cases[coord].ajouterCache(idCache, actif)
-            else:
-                self.cases[coord].supprimerCache(idCache)
-        
-    def majEtatCache(self, actif):
-        emetteur = self.sender().objectName()
-        idCache = int(emetteur.replace("afficherCache_", ""))
-        self.caches[idCache].activer(actif)
-        if actif:
-            nomImg = "oeilBarre2_32.png"
-        else:
-            nomImg = "oeil_32.png"
-        self.fenetre.ui.cp_listeCaches.item(idCache, 1).setIcon(QIcon(":/interface/32/ressource/{}".format(nomImg)))
-        for coord in self.cases:
-            self.cases[coord].activerCache(idCache, actif)
-
-    def majNomCache(self, ligne, colonne):
-        idCache = int(self.fenetre.ui.cp_listeCaches.texte(ligne, 0))
-        nouveauNom = self.fenetre.ui.cp_listeCaches.texte(ligne, 1)
-        if nouveauNom != self.caches[idCache].nom:
-            self.caches[idCache].nom = nouveauNom
-
     def supprimerCache(self):
         ligne = self.fenetre.ui.cp_listeCaches.currentRow()
         idCache = int(self.fenetre.ui.cp_listeCaches.texte(ligne, 0)) 
@@ -1571,33 +1589,7 @@ class Plateau(QGraphicsScene):
         self.fenetre.ui.cp_listeCaches.removeRow(idCache)
         del self.caches[idCache]
 
-    def mettreCacheEnEvidence(self, ligne, colonne):
-        idCache = int(self.fenetre.ui.cp_listeCaches.texte(ligne, 0))
-        for coord in self.cases:
-            if len(self.cases[coord].cachesActifs) > 0:
-                self.cases[coord].polygoneCache.activerSurbrillance((idCache in self.cases[coord].cachesActifs))        
-
-    def ajouterCacheATable(self, cache):
-        """ajoute le cache a la table des caches"""
-        self.fenetre.disconnect(self.fenetre.ui.cp_listeCaches, SIGNAL("cellChanged(int,int)"), self.majNomCache)
-        ligne = self.fenetre.ui.cp_listeCaches.nouvelleLigneFin()
-        if cache.actif():
-            nomImg = "oeilBarre2_32.png"
-        else:
-            nomImg = "oeil_32.png"
-        self.fenetre.ui.cp_listeCaches.majTexte(ligne, 0, str(cache.numero))  
-          
-        item = QTableWidgetItem(QIcon(":/interface/32/ressource/{}".format(nomImg)), cache.nom)
-        item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable | Qt.ItemIsEditable)
-        self.fenetre.ui.cp_listeCaches.setItem(ligne, 1, item)
-        
-        widget = QCheckBox(QString(""))
-        widget.setChecked(cache.actif())
-        widget.setObjectName(QString("afficherCache_{}".format(ligne)))
-        self.connect(widget, SIGNAL("toggled(bool)"), self.majEtatCache)
-        self.fenetre.ui.cp_listeCaches.setCellWidget(ligne, 2, widget)
-        
-        self.fenetre.connect(self.fenetre.ui.cp_listeCaches, SIGNAL("cellChanged(int,int)"), self.majNomCache, Qt.UniqueConnection)
+
     ###############"
         
     ######### gestion des evenements souris et clavier ###############

lib/Terrain.py

@@ -6,7 +6,7 @@ import rsc
 class Terrain():
     """terrain a affecter a une case"""
     def __init__(self, parent=None):
-        self.id = None
+        self.id = rsc.uid("tr")
         self.nom = ""                   #libelle a afficher dans la liste 
         self.couleur = QColor("")       #couleur si pas de texture
         self.imgTexture = rsc.RImage()        #image source de la texture

lib/rsc.py

@@ -2,26 +2,23 @@
 # -*- coding: utf-8 -*-
 """controle l'acces aux ressources variables (sons, images, sauvegardes)"""
 import os
-from PyQt4.QtCore import *
-from PyQt4.QtGui import *
-from ui.ecran_explorateur import Ui_exr_fenetre
-from ui.panneauImage import Ui_exi_panneau
+from shutil import copyfile
+import sys
 
-#le repertoire de l'application
-ppal = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(__file__)), os.pardir))
+from PyQt4.QtCore import Qt, SIGNAL, QString
+from PyQt4.QtGui import QPixmap, QDialog, QFrame, QColor, QPalette, QApplication, \
+    QFileDialog
 
-def repApp():
-    return ppal
+from commun import rep, uid, enregistrerSous, charger, dmConfirmer
+from ui.ecran_editerImage import Ui_edi_fenetre
+from ui.ecran_explorateur import Ui_exr_fenetre
+from ui.panneauImage import Ui_exi_panneau
 
-def repRessources():
-    return ["ressources\\commun", \
-            "ressources\\dd35", \
-            "parties\\Partie1\\ressources"]
 
 def selectionImage():
     retour = None
-    expl = ExplorateurRessources()
-    expl.charger("I")
+    expl = ExplorateurImages()
+    expl.charger()
     expl.show()
     expl.exec_()
     img = expl.selection()
@@ -30,53 +27,98 @@ def selectionImage():
             retour = img
     del expl    
     return retour
-
+    
 class Ressource(object):
     """classe de base des ressources utilisees"""
-    def __init__(self, cheminR = ""):
-        self._cheminR = cheminR
-
-    def cheminR(self):
-        return self._cheminR
-
-    def chemin(self):
-        """renvoie le chemin absolu vers le fichier"""
-        return os.path.join(repApp(), self._cheminR)
+    def __init__(self):
+        """cette classe contient les infos relatives a une ressource importee"""
+        self._type = "rs"
+        self._idR = ""
+        self._nom = ""
+        self._sType = 0   #sous type
+        self._extension = ""
 
     def nom(self):
-        #on vire l'extension
-        nom = ""
-        for car in reversed(self._cheminR):
-            if car in ["\\", "/"]:
-                break
-            else:
-                nom = car + nom
-        nom = os.path.splitext(nom)[0]
-        return nom
-
-    def repR(self):
-        """renvoie le repertoire, presente de maniere relative"""
-        return os.path.dirname(self._cheminR)
-        
+        return self._nom
+    
+    def majNom(self, nom):
+        self._nom = nom
+
+    def typ(self):
+        return self._type
+    
+    def majType(self, typ):
+        self._type = typ
+
+    def sType(self):
+        return self._sType
+    
+    def majSType(self, sType):
+        self._sType = sType
+
+    def idR(self):
+        return self._idR
+
     def extension(self):
-        return os.path.splitext(self._cheminR)[1]
+        return self._extension
 
-    def definition(self):
-        return self._cheminR
-                
-    def existe(self):
-        return os.path.isfile(self.chemin())
+    def libelleSType(self):
+        lst = ["[Non defini]"]
+        return lst[self._sType]
 
+    def fichier(self):
+        """retourne le chemin d'acces au fichier ressource"""
+        return os.path.join(rep("rsc"), "{}{}".format(self._idR, self._extension))
+
+    def importer(self, chemin):
+        """importe la ressource demandee dans le repertoire de ressources Dm"""
+        if not os.path.isfile(chemin): return
+        
+        #on verifie l'extension
+        if not os.path.splitext(chemin)[1] in [".png", ".jpg", ".gif"]: return
+        
+        #nom du fichier importe
+        if len(self._nom) == 0:
+            nom = ""
+            for car in reversed(chemin):
+                if car in ["\\", "/"]:
+                    break
+                else:
+                    nom = car + nom
+            self._nom = os.path.splitext(nom)[0]   
+        self._extension = os.path.splitext(chemin)[1]     
+
+        #nouvel id
+        self._idR = uid(self._type)
+
+        #copie du fichier dans le repertoire des ressources
+        copyfile(chemin, self.fichier())
+        self.enregistrer()
+
+    def enregistrer(self):      
+        cible = os.path.join(rep("rsc"), "{}.rsc".format(self._idR))
+        enregistrerSous(self, cible)
+        
     def estValide(self):
-        return self.existe()
+        return os.path.isfile(self.fichier())
+
+    def supprimer(self):
+        os.remove(self.fichier())
+        os.remove(os.path.join(rep("rsc"), "{}.rsc".format(self._idR)))
 
 class RImage(Ressource):
-    """classe de base des ressources utilisees"""
-    def __init__(self, cheminR = ""):
-        super(RImage, self).__init__(cheminR)
+    """classe de base des ressources de type image"""
+    def __init__(self):
+        super(RImage, self).__init__()
+        self._type = "im"
+
+    def libelleSType(self):
+        lstSTypes = ["[Non defini]", "Creature (portrait)", "Creature (pion)", \
+                  "Decor (portrait)", "Decor (pion)", "Terrain", "Autre"]
+        return lstSTypes[self._sType]
 
     def pix(self, l = 0, h = 0):
-        pix = QPixmap(self.chemin())
+        pix = QPixmap(self.fichier())
         if not pix.isNull():
             if l > 0 and h > 0:
                 pix = pix.scaled(l, h, Qt.KeepAspectRatio, Qt.SmoothTransformation)
@@ -86,15 +128,11 @@ class RImage(Ressource):
                 pix = pix.scaledToHeight(h, Qt.SmoothTransformation)                
         return pix
 
-    def estValide(self):
-        return self.existe() and \
-               self.extension() in [".png", ".jpg", ".gif"]
-
 
-class ExplorateurRessources(QDialog):
+class ExplorateurImages(QDialog):
     def __init__(self, parent=None):
         """initialisation de la fenetre"""
-        super (ExplorateurRessources, self).__init__(parent)
+        super (ExplorateurImages, self).__init__(parent)
         self.createWidgets()
         self._selection = None
         self._panneaux = []
@@ -107,21 +145,20 @@ class ExplorateurRessources(QDialog):
         
         self.connect(self.ui.exr_ok, SIGNAL("clicked()"), self.valider)
         self.connect(self.ui.exr_annuler, SIGNAL("clicked()"), self.annuler)
+        self.connect(self.ui.exr_editer, SIGNAL("clicked()"), self.editer)
+        self.connect(self.ui.exr_supprimer, SIGNAL("clicked()"), self.supprimer)
+        self.connect(self.ui.exr_ajouter, SIGNAL("clicked()"), self.ajouter)
+        self.connect(self.ui.exr_filtreSType, SIGNAL("currentIndexChanged(int)"), self.majFiltre)
         self.connect(self.ui.exr_filtreNom, SIGNAL("textEdited(QString)"), self.majFiltre)
-        self.connect(self.ui.exr_filtreRep, SIGNAL("currentIndexChanged(int)"), self.majFiltre)
         self.majLayout()
 
-    def charger(self, typeRessource = "I"):
-        """ressource vaut I ou S, pour image et sons"""
+    def charger(self):
+        """charge les images disponibles dans l'explorateur"""
         fichiers = []
-        for repR in repRessources():
-            repAbs = os.path.join(repApp(), repR)
-            for (dirpath, dirnames, filenames) in os.walk(repAbs):
-                for f in filenames:
-                    if typeRessource == "I":
-                        r = RImage(os.path.join(repR, f))
-                    else:
-                        r = RSon(os.path.join(repR, f))
+        for attributsFichier in os.walk(rep("rsc")):
+            for f in attributsFichier[2]:
+                if os.path.splitext(f)[1] == ".rsc":
+                    r = charger(os.path.join(rep("rsc"), f))
                     if r.estValide():          
                         fichiers.append(r)
 
@@ -145,15 +182,15 @@ class ExplorateurRessources(QDialog):
         self.majAffichage()
 
     def majAffichage(self):
+        self.ui.exr_editer.setEnabled(self._panneauSelectionne != None)
+        self.ui.exr_supprimer.setEnabled(self._panneauSelectionne != None)
         self.ui.exr_ok.setEnabled(self._panneauSelectionne != None)
 
     def majFiltre(self):
-        filtreRep = ""
-        if self.ui.exr_filtreRep.currentIndex() > 0:
-            filtreRep = repRessources()[(self.ui.exr_filtreRep.currentIndex()-1)]
         filtreNom = self.ui.exr_filtreNom.texte()
+        filtreSType = (self.ui.exr_filtreSType.currentIndex() - 1)
         for panneau in self._panneaux:
-            panneau.appliquerFiltre(filtreRep, filtreNom)
+            panneau.appliquerFiltre(filtreNom, filtreSType)
 
     def majLayout(self):
         self.ui.exr_layout.setColumnMinimumWidth(0, 140)
@@ -164,6 +201,32 @@ class ExplorateurRessources(QDialog):
         self.ui.exr_layout.setColumnStretch(2, 1)
         self.ui.exr_layout.setAlignment(Qt.AlignLeft | Qt.AlignTop)
 
+    def editer(self):
+        self._panneauSelectionne.editer()
+
+    def supprimer(self):
+        msg = "Êtes vous sûr de vouloir supprimer l'image: \n{}".format(self._panneauSelectionne.image().nom())
+        if not dmConfirmer(msg): return
+        self._panneauSelectionne.image().supprimer()
+        self._panneauSelectionne.setVisible(False)
+        self._panneaux.remove(self._panneauSelectionne)  
+        self._panneauSelectionne = None
+        self.majAffichage()     
+        self.ui.exr_layout.update()   
+    
+    def ajouter(self):
+        """permet de choisir des fichiers a importer"""
+        fichiers = QFileDialog.getOpenFileNames(self, 
+                                                QString.fromUtf8("Sélectionnez un/des fichier(s) à importer"), 
+                                                "c:\\", 
+                                                "Images (*.png *.gif *.jpg)")
+        for chemin in list(fichiers):
+            img = RImage()
+            img.importer(str(chemin.toUtf8()))
+            self.ajouterImage(img)
+            
+        self.ui.exr_layout.update()
+        
     def valider(self):
         self._selection = self._panneauSelectionne.image()
         self.done(1)
@@ -187,11 +250,11 @@ class PanneauImage(QFrame):
         self.connect(self.ui.exi_image, SIGNAL("clicked()"), self.clic)
         self.connect(self.ui.exi_nom, SIGNAL("clicked()"), self.clic)
         self.connect(self.ui.exi_details, SIGNAL("clicked()"), self.clic)
-        self.connect(self.ui.exi_situ, SIGNAL("clicked()"), self.clic)
+        self.connect(self.ui.exi_sType, SIGNAL("clicked()"), self.clic)
         self.connect(self.ui.exi_image, SIGNAL("doubleClicked()"), self.doubleClic)
         self.connect(self.ui.exi_nom, SIGNAL("doubleClicked()"), self.doubleClic)
         self.connect(self.ui.exi_details, SIGNAL("doubleClicked()"), self.doubleClic)
-        self.connect(self.ui.exi_situ, SIGNAL("doubleClicked()"), self.doubleClic)
+        self.connect(self.ui.exi_sType, SIGNAL("doubleClicked()"), self.doubleClic)
         
     def selectionner(self, actif):
         if actif:
@@ -203,21 +266,32 @@ class PanneauImage(QFrame):
         self.setPalette(palette)
         
     def chargerImage(self, image):
-        self.ui.exi_image.chargerImage(image)
-        self.ui.exi_nom.majTexte(image.nom())
-        self.ui.exi_details.majTexte((image.extension().replace(".", "")).upper())
-        self.ui.exi_situ.majTexte(image.repR())
         self._image = image
+        self.maj()
 
+    def maj(self):
+        self.ui.exi_image.chargerImage(self._image)
+        self.ui.exi_nom.majTexte(self._image.nom())
+        self.ui.exi_details.majTexte((self._image.extension().replace(".", "")).upper())
+        self.ui.exi_sType.majTexte(self._image.libelleSType())
+        
     def image(self):
         return self._image
 
-    def appliquerFiltre(self, filtreRep, filtreNom):
-        if len(filtreRep) > 0:
-            self.setVisible(filtreNom in self._image.nom() and \
-                            self._image.repR() == filtreRep)
-        else:
-            self.setVisible(filtreNom in self._image.nom())
+    def editer(self):
+        fen = Editerimage()
+        fen.charger(self.image())
+        fen.show()
+        r = fen.exec_()
+        if r == 1:
+            self._image = fen.rimage()
+            self._image.enregistrer()
+        del fen
+        self.maj()
+        
+    def appliquerFiltre(self, filtreNom, filtreSType = -1):
+        self.setVisible(filtreNom in self._image.nom() and \
+                        (filtreSType == -1 or self._image.sType() == filtreSType))
 
     def clic(self):
         if not self._selectionnee:
@@ -235,3 +309,50 @@ class PanneauImage(QFrame):
         if event.button() == 1:
             self.doubleClic()
 
+class Editerimage(QDialog):
+    def __init__(self, parent=None):
+        """initialisation de la fenetre"""
+        super (Editerimage, self).__init__(parent)
+        self.createWidgets()
+        self._rimage = None
+
+    def createWidgets(self):
+        """construction de l'interface"""
+        self.ui = Ui_edi_fenetre()
+        self.ui.setupUi(self)  
+        self.connect(self.ui.edi_enregistrer, SIGNAL("clicked()"), self.enregistrer)
+        self.connect(self.ui.edi_annuler, SIGNAL("clicked()"), self.annuler) 
+        
+    def charger(self, rimage):
+        """charge la rimage en parametre et affiche ses caracteristiques"""
+        self._rimage = rimage
+        self.ui.edi_nom.majTexte(self._rimage.nom())
+        self.ui.edi_sType.setCurrentIndex((self._rimage.sType() - 1))
+        
+    def rimage(self):
+        """retourne l'image modifiee"""
+        return self._rimage
+
+    def enregistrer(self):
+        self._rimage.majNom(self.ui.edi_nom.texte())
+        self._rimage.majSType((self.ui.edi_sType.currentIndex() + 1))
+        self.done(1)
+        
+    def annuler(self):
+        self.done(0)
+        
+    
+
+if __name__ == "__main__":
+    app = QApplication(sys.argv)
+#     img = RImage()
+#     img.importer("C:\\python_tmp\\dm\\DMonde\\rsc\\colonne.png")
+#     img = RImage()
+#     img.importer("C:\\python_tmp\\dm\\DMonde\\rsc\\orc.png")
+#     img = RImage()
+#     img.importer("C:\\python_tmp\\dm\\DMonde\\rsc\\dragon.png")    
+        
+    img = selectionImage()
+    if img:
+        print img.nom()
+    exit()      

lib/ui/convertExplorateur.cmd

@@ -1 +0,0 @@
-pyuic4 -x explorateurRessources.ui -o ecran_explorateur.py

lib/ui/convertExplorateur_image.cmd

@@ -1 +0,0 @@
-pyuic4 -x panneauImage.ui -o panneauImage.py

lib/ui/ecran_explorateur.py

@@ -2,7 +2,7 @@
 
 # Form implementation generated from reading ui file 'explorateurRessources.ui'
 #
-# Created: Mon Jun 29 15:52:51 2015
+# Created: Mon Sep 07 14:03:25 2015
 #      by: PyQt4 UI code generator 4.10.4
 #
 # WARNING! All changes made in this file will be lost!
@@ -27,13 +27,14 @@ class Ui_exr_fenetre(object):
     def setupUi(self, exr_fenetre):
         exr_fenetre.setObjectName(_fromUtf8("exr_fenetre"))
         exr_fenetre.setWindowModality(QtCore.Qt.ApplicationModal)
-        exr_fenetre.resize(510, 259)
+        exr_fenetre.resize(510, 265)
         exr_fenetre.setMinimumSize(QtCore.QSize(470, 200))
         exr_fenetre.setMaximumSize(QtCore.QSize(713, 578))
         font = QtGui.QFont()
         font.setFamily(_fromUtf8("Verdana"))
         exr_fenetre.setFont(font)
         self.verticalLayout = QtGui.QVBoxLayout(exr_fenetre)
+        self.verticalLayout.setSpacing(3)
         self.verticalLayout.setMargin(5)
         self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
         self.frame = QtGui.QFrame(exr_fenetre)
@@ -43,15 +44,19 @@ class Ui_exr_fenetre(object):
         self.exr_panneauHaut = QtGui.QHBoxLayout(self.frame)
         self.exr_panneauHaut.setMargin(3)
         self.exr_panneauHaut.setObjectName(_fromUtf8("exr_panneauHaut"))
-        self.exr_filtreRep = QtGui.QComboBox(self.frame)
-        self.exr_filtreRep.setMinimumSize(QtCore.QSize(170, 22))
-        self.exr_filtreRep.setMaximumSize(QtCore.QSize(170, 22))
-        self.exr_filtreRep.setObjectName(_fromUtf8("exr_filtreRep"))
-        self.exr_filtreRep.addItem(_fromUtf8(""))
-        self.exr_filtreRep.addItem(_fromUtf8(""))
-        self.exr_filtreRep.addItem(_fromUtf8(""))
-        self.exr_filtreRep.addItem(_fromUtf8(""))
-        self.exr_panneauHaut.addWidget(self.exr_filtreRep)
+        self.exr_filtreSType = QtGui.QComboBox(self.frame)
+        self.exr_filtreSType.setMinimumSize(QtCore.QSize(170, 22))
+        self.exr_filtreSType.setMaximumSize(QtCore.QSize(170, 22))
+        self.exr_filtreSType.setObjectName(_fromUtf8("exr_filtreSType"))
+        self.exr_filtreSType.addItem(_fromUtf8(""))
+        self.exr_filtreSType.addItem(_fromUtf8(""))
+        self.exr_filtreSType.addItem(_fromUtf8(""))
+        self.exr_filtreSType.addItem(_fromUtf8(""))
+        self.exr_filtreSType.addItem(_fromUtf8(""))
+        self.exr_filtreSType.addItem(_fromUtf8(""))
+        self.exr_filtreSType.addItem(_fromUtf8(""))
+        self.exr_filtreSType.addItem(_fromUtf8(""))
+        self.exr_panneauHaut.addWidget(self.exr_filtreSType)
         spacerItem = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
         self.exr_panneauHaut.addItem(spacerItem)
         self.label = QtGui.QLabel(self.frame)
@@ -92,7 +97,7 @@ class Ui_exr_fenetre(object):
         self.exr_deroulement.setAlignment(QtCore.Qt.AlignLeading|QtCore.Qt.AlignLeft|QtCore.Qt.AlignTop)
         self.exr_deroulement.setObjectName(_fromUtf8("exr_deroulement"))
         self.scrollAreaWidgetContents = QtGui.QWidget()
-        self.scrollAreaWidgetContents.setGeometry(QtCore.QRect(0, 0, 498, 166))
+        self.scrollAreaWidgetContents.setGeometry(QtCore.QRect(0, 0, 498, 143))
         self.scrollAreaWidgetContents.setObjectName(_fromUtf8("scrollAreaWidgetContents"))
         self.horizontalLayout_2 = QtGui.QHBoxLayout(self.scrollAreaWidgetContents)
         self.horizontalLayout_2.setMargin(3)
@@ -102,6 +107,40 @@ class Ui_exr_fenetre(object):
         self.horizontalLayout_2.addLayout(self.exr_layout)
         self.exr_deroulement.setWidget(self.scrollAreaWidgetContents)
         self.verticalLayout.addWidget(self.exr_deroulement)
+        self.horizontalLayout_3 = QtGui.QHBoxLayout()
+        self.horizontalLayout_3.setContentsMargins(-1, 0, -1, -1)
+        self.horizontalLayout_3.setObjectName(_fromUtf8("horizontalLayout_3"))
+        self.exr_supprimer = QtGui.QToolButton(exr_fenetre)
+        self.exr_supprimer.setEnabled(False)
+        self.exr_supprimer.setMinimumSize(QtCore.QSize(30, 30))
+        self.exr_supprimer.setMaximumSize(QtCore.QSize(30, 30))
+        self.exr_supprimer.setText(_fromUtf8(""))
+        icon1 = QtGui.QIcon()
+        icon1.addPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/corbeille_16.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.exr_supprimer.setIcon(icon1)
+        self.exr_supprimer.setObjectName(_fromUtf8("exr_supprimer"))
+        self.horizontalLayout_3.addWidget(self.exr_supprimer)
+        self.exr_editer = QtGui.QToolButton(exr_fenetre)
+        self.exr_editer.setEnabled(False)
+        self.exr_editer.setMinimumSize(QtCore.QSize(30, 30))
+        self.exr_editer.setMaximumSize(QtCore.QSize(30, 30))
+        icon2 = QtGui.QIcon()
+        icon2.addPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/editer_16.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.exr_editer.setIcon(icon2)
+        self.exr_editer.setObjectName(_fromUtf8("exr_editer"))
+        self.horizontalLayout_3.addWidget(self.exr_editer)
+        spacerItem1 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
+        self.horizontalLayout_3.addItem(spacerItem1)
+        self.exr_ajouter = QtGui.QPushButton(exr_fenetre)
+        self.exr_ajouter.setMinimumSize(QtCore.QSize(30, 30))
+        self.exr_ajouter.setMaximumSize(QtCore.QSize(30, 30))
+        self.exr_ajouter.setText(_fromUtf8(""))
+        icon3 = QtGui.QIcon()
+        icon3.addPixmap(QtGui.QPixmap(_fromUtf8(":/interface/16/ressource/plus_16.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
+        self.exr_ajouter.setIcon(icon3)
+        self.exr_ajouter.setObjectName(_fromUtf8("exr_ajouter"))
+        self.horizontalLayout_3.addWidget(self.exr_ajouter)
+        self.verticalLayout.addLayout(self.horizontalLayout_3)
         self.exr_panneauBas = QtGui.QFrame(exr_fenetre)
         self.exr_panneauBas.setMinimumSize(QtCore.QSize(0, 0))
         self.exr_panneauBas.setFrameShape(QtGui.QFrame.StyledPanel)
@@ -115,8 +154,10 @@ class Ui_exr_fenetre(object):
         self.exr_annuler.setMaximumSize(QtCore.QSize(111, 31))
         self.exr_annuler.setObjectName(_fromUtf8("exr_annuler"))
         self.horizontalLayout.addWidget(self.exr_annuler)
-        spacerItem1 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
-        self.horizontalLayout.addItem(spacerItem1)
+        spacerItem2 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
+        self.horizontalLayout.addItem(spacerItem2)
+        spacerItem3 = QtGui.QSpacerItem(40, 20, QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Minimum)
+        self.horizontalLayout.addItem(spacerItem3)
         self.exr_ok = QtGui.QPushButton(self.exr_panneauBas)
         self.exr_ok.setEnabled(False)
         self.exr_ok.setMinimumSize(QtCore.QSize(131, 31))
@@ -130,12 +171,17 @@ class Ui_exr_fenetre(object):
         QtCore.QMetaObject.connectSlotsByName(exr_fenetre)
 
     def retranslateUi(self, exr_fenetre):
-        exr_fenetre.setWindowTitle(_translate("exr_fenetre", "Explorateur de ressources", None))
-        self.exr_filtreRep.setItemText(0, _translate("exr_fenetre", "Tout", None))
-        self.exr_filtreRep.setItemText(1, _translate("exr_fenetre", "Commun", None))
-        self.exr_filtreRep.setItemText(2, _translate("exr_fenetre", "Règles", None))
-        self.exr_filtreRep.setItemText(3, _translate("exr_fenetre", "Profil", None))
+        exr_fenetre.setWindowTitle(_translate("exr_fenetre", "Explorateur d\'images", None))
+        self.exr_filtreSType.setItemText(0, _translate("exr_fenetre", "Tout", None))
+        self.exr_filtreSType.setItemText(1, _translate("exr_fenetre", "[Non défini]", None))
+        self.exr_filtreSType.setItemText(2, _translate("exr_fenetre", "Créature (portrait)", None))
+        self.exr_filtreSType.setItemText(3, _translate("exr_fenetre", "Créature (pion)", None))
+        self.exr_filtreSType.setItemText(4, _translate("exr_fenetre", "Décor (portrait)", None))
+        self.exr_filtreSType.setItemText(5, _translate("exr_fenetre", "Décor (pion)", None))
+        self.exr_filtreSType.setItemText(6, _translate("exr_fenetre", "Terrain", None))
+        self.exr_filtreSType.setItemText(7, _translate("exr_fenetre", "Autre", None))
         self.label.setText(_translate("exr_fenetre", "Chercher : ", None))
+        self.exr_editer.setText(_translate("exr_fenetre", "...", None))
         self.exr_annuler.setText(_translate("exr_fenetre", "Annuler", None))
         self.exr_ok.setText(_translate("exr_fenetre", "Utiliser", None))
 

lib/ui/ecran_principal.py

@@ -2,7 +2,7 @@
 
 # Form implementation generated from reading ui file 'principal.ui'
 #
-# Created: Fri Aug 28 16:19:45 2015
+# Created: Tue Sep 01 16:42:51 2015
 #      by: PyQt4 UI code generator 4.10.4
 #
 # WARNING! All changes made in this file will be lost!
@@ -814,14 +814,14 @@ class Ui_principal(object):
         self.cp_defPlacement.setIcon(icon27)
         self.cp_defPlacement.setObjectName(_fromUtf8("cp_defPlacement"))
         self.gridLayout_3.addWidget(self.cp_defPlacement, 2, 4, 1, 1)
-        self.toolButton = QtGui.QToolButton(self.creationPlateau_sousPanneauBas)
-        self.toolButton.setMinimumSize(QtCore.QSize(41, 31))
-        self.toolButton.setMaximumSize(QtCore.QSize(41, 31))
+        self.cp_placerCache = QtGui.QToolButton(self.creationPlateau_sousPanneauBas)
+        self.cp_placerCache.setMinimumSize(QtCore.QSize(41, 31))
+        self.cp_placerCache.setMaximumSize(QtCore.QSize(41, 31))
         icon28 = QtGui.QIcon()
         icon28.addPixmap(QtGui.QPixmap(_fromUtf8(":/interface/32/ressource/mainCache_32.png")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
-        self.toolButton.setIcon(icon28)
-        self.toolButton.setObjectName(_fromUtf8("toolButton"))
-        self.gridLayout_3.addWidget(self.toolButton, 0, 2, 1, 1)
+        self.cp_placerCache.setIcon(icon28)
+        self.cp_placerCache.setObjectName(_fromUtf8("cp_placerCache"))
+        self.gridLayout_3.addWidget(self.cp_placerCache, 0, 2, 1, 1)
         self.verticalLayout_3.addWidget(self.creationPlateau_sousPanneauBas)
         self.cp_gererAlt = QtGui.QCheckBox(self.cp_panneau)
         font = QtGui.QFont()
@@ -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, 756, 588))
+        self.grp_deroulement_contenu.setGeometry(QtCore.QRect(0, 0, 100, 30))
         palette = QtGui.QPalette()
         brush = QtGui.QBrush(QtGui.QColor(0, 0, 0))
         brush.setStyle(QtCore.Qt.SolidPattern)
@@ -1649,7 +1649,7 @@ class Ui_principal(object):
         self.cp_afficherNotes.setText(_translate("principal", "...", None))
         self.cp_defPlacement.setToolTip(_translate("principal", "Définir la zone de placement des joueurs", None))
         self.cp_defPlacement.setText(_translate("principal", "...", None))
-        self.toolButton.setText(_translate("principal", "...", None))
+        self.cp_placerCache.setText(_translate("principal", "...", None))
         self.cp_gererAlt.setText(_translate("principal", "Gérer les altitudes", None))
         self.pi_img.setToolTip(_translate("principal", "Image du pion sélectionné", None))
         self.pi_img.setText(_translate("principal", "logo", None))

lib/ui/explorateurRessources.ui

@@ -10,7 +10,7 @@
     <x>0</x>
     <y>0</y>
     <width>510</width>
-    <height>259</height>
+    <height>265</height>
    </rect>
   </property>
   <property name="minimumSize">
@@ -31,9 +31,12 @@
    </font>
   </property>
   <property name="windowTitle">
-   <string>Explorateur de ressources</string>
+   <string>Explorateur d'images</string>
   </property>
-  <layout class="QVBoxLayout" name="verticalLayout" stretch="0,0,0">
+  <layout class="QVBoxLayout" name="verticalLayout" stretch="0,0,0,0">
+   <property name="spacing">
+    <number>3</number>
+   </property>
    <property name="leftMargin">
     <number>5</number>
    </property>
@@ -68,7 +71,7 @@
        <number>3</number>
       </property>
       <item>
-       <widget class="QComboBox" name="exr_filtreRep">
+       <widget class="QComboBox" name="exr_filtreSType">
         <property name="minimumSize">
          <size>
           <width>170</width>
@@ -88,17 +91,37 @@
         </item>
         <item>
          <property name="text">
-          <string>Commun</string>
+          <string>[Non défini]</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>Créature (portrait)</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>Créature (pion)</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>Décor (portrait)</string>
+         </property>
+        </item>
+        <item>
+         <property name="text">
+          <string>Décor (pion)</string>
          </property>
         </item>
         <item>
          <property name="text">
-          <string>Règles</string>
+          <string>Terrain</string>
          </property>
         </item>
         <item>
          <property name="text">
-          <string>Profil</string>
+          <string>Autre</string>
          </property>
         </item>
        </widget>
@@ -240,7 +263,7 @@
         <x>0</x>
         <y>0</y>
         <width>498</width>
-        <height>166</height>
+        <height>143</height>
        </rect>
       </property>
       <layout class="QHBoxLayout" name="horizontalLayout_2">
@@ -263,6 +286,101 @@
      </widget>
     </widget>
    </item>
+   <item>
+    <layout class="QHBoxLayout" name="horizontalLayout_3">
+     <property name="topMargin">
+      <number>0</number>
+     </property>
+     <item>
+      <widget class="QToolButton" name="exr_supprimer">
+       <property name="enabled">
+        <bool>false</bool>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>30</width>
+         <height>30</height>
+        </size>
+       </property>
+       <property name="maximumSize">
+        <size>
+         <width>30</width>
+         <height>30</height>
+        </size>
+       </property>
+       <property name="text">
+        <string/>
+       </property>
+       <property name="icon">
+        <iconset resource="ressource.qrc">
+         <normaloff>:/interface/16/ressource/corbeille_16.png</normaloff>:/interface/16/ressource/corbeille_16.png</iconset>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <widget class="QToolButton" name="exr_editer">
+       <property name="enabled">
+        <bool>false</bool>
+       </property>
+       <property name="minimumSize">
+        <size>
+         <width>30</width>
+         <height>30</height>
+        </size>
+       </property>
+       <property name="maximumSize">
+        <size>
+         <width>30</width>
+         <height>30</height>
+        </size>
+       </property>
+       <property name="text">
+        <string>...</string>
+       </property>
+       <property name="icon">
+        <iconset resource="ressource.qrc">
+         <normaloff>:/interface/16/ressource/editer_16.png</normaloff>:/interface/16/ressource/editer_16.png</iconset>
+       </property>
+      </widget>
+     </item>
+     <item>
+      <spacer name="horizontalSpacer_4">
+       <property name="orientation">
+        <enum>Qt::Horizontal</enum>
+       </property>
+       <property name="sizeHint" stdset="0">
+        <size>
+         <width>40</width>
+         <height>20</height>
+        </size>
+       </property>
+      </spacer>
+     </item>
+     <item>
+      <widget class="QPushButton" name="exr_ajouter">
+       <property name="minimumSize">
+        <size>
+         <width>30</width>
+         <height>30</height>
+        </size>
+       </property>
+       <property name="maximumSize">
+        <size>
+         <width>30</width>
+         <height>30</height>
+        </size>
+       </property>
+       <property name="text">
+        <string/>
+       </property>
+       <property name="icon">
+        <iconset resource="ressource.qrc">
+         <normaloff>:/interface/16/ressource/plus_16.png</normaloff>:/interface/16/ressource/plus_16.png</iconset>
+       </property>
+      </widget>
+     </item>
+    </layout>
+   </item>
    <item>
     <widget class="QFrame" name="exr_panneauBas">
      <property name="minimumSize">
@@ -309,6 +427,19 @@
         </property>
        </widget>
       </item>
+      <item>
+       <spacer name="horizontalSpacer_3">
+        <property name="orientation">
+         <enum>Qt::Horizontal</enum>
+        </property>
+        <property name="sizeHint" stdset="0">
+         <size>
+          <width>40</width>
+          <height>20</height>
+         </size>
+        </property>
+       </spacer>
+      </item>
       <item>
        <spacer name="horizontalSpacer">
         <property name="orientation">

lib/ui/panneauImage.py

@@ -2,7 +2,7 @@
 
 # Form implementation generated from reading ui file 'panneauImage.ui'
 #
-# Created: Mon Jun 29 15:01:46 2015
+# Created: Mon Sep 07 14:03:30 2015
 #      by: PyQt4 UI code generator 4.10.4
 #
 # WARNING! All changes made in this file will be lost!
@@ -26,7 +26,7 @@ except AttributeError:
 class Ui_exi_panneau(object):
     def setupUi(self, exi_panneau):
         exi_panneau.setObjectName(_fromUtf8("exi_panneau"))
-        exi_panneau.resize(153, 54)
+        exi_panneau.resize(219, 77)
         exi_panneau.setMinimumSize(QtCore.QSize(153, 54))
         exi_panneau.setMaximumSize(QtCore.QSize(338, 77))
         font = QtGui.QFont()
@@ -50,18 +50,20 @@ class Ui_exi_panneau(object):
         self.exi_nom = DmLabel(exi_panneau)
         self.exi_nom.setObjectName(_fromUtf8("exi_nom"))
         self.verticalLayout.addWidget(self.exi_nom)
-        self.exi_details = DmLabel(exi_panneau)
+        self.exi_sType = DmLabel(exi_panneau)
         font = QtGui.QFont()
+        font.setPointSize(8)
         font.setItalic(True)
+        self.exi_sType.setFont(font)
+        self.exi_sType.setObjectName(_fromUtf8("exi_sType"))
+        self.verticalLayout.addWidget(self.exi_sType)
+        self.exi_details = DmLabel(exi_panneau)
+        font = QtGui.QFont()
+        font.setPointSize(7)
+        font.setItalic(False)
         self.exi_details.setFont(font)
         self.exi_details.setObjectName(_fromUtf8("exi_details"))
         self.verticalLayout.addWidget(self.exi_details)
-        self.exi_situ = DmLabel(exi_panneau)
-        font = QtGui.QFont()
-        font.setPointSize(7)
-        self.exi_situ.setFont(font)
-        self.exi_situ.setObjectName(_fromUtf8("exi_situ"))
-        self.verticalLayout.addWidget(self.exi_situ)
         spacerItem = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
         self.verticalLayout.addItem(spacerItem)
         self.horizontalLayout.addLayout(self.verticalLayout)
@@ -74,10 +76,11 @@ class Ui_exi_panneau(object):
     def retranslateUi(self, exi_panneau):
         exi_panneau.setWindowTitle(_translate("exi_panneau", "exi_panneau", None))
         self.exi_nom.setText(_translate("exi_panneau", "nom", None))
+        self.exi_sType.setText(_translate("exi_panneau", "stype", None))
         self.exi_details.setText(_translate("exi_panneau", "detail", None))
-        self.exi_situ.setText(_translate("exi_panneau", "situ", None))
 
 from dm import DmLabel
+import ressource_rc
 
 if __name__ == "__main__":
     import sys

lib/ui/panneauImage.ui

@@ -6,8 +6,8 @@
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>153</width>
-    <height>54</height>
+    <width>219</width>
+    <height>77</height>
    </rect>
   </property>
   <property name="minimumSize">
@@ -78,26 +78,28 @@
       </widget>
      </item>
      <item>
-      <widget class="DmLabel" name="exi_details">
+      <widget class="DmLabel" name="exi_sType">
        <property name="font">
         <font>
+         <pointsize>8</pointsize>
          <italic>true</italic>
         </font>
        </property>
        <property name="text">
-        <string>detail</string>
+        <string>stype</string>
        </property>
       </widget>
      </item>
      <item>
-      <widget class="DmLabel" name="exi_situ">
+      <widget class="DmLabel" name="exi_details">
        <property name="font">
         <font>
          <pointsize>7</pointsize>
+         <italic>false</italic>
         </font>
        </property>
        <property name="text">
-        <string>situ</string>
+        <string>detail</string>
        </property>
       </widget>
      </item>
@@ -125,6 +127,8 @@
    <header location="global">dm.h</header>
   </customwidget>
  </customwidgets>
- <resources/>
+ <resources>
+  <include location="ressource.qrc"/>
+ </resources>
  <connections/>
 </ui>