dmonde/DMonde.py

#from __future__ import unicode_literals
# -*- coding: utf-8 -*-
"""Interface principale du programme DMonde
"""
import os
from sys import exit

from PyQt4.QtCore import SIGNAL, Qt, QString
from PyQt4.QtGui import QMainWindow, QGraphicsView, QTableWidget, QLineEdit, \
    QTextEdit, QToolButton, QSlider, QDoubleSpinBox, QWidget, QFrame, \
    QApplication

from lib.Actions import Ligne
from lib.Combattant import PJ
from lib.EcranChargerPlateau import EcranChargerPlateau
from lib.EcranCreerPlateau import EcranCreerPlateau
from lib.EcranEditionMateriel import EcranEditionMateriel
from lib.EcranFondPlateau import EcranFondPlateau
from lib.Plateau import Plateau
from lib.commun import rep, Session
from lib.framePj import FramePj
from lib.mat import chargerMat, supprimerMat
from lib.outilsSvg import afficheSvg, enregistrer, chargerUnique, supprSvg
from lib.rsc import RImage
from lib.ui.ecran_principal import Ui_principal


class DMonde(QMainWindow):
    """interface principale de DMonde"""
    def __init__(self, parent=None):
        """initialisation de la fenetre"""
        super (DMonde, self).__init__()
        self.plateau = None
        self.util = "Joueur"
        self.partie = ""
        self.regles = ""
        self.idPlateauEnCours = ""
        self.plateauConnecte = False
        self.pjs = []   #liste des idM des personnages du groupe
        self.createWidgets()

    def createWidgets(self):
        """construction de l'interface"""
        self.ui = Ui_principal()
        self.ui.setupUi(self)
        self.afficherPanneauxPlateau(False)
        self.connect(self.ui.cbt_sauver, SIGNAL("clicked()"), self.enregistrerPlateau)   
        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 estMj(self):
        return True

    def chargerPartie(self, idPartie):
        """charge la partie"""
        self.profil = "olivier"
        self.partie = "partie1"
        self.regles = "dd35"
        
        self.majFichierInfosSvg()
        self.chargerListePj()

    ########## onglet plateau
    
    def creerEcranFondPlateau(self):
        ecranFondPlateau = EcranFondPlateau(self)
        self.ui.cbt_vue.resetTransform()
        self.ui.cbt_vue.setScene(ecranFondPlateau)

    def nouveauPlateau(self):
        """ouvre la fenetre de creation de plateau"""
        if self.plateau != None:
            if self.plateau.estCree() == True:
                return 
        self.creationPlateau = EcranCreerPlateau()
        plateau = Plateau(self)
        self.creationPlateau.afficher(plateau)
        r = self.creationPlateau.exec_()
        if r == 1:
            self.plateau = self.creationPlateau.resultat()
            self.plateau.creer()
        
    def afficherEcranChargerPlateau(self):
        """ouvre la fenetre de chargement de plateau"""
        if self.plateau != None:
            if self.plateau.estCree(): return
        fen = EcranChargerPlateau(self)
        fen.show()
        r = fen.exec_()
        if r == 1:
            idM = fen.resultat()
            del fen
            self.chargerPlateau(idM)
        
    def chargerPlateau(self, idM):
        if self.plateau: 
            if self.plateau.estCree(): self.fermerPlateau()
        self.plateau = chargerMat(idM, "cbt")
        self.plateau.recreer(self)  

    def chargerDernierPlateau(self):
        """charge le dernier plateau sauvegarde"""
        infosSvg = afficheSvg(os.path.join(rep("cbt"), "infos_sauvegarde"))
        dernier = None
        for id_svg in infosSvg:
            if not dernier or infosSvg[id_svg]["dateSvg"] > infosSvg[dernier]["dateSvg"]:
                dernier = id_svg
        if dernier:
            self.chargerPlateau(dernier)
                                   
    def enregistrerPlateau(self):
        self.plateau.enregistrer("cbt")
        infos = {"nom": self.plateau.nom(), "chapitre": self.plateau.chapitre, "dateCreation":self.plateau.dateCreation, "dateSvg":self.plateau.dateSvg, \
                 "public": self.plateau.public, "enCours": self.plateau.enCours}
        enregistrer(self.plateau.idM(), infos, os.path.join(rep("cbt"), "infos_sauvegarde"))
    
    def fermerPlateau(self):
        self.plateau.fermer()
        self.plateau = None
        self.creerEcranFondPlateau()
        self.afficherPanneauxPlateau(False) 

    def majFichierInfosSvg(self):
        """construit/maj le fichier contenant la liste des
           plateaux sauvegardes et leurs informations"""
        #on parcourt les fichiers de sauvegarde
        f = []
        lstFichiersSvg = []
        for (dirpath, dirnames, filenames) in os.walk(rep("cbt")):
            f.extend(filenames)
            break
        for fichier in f:
            fileName, fileExtension = os.path.splitext(fichier)
            if fileExtension == ".dm":
                lstFichiersSvg.append(fileName)
      
        #on verifie leur presence dans le fichier 'infos_sauvegarde'
        infosSvg = afficheSvg(os.path.join(rep("cbt"), "infos_sauvegarde"))
        index = len(infosSvg)

        #on ajoute les sauvegardes manquantes si besoin
        for fichier in lstFichiersSvg:
            if not fichier in infosSvg:
                plateau = chargerUnique(os.path.join(rep("cbt"), "{}.dm".format(fichier)))
                enregistrer(fichier, {"nom": plateau.nom(), "chapitre": plateau.chapitre, "dateCreation":plateau.dateCreation, "dateSvg":plateau.dateSvg, \
                                      "public": plateau.public, "enCours": plateau.enCours}, "svg\\infos_sauvegarde")
                index += 1     
                  
        #on supprime ceux qui ne sont plus trouves
        for fichier in infosSvg:
            if not fichier in lstFichiersSvg:
                supprSvg(os.path.join(rep("cbt"), "infos_sauvegarde"), fichier)


    ########## apparence de l'onglet plateau
    def afficherPanneauxPlateau(self, actif):
        index = int(actif)   # 0 si faux, 1 si vrai
        self.ui.cbt_panneauBas.setCurrentIndex(index)
        self.ui.cbt_panneauHaut.setCurrentIndex(index)
        self.ui.cbt_panneauDroite.setCurrentIndex(index)
        self.ui.cbt_panneauGauche.setCurrentIndex(index)
        self.ui.cbt_etapeSuivante.setVisible(actif)

    def reinitialiserPanneauxPlateau(self):
        """remet a neuf les commandes liees au plateau"""
        for panneau in [self.ui.cbt_panneauHaut, \
                         self.ui.cbt_panneauBas, \
                         self.ui.cbt_panneauGauche, \
                         self.ui.cbt_panneauDroite]:
            #listes
            for liste in panneau.findChildren(QTableWidget):
                while liste.rowCount() > 0:
                    liste.removeRow(0)
            #textes
            for texte in panneau.findChildren(QLineEdit):
                texte.clear()         
            for texte in panneau.findChildren(QTextEdit):
                texte.clear()
            #a cocher
            for bouton in panneau.findChildren(QToolButton):
                if bouton.isCheckable():
                    bouton.setChecked(False)
            #autre
            for item in panneau.findChildren(QSlider):
                item.setValue(1)
            for item in panneau.findChildren(QDoubleSpinBox):
                item.setValue(0)                


    ########## onglet groupe
    def chargerListePj(self):
        for attributsFichier in os.walk(rep("grp")):
            for f in attributsFichier[2]:
                pj = chargerMat(os.path.join(attributsFichier[0], f))
                self.pjAjouterAListe(pj)
        self.ui.grp_deroulement_layout.setAlignment(Qt.AlignTop)

    def pjAjouterAListe(self, pj = None):
        compteur = len(self.pjs)
        colonne = (compteur % 3) * 2
        ligne = int(compteur / 3)
        self.pjs.append(pj.idM())
        
        panneau = FramePj(compteur)
        if pj:
            panneau.chargerPj(pj)
        panneau.setObjectName(QString("pj_panneau_{}".format(compteur)))
        self.connect(panneau, SIGNAL("pjModifie(int)"), self.pjEnregistrer)
        self.ui.grp_deroulement_layout.addWidget(panneau, ligne, colonne)
        
        ## pour l'espacement entre les panneaux
        w = QWidget()
        self.ui.grp_deroulement_layout.addWidget(w, ligne, colonne + 1)

    def pjSupprimer(self, index):
        panneau = self.findChild(QFrame, "pj_panneau_{}".format(index))
        pj = panneau.pj()
        supprimerMat(pj.idM(), "grp")
        self.ui.grp_deroulement_layout.removeWidget(panneau)

    def nouveauPj(self):
        fen = EcranEditionMateriel(PJ())
        fen.afficher()
        fen.exec_()
        pj = fen.mat()
        del fen
        pj.enregistrer("grp")
        self.pjAjouterAListe(pj)

    def pjEnregistrer(self, idPj):
        panneau = self.findChild(QFrame, "pj_panneau_{}".format(idPj))
        pj = panneau.pj()
        pj.enregistrer("grp")

    def resizeEvent(self, event):
        val = (self.ui.dm_panneauCentre.width() - 20) / 3
        self.ui.dm_panneauCentre.setStyleSheet("QTabBar::tab { height: 25; width: "+str(val)+"px; }")
        
        
if __name__ == "__main__":
    s = Session()
    arg = ["DMonde", s.idS()]
    app = QApplication(arg)
    #settrace(trace_calls)
    dm = DMonde()
    dm.show()
    r = app.exec_()
    s.fin()
    exit(r)