dmonde/DMonde.py

#from __future__ import unicode_literals
# -*- coding: utf-8 -*-
from __future__ import division
import os
from sys import exit, argv, getsizeof, settrace
from time import time, sleep, strftime, localtime

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.outilsSvg import *

from lib.Case import Case
from lib.Pion import Pion
from lib.PionDecor import PionDecor

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()
        
    def createWidgets(self):
        """construction de l'interface"""
        self.ui = Ui_principal()
        self.ui.setupUi(self)
        self.majVisibilitePanneauxPlateau("")
        self.connect(self.ui.sauverPlateau, SIGNAL("clicked()"), self.sauverPlateau)   
        self.connect(self.ui.fermerPlateau, SIGNAL("clicked()"), self.fermerPlateau)
        self.ui.vuePlateau.setViewportUpdateMode(QGraphicsView.BoundingRectViewportUpdate)

        self.majFichierInfosSvg()
        self.creerEcranFondPlateau()
        
    def creerEcranFondPlateau(self):
        ecranFondPlateau = EcranFondPlateau(self)
        self.ui.vuePlateau.resetTransform()
        self.ui.vuePlateau.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, plateau):
        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()

        return plateau

    
    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.infoOrdreJeu.setVisible(conditionPlateau)   
        self.ui.infoPion.setVisible(conditionPlateau)
        self.ui.infoDecor.setVisible(conditionPlateau)
        self.ui.infoCase.setVisible(conditionPlateau)

        #autre
        self.ui.nomPlateau.setVisible(conditionPlateau)
        self.ui.sauverPlateau.setVisible(conditionPlateau)
        self.ui.fermerPlateau.setVisible(conditionPlateau)
        self.ui.etiquetteModeAffichagePlateau.setVisible(conditionPlateau)
        self.ui.modeAffichagePlateau.setVisible(conditionPlateau)
        self.ui.combatTour.setVisible(conditionPlateau)
        
        #barre de combat:
        if len(mode) > 0:
            self.majVisibiliteBarreCombat("menu")
        else:
            self.majVisibiliteBarreCombat("aucun")
        self.ui.combatPasserTour.setVisible(conditionPlateau)
        self.ui.combatInventaire.setVisible(conditionPlateau)

        #modes creation/combat
        self.ui.modeCombatPlateau.setVisible(conditionModeCreation)
        self.ui.outilsEditionPlateau.setVisible(conditionModeCreation)
        self.ui.outilsCombatPlateau.setVisible(conditionModeCombat)
        self.ui.modeCreationPlateau.setVisible(conditionModeCombat)

    def reinitialiserPanneauxPlateau(self):
        """remet a neuf les commandes liees au plateau"""
        for panneau in [self.ui.panneauInfosPlateau, \
                         self.ui.outilsEditionPlateau, \
                         self.ui.outilsCombatPlateau]:
            #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 barreCombatMenu(self):
        self.majVisibiliteBarreCombat("menu")

    def barreCombatVol(self):
        self.majVisibiliteBarreCombat("vol")

    def barreCombatZone(self):
        self.majVisibiliteBarreCombat("zone")        

    def majVisibiliteBarreCombat(self, mode = ""):
        """affiche ou cache les commandes de la barre de combat"""
        #modes : "aucun", "menu", "vol", "zone"
        for item in self.ui.barreBasCombat.children():
            try:
                item.setVisible(False)
            except:
                pass
            
        if mode != "aucun":
            self.ui.combatPionSelectionne.setVisible(True)
            self.ui.combatPionSelectionne_img.setVisible(True)
            self.ui.combatPionSelectionne_img.setPixmap(QPixmap())   
            self.ui.combatPasserTour.setVisible(True)
            self.ui.combatInventaire.setVisible(True)
        
        if mode == "menu" or mode == "":
            self.ui.combatDeplacement.setVisible(True)
            self.ui.combatAttaqueCaC.setVisible(True)
            self.ui.combatAttaqueDist.setVisible(True)
            self.ui.combatAttaqueZone.setVisible(True)
            self.ui.combatVol.setVisible(True)
            
        elif mode == "vol":
            self.ui.combatVol.setVisible(True)
            self.ui.combatVol_altitude.setVisible(True)
            self.ui.combatRetour.setVisible(True)
            
        elif mode == "zone":
            self.ui.combatZone_ligne.setVisible(True)
            self.ui.combatZone_disque.setVisible(True)
            self.ui.combatZone_disqueRayon.setVisible(True)
            self.ui.combatZone_cone.setVisible(True)
            self.ui.combatRetour.setVisible(True)








        
if __name__ == "__main__":
   app = QApplication(argv)
   #settrace(trace_calls)
   dm = DMonde()
   dm.show()
   r = app.exec_()
   exit(r)