dm/DMonde/old/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

from lib.EcranCreationPlateau import EcranCreationPlateau
from lib.EcranFondPlateau import EcranFondPlateau
from lib.Plateau import Plateau
from lib.Monde import Monde

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.createWidgets()
        self.monde = None
        
    def createWidgets(self):
        """construction de l'interface"""
        self.ui = Ui_principal()
        self.ui.setupUi(self)
        self.majVisibilitePanneauxPlateau("")
        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.mde_carte.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.chargerMonde()
		
    def chargerMonde(self):
        self.monde=Monde(self)
        self.monde.charger()
        
    def creerEcranFondPlateau(self):
        ecranFondPlateau = EcranFondPlateau(self)
        self.ui.cbt_vue.resetTransform()
        self.ui.cbt_vue.setScene(ecranFondPlateau)
        
    def afficherEcranCreationPlateau(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 = EcranCreationPlateau(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 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 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 fermerPlateau(self):
        self.plateau.fermer()
        self.plateau = None
        self.creerEcranFondPlateau()
##        self.majVisibilitePanneauxPlateau("") 

    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)

    def majVisibilitePanneauxPlateau(self, mode):
        """affiche ou cache les panneaux d'edition, d'information et de gestion du plateau"""
        #self.ui.panneauInfosPlateau.setVisible(False)
        conditionPlateau = (len(mode) > 0)
        conditionModeCreation = (len(mode) > 0 and mode == "creation")
        conditionModeCombat = (len(mode) > 0 and mode == "combat")

        #panneaux d'infos
        self.ui.inf_panneau.setVisible(conditionPlateau)
        self.ui.cbt_barreHaut.setVisible(conditionPlateau)
        
        #modes creation/combat
        self.ui.cbt_modeCombat.setVisible(conditionModeCreation)
        self.ui.cp_panneau.setVisible(conditionModeCreation)

        self.ui.cbt_modeCreation.setVisible(conditionModeCombat)
        self.ui.pi_panneau.setVisible(conditionModeCombat)

    def reinitialiserPanneauxPlateau(self):
        """remet a neuf les commandes liees au plateau"""
        for panneau in [self.ui.inf_panneau, \
                         self.ui.cbt_barreHaut, \
                         self.ui.cp_panneau, \
                         self.ui.pi_panneau]:
            #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)                

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