dmonde/DMonde.py

#from __future__ import unicode_literals
# -*- coding: utf-8 -*-
"""Interface principale du programme DMonde
"""
from __future__ import division
import os
from sys import exit, argv, getsizeof, settrace
from time import time, sleep, strftime, localtime
import pydoc

from PyQt4.QtCore import *
from PyQt4.QtGui import *

from lib.ui.ecran_principal import Ui_principal
import lib.rsc as rsc

from lib.EcranCreerPlateau import EcranCreerPlateau
from lib.EcranChargerPlateau import EcranChargerPlateau
from lib.EcranFondPlateau import EcranFondPlateau
from lib.Plateau import Plateau
from lib.EcranEditionCombattant import EcranEditionCombattant
from lib.framePj import FramePj
from lib.outilsSvg import *

from lib.Case import Case
from lib.Combattant import Combattant
from lib.Decor import Decor
from lib.Terrain import Terrain

from lib.Cache import Cache
from lib.EntreeSortie import EntreeSortie

#fonction ci dessous: deboguage, suit les appels faits aux fonctions
#settrace(trace_calls)
def trace_calls(frame, event, arg):
    if event != 'call':
        return
    co = frame.f_code
    func_name = co.co_name
    if func_name == 'write':
        # Ignore write() calls from print statements
        return
    func_line_no = frame.f_lineno
    func_filename = co.co_filename
    caller = frame.f_back
    caller_line_no = caller.f_lineno
    caller_filename = caller.f_code.co_filename
    #print 'Call to %s on line %s of %s from line %s of %s' % \
    #    (func_name, func_line_no, func_filename,
    #     caller_line_no, caller_filename)
    print("{} ({})".format(func_name, func_filename))
    return


class DMonde(QMainWindow):
    """interface comprenant: chat ecrit, fenetre d'infos, lancer de des, echange de fichiers, lancement du chat vocal"""
    def __init__(self, parent=None):
        """initialisation de la fenetre"""
        super (DMonde, self).__init__()
        self.plateau = None
        self.partie = "partie1"
        self.idPlateauEnCours = ""
        self.plateauConnecte = False
        self._compteurPj = 0
        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.sauverPlateau)   
        self.connect(self.ui.cbt_fermer, SIGNAL("clicked()"), self.fermerPlateau)
        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.majFichierInfosSvg()
        self.creerEcranFondPlateau()
        self.chargerListePj()
        self.connect(self.ui.grp_nouveauPj, SIGNAL("clicked()"), self.nouveauPj)
##        self.showMaximized()


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

    def afficherEcranCreerPlateau(self):
        """ouvre la fenetre de creation de plateau"""
        valide = True
        if self.plateau != None:
            if self.plateau.estCree() == True:
                valide = False
        if valide:
            self.creationPlateau = EcranCreerPlateau(self)
            self.creationPlateau.setWindowModality(Qt.ApplicationModal)
            self.creationPlateau.show()
            self.creationPlateau.raise_()

    def creerPlateau(self, nom, chapitre, formeCases, largeur, hauteur, couleur):
        """cree le plateau entre en parametre"""
        nouvelId = str(len(afficheSvg("parties\\{}\\svg\\infos_sauvegarde".format(self.partie))))
        QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
        self.plateau = Plateau(self)
        self.plateau.creer(nouvelId, nom, chapitre, formeCases, largeur, hauteur, couleur)
        QApplication.restoreOverrideCursor()
        del self.creationPlateau

    def afficherEcranChargerPlateau(self):
        """ouvre la fenetre de chargement de plateau"""
        valide = True
        if self.plateau != None:
            if self.plateau.estCree() == True:
                valide = False
        if valide:
            self.chargementPlateau = EcranChargerPlateau(self)
            self.chargementPlateau.setWindowModality(Qt.ApplicationModal)
            self.chargementPlateau.show()
            self.chargementPlateau.raise_()

    def chargerPlateau(self, nomFichierSvg):
        if self.plateau != None:
            if self.plateau.estCree() == True:
                self.fermerPlateau()
        QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
        self.plateau = chargerUnique("parties\\{}\\svg\\{}.p".format(self.partie, nomFichierSvg))
        if self.plateau:
            self.plateau.recreer(self)
        else:
            self.plateau = Plateau(self)
        QApplication.restoreOverrideCursor()    

    def chargerDernierPlateau(self):
        """charge le dernier plateau sauvegarde"""
        infosSvg = afficheSvg("parties\\{}\\svg\\infos_sauvegarde".format(self.partie))
        ligne  = 0
        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 sauverPlateau(self):
        QApplication.setOverrideCursor(QCursor(Qt.WaitCursor))
        if self.plateau.id in afficheSvg("parties\\{}\\svg\\infos_sauvegarde".format(self.partie)):
           idPlateau = self.plateau.id
        else:   
           idPlateau = str(len(afficheSvg("parties\\{}\\svg\\infos_sauvegarde".format(self.partie))))

        enregistrerUnique(self.plateau, "parties\\{}\\svg\\{}.p".format(self.partie, idPlateau))
        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(str(idPlateau), infos, "parties\\{}\\svg\\infos_sauvegarde".format(self.partie))
        QApplication.restoreOverrideCursor()
    
    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
        index = 0   
        f = []
        lstFichiersSvg = []
        for (dirpath, dirnames, filenames) in os.walk("parties\\{}\\svg\\".format(self.partie)):
            f.extend(filenames)
            break
        for fichier in f:
            fileName, fileExtension = os.path.splitext(fichier)
            if fileExtension == ".p":
                lstFichiersSvg.append(fileName)
      
        #on verifie leur presence dans le fichier 'infos_sauvegarde'
        infosSvg = afficheSvg("parties\\{}\\svg\\infos_sauvegarde".format(self.partie))
        index = len(infosSvg)

        #on ajoute les sauvegardes manquantes si besoin
        for fichier in lstFichiersSvg:
            if not fichier in infosSvg:
                plateau = chargerUnique("parties\\{}\\svg\\{}.p".format(self.partie, 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("parties\\{}\\svg\\infos_sauvegarde".format(self.partie), 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)

    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):
        listePj = chargerUnique("parties\\{}\\groupe".format(self.partie))
        if not listePj: listePj = []
        self.ui.grp_deroulement_layout.setAlignment(Qt.AlignTop)
        for pj in listePj:
            self.pjAjouterAListe(pj)

    def pjAjouterAListe(self, pj = None):
        self._compteurPj += 1
        panneau = FramePj(self._compteurPj)
        if pj:
            panneau.chargerPj(pj)
        panneau.setObjectName(QString("pj_panneau_{}".format(self._compteurPj)))
        self.connect(panneau, SIGNAL("pjModifie(int)"), self.pjEnregistrer)
        self.ui.grp_deroulement_layout.addWidget(panneau)    

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

    def nouveauPj(self):
        self.editionPj = EcranEditionCombattant()
        self.editionPj.setAttribute(Qt.WA_DeleteOnClose)
        r = self.editionPj.exec_()
        pj = self.editionPj.combattant
        self.pjAjouterAListe(pj)
        self.pjEnregistrer(self._compteurPj)

    def pjEnregistrer(self, idPj):
        listePj = chargerUnique("parties\\{}\\groupe".format(self.partie))
        if not listePj: listePj = []
        panneau = self.findChild(QFrame, "pj_panneau_{}".format(idPj))
        pj = panneau.pj()
        listePj.append(pj)
        enregistrerUnique(listePj, "parties\\{}\\groupe".format(self.partie))

    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__":
   app = QApplication(argv)
   #settrace(trace_calls)
   dm = DMonde()
   dm.show()
   r = app.exec_()
   exit(r)