Nouvel écran de création de plateau

DMonde.py

@@ -1,9 +1,12 @@
 #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 *

a faire.txt

@@ -1,4 +1,4 @@
-virer l'ecran fond plateau
+reprendre l'affichage lorsqu'aucun plateau n'est chargé
 
 creer des id uniques pour les plateaux et objets ("p"+partie++chapitre+nom? ou tps en s a la creation + préfixe?)
 

doc.py

@@ -0,0 +1,3 @@
+import lib.Plateau
+
+print help(lib.Plateau)

docPlateau.txt

@@ -0,0 +1,442 @@
+class Plateau(PyQt4.QtGui.QGraphicsScene)
+     |  plateau de jeu contenant les cases, decors et pions
+     |  
+     |  Method resolution order:
+     |      Plateau
+     |      PyQt4.QtGui.QGraphicsScene
+     |      PyQt4.QtCore.QObject
+     |      sip.wrapper
+     |      sip.simplewrapper
+     |      __builtin__.object
+     |  
+     |  Methods defined here:
+     |  
+     |  __getstate__(self)
+     |  
+     |  __init__(self, fenetre, parent=None)
+     |  
+     |  __setstate__(self, state)
+     |  
+     |  afficheEcranEditionAttaques(self)
+     |      affiche l'ecran d'edition/creation d'attaques
+     |  
+     |  afficheEcranEditionCreatures(self, creature=None)
+     |      affiche l'ecran d'edition/creation de creatures
+     |  
+     |  afficheEcranEditionDecors(self, decor=None)
+     |      affiche l'ecran d'edition/creation de decors
+     |  
+     |  afficheEcranEditionTerrains(self, terrain=None)
+     |      affiche l'ecran d'edition/creation de terrains
+     |  
+     |  afficheEcranGestionCombat(self)
+     |      affiche l'ecran de gestion du combat
+     |  
+     |  afficherChampDeplacement(self, actif)
+     |      cree et affiche ou efface et detruit le champ de deplacement du pion selectionne
+     |  
+     |  afficherListeCases(self, listeCases, actif)
+     |      met ou non en evidence les cases selectionnees
+     |  
+     |  afficherNotesPion(self)
+     |      affiche les notes du pion selectionne dans le QTextEdit dedie
+     |  
+     |  agrandirNotesMjPlateau(self)
+     |      affiche les notes du plateau dans une QDialog, puis recupere les donnees qui y sont saisies
+     |  
+     |  attaqueECCelluleModifiee(self, ligne, colonne)
+     |      une cellule de la liste d'attributs de l'attaque en cours a ete modifiee
+     |  
+     |  caseCliquee(self, x, y)
+     |      on a clique sur la case (clic gauche)
+     |  
+     |  caseMaj(self, coordCase)
+     |      met a jour la case selon le mode actif (et les cases adjacentes selon l'epaisseur du pinceau)
+     |  
+     |  caseSurvol(self, x, y)
+     |      une case est survole par le curseur, on affiche ses informations dans la zone prevue
+     |  
+     |  caseSurvolClicEnfonce(self, coordCase)
+     |      une case est survolee par le curseur (le clic gauche est enfonce)
+     |  
+     |  casesSousForme(self, forme, plein=True, epaisseur=0)
+     |      renvoie la liste des cases en collision avec un QGraphicsItem en parametre
+     |      plein = False: pas le contenu de la forme
+     |      epaisseur = renvoie aussi les cases voisines jusqu'a la distance demandee
+     |  
+     |  chercherCouleur(self)
+     |      ouvre la boite de dialogue de selection de couleur
+     |  
+     |  clicGaucheRelache(self)
+     |      si une forme de selection etait affichee, elle est validee
+     |  
+     |  clicListOrdreJeu(self, ligne, col)
+     |      on a clique dans la liste d'ordre de jeu, le pion correspondant est selectionne et centre sur la carte
+     |  
+     |  connexions(self)
+     |      connecte le plateau aux differents widgets de la fenetre principale
+     |  
+     |  coordCentreListeCases(self, listeCases)
+     |      renvoie les coordonnees centrales d'une liste de cases
+     |  
+     |  coordonneesAuPoint(self, point)
+     |      renvoie les coordonnees de la case situee au QPointF entre en parametre
+     |  
+     |  coordonneesValides(self, coord)
+     |      les coordonnees entrees en parametre sont elles celles d'une case du plateau
+     |  
+     |  creatureEdit(self)
+     |      ouvre la fenetre 'creatures' en mode edition
+     |  
+     |  creatureNouveau(self)
+     |      ouvre la fenetre 'creatures' en mode edition
+     |  
+     |  creer(self, idPlateau, nom, chapitre, formeCases, nbCasesX, nbCasesY, couleur=<PyQt4.QtGui.QColor object>)
+     |      cree le plateau
+     |  
+     |  creerOrigineFormeDessin(self, coord)
+     |      place le point d'origine de la forme de selection
+     |  
+     |  curseurArc(self)
+     |  
+     |  curseurBaguette(self)
+     |  
+     |  curseurEpee(self, valide=True)
+     |  
+     |  curseurGomme(self)
+     |  
+     |  curseurPinceau(self)
+     |  
+     |  curseurSelection(self)
+     |      ########### affichage des curseurs personnalises ########
+     |  
+     |  curseurSeringue(self)
+     |  
+     |  decorEdit(self)
+     |      ouvre la fenetre 'decors' en mode edition
+     |  
+     |  decorNouveau(self)
+     |      ouvre la fenetre 'decors' en mode edition
+     |  
+     |  estCibleAttaqueDistValide(self, coordOrigine, coordCible, zPion=0)
+     |      la case cible est elle valide pour une attaque a distance depuis la position et hauteur
+     |      du pion selectionne? on compare pour ce faire les altitudes des cases sur la ligne de mire
+     |  
+     |  estCree(self)
+     |      renvoie vrai si des cases ont ete creees
+     |  
+     |  fermer(self)
+     |      ferme le plateau 'proprement'
+     |  
+     |  initListeAttaques(self)
+     |      met en forme et connecte la liste des attaques du pion
+     |  
+     |  initListeOrdreJeu(self)
+     |      cree les colonnes et met en forme la table ordre jeu
+     |  
+     |  initialisationGraphique(self)
+     |      cree la scene graphique et les parametres necessaires a son fonctionnement, et met a jour l'interface
+     |  
+     |  keyPressEvent(self, event)
+     |      gestion des evenements clavier
+     |  
+     |  listeAttaquesCelluleCliquee(self, ligne, colonne)
+     |      on a clique sur une cellule de la liste des attaques
+     |  
+     |  listeAttributCelluleModifiee(self, ligne, colonne)
+     |      une cellule de la liste des attributs a ete modifiee
+     |  
+     |  lstCoordAdjacentes(self, x, y)
+     |      renvoie la liste des coordonnees adjacentes, sans condition d'existence sur le plateau
+     |      attention: l'ordre est important
+     |  
+     |  majAffichageCache(self, numCache, afficher=True)
+     |      met a jour l'affichage des cases selon les parametres enregistres pour le cache
+     |  
+     |  majAffichageMenuCache(self)
+     |      un bouton 'cache' a ete clique, on met a jour les infos
+     |  
+     |  majAffichagePionSelectionne(self)
+     |      affiche le nom et le logo du pion actuellement selectionne
+     |  
+     |  majAffichageTour(self)
+     |      met a jour l'affichage du tour en cours
+     |  
+     |  majBoutonsCaches(self)
+     |      met a jour l'affichage et connecte les boutons de caches
+     |  
+     |  majBoutonsCouleursPerso(self)
+     |      met a jour l'affichage des couleurs customisees dans la boite de dialogue de selection de couleur
+     |  
+     |  majCouleurPion(self)
+     |      selectionne une nouvelle couleur
+     |  
+     |  majEpaisseurPinceau(self, epaisseur)
+     |      met a jour l'epaisseur du pinceau (en cases)
+     |  
+     |  majEtatCacheEnCours(self)
+     |      met a jour l'etat (actif ou non) du cache selon l'etat de la case correspondante
+     |  
+     |  majFormeAttaqueZone(self)
+     |      cree la forme de l'attaque de zone
+     |  
+     |  majFormeDessin(self)
+     |      cree/maj la forme utilisee pour selectionner les cases et met a jour la liste des cases selectionnes
+     |  
+     |  majInfosAttaqueEC(self)
+     |      met a jour les infos de l'attaque en cours (selectionnee)
+     |  
+     |  majInfosCase(self, case=None)
+     |      met a jour les informations d'un pion dans la zone prevue
+     |  
+     |  majInfosDecor(self, pionDecor=None)
+     |      met a jour les informations d'un pion dans la zone prevue
+     |  
+     |  majInfosPion(self, pionSurvole=None)
+     |      met a jour les informations d'un pion dans la zone prevue
+     |  
+     |  majLigneMireAttaqueDist(self, coordCible=None)
+     |      met a jour la ligne de mire representant l'attaque a distance
+     |  
+     |  majListCreatures(self)
+     |      mise a jour de la liste des creatures depuis la sauvegarde
+     |  
+     |  majListDecors(self)
+     |      mise a jour de la liste des decors depuis la sauvegarde
+     |  
+     |  majListTerrains(self)
+     |      mise a jour de la liste des terrains depuis la sauvegarde
+     |  
+     |  majListeAttaques(self)
+     |      met a jour la liste des attaques du pion dans le panneau de combat
+     |  
+     |  majListeAttributs(self)
+     |      met a jour la liste des attributs dans le panneau de combat
+     |  
+     |  majListeCases(self, listeCases)
+     |      met a jour les cases dont les coordonnees sont dans la liste
+     |  
+     |  majListeOrdreJeu(self)
+     |      met a jour la liste des pions infoOrdreJeu
+     |  
+     |  majListesPions(self, numPion=None)
+     |      met a jour les listes contenant des donnees liees aux pions
+     |  
+     |  majMode(self, mode='standard', param=None)
+     |      modifie ou reinitialise le type d'interaction avec le plateau
+     |  
+     |  majModeAffichage(self, index)
+     |      met a jour le mode d'affichage
+     |  
+     |  majModeCombat(self, mode='')
+     |      met a jour le mode de combat actif pour le pion selectionne
+     |  
+     |  majModeCombatAttaqueCaC(self)
+     |      active le mode de combat 'corps-a-corps'
+     |  
+     |  majModeCombatAttaqueDist(self)
+     |      active le mode de combat 'attaque a distance'
+     |  
+     |  majModeCombatDeplacement(self)
+     |      active le mode de combat 'deplacement' (mode standard)
+     |  
+     |  majModeCombatZone(self)
+     |  
+     |  majModeCombatZoneForme(self)
+     |  
+     |  majModeDefinirEntree(self)
+     |  
+     |  majModeDefinirSortie(self)
+     |  
+     |  majModeForme(self)
+     |      met a jour la forme utilisee pour la peinture
+     |  
+     |  majModePionSupprimer(self)
+     |      enclenche le mode suppression de pions sur clic gauche (creatures ou decors)
+     |  
+     |  majModeZonePlacement(self)
+     |  
+     |  majNotesAttaqueEC(self)
+     |      met a jour les notes de l'attaque en cours (selectionnee)
+     |  
+     |  majNotesPion(self)
+     |      les notes du pion ont ete mises a jour
+     |  
+     |  majNotesPlateau(self)
+     |      les notes du plateau ont ete maj a l'ecran
+     |  
+     |  majOrdreJeu(self)
+     |      met a jour l'ordre de jeu des pions en fonction de l'attribut prevu par les regles s'il existe,
+     |      ou en fonction de l'ordre de jeu parametre sinon
+     |  
+     |  majProjectionAttaqueCaC(self, pionCible)
+     |      affiche ou non la cible de l'attaque au corps a corps, selon sa validite ou non
+     |  
+     |  majProjectionPosition(self, activer, z=0)
+     |      maj l'affichage de la projection de la position d'un objet avant creation ou deplacement (pion, decor...)
+     |  
+     |  majZPion(self, valeur)
+     |      met a jour l'altitude du pion selectionne
+     |  
+     |  majZoneAttaqueCaC(self, actif=True)
+     |      affiche ou non les cases a portee du pion selectionne pour une attaque au corps-a-corps
+     |  
+     |  majZonePlacement(self, listeCases)
+     |      met a jour la forme et l'affichage de la zone de placement initale des joueurs
+     |  
+     |  materialiserPions(self, actif)
+     |      avtive/desactive la reception par les pions (autres que le pion selectionne) des hover events
+     |  
+     |  modeCaseEffet(self)
+     |      enclenche le mode de mise a jour de l'ffet actif des cases
+     |  
+     |  modeCopieTerrain(self)
+     |      enclenche le mode copie de case
+     |  
+     |  modeCreationCreaturePion(self, ligne, col)
+     |      enclenche le mode de creation de pions depuis la liste des creatures
+     |  
+     |  modeCreationDecor(self, ligne, col)
+     |      enclenche le mode de creation de decors depuis la liste des decors
+     |  
+     |  modeCreationPion(self)
+     |      enclenche le mode de creation de pions simples
+     |  
+     |  modeMajAltitudeCase(self)
+     |  
+     |  modeMajTerrainCase(self, ligne, col)
+     |      enclenche le mode permettant la mise a jour du terrain des cases
+     |  
+     |  modePeintureCase(self)
+     |      enclenche le mode peinture de case a partir de la couleur selectionnee
+     |  
+     |  modePeintureCase_perso(self)
+     |  
+     |  mouseMoveEvent(self, event)
+     |  
+     |  mousePressEvent(self, event)
+     |  
+     |  mouseReleaseEvent(self, event)
+     |  
+     |  numeroterNom(self, nom)
+     |      renvoie le nom du pion avec un numero complementaire si necessaire
+     |  
+     |  pionClique(self, numPion)
+     |      on a clique sur ce pion
+     |  
+     |  pionCreer(self, coordCase)
+     |      creer un jeton aux coordonnees indiquees
+     |  
+     |  pionDecorCreer(self, coordCase)
+     |      creer un jeton aux coordonnees indiquees
+     |  
+     |  pionDecorSaisir(self, numPionDecor)
+     |      on saisit un pion decor (mode creation seulement)
+     |  
+     |  pionDecorSelectionne(self)
+     |      renvoie le pion actuellement selectionne
+     |  
+     |  pionDecorSupprimer(self, num)
+     |      supprime le pion entre en parametre
+     |  
+     |  pionDecorSurvol(self, numPionDecor)
+     |      le pion-decor est survole par le curseur, on affiche ses informations dans la zone prevue
+     |  
+     |  pionDeplacerDansOrdreJeu(self, numPion, nouvellePosition)
+     |      deplace un pion dans le dictionnaire gerant l'ordre de jeu de maniere a assurer sa coherence
+     |      nouvellePosition = 0 supprime le pion de la liste
+     |  
+     |  pionDeposer(self, coordCase)
+     |      on depose le pion sur la case voulue
+     |  
+     |  pionDoubleClic(self, numPion)
+     |      on a double-clique sur le pion
+     |  
+     |  pionSaisir(self, numPion)
+     |      on saisit un pion
+     |  
+     |  pionSelectionne(self)
+     |      renvoie le pion actuellement selectionne
+     |  
+     |  pionSuivant(self)
+     |      selection du pion suivant dans la liste d'ordre de jeu
+     |  
+     |  pionSupprimer(self, num)
+     |      supprime le pion entre en parametre
+     |  
+     |  pionSurCase(self, coord)
+     |      renvoie le pion present sur la case, none sinon
+     |  
+     |  pionSurvol(self, numPion)
+     |      le pion est survole par le curseur, on affiche ses informations dans la zone prevue
+     |  
+     |  pionsSurListeCase(self, listeCases)
+     |      renvoie la liste des pions presents sur la liste de cases
+     |  
+     |  placerCacheEnCours(self)
+     |      active le mode de mise a jour de la liste des cases cachees par ce cache
+     |  
+     |  plateauModeCombat(self)
+     |  
+     |  plateauModeCreation(self)
+     |      ##### activation des differents modes d'interaction avec le plateau et mises a jour des principaux parametres  #######
+     |  
+     |  polygoneAgglo(self, listeCases)
+     |      renvoie un polygone contruit par agglomeration des polygones des cases de la liste
+     |      les cases doivent etre adjacentes (cases hexagonales ou carrees)
+     |  
+     |  polygoneCone(self, point1, point2)
+     |      renvoie le polygone du cone defini par les deux points (origine, distance)
+     |  
+     |  preSelectionCollision(self, point1, point2)
+     |      renvoie une liste des cases qui peuvent etre concernees par une collision avec
+     |      un graphicsItem (pour des raisons de performance)
+     |  
+     |  recreer(self, fenetre)
+     |  
+     |  rectEllipseCirculaire(self, centre, rayon)
+     |      renvoie le QRectF definissant une ellipse ayant le QPointF pour centre et le rayon en cases entres en param
+     |      attention: l'ellipse n'est pas tout a fait circulaire, elle couvre horizontalement et
+     |      verticalement le nombre de cases demandees
+     |  
+     |  rectFormeDessin(self, point1, point2)
+     |      retourne le rectangle repesentant la forme de selection
+     |      determine pour ce faire les points A et B, cad le point haut-droit et le point bas-gauche
+     |  
+     |  reinitAttaqueZone(self)
+     |  
+     |  selectionFrontiere(self)
+     |      retourne les cases selectionnees lors de l'utilisation de la forme 'frontiere'
+     |  
+     |  terrainEdit(self)
+     |      ouvre la fenetre 'terrains' en mode edition
+     |  
+     |  terrainNouveau(self)
+     |      ouvre la fenetre 'terrains' en mode edition
+     |  
+     |  utiliserAttaque(self, numAttaque)
+     |      le pion selectionne utilise son attaque n
+     |  
+     |  validerAttaqueDist(self)
+     |      on essaie de valider une attaque a distance vers un pion ou une case
+     |  
+     |  validerAttaqueZone(self)
+     |      l'attaque de zone est validee
+     |  
+     |  validerFormeDessin(self)
+     |      la projection des cases a peindre a ete acceptee, on peint ces cases
+     |  
+     |  voirCacheEnCours(self)
+     |      centre la vue sur et met en evidence le cache actif
+     |  
+     |  wheelEvent(self, event)
+     |      zoom/dezoom avec la molette de la souris
+     |  
+     |  zone(self, origine, distance, z=0, conditionFranchissable=False, conditionVisible=False)
+     |      renvoie un dictionnaire representant la liste des coordonnees des cases comprises dans la zone
+     |      la zone en question est la liste des cases situees a une distance d des coordonnees d'origine
+     |      z = 0 -> hauteur z de l'origine par rapport a l'altitude de la case
+     |      conditionFranchissable = Vrai -> les cases infranchissables ne sont pas prises en compte
+     |      conditionVisible = Vrai -> les cases bloquant la visibilite ne sont pas prises en compte
+     |      [cf methode A* (A-star)]
+     |  

interface_qt8_2/DMonde.py

@@ -0,0 +1,1333 @@
+from __future__ import unicode_literals
+# -*- coding: utf-8 -*-
+import os
+from sys import exit, argv
+from time import time, sleep
+from threading import Thread
+from socket import socket, AF_INET, SOCK_STREAM
+from subprocess import Popen, PIPE
+import logging
+import cPickle as pickle
+
+#modules importes
+from psutil import process_iter
+
+#import de QT et des interfaces
+from PyQt4.QtCore import *
+from PyQt4.QtGui import *
+from PyQt4 import QtOpenGL
+#from PyQt4 import QtCore, QtGui
+from ecran_connexion import Ui_ecranConnexion
+from ecran_principal import Ui_principal
+from ecran_chatPrive import Ui_chatPrive
+from visionneuse import Ui_visionneuse
+
+#modules persos
+from serveur import Serveur, ServeurVoc
+from lancer import jet
+from clientvoc import ClientVoc
+
+#fonctions potentiellement utiles:
+  #print(psutil.connections())
+  #print(psutil.net_io_counters(pernic=True))
+
+#gestion des erreurs et log
+logging.basicConfig(level=logging.DEBUG)
+logProg = logging.getLogger(__name__)
+handlerProg = logging.FileHandler('prog.log')
+handlerProg.setFormatter(logging.Formatter('[%(asctime)s] %(levelname)s- %(message)s'))  #'%(name)s' nom du thread
+logProg.addHandler(handlerProg)
+logProg.debug("    ----------------------    \n")
+
+
+
+def ipValide(addr):
+    """controle la validite d'une adresse ip"""
+    #if addr == "localhost":
+    #    retour = addr
+    #else:    
+    #   try:
+    #      socket.inet_aton(addr)
+    #      retour = True
+       #except socket.error:
+    #   except:   
+    #      retour = False
+    retour = True
+    return retour  
+
+
+class EcranConnexion(QGroupBox):
+    """fenetre de connexion a l'application et module d'envoi/reception"""
+    def __init__(self, parent=None):
+        """initialisation de la connexion et creation de la fenetre"""
+        super (EcranConnexion, self).__init__(parent)        
+        self.client_connecte = False
+        self.serveur_connecte = False
+        self.idServeur = ""
+        self.idClient = "00"
+        self.ip = ""
+        self.pseudo = ""
+        self.autresCo = {}
+
+        #liste des chat prives ouverts avec les autres clients
+        self.chatPrive = {}
+        
+        #echanges fichiers
+        self.eFichier = {"id": "00", "chemin": "", "fichier": None, "dest": "", "envoi" : False, "annule" : False, "invisible": False}
+                           #fichier en cours d'envoi : id fichier, chemin du fichier, fichier (objet), dest, envoi autorise, envoi annule
+        self.destFichier = {}   #liste des clients dont on attend confirmation pour l'envoi de fichier
+        self.rFichier = {} #liste des fichiers recus ou en cours de reception
+                           #(id fichier: dictionnaire des infos du fichier [nom, taille (en o), recu (en o), ligne du tableau d'affichage])
+        self.repReceptionFichiers = os.getcwd()+"\\FichiersRecus\\"
+        
+        #chat voc
+        self.ipServeurVoc = ""
+        self.port = 6660
+
+        #recup des param et affichage:
+        try:
+            logProg.info(self.recupParamCo())
+        except:
+            logProg.info("pas de parametres a recuperer")
+        self.createWidgets()
+
+    def createWidgets(self):
+        """creation de l'interface de connexion"""
+        self.ui = Ui_ecranConnexion()
+        self.ui.setupUi(self)
+        if len(self.ip) > 0:
+            self.ui.in_ip.setText(QString.fromUtf8(self.ip))
+        if self.port > 0:
+            self.ui.in_port.setText(QString.fromUtf8(str(self.port)))
+        if len(self.pseudo) > 0:
+            self.ui.in_pseudo.setText(QString.fromUtf8(self.pseudo))
+            
+        self.connect(self.ui.fermer, SIGNAL("clicked()"), self.fermer)
+        self.connect(self.ui.creerServeur, SIGNAL("clicked()"), self.creerServeur)
+        self.connect(self.ui.seConnecter, SIGNAL("clicked()"), self.seConnecter)
+
+    def msg(self, txt):
+        """affichage d'un message informatif sous forme de label"""
+        self.ui.txt_msg.setText(QString.fromUtf8(txt))
+        QApplication.processEvents()
+
+    def creerServeur(self):
+        """instancie un serveur local"""
+        self.pseudo = self.ui.in_pseudo.text()
+        self.port = self.ui.in_port.text()        
+        if len(self.pseudo) == 0 or len(self.port) == 0:
+            self.msg("Parametres incorrects")
+        else:    
+            self.ui.in_ip.setText(QString.fromUtf8("localhost"))
+            self.s = Serveur(int(self.ui.in_port.text()))
+            self.serveur_connecte, txt = self.s.creer()
+            self.msg(txt)
+            if self.serveur_connecte:
+               self.seConnecter()
+
+    def seConnecter(self):
+        """se connecte au serveur correspondant a l'ip et au port saisis"""
+        self.pseudo = self.ui.in_pseudo.text()
+        self.port = self.ui.in_port.text()
+        self.ip = self.ui.in_ip.text()
+        essais = 0
+        if len(self.pseudo) == 0 or not ipValide(self.ip) or len(self.port) == 0:
+            self.msg("Parametres incorrects")
+        else:    
+            self.msg("En attente du serveur...")    
+            while self.client_connecte == False:
+            #en attente de la connexion    
+                try:
+                   self.cnn = socket(AF_INET, SOCK_STREAM)
+                   self.cnn.connect((self.ip, int(self.port)))
+                   self.client_connecte = True
+                   txt = "Connexion etablie avec le serveur sur le port {}\n".format(self.port)
+                   logProg.info(txt)
+                except KeyboardInterrupt:
+                   break
+                except:
+                   essais += 1
+                   if essais > 3:
+                       txt = "Delai depasse"
+                       self.msg(txt)
+                       logProg.warning(txt)
+                       break
+                   txt = "Connexion : essai {}".format(essais) 
+                   self.msg(txt)
+                   logProg.info(txt)
+
+        if self.client_connecte:
+            #demarre le fil de reception
+            Thread(None, self.filReception, None, (), {}).start()
+            #previent le serveur et envoie le pseudo
+            self.envoi("ci", "sa", self.pseudo)
+            self.msg(txt)
+            sleep(0.01)
+            self.close()
+        else:
+            txt = "Erreur: impossible de se connecter"
+            self.msg(txt)
+            logProg.error(txt)
+    
+    def filReception(self):
+        """thread de reception des donnees du serveur, reste actif tant que l'application est active"""
+        while self.client_connecte:
+           recu = self.cnn.recv(1024)
+           if len(recu) > 0:
+               self.traitement(recu)
+        
+    def traitement(self, msg):
+        """determine le traitement a apporter a un message recu, selon sa nature"""
+        if len(msg) >= 6:        
+            emet = msg[2:4]
+            dest = msg[4:6]
+            categorie = msg[:1]
+            nature = msg[:2]
+            try:
+               contenu = msg[6:]
+            except:
+               contenu = "" 
+
+            if nature != "fd" and nature != "ff":
+                #on decode le message, sauf s'il contient des donnees binaires issues d'un fichier
+                contenu = contenu.decode('utf-8')
+            
+            if nature == "ci":
+                #recoit l'identifiant du client fourni par le serveur
+                self.idClient = dest
+                logProg.info("mon id est: {}\n".format(self.idClient))
+                
+            elif nature == "cc":
+                #un autre client se connecte
+                if contenu[0:2] != self.idClient:
+                    self.autresCo[str(contenu[0:2])] = str(contenu[2:])
+                    #on lui envoie notre id+x+pseudo (x=c si on est client simple, s si on est serveur)
+                    sleep(0.02)
+                    if self.serveur_connecte:
+                        code = "s"
+                    else:
+                        code = "c"
+                    self.envoi("cp", contenu[0:2], "{}{}{}".format(self.idClient, code, self.pseudo))
+                    logProg.info("{} s'est connecte ({})".format(contenu[2:], contenu[0:2]))
+                    self.recuInfo("cc", "{} s'est connecte ({})".format(contenu[2:], contenu[0:2]))
+                    self.emit(SIGNAL("majAffichageLstClient()"))
+
+            elif nature == "cp":
+                #ce client est deja present
+                idClient = str(contenu[0:2])
+                self.autresCo[idClient] = str(contenu[3:])
+                if str(contenu[2:3]) == "s":
+                    self.idServeur = idClient
+                sleep(0.001)
+                logProg.info("{} est deja present [{}]".format(str(contenu[3:]), idClient))
+                self.emit(SIGNAL("majAffichageLstClient()"))
+
+            elif nature == "cd":
+                #un client se deconnecte
+                if contenu != self.idClient and len(contenu) == 2:
+                    logProg.info("{} s'est deconnecte ({})".format(self.autresCo[contenu], contenu))
+                    self.recuInfo("cd", "{} s'est deconnecte ({})".format(self.autresCo[contenu], contenu))
+                    if contenu in self.chatPrive:
+                         self.chatPrive[contenu].close()
+                         del self.chatPrive[contenu]
+
+                    del self.autresCo[contenu]
+                    sleep(0.001)
+                    self.emit(SIGNAL("majAffichageLstClient()"))
+                    
+            elif categorie == "m":
+                if nature == "m ":
+                    #afficher dans le chat publique
+                    logProg.info("chat: {} -> {}\n".format(emet, contenu))
+                    self.recuMsg(emet, contenu)
+                    
+                elif nature == "mp":
+                    #message pour le chat prive
+                    self.emit(SIGNAL("chatPrive(QString, QString,QString)"), QString.fromUtf8(emet), QString.fromUtf8(contenu), QString.fromUtf8(""))
+
+                elif nature == "md":
+                    #jet de des pour le chat prive
+                    self.emit(SIGNAL("chatPrive(QString, QString,QString)"), QString.fromUtf8(emet), QString.fromUtf8(contenu), QString.fromUtf8("red"))
+   
+            elif categorie == "i":
+                #afficher dans la fenetre évènement
+                self.recuInfo(nature, contenu)
+                if nature == "id":
+                    #jet de dés: afficher en rouge
+                    logProg.info("jet de dé: {} -> {}\n".format(emet, contenu))
+                elif nature == "ic":
+                    #nouveau client connecte: afficher en bleu
+                    logProg.info("info connexion: {} -> {}\n".format(emet, contenu))
+                    
+            elif categorie == "f":
+                #envoi ou reception de fichier
+                if nature == "f0":
+                    #le serveur nous renvoie l'identifiant du fichier que l'on veut envoyer
+                    if self.eFichier["id"] == "00":
+                       self.eFichier["id"] = contenu
+                    else:
+                       logProg.warning("Un fichier est deja en cours d'envoi\n")
+                       
+                elif nature == "fp":
+                    #un clients est pret a recevoir le fichier
+                    self.pretEnvoiFichier(emet)
+
+                elif nature == "fi":
+                    #quelqu'un nous envoie un fichier
+                    try:
+                       if len(contenu)>2:
+                          #les 2 premiers car sont l'identifiant, puis le nom/taille du fichier (taille.nom)
+                          try:
+                             taille = int(contenu[2:].split(".",1)[0]) #on coupe seulement suivant le premier point 
+                             nom_recu = contenu[2:].split(".",1)[1]
+                          except:
+                             logProg.error("impossible de lire la taille du nouveau fichier: {}".format(contenu[2:]))
+                             taille = 0
+                             nom_recu = contenu[2:]
+                          
+                          #on determine le nom qu'aura le fichier recu (au cas ou un fichier portant ce nom existe deja)   
+                          essai = self.nouveauFichier(contenu[0:2], nom_recu, taille)
+                          logProg.info("Creation d'un nouveau fichier: {}".format(essai))
+                          if len(essai) > 0:
+                              if dest == self.idClient:
+                                  #si le fichier n'est destine qu'a nous, on affiche aussi le msg dans la fenetre de chat prive
+                                  txt = "{} vous envoie {} ({} ko)".format(emet, nom_recu, int(taille/1000))
+                                  self.emit(SIGNAL("chatPrive(QString, QString, QString)"), QString.fromUtf8(emet), QString.fromUtf8(txt), QString.fromUtf8("blue"))
+                              self.recuInfo(nature, "Fichier {} en cours de reception ({} ko)".format(nom_recu, int(taille/1000)))
+                              #on envoie confirmation de la reception:
+                              sleep(0.001)
+                              self.envoi("fp", emet, contenu[0:2])
+                              self.emit(SIGNAL("majAffichageRecFichier(QString)"), QString.fromUtf8(contenu[0:2]))
+                          else:
+                              self.recuInfo(nature, "Impossible de créer le fichier à recevoir")
+                              logProg.error("Impossible de créer le fichier à recevoir")
+                       else:
+                          logProg.error("erreur reception fichier: id ou nom du fichier incorrect\n") 
+                    except:
+                        #erreur de reception
+                        logProg.error("erreur de reception des donnees du fichier\n")
+                        self.envoi("fe", emet, contenu[0:2])
+                        
+                elif nature == "fd":
+                    #on recoit les donnees a ecrire dans le fichier
+                    try:
+                       if len(contenu) > 2:
+                           if not self.rFichier[contenu[0:2]]["annule"]:
+                              self.rFichier[contenu[0:2]]["fichier"].write(contenu[2:])
+                              self.rFichier[contenu[0:2]]["recu"] += len(contenu[2:])
+                              try:
+                                 taux = int(100*self.rFichier[contenu[0:2]]["recu"] / self.rFichier[contenu[0:2]]["taille"])
+                              except:
+                                 taux = "." 
+                              self.emit(SIGNAL("majAffichageRecFichier(QString)"), QString.fromUtf8(contenu[0:2]))
+                        
+                              #le client renvoie la longueur de la donnee recue a l'emetteur pour confirmation
+                              sleep(0.001)
+                              self.envoi("fp", emet, contenu[0:2])
+                       elif len(contenu) == 2:
+                           #l'emetteur redemande confirmation, on lui envoie
+                           if not self.rFichier[contenu[0:2]]["annule"]:
+                              self.envoi("fp", emet, contenu[0:2])
+                       else:
+                           #erreur de reception, on annule la reception et on le signale
+                           logProg.error("erreur de reception des donnees du fichier\n")
+                           self.rFichier[contenu[0:2]]["annule"] = True
+                           self.envoi("fe", emet, contenu[0:2])
+                    except:
+                        #erreur de reception, on annule la reception et on le signale
+                        logProg.error("erreur de reception des donnees du fichier\n")
+                        self.rFichier[contenu[0:2]]["annule"] = True
+                        self.envoi("fe", emet, contenu[0:2])
+                        
+                        
+                elif nature == "ff":
+                    #fin de reception du fichier
+                    try:
+                       self.rFichier[contenu[0:2]]["fichier"].write(contenu[2:])
+                       sleep(0.001)
+                       self.envoi("fp", emet, contenu[0:2])                    
+                       sleep(0.01)
+                       self.rFichier[contenu[0:2]]["fichier"].close()
+                       self.rFichier[contenu[0:2]]["termine"] = True
+                    except:
+                        #erreur de reception, on annule la reception et on le signale
+                        logProg.error("erreur de reception des donnees du fichier\n")
+                        self.rFichier[contenu[0:2]]["annule"] = True
+                        self.envoi("fe", emet, contenu[0:2])
+                        
+                    if self.rFichier[contenu[0:2]]["termine"]:    
+                        self.emit(SIGNAL("majAffichageRecFichier(QString)"), QString.fromUtf8(contenu[0:2]))
+                        self.emit(SIGNAL("imageRecue(QString)"), QString.fromUtf8(contenu[0:2]))
+                        self.recuInfo("ff", "Fichier {} recu\n".format(self.rFichier[contenu[0:2]]["nomOriginal"]))
+                        if dest == self.idClient:
+                             #si le fichier n'est destine qu'a nous, on affiche aussi le msg dans la fenetre de chat prive
+                             txt = "Fichier {} bien recu".format(self.rFichier[contenu[0:2]]["nomOriginal"])
+                             self.emit(SIGNAL("chatPrive(QString, QString, QString)"), QString.fromUtf8(emet), QString.fromUtf8(txt), QString.fromUtf8("blue"))
+                        logProg.info("Fichier recu")
+                    
+                elif nature == "fa":
+                    #envoi annule
+                    logProg.info("Annulation de la reception du fichier")
+                    if self.rFichier[contenu[0:2]]:
+                       self.rFichier[contenu[0:2]]["annule"] = True 
+                       self.recuInfo("ff", "Reception {} annule \n".format(self.rFichier[contenu[0:2]]["nom"]))
+                       if dest == self.idClient:
+                           #si le fichier n'est destine qu'a nous, on affiche aussi le msg dans la fenetre de chat prive
+                           txt = "Transfert du fichier {} annule".format(self.rFichier[contenu[0:2]]["nomOriginal"])
+                           self.emit(SIGNAL("chatPrive(QString, QString, QString)"), QString.fromUtf8(emet), QString.fromUtf8(txt), QString.fromUtf8("blue")) 
+                       self.emit(SIGNAL("majAffichageRecFichier(QString)"), QString.fromUtf8(contenu[0:2]))
+                       sleep(0.01)
+                       self.rFichier[contenu[0:2]]["fichier"].close()                                 
+                       #on supprime le fichier incomplet:
+                       essais = 0
+                       while essais < 100:
+                           try:
+                              os.remove(self.rFichier[contenu[0:2]]["fichier"].name)
+                              break
+                           except:
+                              essais += 1
+                       if essais ==  100:
+                           logProg.error("Possible erreur de suppression du fichier temporaire")
+                       del self.rFichier[contenu[0:2]]
+                       
+                elif nature == "fe":
+                    #le destinataire du fichier signale une erreur de reception
+                    self.recuInfo("fe", "{}: erreur de reception du fichier, l'envoi est annule \n".format(emet))
+                    self.annuleEnvoiFichier()
+
+                    
+            elif categorie == "s":
+                #infos sur le fonctionnement du serveur principal
+                if nature == "sd":
+                    #le serveur a ete ferme
+                    self.serveurDeco()
+                    
+            elif categorie == "v":
+                #infos liees au chat vocal
+                if nature == "vs":
+                    #un serveur vocal a ete cree
+                    self.recuInfo("vs", "{} a cree un serveur vocal ({})".format(self.autresCo[emet], contenu))
+                    self.ipServeurVoc = contenu
+                    
+                if nature == "vi":
+                    #un client rejoint le chat vocal
+                    self.recuInfo("vi", "{} a rejoint le chat vocal".format(self.autresCo[emet]))
+
+                if nature == "vq":
+                    #un client quitte le chat vocal
+                    self.recuInfo("vq", "{} a quitte le chat vocal".format(self.autresCo[emet]))
+
+                if nature == "vf":
+                    #fermeture du serveur vocal
+                    self.recuInfo("vf", "{} a ferme le serveur vocal".format(self.autresCo[emet]))
+                    
+            elif categorie == "p":
+                if nature == "pi":
+                    #nouveau plateau créé
+                    logProg.info("nouveau plateau: {}\n".format(emet, contenu))
+        else:
+            logProg.warning("Erreur: message illisible -> {}\n".format(msg))
+
+
+    def recuInfo(self, nature, contenu):
+        """signale une nouvelle information"""
+        self.emit(SIGNAL("nouvelleInfo(QString, QString)"), QString.fromUtf8(nature), QString.fromUtf8(contenu))
+
+    def recuMsg(self, emetteur, contenu):
+        """signale un nouveau message texte pour le chat ecrit"""
+        self.emit(SIGNAL("msgChat(QString, QString)"), QString.fromUtf8(emetteur), QString.fromUtf8(contenu))
+        
+    def envoi(self, nature, dest, msg, idFichier = ""):
+        """envoie un message au serveur TCP
+           - longueur du message (3 car)
+           - nature du message (2 car)
+           - exp: id de l'expediteur (2 car)
+           - dest: id du destinataire (2 car)
+           - msg: contenu du message  (999 car max)
+           - un identifiant pour le fichier le cas echeant"""
+        
+        exp = self.idClient
+        if self.client_connecte:
+            try:
+               if len(msg) <= 999:
+                  if len(idFichier) == 0:
+                     msg = unicode(msg)   
+                     lg = "%003.f"%len(msg.encode('utf-8')) #la longueur apres encodage peut changer
+                     txt = "{}{}{}{}{}".format(lg, nature, exp, dest, msg)
+                     txt = txt.encode('utf-8')
+                  else:
+                     lg = "%003.f"%(len(msg)+2)
+                     txt = "{}{}{}{}{}".format(lg, nature, exp, dest, idFichier)
+                     txt = txt.encode('utf-8') + msg
+                  
+                  retour = len(txt)
+                  self.cnn.sendall(txt)
+   
+               else:
+                  self.recuInfo("  ","999 caracteres au max.")
+                  retour = 0
+                  
+            except:
+                retour = 0
+                logProg.warning("Envoi impossible")
+        else:
+            retour = ""
+            logProg.warning("Le client n'est pas connecte au serveur")
+            self.recuInfo("  ","Vous n'etes pas connecte a un serveur")
+     
+        return retour
+
+    def envoiFichier(self, chemin, dest = "ac"):
+        """intialise l'envoi d'un fichier"""
+        if self.eFichier["id"] == "00":
+           # on verifie si le fichier existe:
+           fichier = None
+           
+           try:
+               fichier = open(chemin, "rb")
+           except:
+               logProg.error("Le fichier '{}' est introuvable.".format(fichier))
+
+           if not os.path.getsize(chemin) > 0:
+               logProg.error("Envoi impossible - fichier vide")
+               fichier.close()
+               fichier = None
+              
+           if fichier:
+               #on demande un identifiant au serveur
+               self.eFichier["fichier"] = fichier
+               self.eFichier["chemin"] = chemin
+               self.eFichier["dest"] = dest
+               self.eFichier["annule"] = False
+               self.emit(SIGNAL("initEnvFichier(QString, QString)"), QString.fromUtf8(os.path.basename(chemin)), QString.fromUtf8("0"))
+               logProg.debug(self.eFichier)
+               if dest == "ac":
+                   for idC in self.autresCo:
+                       self.destFichier[idC] = False
+               else:
+                   self.destFichier[dest] = False
+               #on demande un identifiant au serveur    
+               self.envoi("f0","sa","")
+               Thread(None, self.envoiFichier_fil, None, (), {}).start()               
+                 
+        else:
+           self.recuInfo("fi", "Impossible d'envoyer le fichier, un fichier est peut-etre deja en cours d'envoi")
+          
+
+    def envoiFichier_fil(self):
+        """le fichier est pret a etre envoye, on attend confirmation des destinataires"""
+        #on attend que l'id du fichier soit mis a jour
+        essais = 0
+        while self.eFichier["id"]=="00" and essais < 3000:
+           sleep(0.001)
+           essais += 1
+           
+        if len(self.eFichier["id"]) == 2 and self.eFichier["id"] != "00": 
+           idFichier = self.eFichier["id"]
+           dest = self.eFichier["dest"]
+           nomFichier = os.path.basename(self.eFichier["chemin"])
+           taille = os.path.getsize(self.eFichier["chemin"])
+           logProg.debug("{} a pour id {}\n".format(nomFichier, idFichier))
+
+           #on previent les destinataires, et on leur transmet l'identifiant et taille.nom du fichier (taille au format numerique, en octets)
+           logProg.info("En attente des destinataires...")
+           self.recuInfo("fi", "{} - En attente des destinataires...".format(nomFichier))
+           self.envoi("fi", dest, "{}{}.{}".format(idFichier, taille, nomFichier))
+
+           essais = 0
+           while not self.eFichier["envoi"] and not self.eFichier["annule"]:
+              sleep(0.001)
+              essais += 1
+              if essais >= 3000:
+                  logProg.error("Pas de reponse des destinataires - envoi avorte")
+                  self.eFichier["annule"] = True
+
+              
+           if not self.eFichier["annule"]:
+              #on a recu confirmation de la part des destinataires 
+              envoye = 0
+              essais = 0
+            
+              #on lit un premier paquet de donnees
+              data = self.eFichier["fichier"].read(512)
+              
+              while len(data) == 512 and not self.eFichier["annule"]:           
+                  #on reinitialise le controle de reception pour le prochain paquet:
+                  self.eFichier["envoi"] = False
+                  if dest == "ac":
+                     for idC in self.autresCo:
+                         self.destFichier[idC] = False
+                  else:
+                     self.destFichier[dest] = False
+
+                  #on envoie le paquet precedent, que les destinataires ont confirme pouvoir recevoir
+                  self.envoi("fd", dest, data, idFichier)
+                  envoye += len(data)
+                  taux = str((100*envoye)/taille)
+                  self.emit(SIGNAL("initEnvFichier(QString, QString)"), QString.fromUtf8(""), QString.fromUtf8(taux))
+                  
+                  #logProg.info("{} / {}".format(int(envoye/1000), int(taille/1000))) #attention: ralentit enormement l'envoi
+
+                  #on attend que les clients confirment reception pour envoyer le prochain
+                  essais = 0
+                  while not self.eFichier["envoi"]:
+                      if self.eFichier["annule"]:
+                          break
+                      sleep(0.001)
+                      essais += 1
+                      if essais >= 500:
+                          #on renvoie un message toutes les demi-secondes pour redemander confirmation 
+                          self.envoi("fd", dest, b'', idFichier)
+                          essais = 0
+   
+                  #on lit le paquet suivant             
+                  data = self.eFichier["fichier"].read(512)
+
+              #FIN DE LA BOUCLE, on a envoye tous les paquets de 512o, il reste donc un dernier paquet a envoyer    
+
+              #pour dernier paquet on ajoute au drapeau: "%003.f"%len(paquet)   
+              #on signale que c'est le dernier paquet et on ajoute 3 caracteres pour en specifier la taille:
+                  
+              #ENVOI DU DERNIER PAQUET: 
+              if not self.eFichier["annule"]:
+                  
+                  #on reinitialise le controle de reception pour le prochain paquet:
+                  self.eFichier["envoi"] = False
+                  if dest == "ac":
+                     for idC in self.autresCo:
+                         self.destFichier[idC] = False
+                  else:
+                     self.destFichier[dest] = False
+                     
+                  #on envoie le paquet precedent, que les destinataires ont confirme pouvoir recevoir   
+                  self.envoi("ff", dest, data, idFichier)
+                  envoye += len(data)
+                  taux = str((100*envoye)/taille)
+                  self.emit(SIGNAL("initEnvFichier(QString, QString)"), QString.fromUtf8(""), QString.fromUtf8(taux))                  
+
+                  #on attend que les clients confirment reception pour envoyer le signal de fin
+                  essais = 0
+                  while not self.eFichier["envoi"]:
+                      if self.eFichier["annule"]:
+                          break
+                      sleep(0.001)
+                      essais += 1
+                      if essais >= 500:
+                          #on renvoie un message pour redemander confirmation
+                          logProg.warning("envoi fichier - on redemande confirmation")
+                          self.envoi("fd", dest, b'', idFichier)
+                          essais = 0
+                  #on signale au serveur qu'il peut liberer l'id du fichier 
+                  self.envoi("f1", "sa", "{}".format(idFichier))
+                  self.recuInfo("ff", "- {} a bien ete envoye -".format(nomFichier))
+                  logProg.info("\n- Fichier envoye -")
+ 
+           else:
+              logProg.error("Erreur envoi fichier: signal serveur non-recu -> {}".format(self.eFichier["id"]))
+              
+        else:
+           logProg.error("Erreur envoi fichier: identifiant incorrect -> {}".format(idFichier))
+
+        self.eFichier["fichier"].close()
+        self.eFichier = {"id": "00", "chemin": "", "fichier": None, "dest": "", "envoi" : False, "annule": False}
+
+            
+    def pretEnvoiFichier(self, idClient):
+        """signale un destinataire comme etant pret a recevoir le fichier ou le paquet de donnees,
+           et renvoie Vrai si tous les destinataires sont prets"""
+        pretEnvoi = False
+        if self.eFichier["dest"] == "ac":
+            self.destFichier[idClient] = True
+            pretEnvoi = True
+            for idC in self.destFichier:
+                if self.destFichier[idC] == False:
+                    pretEnvoi = False
+        else:
+            if idClient == self.eFichier["dest"]:
+                pretEnvoi = True
+        #print("{} -> {}".format(idClient, pretEnvoi))        
+        self.eFichier["envoi"] = pretEnvoi
+               
+
+    def annuleEnvoiFichier(self):
+        """annule l'envoi d'un fichier"""
+        logProg.warning("Annulation de l'envoi")
+        self.envoi("fa", self.eFichier["dest"], "{}".format(self.eFichier["id"]))
+        self.eFichier["annule"] = True
+        essais = 0
+        while not self.eFichier["id"] == "00":
+            sleep(0.01)
+            essais += 1
+            if essais > 500:
+                logProg.error("Erreur: impossible d'annuler l'envoi")
+                
+        if self.eFichier["id"] == "00":
+           logProg.info("-> Envoi annulé")
+           self.recuInfo("fa", "- Envoi du fichier annule -")
+           self.emit(SIGNAL("initEnvFichier(QString, QString)"), QString.fromUtf8(""), QString.fromUtf8("x"))
+
+
+    def nouveauFichier(self, idFichier, nomFichier, taille):
+        """cree le fichier a recevoir - le renomme si un fichier portant ce nom existe deja - retourne le chemin complet"""
+        k = 1
+        tmp = nomFichier
+        retour = ""
+        try:
+           while os.path.isfile(self.repReceptionFichiers+tmp):     
+              k += 1
+              tmp = nomFichier.split(".")[0]+str(k)+"."+nomFichier.split(".")[1]
+              if k == 100:
+                  tmp = ""
+                  break
+           if len(tmp) > 0:
+              fichier = open((self.repReceptionFichiers + tmp), "wb") 
+              self.rFichier[idFichier] = {"fichier": fichier, "nom": tmp, "nomOriginal": nomFichier, "taille": taille, "recu": 0, "ligneAffichage": None, "termine": False, "annule": False}
+              retour = tmp
+        except:
+           logProg.error("Impossible de creer le fichier")
+        return retour
+
+    def serveurDeco(self):
+        """le serveur a ferme - on affiche a nouveau l'ecran de connexion"""
+        #on annule les envois de fichier en cours
+        if self.eFichier["fichier"] != None:
+            self.eFichier["annule"] = True
+            self.emit(SIGNAL("initEnvFichier(QString, QString)"), QString.fromUtf8(""), QString.fromUtf8("x"))
+        #on annule les receptions de fichiers en cours
+        for idFichier in self.rFichier:
+            if not self.rFichier[idFichier]["termine"]:
+               logProg.warning("{} - reception annulee".format(self.rFichier[idFichier]["nom"]))
+               self.rFichier[idFichier]["fichier"].close()
+               os.remove(self.rFichier[idFichier]["fichier"].name)
+               self.emit(SIGNAL("majAffichageRecFichier(QString)"), QString.fromUtf8(idFichier))
+        self.rFichier = {}  
+        
+        self.recuInfo("sd", "(!) Le serveur a mis la clef sous la porte (!)")
+        self.idServeur = ""
+        logProg.warning("Serveur deconnecte")
+        self.cnn.close()
+        self.client_connecte = False
+        self.serveur_lance = False
+        sleep(0.01)
+        self.emit(SIGNAL("majAffichage()"))
+        #on affiche l'ecran de connexion
+        self.show()
+        self.raise_()
+        self.activateWindow()
+        self.msg("Le serveur a ete deconnecte")
+
+    def recupParamCo(self):
+        """recupere les derniers parametres de connexion enregistres s'il existent"""
+        try:
+            with open("parametresCo", 'rb') as input:
+                dico = pickle.load(input)
+                self.pseudo = dico["pseudo"]
+                self.port = dico["port"]
+                self.ip = dico["ip"]
+                if os.path.isdir(dico["repReceptionFichiers"]):
+                    self.repReceptionFichiers = dico["repReceptionFichiers"] 
+            retour = dico
+            input.close()
+        except IOError:
+            retour = ("Erreur: parametresCo introuvable")
+
+        return retour        
+
+    def sauverParamCo(self):
+        """sauvegarde les parametres de connexion pour une prochaine utilisation"""
+        with open("parametresCo", 'wb') as output:
+             dico = {"pseudo": str(self.pseudo), "port" : int(self.port), "ip": str(self.ip), "repReceptionFichiers" : str(self.repReceptionFichiers)}
+             pickle.dump(dico, output, -1)
+        output.close()
+        chaine = "parametres sauvegarde."
+
+        return chaine
+
+    def fermer(self):
+        """fermeture de la connexion, et du serveur le cas echeant"""      
+        if self.client_connecte:
+           try:
+              self.envoi("cd", "sa", "") 
+           except:
+              logProg.warning("impossible de prévenir le serveur de la deco")
+           for fenetre in self.chatPrive:
+               self.chatPrive[fenetre].close()
+           self.chatPrive = {}
+           self.client_connecte = False
+           self.cnn.close()
+           if self.eFichier["fichier"] != None:
+               self.eFichier["annule"] = True
+           sleep(0.001)
+           logging.info(self.sauverParamCo())
+     
+        if self.serveur_connecte:
+           self.s.stop()
+           self.serveur_connecte = False   
+           sleep(0.001)
+           
+        self.close()
+        
+    def closeEvent(self, event):
+        """sur fermeture de la fenetre"""
+        if self.client_connecte:
+            self.emit(SIGNAL("majAffichage()"))
+        else:    
+            self.fermer()
+ 
+
+
+class AfficherImage(QGroupBox):
+    """fenetre pop-up permettant l'affichage d'une image"""
+    def __init__(self, chemin, parent=None):
+        super (AfficherImage, self).__init__(parent)
+        self.ui = Ui_visionneuse()
+        self.ui.setupUi(self)
+        self.setWindowTitle(QString.fromUtf8(chemin))
+        myPixmap = QPixmap(chemin)
+        myScaledPixmap = myPixmap.scaled(self.ui.label.size(), Qt.KeepAspectRatio)
+        self.ui.label.setPixmap(myScaledPixmap)
+        self.resize(myScaledPixmap.width(),myScaledPixmap.height())
+        
+
+
+class ChatPrive(QMainWindow):
+    """interface de chat prive entre 2 joueurs"""
+    def __init__(self, connexion, interloc, parent=None):
+        """initialisation de la fenetre"""
+        super (ChatPrive, self).__init__(parent)
+        self.co = connexion
+        self.idInterloc = interloc
+        self.createWidgets()
+
+    def createWidgets(self):
+        """construction de l'interface"""
+        #construction de l'interface
+        self.ui = Ui_chatPrive()
+        self.ui.setupUi(self)
+        self.ui.lblInterlocChatPrive.setText(QString.fromUtf8("Chat prive avec {}".format(self.co.autresCo[self.idInterloc])))
+        self.connect(self.ui.inSaisieChatPrive, SIGNAL("returnPressed()"), self.envoiMsgPrive)
+        self.connect(self.ui.envoiFichierChatPrive, SIGNAL("clicked()"), self.envoyerfichierPrive) 
+        self.connect(self.ui.inDesChatPrive, SIGNAL("returnPressed()"), self.jetDesPrive)
+
+    def envoiMsgPrive(self):
+        """ajout d'une ligne au chat prive"""
+        msg = self.ui.inSaisieChatPrive.text()
+        self.afficherMsgPrive(self.co.idClient, msg)
+        self.co.envoi("mp", "{}".format(self.idInterloc), msg)
+        self.ui.inSaisieChatPrive.clear()
+        QApplication.processEvents()
+
+    def envoyerfichierPrive(self):
+        """envoi d'un fichier a l'interlocuteur actuel"""
+        if self.co.eFichier["id"] == "00":
+           fichier = QFileDialog.getOpenFileName(
+                       self, 
+                       "Selectionnez un fichier a envoyer", 
+                       "c:\\", 
+                       "")
+           if len(str(fichier)) > 0:
+              self.co.envoiFichier(str(fichier), self.idInterloc)
+        else:
+           self.co.annuleEnvoiFichier()
+    
+    def jetDesPrive(self):
+        """ajout d'une ligne de jet de des au chat prive"""
+        expr = str(self.ui.inDesChatPrive.text())
+        self.ui.inDesChatPrive.clear()
+        res, detail = jet(expr)
+        if res > 0:
+            txt = "{}   ({})  [{}]".format(res, detail, expr)
+            self.afficherMsgPrive(self.co.idClient, txt, "red")
+            self.co.envoi("md", self.idInterloc, txt)
+        else:
+            self.afficherMsgPrive(self.co.idClient, "mmmhh, pas bon le jet", "red")
+        return res
+
+    def afficherMsgPrive(self, emetteur, msg, couleur="black"):
+        """ajoute un message au chat prive"""
+        emetteur = str(emetteur)
+        if len(couleur)>0 and couleur != "black":
+            if emetteur != self.co.idClient:
+                pseudo = self.co.autresCo["{}".format(emetteur)]
+            else:
+                pseudo = self.co.pseudo
+            txt = "<font color=\"{}\">{} - {}</font>".format(couleur, pseudo, msg)
+        else:    
+            if emetteur == self.co.idClient:
+                txt = "<font color=\"blue\">{} : </font> {}".format(self.co.pseudo, msg)
+            elif emetteur in self.co.autresCo:
+                pseudo = self.co.autresCo["{}".format(emetteur)]
+                txt = "<font color=\"green\">{} : </font> {}".format(pseudo, msg)
+            else:
+                txt = str(msg)
+
+        txt = QString.fromUtf8(txt)
+        item = QListWidgetItem(self.ui.lstChatPrive)
+        self.ui.lstChatPrive.addItem(item)
+        label = QLabel()
+        label.setWordWrap(True)
+        label.setText(txt)
+        item.setSizeHint(QSize(1, label.heightForWidth (self.ui.lstChatPrive.width()) + 5))
+        self.ui.lstChatPrive.setItemWidget(item, label)
+        self.ui.lstChatPrive.scrollToItem(item)
+        self.show()
+        self.raise_()
+        self.activateWindow()
+        QApplication.processEvents()
+
+class EcranPrincipal(QMainWindow):
+    """interface comprenant: chat ecrit, fenetre d'infos, lancer de des, echange de fichiers, lancement du chat vocal"""
+    def __init__(self, connexion, parent=None):
+        """initialisation de la fenetre"""
+        super (EcranPrincipal, self).__init__(parent)
+        self.co = connexion
+        self.connecte = True
+        self.estServeurVoc = False
+        self.estClientVoc = False
+        self.cases = {}
+        self.createWidgets()
+
+    def createWidgets(self):
+        """construction de l'interface"""
+        #construction de l'interface
+        self.ui = Ui_principal()
+        self.ui.setupUi(self)
+
+        #connexion des commandes
+        self.connect(self.ui.inChat, SIGNAL("returnPressed()"), self.envoiMsg)
+        self.connect(self.ui.d20, SIGNAL("clicked()"), self.d20)
+        self.connect(self.ui.d100, SIGNAL("clicked()"), self.d100)
+        self.connect(self.ui.inJetDes, SIGNAL("returnPressed()"), self.autreJet)
+        self.connect(self.ui.envoiFichier, SIGNAL("clicked()"), self.envoyerfichier) 
+        self.connect(self.ui.repReceptionFichiers, SIGNAL("clicked()"), self.repReception)
+        self.connect(self.ui.listFichiers, SIGNAL("itemDoubleClicked(QTreeWidgetItem*, int)"), self.ouvrirFichier)
+        self.connect(self.ui.lstStatutJoueurs, SIGNAL("itemDoubleClicked (QListWidgetItem *)"), self.ouvrirChatPrive)
+        self.connect(self.ui.chatVoc, SIGNAL("clicked()"), self.chatVoc)
+
+        #reception des signaux self.emit(SIGNAL("majAffichage()"))
+        self.connect(self, SIGNAL("msgChat(QString, QString)"), self.ajoutChat)
+        self.connect(self.co, SIGNAL("msgChat(QString, QString)"), self.ajoutChat)
+        self.connect(self, SIGNAL("nouvelleInfo(QString, QString)"), self.ajoutInfo)
+        self.connect(self.co, SIGNAL("nouvelleInfo(QString, QString)"), self.ajoutInfo)
+        self.connect(self, SIGNAL("majAffichageRecFichier(QString)"), self.afficheReception)
+        self.connect(self.co, SIGNAL("majAffichageRecFichier(QString)"), self.afficheReception)
+        self.connect(self, SIGNAL("imageRecue(QString)"), self.imageRecue)
+        self.connect(self.co, SIGNAL("imageRecue(QString)"), self.imageRecue)
+        self.connect(self, SIGNAL("initEnvFichier(QString, QString)"), self.afficheEnvoi)
+        self.connect(self.co, SIGNAL("initEnvFichier(QString, QString)"), self.afficheEnvoi)
+        self.connect(self, SIGNAL("majAffichage()"), self.majStatut)
+        self.connect(self.co, SIGNAL("majAffichage()"), self.majStatut)
+        self.connect(self, SIGNAL("majAffichageLstClient()"), self.majStatutLstClients)
+        self.connect(self.co, SIGNAL("majAffichageLstClient()"), self.majStatutLstClients)
+        self.connect(self, SIGNAL("chatPrive(QString, QString, QString)"), self.chatPrive)
+        self.connect(self.co, SIGNAL("chatPrive(QString, QString, QString)"), self.chatPrive)
+
+        #plateau de jeu
+        self.creerPlateau(20,20)
+        self.nouveauPion()
+        
+        #mise a jour de l'affichage
+        self.majStatut()
+        self.majStatutLstClients()
+
+    """def msg(self, txt):
+        
+        self.ui.txt_msg.setText(QString.fromUtf8(txt))
+        QApplication.processEvents()"""
+
+    def ajoutChat(self, emetteur, msg):
+        """ajoute une nouvelle ligne au chat ecrit"""
+        emetteur = str(emetteur)
+        if emetteur == self.co.idClient:
+            txt = "<font color=\"blue\">{} : </font> {}".format(self.co.pseudo, msg)
+        else:
+            pseudo = self.co.autresCo["{}".format(emetteur)]
+            txt = "<font color=\"green\">{} : </font> {}".format(pseudo, msg)
+            
+        txt = QString.fromUtf8(txt)
+        item = QListWidgetItem(self.ui.listAffichage)
+        self.ui.listAffichage.addItem(item)
+        label = QLabel()
+        label.setWordWrap(True)
+        label.setText(txt)
+        item.setSizeHint(QSize(1, label.heightForWidth (self.ui.listAffichage.width()) + 5))
+        self.ui.listAffichage.setItemWidget(item, label)
+        self.ui.listAffichage.scrollToItem(item)
+        QApplication.processEvents()
+
+    def ajoutInfo(self, nature, msg):
+        """ajoute une nouvelle ligne a la liste des evenements"""
+        #couleur selon nature de l'info:
+        if nature[:1] == "c":
+            txt = "<font color=\"green\">{}</font>".format(msg)
+        elif nature == "id":
+            txt = "<font color=\"red\">{}</font>".format(msg)
+        elif nature[:1] == "f":
+            txt = "<font color=\"blue\">{}</font>".format(msg)    
+        elif nature[:1] == "v":
+            txt = "<font color=\"orange\">{}</font>".format(msg)    
+        else:
+            txt = msg
+
+        txt = QString.fromUtf8(txt)         
+        item = QListWidgetItem(self.ui.listEvenement)
+        self.ui.listEvenement.addItem(item)
+        
+        label = QLabel()
+        label.setWordWrap(True)
+        label.setText(txt)
+        item.setSizeHint(QSize(110, label.heightForWidth (self.ui.listEvenement.width()) + 6))
+        self.ui.listEvenement.setItemWidget(item, label)
+        self.ui.listEvenement.scrollToItem(item)
+        QApplication.processEvents()
+
+             
+    def envoiMsg(self):
+        """envoie un message pour le chat ecrit"""
+        msg = self.ui.inChat.text()
+        self.co.envoi("m ", "tc", msg)
+        self.ui.inChat.clear()
+        QApplication.processEvents()
+
+    def lancerD(self, expr):
+        """fonction de lancer de des"""
+        res, detail = jet(expr)
+        if res > 0:
+            txt = "{}: {}   ({})  [{}]".format(self.co.pseudo, res, detail, expr)
+            self.co.envoi("id", "tc", txt)
+        else:
+            self.ajoutInfo("id", "mmmhh, pas bon le jet")
+        return res
+             
+    def d20(self):
+        """lance un D20"""
+        self.lancerD("1d20")
+        
+    def d100(self):
+        """lance un D100"""
+        self.lancerD("1d100")
+
+    def autreJet(self):
+        """lance un jet personnalise"""
+        expr = str(self.ui.inJetDes.text())
+        retour = self.lancerD(expr)
+        self.ui.inJetDes.clear()
+
+    def envoyerfichier(self):
+        """selectionne et envoie un fichier ou annule l'envoi en cours s'il existe"""
+        if self.co.eFichier["id"] == "00":
+           fichier = QFileDialog.getOpenFileName(
+                       self, 
+                       "Selectionnez un fichier a envoyer", 
+                       "c:\\", 
+                       "")
+           if len(str(fichier)) > 0:
+              self.co.envoiFichier(str(fichier))
+        else:
+           self.co.annuleEnvoiFichier()
+           
+    def ouvrirFichier(self):
+        """ouvre un fichier depuis la liste des fichiers recus/envoyes"""
+        item = self.ui.listFichiers.currentItem()
+        eR = item.text(0)
+        taux = item.text(1)
+        nom = item.text(2)
+        if eR == "R":
+            if taux == "ok":
+                try:
+                    chemin = "{}\\{}".format(self.co.repReceptionFichiers, nom)
+                    Popen(chemin, shell=True, stdout=PIPE) #from subprocess
+                except:
+                    print("impossible d'ouvrir le fichier")
+
+
+
+
+    def repReception(self):
+        """permet de choisir son repertoire de reception des fichiers"""
+        dossier = QFileDialog.getExistingDirectory(self)
+        if len(dossier) > 0:
+            if dossier[len(dossier)-1:] != "\\":
+                dossier += "\\"
+            self.co.repReceptionFichiers = str(dossier)
+            self.majStatut()
+
+    def afficheReception(self, idFichier):
+           """ajoute/maj une ligne dans la liste des fichiers en cours de reception"""
+           idFichier = str(idFichier)
+        #try:                                              
+           if self.co.rFichier[idFichier]["ligneAffichage"] == None:
+              self.co.rFichier[idFichier]["ligneAffichage"] = QTreeWidgetItem(self.ui.listFichiers, ["R", "0", self.co.rFichier[idFichier]["nom"]])
+              self.ui.listFichiers.scrollToItem(self.co.rFichier[idFichier]["ligneAffichage"])
+           else:
+              if self.co.rFichier[idFichier]["termine"]:
+                 taux = "ok"
+              elif self.co.rFichier[idFichier]["annule"]:
+                 taux = "x"
+              else:    
+                 taux = str(int(100*self.co.rFichier[idFichier]["recu"]/self.co.rFichier[idFichier]["taille"]))
+              self.co.rFichier[idFichier]["ligneAffichage"].setText(1, taux)                                                          
+        #except:
+        #    logProg.error("erreur d'affichage de la progression: " + idFichier)
+
+    def imageRecue(self, idFichier):
+        """verifie si le fichier recu est une image, et l'ouvre le cas echeant"""
+        idFichier = str(idFichier)
+        if self.co.rFichier[idFichier]["termine"]:
+           try: 
+              typeFichier = self.co.rFichier[idFichier]["nom"].split(".")[len(self.co.rFichier[idFichier]["nom"].split("."))-1]
+           except:
+              typeFichier = "" 
+
+        if typeFichier.lower() in ["png", "jpeg", "jpg"]:
+             #si c'est une image, on l'ouvre dans une nouvelle fenetre
+             logProg.debug("ouverture d'une image : " + self.co.rFichier[idFichier]["nom"])
+             chemin = self.co.repReceptionFichiers + self.co.rFichier[idFichier]["nom"]
+             #print(chemin)
+             self.affiche = AfficherImage("{}".format(chemin))
+             self.affiche.show()
+             self.affiche.raise_()
+             QApplication.processEvents()
+
+    def afficheEnvoi(self, fichier, taux):
+        """ajoute/maj une ligne a la liste des fichiers en cours d'envoi"""
+        fichier = str(fichier)
+        taux = str(taux)
+        if len(fichier) > 0:
+            self.ligneEFichier = QTreeWidgetItem(self.ui.listFichiers, ["E", taux, fichier])
+            self.ui.listFichiers.scrollToItem(self.ligneEFichier)
+        elif len(taux) > 0:
+            if taux != self.ligneEFichier.text(1): 
+                self.ligneEFichier.setText(1, taux)
+            
+    def majStatut(self):
+        """met a jour l'onglet de statut de connexion"""
+        self.ui.txtStatutCoPseudo.setText(QString.fromUtf8("Pseudo : {}".format(self.co.pseudo)))
+        if self.co.serveur_connecte:
+            self.ui.txtStatutCoServeur.setText(QString.fromUtf8("Serveur : {} [{}]".format(self.co.pseudo, self.co.ip)))
+        elif len(self.co.idServeur) > 0 and self.co.idServeur in self.co.autresCo:
+            self.ui.txtStatutCoServeur.setText(QString.fromUtf8("Serveur : {} [{}]".format(self.co.autresCo[self.co.idServeur], self.co.ip)))
+        else:
+            self.ui.txtStatutCoServeur.setText(QString.fromUtf8("Serveur : Pas de serveur"))
+            
+        if self.estServeurVoc:
+            self.ui.txtStatutCoServeur.setText(QString.fromUtf8("Serveur vocal : {} [{}]".format(self.co.pseudo, self.co.ip)))
+        QApplication.processEvents()
+        
+    def majStatutLstClients(self):
+        """met a jour la liste des joueurs"""
+        self.ui.lstStatutJoueurs.clear()
+        txt = "{} - {}".format(self.co.idClient, self.co.pseudo)
+        self.ui.lstStatutJoueurs.addItem(QString.fromUtf8(txt))
+        for idClient in self.co.autresCo:
+            txt = "{} - {}".format(idClient, self.co.autresCo[idClient])
+            self.ui.lstStatutJoueurs.addItem(QString.fromUtf8(txt))
+        self.majStatut()    
+        QApplication.processEvents()
+        
+    def ouvrirChatPrive(self):
+        """ouvre un chat prive avec le joueur sur lequel on a clique"""
+        item = self.ui.lstStatutJoueurs.currentItem()
+        idInterloc = str(item.text())[0:2]
+        if idInterloc != self.co.idClient:
+           self.chatPrive(idInterloc)
+           
+
+    def chatPrive(self, idInterloc, txt="", couleur=""):
+        """ouvre la fenetre de chat prive si elle ne l'est pas deja, puis affiche le message"""
+        idInterloc = str(idInterloc)
+        if not idInterloc in self.co.chatPrive:
+           self.co.chatPrive[idInterloc] = ChatPrive(self.co, idInterloc)
+        self.co.chatPrive[idInterloc].show()
+        if len(txt)>0:
+            if len(couleur)>0:
+                self.co.chatPrive[idInterloc].afficherMsgPrive(idInterloc, txt, couleur)
+            else:
+                self.co.chatPrive[idInterloc].afficherMsgPrive(idInterloc, txt)
+                              
+    def creerServeurVoc(self):
+        """cree un serveur vocal"""
+        if not self.estServeurVoc:
+            self.sVoc = ServeurVoc(6660)
+              #on ouvre une boite de dialogue pour demander l'ip distante
+                #de celui qui veut ouvrir le serveur voc
+            ipS, ok = QInputDialog.getText(self, 'Creation du serveur vocal', 
+            'Saisissez votre adresse IP distante :')
+            if ok:
+               if ipValide(ipS):
+                  #self.co.ipServeurVoc = self.ui.ipServeurVoc.text()
+                  self.co.ipServeurVoc = ipS
+                  txt = self.sVoc.creer()
+                  self.ajoutInfo("vs", txt)
+                  if self.sVoc.serveur_lance:
+                     self.co.envoi("vs","ac","{}".format(self.co.ipServeurVoc))
+                     self.estServeurVoc = True
+                     self.majStatut()
+                  else:
+                     self.ajoutInfo("vs", "Erreur - Creation du serveur vocal annulee") 
+               else:
+                  self.ajoutInfo("vs", "Veuillez entrer une adresse ip valide")
+        else:
+            self.fermerServeurVoc()
+            
+
+    def fermerServeurVoc(self):
+        """ferme le serveur vocal"""
+        txt = self.sVoc.stop()
+        self.ajoutInfo("vs", txt)
+        if not self.sVoc.serveur_lance:
+            self.co.envoi("vf","ac","")
+            self.estServeurVoc = False
+            self.majStatut()
+        
+    def chatVoc(self):
+        """connexion au chat vocal"""
+        if not self.estClientVoc:
+             if len(self.co.ipServeurVoc) == 0:
+                if QMessageBox.question(self.parent(), "Chat Vocal", "Aucun serveur vocal ne semble avoir ete cree, /nVoulez-vous en creer un?",
+                                        QMessageBox.Yes | QMessageBox.No) == QMessageBox.Yes:
+                    self.creerServeurVoc()
+                    sleep(0.01)
+                    
+             if len(self.co.ipServeurVoc) > 0:
+                  self.cVoc = ClientVoc(self.co.idClient, self.co.ipServeurVoc, 6660)
+                  txt = self.cVoc.creer()
+                  if self.cVoc.connecte:
+                      self.ajoutInfo("vi", txt)
+                      self.co.envoi("vi","ac","")
+                      self.estClientVoc = True
+                      self.majStatut()
+                  
+        else:
+            self.quitterChatVoc()
+
+    def quitterChatVoc(self):
+        """deconnexion du chat vocal"""
+        if self.estClientVoc:
+            txt = self.cVoc.stop()
+            self.ajoutInfo("vq", txt)
+            self.co.envoi("vq","ac","")
+            self.estClientVoc = False
+            self.majStatut()
+        if self.sVoc.serveur_lance:
+            self.fermerServeurVoc()
+        
+
+    def creerPlateau(self, x, y):
+        """Creation du Plateau de combat"""
+        if x > 0 and y > 0 and x == int(x) and y == int(y):
+            self.plateau = QGraphicsScene(self)
+            self.cCase = 30
+            self.plateau.setSceneRect(0, 0, self.cCase*x, self.cCase*y)
+
+            pinceau = QPen()
+            pinceau.setColor(QColor(85, 85, 85, 85))
+            pinceau.setWidth(1)
+            i = 0
+            j = 0
+            for i in range(x):
+                for j in range(y):
+                    if 1 == (i % 2):
+                        j += 0.5
+                    polygon = QPolygonF()
+                    polygon << QPointF(i*self.cCase,(j+0.5)*self.cCase) << QPointF((i+0.34)*self.cCase,j*self.cCase)<< QPointF((i+1)*self.cCase,(j)*self.cCase) << QPointF((i+1.34)*self.cCase,(j+0.5)*self.cCase) << QPointF((i+1)*self.cCase,(j+1)*self.cCase) << QPointF((i+0.34)*self.cCase,(j+1)*self.cCase)
+                    self.plateau.addPolygon(polygon)
+                 
+            self.ui.vuePlateau.setScene(self.plateau)
+
+
+    def nouveauPion(self):
+        """essai de creation graphique: ajout d'un pion sur le plateau de jeu"""
+        #creation d'un pion
+        pinceau = QPen()
+        pinceau.setColor(QColor(0, 0, 0, 120))
+        pinceau.setWidth(2)
+        self.pion = QGraphicsEllipseItem(0, 0, self.cCase, self.cCase)
+        self.pion.setPen(pinceau)
+        self.pion.setFlag(QGraphicsItem.ItemIsMovable)
+        self.pion.setFlag(QGraphicsItem.ItemIsFocusable)
+        self.pion.setBrush(QColor(255, 0, 0, 150))
+
+        #ombre
+        self.shadow = QGraphicsDropShadowEffect() 
+        self.shadow.setColor(QColor(50, 50, 50, 200)) 
+        self.shadow.setXOffset(1) 
+        self.shadow.setYOffset(1) 
+        self.shadow.setBlurRadius(3) 
+        self.pion.setGraphicsEffect(self.shadow)
+        self.shadow.setEnabled(True)
+
+        self.plateau.addItem(self.pion)
+
+    def closeEvent(self, event):
+        """sur fermeture de la fenetre"""
+        if self.estClientVoc:
+            self.cVoc.stop()
+        if self.estServeurVoc:
+            self.sVoc.stop()
+        self.co.fermer()
+        sleep(0.01)
+        self.connecte = False    
+        self.close()             
+        
+if __name__ == "__main__":
+    demarrageOk = True
+    #repertoire de travail et creation des dossiers necessaires:
+    try:
+       repCourant = os.getcwd()
+    except:
+       repCourant = ""
+       
+    if not len(repCourant) > 0:
+        logProg.error("Impossible de determiner le repertoire courant")
+        demarrageOk = False
+    else:
+        try:
+            #repertoire media (musiques+images)
+            if not os.path.exists(repCourant+"\\media"):
+               os.mkdir(repCourant+"\\media")
+            #repertoire utilisateur (sauvegardes)
+            if not os.path.exists(repCourant+"\\svg"):
+               os.mkdir(repCourant+"\\svg")
+            #repertoire reception des fichiers persos
+            if not os.path.exists(repCourant+"\\FichiersRecus"):
+               os.mkdir(repCourant+"\\FichiersRecus")
+        except:
+            logProg.error("Erreur de creation des repertoires de l'application")
+            demarrageOk = False         
+                 
+    #verif si l'appli est deja lancee:    
+    nomAppli = "DMonde.exe"
+    compte = 0
+    for proc in process_iter():    #from psutil
+        try:
+            nomProc = proc.name()
+            if nomProc == nomAppli:
+                compte += 1
+            if compte > 1:
+                demarrageOk = False
+                logProg.error("Une instance de l'application est deja en cours d'execution")
+                break
+        except:
+            pass
+        
+    if demarrageOk: 
+    #lancement de l'appli    
+        app = QApplication(argv)  #'argv' vient de 'sys'
+        connexion = EcranConnexion()    
+        connexion.show()
+        r = app.exec_()
+        if r == 0 and connexion.client_connecte:
+            #si pas d'erreur et client connecte, on ouvre l'interface principale
+            ecranPrincipal = EcranPrincipal(connexion)
+            ecranPrincipal.show()
+            r = app.exec_()
+            exit(r)   #'exit' vient de 'sys'
+        
+
+    
+
+
+    
+    
+    

interface_qt8_2/a faire.txt

@@ -0,0 +1,88 @@
+mettre en place un limitateur de débit en émission
+
+améliorer la gestion des erreurs en général
+A Faire:
+
+reprendre le fonctionnement du chat vocal:
+    - fermeture du serveur/chat vocal fait tout planter
+
+reprendre le fonctionnement de l'échange des fichiers
+    - encore problèmes unicodes (???)
+
+créer un install propre
+
+mettre en place un thread de demande de réponse du client au serveur?
+
+echange fichier : si erreur d'envoi, modifier affichage de la ligne
+
+plateau de jeu:
+  - créer l'objet case, avec les infos (coordonnées terrain...)
+  - créer l'objet pion: il doit se recentrer sur la case sur laquelle est son centre aprés avoir été deplacé
+
+préparer l'interface de combat (cf: maquette_plateauCombat.doc)
+
+----
+
+
+fait le 01/07
+
+chat privé: mettre en place les modes d'échanges via serveur
+            gérer l'ouverture lors de la réception d'un message
+            fermer correctement ces fenetres à la fermeture de l'appli
+
+creation d'une vue graphique avec qt (quadrillage+pion grossier)
+
+mise à jour des infos serveur
+
+
+
+fait le 30/06
+
+serveur et chat vocal derrière un seul bouton
+ajout des layouts dans qtcreator
+creation de la boite à onglets contenant les infos de co, la liste des joueurs, et l'echange de fichiers
+début de création d'un chat privé (interface, mise en place des fonctions de base)
+
+
+
+fait 27 et 28/06/2014
+
+prog regis mis à jour
+
+verifier validité dossier reception
+
+corriger la fonction inserImgChat
+
+image qui s'ouvre n'est pas l'image recue
+
+echange fichier -  rapidité ok
+                -  afficher % de réception 
+                -  trier la liste par ordre décroissant	(remplacé par un scroll automatique)
+                -  si erreur reception, prévenir emetteur
+                -  possible conflit en cas d'annulation, lors de la suppression du fichier
+
+
+
+fait le 28/04:
+
+  - permettre d'ouvrir les fichiers directement depuis la liste (uniquement en reception pour l'instant)
+
+  - retours a la ligne et hauteur automatique dans listes
+
+  - serveur fonctionne avec une liste tampon, traitement des données 'centralisé'
+
+  - tentatives de donnexion au serveur
+
+  - insérer des images dans le chat
+
+  - permettre de se reconnecter sans avoir a fermer la fenetre du chat (en cas de deco du serveur)
+
+  - annuler les envois/reception en cas d'erreur ou de deconnexion du serveur ou du client
+
+le 0205:
+
+  - controler si une instance de l'appli est deja lancee
+
+  - créer un setup propre (en partie)
+
+  - fichiers .log pour le deboguage

interface_qt8_2/anason.py

@@ -0,0 +1,206 @@
+# -*-coding:Latin-1 -*
+"""Analyse du micro et stockage des parametres pour le chat vocal"""
+import audioop
+import time
+from math import fabs
+import cPickle as pickle #lecture/ecriture d'objets dans un fichier
+
+#modules complémentaires
+import pymedia.audio.sound as sound
+
+
+class AnaSon():
+    """analyse et stocke les parametres d'entree du son (version pymedia)"""
+    def __init__(self):
+        """initialisation des parametres par defauts"""
+        #puissance moyenne du son en silence
+        self.pMoy_silence = 1800
+        #ecarts liees aux parasites
+        self.ecartSilence = 500
+        #puissance moyenne du son en parlant
+        self.pMoy_parle = 16000
+        #coeff de puissance
+        self.coeffP = 1.00
+        #puissance de reference
+        self.pRef = 20000
+        #forme d'onde (liste des puissances) en silence et en parlant
+        self.formeS = []
+        self.formeP = []
+        #duree des tests
+        self.duree = 5
+        #peripheriques par defaut:
+        self.IDmicro = 0
+
+        #pour le traitement du son:
+        self.compte = 0
+
+        #affiche des infos
+        self.affichage = True
+        
+        #fichier de sauvegarde
+        self.fichier = "param_micro"
+        self.ecoute = False
+
+        #pour enregistrement de la reception
+        #self.enregistrement = open( "ResultatAnalyse.mp3", 'wb' )
+
+    def recup(self):
+        """recupere si possible les parametres enregistres"""
+        try:
+             with open(self.fichier, 'rb') as f:
+                 tmp = pickle.load(f)
+             f.close()
+             print("Parametres récupérés")
+        except IOError:
+            tmp = self
+            print("Pas de parametres enregistres, parametres par defaut utilises")
+        return tmp
+        
+    def sauver(self):
+        """sauvegarde les parametres analyses"""
+        with open(self.fichier, 'wb') as f:
+           pickle.dump(self, f, -1)
+        f.close()
+        print("Parametres sauvegardes.")
+
+    def analyser(self):
+        """lance l'analyse du son"""
+        print("\n*** Analyse du micro ***\n")
+        
+        #phase 1: quel micro?
+        print(sound.getIDevices())
+        self.IDmicro = input("\nMicro par defaut? (id) > ")
+        micro = sound.Input( 16000, 1, sound.AFMT_S16_LE, self.IDmicro )
+        micro.start()
+        sortie = sound.Output( 16000, 1, sound.AFMT_S16_LE )
+        enregistrement = open( "ResultatsAnaSon.mp3", 'wb' )
+        
+        # phase 2 : parasites
+        #liste des donnees recues au cours de l'analyse
+        frames_test = []
+        
+        #boucle de reception
+        print("Test des parasites: ne parlez pas (env. {} sec)\n".format(self.duree+1))
+        pause = raw_input("Appuyez sur Entree pour lancer: \n")
+        t0 = time.time()
+        while time.time() - t0 < self.duree:
+           son = micro.getData()
+           if son and len(son):
+              frames_test.append(son)
+              #audioop.rms renvoie la puissance moyenne du son
+              self.formeS.append(audioop.rms(son,2))
+        #on enleve la premiere valeur qui n'est generalement pas representative:
+        del frames_test[0]
+        del self.formeS[0]
+        print("{}\n".format(self.formeS)) 
+        
+        #donnees utilisees pour l'attenuation du son lors des silences:
+        self.pMoy_silence = audioop.rms(b''.join(frames_test),2)
+        self.ecartMax = 0
+        
+        ecart_mesure = 0
+        for son in frames_test:
+            if fabs(audioop.rms(son,2) - self.pMoy_silence) > ecart_mesure:
+                ecart_mesure = fabs(audioop.rms(son,2) - self.pMoy_silence)
+        if ecart_mesure > 10:
+            self.ecartSilence = ecart_mesure
+            
+        # phase 3 : parle
+        frames_test = []
+        print("Test de la voix: parlez normalement (env. {} sec)\n ".format(self.duree+1))
+        pause = raw_input("Appuyez sur Entree pour lancer: \n")
+        t0 = time.time()
+        while time.time() - t0 < self.duree:
+           son = micro.getData()
+           if son and len(son):
+              self.formeP.append(audioop.rms(son,2))
+              if audioop.rms(son,2) > (self.pMoy_silence + self.ecartSilence):
+                 frames_test.append(son)                 
+
+        #on enleve la premiere valeur qui n'est generalement pas representative:
+        del self.formeP[0]
+        print("{}\n".format(self.formeP))
+        
+        if len(frames_test)>0:
+           del frames_test[0]        
+           self.pMoy_parle = audioop.rms(b''.join(frames_test),2) 
+           #mise a jour du coeff de puissance:
+           if self.pMoy_parle != 0:        
+              self.coeffP = self.pRef / self.pMoy_parle
+              if self.coeffP < 0.2:
+                  self.coeffP = 0.20
+              elif self.coeffP > 4:
+                  self.coeffP = 4.00
+        else:
+            print("\n (!) Erreur: la puissance de la voix est insuffisante pour etre detectee")
+        print("\n*** Fin de l'analyse ***\n")
+        micro.stop()
+        enregistrement.close()
+
+        self.sauver() 
+
+    def traitement(self, data):
+        """renvoie la donnee sonore traitee selon les parametres utilises"""
+        #est-on dans la 'zone de silence'?
+        kS = 1
+        retour = None
+        seuil_iterations = 3
+        if audioop.rms(data,2) <= self.pMoy_silence + self.ecartSilence:
+              #on ne diminue la puissance du son qu'apres un certain nombre d'iterations (4 ici)
+              self.compte += 1
+              if self.compte > seuil_iterations:
+                  if self.affichage and self.compte == seuil_iterations + 1:
+                      print("\n-> silence")
+                  kS = 0.2    
+        else:
+              if self.affichage and self.compte != 0:
+                  print("\n-> parle")
+              self.compte = 0
+              #retour = audioop.mul(data, 2, (self.coeffP))  
+              kS = 1
+        retour = audioop.mul(data, 2, (kS * self.coeffP))        
+        return retour                
+     
+    def ecouterMicro(self):
+        """ecouter son micro"""
+        micro = sound.Input( 16000, 1, sound.AFMT_S16_LE, self.IDmicro )
+        micro.start()
+        sortie = sound.Output( 16000, 1, sound.AFMT_S16_LE )
+
+        t0 = time.time()
+        #while time.time() - t0 < self.duree:
+        while True:
+            son = micro.getData()
+            if son and len(son):
+              son_traite = self.traitement(son)
+              #print("{} - {}".format(audioop.rms(son,2), audioop.rms(son_traite,2)))
+              sortie.play(son_traite)
+              
+        micro.stop()
+        
+    def __repr__(self):
+        """affiche les parametres utilises"""
+        chaine = "\n*** Parametres utilises ***\n"\
+                 "\n    Puissance moyenne en silence: {} "\
+                 "\n    Amplitude parasites: {} "\
+                 "\n    Puissance moyenne en parlant: {} "\
+                 "\n    Multiplicateur applique: {} "\
+                 "".format(self.pMoy_silence, self.ecartSilence, self.pMoy_parle, self.coeffP)     
+        return chaine  
+
+
+
+######### si lancement direct ########
+if __name__ == "__main__":
+   a = AnaSon()
+   a.analyser()
+   #a = None
+   #a = AnaSon()
+   #a = a.recup()
+   print(a)
+   #a.ecouterMicro()
+   #a.analyser()
+   pause = raw_input("appuyez sur entree")
+   
+
+

interface_qt8_2/chatVoc.log

@@ -0,0 +1,162 @@
+[2014-07-05 13:50:00,007] DEBUG -     ----------------------    
+
+[2014-07-05 13:51:50,026] DEBUG -     ----------------------    
+
+[2014-07-05 14:08:48,171] DEBUG -     ----------------------    
+
+[2014-07-05 14:16:14,937] DEBUG -     ----------------------    
+
+[2014-07-05 14:17:50,112] DEBUG -     ----------------------    
+
+[2014-07-05 14:18:25,431] DEBUG -     ----------------------    
+
+[2014-07-05 14:47:23,293] DEBUG -     ----------------------    
+
+[2014-07-05 15:02:40,694] DEBUG -     ----------------------    
+
+[2014-07-05 15:04:39,785] DEBUG -     ----------------------    
+
+[2014-07-05 15:05:43,401] DEBUG -     ----------------------    
+
+[2014-07-05 15:06:40,233] DEBUG -     ----------------------    
+
+[2014-07-05 15:07:21,901] DEBUG -     ----------------------    
+
+[2014-07-05 15:07:39,404] DEBUG -     ----------------------    
+
+[2014-07-05 15:09:36,342] DEBUG -     ----------------------    
+
+[2014-07-05 15:10:55,638] DEBUG -     ----------------------    
+
+[2014-07-05 15:12:45,711] DEBUG -     ----------------------    
+
+[2014-07-05 15:24:49,164] DEBUG -     ----------------------    
+
+[2014-07-05 15:26:18,351] DEBUG -     ----------------------    
+
+[2014-07-05 15:27:27,927] DEBUG -     ----------------------    
+
+[2014-07-05 15:30:54,081] DEBUG -     ----------------------    
+
+[2014-07-05 15:31:58,805] DEBUG -     ----------------------    
+
+[2014-07-07 16:32:13,309] DEBUG -     ----------------------    
+
+[2014-07-07 16:36:34,032] DEBUG -     ----------------------    
+
+[2014-07-07 16:38:17,148] DEBUG -     ----------------------    
+
+[2014-07-07 16:39:47,753] DEBUG -     ----------------------    
+
+[2014-07-07 16:40:52,012] DEBUG -     ----------------------    
+
+[2014-07-07 16:41:59,371] DEBUG -     ----------------------    
+
+[2014-07-07 16:42:22,772] DEBUG -     ----------------------    
+
+[2014-07-07 16:50:19,072] DEBUG -     ----------------------    
+
+[2014-07-07 16:56:12,111] DEBUG -     ----------------------    
+
+[2014-07-07 17:03:24,565] DEBUG -     ----------------------    
+
+[2014-07-07 17:04:59,351] DEBUG -     ----------------------    
+
+[2014-07-07 17:05:32,549] DEBUG -     ----------------------    
+
+[2014-07-07 17:05:52,595] DEBUG -     ----------------------    
+
+[2014-07-07 17:06:30,424] DEBUG -     ----------------------    
+
+[2014-07-07 17:07:42,730] DEBUG -     ----------------------    
+
+[2014-07-07 17:07:47,910] DEBUG -     ----------------------    
+
+[2014-07-07 17:08:33,588] DEBUG -     ----------------------    
+
+[2014-07-07 17:08:54,789] DEBUG -     ----------------------    
+
+[2014-07-07 17:09:17,142] DEBUG -     ----------------------    
+
+[2014-07-07 17:10:36,355] DEBUG -     ----------------------    
+
+[2014-07-07 17:10:52,976] DEBUG -     ----------------------    
+
+[2014-07-07 17:14:57,108] DEBUG -     ----------------------    
+
+[2014-07-07 17:34:22,923] DEBUG -     ----------------------    
+
+[2014-07-07 17:35:32,171] DEBUG -     ----------------------    
+
+[2014-07-07 17:35:58,240] DEBUG -     ----------------------    
+
+[2014-07-07 17:38:04,053] DEBUG -     ----------------------    
+
+[2014-07-07 17:43:24,693] DEBUG -     ----------------------    
+
+[2014-07-07 17:48:36,408] DEBUG -     ----------------------    
+
+[2014-07-07 17:53:40,812] DEBUG -     ----------------------    
+
+[2014-07-07 17:56:57,667] DEBUG -     ----------------------    
+
+[2014-07-07 17:57:17,262] DEBUG -     ----------------------    
+
+[2014-07-07 17:58:03,546] DEBUG -     ----------------------    
+
+[2014-07-07 18:00:48,377] DEBUG -     ----------------------    
+
+[2014-07-07 18:01:10,013] DEBUG -     ----------------------    
+
+[2014-07-07 18:01:43,118] DEBUG -     ----------------------    
+
+[2014-07-07 18:16:34,519] DEBUG -     ----------------------    
+
+[2014-07-07 18:16:56,141] DEBUG -     ----------------------    
+
+[2014-07-07 18:21:35,335] DEBUG -     ----------------------    
+
+[2014-07-07 18:22:39,763] DEBUG -     ----------------------    
+
+[2014-07-07 18:26:07,835] DEBUG -     ----------------------    
+
+[2014-07-07 18:26:59,440] DEBUG -     ----------------------    
+
+[2014-07-07 18:28:08,938] DEBUG -     ----------------------    
+
+[2014-07-07 18:29:10,778] DEBUG -     ----------------------    
+
+[2014-07-07 18:30:58,855] DEBUG -     ----------------------    
+
+[2014-07-07 18:31:50,085] DEBUG -     ----------------------    
+
+[2014-07-07 18:34:12,187] DEBUG -     ----------------------    
+
+[2014-07-07 18:35:06,895] DEBUG -     ----------------------    
+
+[2014-07-07 18:38:35,171] DEBUG -     ----------------------    
+
+[2014-07-07 18:39:01,145] DEBUG -     ----------------------    
+
+[2014-07-07 18:40:08,132] DEBUG -     ----------------------    
+
+[2014-07-07 18:55:32,247] DEBUG -     ----------------------    
+
+[2014-07-07 23:40:21,607] DEBUG -     ----------------------    
+
+[2014-07-07 23:40:50,233] DEBUG -     ----------------------    
+
+[2014-07-08 09:43:10,864] DEBUG -     ----------------------    
+
+[2014-07-08 09:44:09,434] DEBUG -     ----------------------    
+
+[2014-07-08 09:44:38,992] DEBUG -     ----------------------    
+
+[2014-07-15 10:14:30,279] DEBUG -     ----------------------    
+
+[2014-07-15 10:32:05,559] DEBUG -     ----------------------    
+
+[2014-07-25 12:53:28,052] DEBUG -     ----------------------    
+
+[2015-05-04 11:06:00,440] DEBUG -     ----------------------    
+

interface_qt8_2/chatprive.ui

@@ -0,0 +1,95 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>chatPrive</class>
+ <widget class="QWidget" name="chatPrive">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>334</width>
+    <height>395</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Chat privé</string>
+  </property>
+  <widget class="QListWidget" name="lstChatPrive">
+   <property name="geometry">
+    <rect>
+     <x>20</x>
+     <y>30</y>
+     <width>291</width>
+     <height>281</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QLineEdit" name="inSaisieChatPrive">
+   <property name="geometry">
+    <rect>
+     <x>20</x>
+     <y>320</y>
+     <width>291</width>
+     <height>20</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QLineEdit" name="inDesChatPrive">
+   <property name="geometry">
+    <rect>
+     <x>170</x>
+     <y>360</y>
+     <width>141</width>
+     <height>20</height>
+    </rect>
+   </property>
+  </widget>
+  <widget class="QLabel" name="label">
+   <property name="geometry">
+    <rect>
+     <x>170</x>
+     <y>340</y>
+     <width>101</width>
+     <height>20</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Jeter les dés : </string>
+   </property>
+  </widget>
+  <widget class="QPushButton" name="envoiFichierChatPrive">
+   <property name="geometry">
+    <rect>
+     <x>20</x>
+     <y>350</y>
+     <width>121</width>
+     <height>31</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Envoyer un fichier</string>
+   </property>
+  </widget>
+  <widget class="QLabel" name="lblInterlocChatPrive">
+   <property name="geometry">
+    <rect>
+     <x>20</x>
+     <y>10</y>
+     <width>291</width>
+     <height>20</height>
+    </rect>
+   </property>
+   <property name="font">
+    <font>
+     <pointsize>10</pointsize>
+     <weight>75</weight>
+     <bold>true</bold>
+    </font>
+   </property>
+   <property name="text">
+    <string>Interloc</string>
+   </property>
+  </widget>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

interface_qt8_2/clientvoc.py

@@ -0,0 +1,185 @@
+# -*-coding:Latin-1 -*
+"""fonction client du chat vocal (protocole UDP)"""
+from socket import socket, AF_INET, SOCK_DGRAM
+from time import sleep
+from threading import Thread
+from os import system
+import logging
+
+#modules complémentaires
+import pymedia.audio.sound as sound
+import pymedia.audio.acodec as acodec
+from pyaudio import PyAudio, paInt16
+
+#modules perso
+from anason import AnaSon
+from lecture import Lecture
+
+#gestion des erreurs et log
+logging.basicConfig(level=logging.DEBUG)
+logCVoc = logging.getLogger(__name__)
+handlerCVoc = logging.FileHandler('chatVoc.log')
+handlerCVoc.setFormatter(logging.Formatter('[%(asctime)s] %(levelname)s - %(message)s'))  #%(name)s - nom du module
+logCVoc.addHandler(handlerCVoc)
+logCVoc.debug("    ----------------------    \n")
+
+port = 6660
+frequence = 22050
+#param d'encodage/decodage
+cparams= { 'id': acodec.getCodecID( 'mp3' ),
+           'bitrate': 32000,
+           'sample_rate': frequence,
+           'channels': 1 }
+taille_paquets = 1024
+debug = False
+
+######### Fils secondaires #########
+
+class ReceptionVoc(Thread):
+    """fil gerant la reception du son"""
+    def __init__(self, cnn):
+        """création du fil reception"""
+        self.connecte = True
+        Thread.__init__(self)
+        self.cnn = cnn
+        self.essais = 0
+        self.connectes = {}
+        
+    def run(self):
+        """reception: tourne en boucle tant que la connexion est active"""
+        while self.connecte:
+            try:
+                fr, adresse = self.cnn.recvfrom(taille_paquets)
+                #print("recu {}".format(len(fr)))
+
+                #les 2 premiers caracteres sont le pseudo de l'expediteur   
+                expediteur = fr[:2]
+                donnee = fr[2:]
+                if not expediteur in self.connectes.keys():
+                    #nouveau connecte
+                    try:
+                       fil = Lecture(expediteur, cparams, debug)
+                       fil.start()
+                       self.connectes[expediteur] = fil
+                       logCVoc.info("\n -> Connecte a {}".format(expediteur))
+                    except KeyboardInterrupt:
+                       logCVoc.error("{} - Erreur de reception".format(expediteur))
+                else: 
+                   if donnee:       
+                      self.connectes[expediteur].lire(donnee)
+                
+                self.essais = 0
+            except IOError, e: 
+               if e.errno == 10022:    
+                   sleep(0.001)
+                   self.essais += 1
+                   if self.essais == 1000:
+                      logCVoc.warning("pas de reception")
+                      self.essais = 0
+                      
+    def stop(self):
+        """Fermeture du fil Reception"""
+        logCVoc.info("\nChat vocal : Reception interrompue")
+        for fil in self.connectes.values():
+            fil.stop()
+        self.connecte = False
+        self.cnn.close()
+        
+        
+#fin du fil reception   
+
+#objet client:
+class ClientVoc(Thread):
+    """client pour le chat vocal"""
+    def __init__(self, idClient, ipServeur, port):
+        """création du client"""
+        Thread.__init__(self)
+        self.idClient = idClient
+        self.ipServeur = ipServeur
+        self.port = 6660
+        
+        ###parametrage du socket udp###
+        self.cnn = socket(AF_INET, SOCK_DGRAM)
+        self.connecte = False
+
+        #flux microphone:
+        self.stream = PyAudio().open(format = paInt16,    
+                                     channels = 1,
+                                     rate = frequence,
+                                     input = True,
+                                     frames_per_buffer = 1024)
+        #encodage:
+        self.ac = acodec.Encoder( cparams )
+        
+        #traitement du son?
+        self.traitement = False
+        if self.traitement:
+            #parametres de traitement du son:
+            self.ana = AnaSon()
+            #on recupere les parametres enregistres si possible
+            self.ana = self.ana.recup()
+        
+    def creer(self):
+        """demarre une instance client pour le chat vocal"""
+        if len(self.idClient) == 2 and len(self.ipServeur) > 0 :
+            self.thR = ReceptionVoc(self.cnn)
+            self.thR.start()
+            self.connecte = True
+            self.start()
+            txt = "Chat vocal demarre"
+            logCVoc.info(txt)
+        else:
+            txt = "Chat vocal : erreur dans les parametres d'entree"
+            logCVoc.error(txt)  
+        return txt 
+
+    def run(self):
+       """emission: tourne en boucle tant que la connexion est active"""
+       #on affiche les parametres du micro
+       if self.traitement:
+          logCVoc.info(self.ana)
+          
+       while self.connecte:
+              #son = micro.getData()
+              son = self.stream.read(1024)
+              if son and len(son):
+                  if self.traitement:
+                     son = self.ana.traitement(son)
+                      
+                  if son:
+                     son_encode = self.ac.encode(son)
+                
+                     for fr in son_encode:
+                         if len(fr) < (taille_paquets - 2):
+                             #on ajoute l'id du client au debut du paquet
+                             envoi = self.idClient + fr
+                             #print("envoi {}".format(len(fr)))
+                             self.cnn.sendto(envoi, (self.ipServeur, port))
+                         else:
+                             logCVoc.warning("1 paquet trop volumineux")
+              else:
+                  #si pas de son, on attend un peu
+                  sleep(0.003)
+
+    def stop(self):
+        """quitte la session de chat"""
+        if self.connecte:
+            self.thR.stop()
+        self.stream.close()
+        self.cnn.close()
+        txt = "Fermeture du chat vocal"
+        logCVoc.info(txt)
+
+        return txt
+            
+### fil principal ###
+if __name__ == "__main__":
+   # si lancement direct:
+   idClient = raw_input("id client (2car)")
+   c = ClientVoc(idClient, "localhost", 6660)
+   c.creer()
+   system("pause")
+   c.stop()
+
+
+

interface_qt8_2/connexion.ui

@@ -0,0 +1,172 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>ecranConnexion</class>
+ <widget class="QGroupBox" name="ecranConnexion">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>409</width>
+    <height>215</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>D-Monde</string>
+  </property>
+  <property name="title">
+   <string>Ecran de connexion</string>
+  </property>
+  <widget class="QPushButton" name="creerServeur">
+   <property name="geometry">
+    <rect>
+     <x>240</x>
+     <y>40</y>
+     <width>141</width>
+     <height>31</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Créer un serveur</string>
+   </property>
+   <property name="autoDefault">
+    <bool>false</bool>
+   </property>
+  </widget>
+  <widget class="QPushButton" name="seConnecter">
+   <property name="geometry">
+    <rect>
+     <x>240</x>
+     <y>80</y>
+     <width>141</width>
+     <height>31</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Se connecter</string>
+   </property>
+  </widget>
+  <widget class="QLineEdit" name="in_ip">
+   <property name="geometry">
+    <rect>
+     <x>20</x>
+     <y>90</y>
+     <width>151</width>
+     <height>20</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string/>
+   </property>
+   <property name="maxLength">
+    <number>15</number>
+   </property>
+  </widget>
+  <widget class="QLineEdit" name="in_port">
+   <property name="geometry">
+    <rect>
+     <x>20</x>
+     <y>140</y>
+     <width>151</width>
+     <height>20</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>6660</string>
+   </property>
+   <property name="maxLength">
+    <number>5</number>
+   </property>
+  </widget>
+  <widget class="QPushButton" name="fermer">
+   <property name="geometry">
+    <rect>
+     <x>240</x>
+     <y>140</y>
+     <width>141</width>
+     <height>21</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Fermer</string>
+   </property>
+  </widget>
+  <widget class="QLineEdit" name="in_pseudo">
+   <property name="geometry">
+    <rect>
+     <x>20</x>
+     <y>40</y>
+     <width>151</width>
+     <height>20</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string/>
+   </property>
+   <property name="maxLength">
+    <number>15</number>
+   </property>
+  </widget>
+  <widget class="QLabel" name="label_ip">
+   <property name="geometry">
+    <rect>
+     <x>20</x>
+     <y>70</y>
+     <width>111</width>
+     <height>16</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Adresse ip du serveur :</string>
+   </property>
+  </widget>
+  <widget class="QLabel" name="label_port">
+   <property name="geometry">
+    <rect>
+     <x>20</x>
+     <y>120</y>
+     <width>111</width>
+     <height>16</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Port :</string>
+   </property>
+  </widget>
+  <widget class="QLabel" name="label_pseudo">
+   <property name="geometry">
+    <rect>
+     <x>20</x>
+     <y>20</y>
+     <width>111</width>
+     <height>16</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Votre pseudo :</string>
+   </property>
+  </widget>
+  <widget class="QLabel" name="txt_msg">
+   <property name="geometry">
+    <rect>
+     <x>20</x>
+     <y>180</y>
+     <width>361</width>
+     <height>20</height>
+    </rect>
+   </property>
+   <property name="font">
+    <font>
+     <family>Arial Rounded MT Bold</family>
+    </font>
+   </property>
+   <property name="text">
+    <string/>
+   </property>
+   <property name="alignment">
+    <set>Qt::AlignCenter</set>
+   </property>
+  </widget>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

interface_qt8_2/convert.cmd

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

interface_qt8_2/ecran_chatPrive.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'chatPrive.ui'
+#
+# Created: Mon Jun 30 17:51:04 2014
+#      by: PyQt4 UI code generator 4.10.4
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt4 import QtCore, QtGui
+
+try:
+    _fromUtf8 = QtCore.QString.fromUtf8
+except AttributeError:
+    def _fromUtf8(s):
+        return s
+
+try:
+    _encoding = QtGui.QApplication.UnicodeUTF8
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig, _encoding)
+except AttributeError:
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig)
+
+class Ui_chatPrive(object):
+    def setupUi(self, chatPrive):
+        chatPrive.setObjectName(_fromUtf8("chatPrive"))
+        chatPrive.resize(334, 395)
+        self.lstChatPrive = QtGui.QListWidget(chatPrive)
+        self.lstChatPrive.setGeometry(QtCore.QRect(20, 30, 291, 281))
+        self.lstChatPrive.setObjectName(_fromUtf8("lstChatPrive"))
+        self.inSaisieChatPrive = QtGui.QLineEdit(chatPrive)
+        self.inSaisieChatPrive.setGeometry(QtCore.QRect(20, 320, 291, 20))
+        self.inSaisieChatPrive.setObjectName(_fromUtf8("inSaisieChatPrive"))
+        self.inDesChatPrive = QtGui.QLineEdit(chatPrive)
+        self.inDesChatPrive.setGeometry(QtCore.QRect(170, 360, 141, 20))
+        self.inDesChatPrive.setObjectName(_fromUtf8("inDesChatPrive"))
+        self.label = QtGui.QLabel(chatPrive)
+        self.label.setGeometry(QtCore.QRect(170, 340, 101, 20))
+        self.label.setObjectName(_fromUtf8("label"))
+        self.envoiFichierChatPrive = QtGui.QPushButton(chatPrive)
+        self.envoiFichierChatPrive.setGeometry(QtCore.QRect(20, 350, 121, 31))
+        self.envoiFichierChatPrive.setObjectName(_fromUtf8("envoiFichierChatPrive"))
+        self.lblInterlocChatPrive = QtGui.QLabel(chatPrive)
+        self.lblInterlocChatPrive.setGeometry(QtCore.QRect(20, 10, 291, 20))
+        font = QtGui.QFont()
+        font.setPointSize(10)
+        font.setBold(True)
+        font.setWeight(75)
+        self.lblInterlocChatPrive.setFont(font)
+        self.lblInterlocChatPrive.setObjectName(_fromUtf8("lblInterlocChatPrive"))
+
+        self.retranslateUi(chatPrive)
+        QtCore.QMetaObject.connectSlotsByName(chatPrive)
+
+    def retranslateUi(self, chatPrive):
+        chatPrive.setWindowTitle(_translate("chatPrive", "Chat privé", None))
+        self.label.setText(_translate("chatPrive", "Jeter les dés : ", None))
+        self.envoiFichierChatPrive.setText(_translate("chatPrive", "Envoyer un fichier", None))
+        self.lblInterlocChatPrive.setText(_translate("chatPrive", "Interloc", None))
+
+
+if __name__ == "__main__":
+    import sys
+    app = QtGui.QApplication(sys.argv)
+    chatPrive = QtGui.QWidget()
+    ui = Ui_chatPrive()
+    ui.setupUi(chatPrive)
+    chatPrive.show()
+    sys.exit(app.exec_())
+

interface_qt8_2/ecran_connexion.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'connexion.ui'
+#
+# Created: Sat Mar 29 14:45:54 2014
+#      by: PyQt4 UI code generator 4.10.4
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt4 import QtCore, QtGui
+
+try:
+    _fromUtf8 = QtCore.QString.fromUtf8
+except AttributeError:
+    def _fromUtf8(s):
+        return s
+
+try:
+    _encoding = QtGui.QApplication.UnicodeUTF8
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig, _encoding)
+except AttributeError:
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig)
+
+class Ui_ecranConnexion(object):
+    def setupUi(self, ecranConnexion):
+        ecranConnexion.setObjectName(_fromUtf8("ecranConnexion"))
+        ecranConnexion.resize(409, 215)
+        self.creerServeur = QtGui.QPushButton(ecranConnexion)
+        self.creerServeur.setGeometry(QtCore.QRect(240, 40, 141, 31))
+        self.creerServeur.setAutoDefault(False)
+        self.creerServeur.setObjectName(_fromUtf8("creerServeur"))
+        self.seConnecter = QtGui.QPushButton(ecranConnexion)
+        self.seConnecter.setGeometry(QtCore.QRect(240, 80, 141, 31))
+        self.seConnecter.setObjectName(_fromUtf8("seConnecter"))
+        self.in_ip = QtGui.QLineEdit(ecranConnexion)
+        self.in_ip.setGeometry(QtCore.QRect(20, 90, 151, 20))
+        self.in_ip.setText(_fromUtf8(""))
+        self.in_ip.setMaxLength(15)
+        self.in_ip.setObjectName(_fromUtf8("in_ip"))
+        self.in_port = QtGui.QLineEdit(ecranConnexion)
+        self.in_port.setGeometry(QtCore.QRect(20, 140, 151, 20))
+        self.in_port.setMaxLength(5)
+        self.in_port.setObjectName(_fromUtf8("in_port"))
+        self.fermer = QtGui.QPushButton(ecranConnexion)
+        self.fermer.setGeometry(QtCore.QRect(240, 140, 141, 21))
+        self.fermer.setObjectName(_fromUtf8("fermer"))
+        self.in_pseudo = QtGui.QLineEdit(ecranConnexion)
+        self.in_pseudo.setGeometry(QtCore.QRect(20, 40, 151, 20))
+        self.in_pseudo.setText(_fromUtf8(""))
+        self.in_pseudo.setMaxLength(15)
+        self.in_pseudo.setObjectName(_fromUtf8("in_pseudo"))
+        self.label_ip = QtGui.QLabel(ecranConnexion)
+        self.label_ip.setGeometry(QtCore.QRect(20, 70, 111, 16))
+        self.label_ip.setObjectName(_fromUtf8("label_ip"))
+        self.label_port = QtGui.QLabel(ecranConnexion)
+        self.label_port.setGeometry(QtCore.QRect(20, 120, 111, 16))
+        self.label_port.setObjectName(_fromUtf8("label_port"))
+        self.label_pseudo = QtGui.QLabel(ecranConnexion)
+        self.label_pseudo.setGeometry(QtCore.QRect(20, 20, 111, 16))
+        self.label_pseudo.setObjectName(_fromUtf8("label_pseudo"))
+        self.txt_msg = QtGui.QLabel(ecranConnexion)
+        self.txt_msg.setGeometry(QtCore.QRect(20, 180, 361, 20))
+        font = QtGui.QFont()
+        font.setFamily(_fromUtf8("Arial Rounded MT Bold"))
+        self.txt_msg.setFont(font)
+        self.txt_msg.setText(_fromUtf8(""))
+        self.txt_msg.setAlignment(QtCore.Qt.AlignCenter)
+        self.txt_msg.setObjectName(_fromUtf8("txt_msg"))
+
+        self.retranslateUi(ecranConnexion)
+        QtCore.QMetaObject.connectSlotsByName(ecranConnexion)
+
+    def retranslateUi(self, ecranConnexion):
+        ecranConnexion.setWindowTitle(_translate("ecranConnexion", "D-Monde", None))
+        ecranConnexion.setTitle(_translate("ecranConnexion", "Ecran de connexion", None))
+        self.creerServeur.setText(_translate("ecranConnexion", "Créer un serveur", None))
+        self.seConnecter.setText(_translate("ecranConnexion", "Se connecter", None))
+        self.in_port.setText(_translate("ecranConnexion", "6660", None))
+        self.fermer.setText(_translate("ecranConnexion", "Fermer", None))
+        self.label_ip.setText(_translate("ecranConnexion", "Adresse ip du serveur :", None))
+        self.label_port.setText(_translate("ecranConnexion", "Port :", None))
+        self.label_pseudo.setText(_translate("ecranConnexion", "Votre pseudo :", None))
+
+
+if __name__ == "__main__":
+    import sys
+    app = QtGui.QApplication(sys.argv)
+    ecranConnexion = QtGui.QGroupBox()
+    ui = Ui_ecranConnexion()
+    ui.setupUi(ecranConnexion)
+    ecranConnexion.show()
+    sys.exit(app.exec_())
+

interface_qt8_2/ecran_envoiFichier.py

@@ -0,0 +1,69 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'envoiFichier.ui'
+#
+# Created: Fri Jun 27 14:27:57 2014
+#      by: PyQt4 UI code generator 4.10.4
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt4 import QtCore, QtGui
+
+try:
+    _fromUtf8 = QtCore.QString.fromUtf8
+except AttributeError:
+    def _fromUtf8(s):
+        return s
+
+try:
+    _encoding = QtGui.QApplication.UnicodeUTF8
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig, _encoding)
+except AttributeError:
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig)
+
+class Ui_envoiFichiers(object):
+    def setupUi(self, envoiFichiers):
+        envoiFichiers.setObjectName(_fromUtf8("envoiFichiers"))
+        envoiFichiers.resize(543, 422)
+        self.pushButton = QtGui.QPushButton(envoiFichiers)
+        self.pushButton.setGeometry(QtCore.QRect(180, 30, 151, 31))
+        self.pushButton.setObjectName(_fromUtf8("pushButton"))
+        self.treeWidget = QtGui.QTreeWidget(envoiFichiers)
+        self.treeWidget.setGeometry(QtCore.QRect(20, 80, 501, 281))
+        self.treeWidget.setColumnCount(2)
+        self.treeWidget.setObjectName(_fromUtf8("treeWidget"))
+        item_0 = QtGui.QTreeWidgetItem(self.treeWidget)
+        item_1 = QtGui.QTreeWidgetItem(item_0)
+        item_1 = QtGui.QTreeWidgetItem(item_0)
+        self.pushButton_2 = QtGui.QPushButton(envoiFichiers)
+        self.pushButton_2.setGeometry(QtCore.QRect(350, 370, 151, 21))
+        self.pushButton_2.setObjectName(_fromUtf8("pushButton_2"))
+
+        self.retranslateUi(envoiFichiers)
+        QtCore.QMetaObject.connectSlotsByName(envoiFichiers)
+
+    def retranslateUi(self, envoiFichiers):
+        envoiFichiers.setWindowTitle(_translate("envoiFichiers", "Envoi de fichiers", None))
+        self.pushButton.setText(_translate("envoiFichiers", "Envoyer un fichier", None))
+        self.treeWidget.headerItem().setText(0, _translate("envoiFichiers", "Fichier", None))
+        self.treeWidget.headerItem().setText(1, _translate("envoiFichiers", "Statut", None))
+        __sortingEnabled = self.treeWidget.isSortingEnabled()
+        self.treeWidget.setSortingEnabled(False)
+        self.treeWidget.topLevelItem(0).setText(0, _translate("envoiFichiers", "Nouvel élément", None))
+        self.treeWidget.topLevelItem(0).child(0).setText(0, _translate("envoiFichiers", "Nouveau sous-élément", None))
+        self.treeWidget.topLevelItem(0).child(1).setText(0, _translate("envoiFichiers", "Nouveau sous-élément", None))
+        self.treeWidget.setSortingEnabled(__sortingEnabled)
+        self.pushButton_2.setText(_translate("envoiFichiers", "Annuler l\'envoi", None))
+
+
+if __name__ == "__main__":
+    import sys
+    app = QtGui.QApplication(sys.argv)
+    envoiFichiers = QtGui.QWidget()
+    ui = Ui_envoiFichiers()
+    ui.setupUi(envoiFichiers)
+    envoiFichiers.show()
+    sys.exit(app.exec_())
+

interface_qt8_2/ecran_principal.py

@@ -0,0 +1,437 @@
+# -*- coding: utf-8 -*-
+
+# Form implementation generated from reading ui file 'mainwindow.ui'
+#
+# Created: Tue Jul 01 17:07:29 2014
+#      by: PyQt4 UI code generator 4.10.4
+#
+# WARNING! All changes made in this file will be lost!
+
+from PyQt4 import QtCore, QtGui
+
+try:
+    _fromUtf8 = QtCore.QString.fromUtf8
+except AttributeError:
+    def _fromUtf8(s):
+        return s
+
+try:
+    _encoding = QtGui.QApplication.UnicodeUTF8
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig, _encoding)
+except AttributeError:
+    def _translate(context, text, disambig):
+        return QtGui.QApplication.translate(context, text, disambig)
+
+class Ui_principal(object):
+    def setupUi(self, principal):
+        principal.setObjectName(_fromUtf8("principal"))
+        principal.resize(882, 623)
+        principal.setMinimumSize(QtCore.QSize(882, 623))
+        self.baseWidget = QtGui.QWidget(principal)
+        self.baseWidget.setObjectName(_fromUtf8("baseWidget"))
+        self.horizontalLayout = QtGui.QHBoxLayout(self.baseWidget)
+        self.horizontalLayout.setObjectName(_fromUtf8("horizontalLayout"))
+        self.tabWidget = QtGui.QTabWidget(self.baseWidget)
+        self.tabWidget.setMinimumSize(QtCore.QSize(641, 561))
+        self.tabWidget.setObjectName(_fromUtf8("tabWidget"))
+        self.Combats_tab = QtGui.QWidget()
+        self.Combats_tab.setObjectName(_fromUtf8("Combats_tab"))
+        self.frame_2 = QtGui.QFrame(self.Combats_tab)
+        self.frame_2.setGeometry(QtCore.QRect(0, 0, 71, 531))
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(170, 170, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(170, 0, 0))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(170, 170, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(170, 0, 0))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(170, 170, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(240, 240, 240))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
+        self.frame_2.setPalette(palette)
+        self.frame_2.setFrameShape(QtGui.QFrame.StyledPanel)
+        self.frame_2.setFrameShadow(QtGui.QFrame.Raised)
+        self.frame_2.setObjectName(_fromUtf8("frame_2"))
+        self.newW = QtGui.QPushButton(self.frame_2)
+        self.newW.setGeometry(QtCore.QRect(0, 20, 71, 31))
+        self.newW.setObjectName(_fromUtf8("newW"))
+        self.ligne = QtGui.QPushButton(self.frame_2)
+        self.ligne.setGeometry(QtCore.QRect(0, 50, 71, 31))
+        self.ligne.setObjectName(_fromUtf8("ligne"))
+        self.texte = QtGui.QPushButton(self.frame_2)
+        self.texte.setGeometry(QtCore.QRect(0, 80, 71, 31))
+        self.texte.setObjectName(_fromUtf8("texte"))
+        self.plusJeton = QtGui.QPushButton(self.frame_2)
+        self.plusJeton.setGeometry(QtCore.QRect(0, 370, 31, 31))
+        self.plusJeton.setObjectName(_fromUtf8("plusJeton"))
+        self.moinsJeton = QtGui.QPushButton(self.frame_2)
+        self.moinsJeton.setGeometry(QtCore.QRect(40, 370, 31, 31))
+        self.moinsJeton.setObjectName(_fromUtf8("moinsJeton"))
+        self.label_4 = QtGui.QLabel(self.frame_2)
+        self.label_4.setGeometry(QtCore.QRect(10, 350, 51, 16))
+        self.label_4.setObjectName(_fromUtf8("label_4"))
+        self.label_5 = QtGui.QLabel(self.frame_2)
+        self.label_5.setGeometry(QtCore.QRect(10, 0, 51, 16))
+        self.label_5.setObjectName(_fromUtf8("label_5"))
+        self.nameJeton = QtGui.QLineEdit(self.frame_2)
+        self.nameJeton.setGeometry(QtCore.QRect(0, 400, 71, 20))
+        self.nameJeton.setObjectName(_fromUtf8("nameJeton"))
+        self.butStatut = QtGui.QPushButton(self.frame_2)
+        self.butStatut.setGeometry(QtCore.QRect(0, 430, 71, 31))
+        self.butStatut.setObjectName(_fromUtf8("butStatut"))
+        self.statut = QtGui.QLineEdit(self.frame_2)
+        self.statut.setGeometry(QtCore.QRect(0, 460, 71, 20))
+        self.statut.setObjectName(_fromUtf8("statut"))
+        self.type = QtGui.QLineEdit(self.frame_2)
+        self.type.setGeometry(QtCore.QRect(0, 140, 71, 20))
+        self.type.setText(_fromUtf8(""))
+        self.type.setObjectName(_fromUtf8("type"))
+        self.butType = QtGui.QPushButton(self.frame_2)
+        self.butType.setGeometry(QtCore.QRect(0, 110, 71, 31))
+        self.butType.setObjectName(_fromUtf8("butType"))
+        self.vuePlateau = QtGui.QGraphicsView(self.Combats_tab)
+        self.vuePlateau.setGeometry(QtCore.QRect(80, 10, 551, 521))
+        self.vuePlateau.setObjectName(_fromUtf8("vuePlateau"))
+        self.tabWidget.addTab(self.Combats_tab, _fromUtf8(""))
+        self.Monde_tab = QtGui.QWidget()
+        self.Monde_tab.setObjectName(_fromUtf8("Monde_tab"))
+        self.frame = QtGui.QFrame(self.Monde_tab)
+        self.frame.setGeometry(QtCore.QRect(0, 0, 71, 531))
+        palette = QtGui.QPalette()
+        brush = QtGui.QBrush(QtGui.QColor(170, 170, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(170, 0, 0))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(170, 170, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(170, 0, 0))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Base, brush)
+        brush = QtGui.QBrush(QtGui.QColor(170, 170, 255))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Button, brush)
+        brush = QtGui.QBrush(QtGui.QColor(240, 240, 240))
+        brush.setStyle(QtCore.Qt.SolidPattern)
+        palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Base, brush)
+        self.frame.setPalette(palette)
+        self.frame.setFrameShape(QtGui.QFrame.StyledPanel)
+        self.frame.setFrameShadow(QtGui.QFrame.Raised)
+        self.frame.setObjectName(_fromUtf8("frame"))
+        self.points = QtGui.QPushButton(self.frame)
+        self.points.setGeometry(QtCore.QRect(0, 0, 71, 31))
+        self.points.setObjectName(_fromUtf8("points"))
+        self.itineraire = QtGui.QPushButton(self.frame)
+        self.itineraire.setGeometry(QtCore.QRect(0, 30, 71, 31))
+        self.itineraire.setObjectName(_fromUtf8("itineraire"))
+        self.texte_2 = QtGui.QPushButton(self.frame)
+        self.texte_2.setGeometry(QtCore.QRect(0, 60, 71, 31))
+        self.texte_2.setObjectName(_fromUtf8("texte_2"))
+        self.dessin = QtGui.QPushButton(self.frame)
+        self.dessin.setGeometry(QtCore.QRect(0, 90, 71, 31))
+        self.dessin.setObjectName(_fromUtf8("dessin"))
+        self.supp = QtGui.QPushButton(self.frame)
+        self.supp.setGeometry(QtCore.QRect(0, 120, 71, 31))
+        self.supp.setObjectName(_fromUtf8("supp"))
+        self.tabWidget.addTab(self.Monde_tab, _fromUtf8(""))
+        self.Groupe_tab = QtGui.QWidget()
+        self.Groupe_tab.setObjectName(_fromUtf8("Groupe_tab"))
+        self.tabWidget.addTab(self.Groupe_tab, _fromUtf8(""))
+        self.horizontalLayout.addWidget(self.tabWidget)
+        self.layoutPanneauDroite = QtGui.QVBoxLayout()
+        self.layoutPanneauDroite.setSizeConstraint(QtGui.QLayout.SetFixedSize)
+        self.layoutPanneauDroite.setObjectName(_fromUtf8("layoutPanneauDroite"))
+        self.label = QtGui.QLabel(self.baseWidget)
+        self.label.setMinimumSize(QtCore.QSize(199, 13))
+        self.label.setMaximumSize(QtCore.QSize(369, 16777215))
+        font = QtGui.QFont()
+        font.setBold(True)
+        font.setWeight(75)
+        self.label.setFont(font)
+        self.label.setObjectName(_fromUtf8("label"))
+        self.layoutPanneauDroite.addWidget(self.label)
+        self.listEvenement = QtGui.QListWidget(self.baseWidget)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
+        sizePolicy.setHorizontalStretch(20)
+        sizePolicy.setVerticalStretch(20)
+        sizePolicy.setHeightForWidth(self.listEvenement.sizePolicy().hasHeightForWidth())
+        self.listEvenement.setSizePolicy(sizePolicy)
+        self.listEvenement.setMinimumSize(QtCore.QSize(199, 73))
+        self.listEvenement.setMaximumSize(QtCore.QSize(369, 16777215))
+        self.listEvenement.setObjectName(_fromUtf8("listEvenement"))
+        self.layoutPanneauDroite.addWidget(self.listEvenement)
+        self.layoutDes = QtGui.QHBoxLayout()
+        self.layoutDes.setSpacing(3)
+        self.layoutDes.setSizeConstraint(QtGui.QLayout.SetNoConstraint)
+        self.layoutDes.setObjectName(_fromUtf8("layoutDes"))
+        self.d20 = QtGui.QPushButton(self.baseWidget)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Ignored, QtGui.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.d20.sizePolicy().hasHeightForWidth())
+        self.d20.setSizePolicy(sizePolicy)
+        self.d20.setMinimumSize(QtCore.QSize(53, 23))
+        self.d20.setMaximumSize(QtCore.QSize(72, 16777215))
+        self.d20.setAutoDefault(False)
+        self.d20.setObjectName(_fromUtf8("d20"))
+        self.layoutDes.addWidget(self.d20)
+        self.d100 = QtGui.QPushButton(self.baseWidget)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Ignored, QtGui.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.d100.sizePolicy().hasHeightForWidth())
+        self.d100.setSizePolicy(sizePolicy)
+        self.d100.setMinimumSize(QtCore.QSize(52, 23))
+        self.d100.setMaximumSize(QtCore.QSize(72, 16777215))
+        self.d100.setObjectName(_fromUtf8("d100"))
+        self.layoutDes.addWidget(self.d100)
+        self.inJetDes = QtGui.QLineEdit(self.baseWidget)
+        self.inJetDes.setMinimumSize(QtCore.QSize(86, 20))
+        self.inJetDes.setMaximumSize(QtCore.QSize(217, 16777215))
+        self.inJetDes.setWhatsThis(_fromUtf8(""))
+        self.inJetDes.setInputMask(_fromUtf8(""))
+        self.inJetDes.setObjectName(_fromUtf8("inJetDes"))
+        self.layoutDes.addWidget(self.inJetDes)
+        self.layoutDes.setStretch(0, 1)
+        self.layoutDes.setStretch(1, 1)
+        self.layoutDes.setStretch(2, 3)
+        self.layoutPanneauDroite.addLayout(self.layoutDes)
+        self.layoutEnTeteChat = QtGui.QHBoxLayout()
+        self.layoutEnTeteChat.setObjectName(_fromUtf8("layoutEnTeteChat"))
+        self.label_3 = QtGui.QLabel(self.baseWidget)
+        self.label_3.setMinimumSize(QtCore.QSize(10, 23))
+        self.label_3.setMaximumSize(QtCore.QSize(271, 16777215))
+        font = QtGui.QFont()
+        font.setBold(True)
+        font.setWeight(75)
+        self.label_3.setFont(font)
+        self.label_3.setObjectName(_fromUtf8("label_3"))
+        self.layoutEnTeteChat.addWidget(self.label_3)
+        self.chatVoc = QtGui.QPushButton(self.baseWidget)
+        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Ignored, QtGui.QSizePolicy.Fixed)
+        sizePolicy.setHorizontalStretch(0)
+        sizePolicy.setVerticalStretch(0)
+        sizePolicy.setHeightForWidth(self.chatVoc.sizePolicy().hasHeightForWidth())
+        self.chatVoc.setSizePolicy(sizePolicy)
+        self.chatVoc.setMinimumSize(QtCore.QSize(64, 23))
+        self.chatVoc.setMaximumSize(QtCore.QSize(90, 16777215))
+        self.chatVoc.setObjectName(_fromUtf8("chatVoc"))
+        self.layoutEnTeteChat.addWidget(self.chatVoc)
+        self.layoutEnTeteChat.setStretch(1, 1)
+        self.layoutPanneauDroite.addLayout(self.layoutEnTeteChat)
+        self.listAffichage = QtGui.QListWidget(self.baseWidget)
+        self.listAffichage.setMinimumSize(QtCore.QSize(199, 96))
+        self.listAffichage.setMaximumSize(QtCore.QSize(369, 16777215))
+        self.listAffichage.setObjectName(_fromUtf8("listAffichage"))
+        self.layoutPanneauDroite.addWidget(self.listAffichage)
+        self.inChat = QtGui.QLineEdit(self.baseWidget)
+        self.inChat.setMinimumSize(QtCore.QSize(199, 20))
+        self.inChat.setMaximumSize(QtCore.QSize(369, 16777215))
+        self.inChat.setObjectName(_fromUtf8("inChat"))
+        self.layoutPanneauDroite.addWidget(self.inChat)
+        self.tabStatutAppli = QtGui.QTabWidget(self.baseWidget)
+        self.tabStatutAppli.setMinimumSize(QtCore.QSize(201, 151))
+        self.tabStatutAppli.setMaximumSize(QtCore.QSize(369, 16777215))
+        self.tabStatutAppli.setObjectName(_fromUtf8("tabStatutAppli"))
+        self.tabConnexion = QtGui.QWidget()
+        self.tabConnexion.setObjectName(_fromUtf8("tabConnexion"))
+        self.verticalLayout_2 = QtGui.QVBoxLayout(self.tabConnexion)
+        self.verticalLayout_2.setObjectName(_fromUtf8("verticalLayout_2"))
+        self.txtStatutCoPseudo = QtGui.QLabel(self.tabConnexion)
+        self.txtStatutCoPseudo.setMinimumSize(QtCore.QSize(179, 13))
+        self.txtStatutCoPseudo.setMaximumSize(QtCore.QSize(16777215, 18))
+        self.txtStatutCoPseudo.setObjectName(_fromUtf8("txtStatutCoPseudo"))
+        self.verticalLayout_2.addWidget(self.txtStatutCoPseudo)
+        self.txtStatutCoServeur = QtGui.QLabel(self.tabConnexion)
+        self.txtStatutCoServeur.setMinimumSize(QtCore.QSize(179, 13))
+        self.txtStatutCoServeur.setMaximumSize(QtCore.QSize(16777215, 18))
+        self.txtStatutCoServeur.setObjectName(_fromUtf8("txtStatutCoServeur"))
+        self.verticalLayout_2.addWidget(self.txtStatutCoServeur)
+        self.txtStatutCoServeurVoc = QtGui.QLabel(self.tabConnexion)
+        self.txtStatutCoServeurVoc.setMinimumSize(QtCore.QSize(179, 13))
+        self.txtStatutCoServeurVoc.setMaximumSize(QtCore.QSize(16777215, 17))
+        self.txtStatutCoServeurVoc.setObjectName(_fromUtf8("txtStatutCoServeurVoc"))
+        self.verticalLayout_2.addWidget(self.txtStatutCoServeurVoc)
+        self.txtStatutCoDebits = QtGui.QLabel(self.tabConnexion)
+        self.txtStatutCoDebits.setMinimumSize(QtCore.QSize(179, 0))
+        self.txtStatutCoDebits.setMaximumSize(QtCore.QSize(16777215, 18))
+        self.txtStatutCoDebits.setObjectName(_fromUtf8("txtStatutCoDebits"))
+        self.verticalLayout_2.addWidget(self.txtStatutCoDebits)
+        self.txtStatutCoEcranCo = QtGui.QPushButton(self.tabConnexion)
+        self.txtStatutCoEcranCo.setMinimumSize(QtCore.QSize(179, 23))
+        self.txtStatutCoEcranCo.setMaximumSize(QtCore.QSize(16777215, 23))
+        self.txtStatutCoEcranCo.setObjectName(_fromUtf8("txtStatutCoEcranCo"))
+        self.verticalLayout_2.addWidget(self.txtStatutCoEcranCo)
+        self.tabStatutAppli.addTab(self.tabConnexion, _fromUtf8(""))
+        self.tabJoueurs = QtGui.QWidget()
+        self.tabJoueurs.setObjectName(_fromUtf8("tabJoueurs"))
+        self.verticalLayout = QtGui.QVBoxLayout(self.tabJoueurs)
+        self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
+        self.lstStatutJoueurs = QtGui.QListWidget(self.tabJoueurs)
+        self.lstStatutJoueurs.setMinimumSize(QtCore.QSize(177, 0))
+        font = QtGui.QFont()
+        font.setFamily(_fromUtf8("Segoe UI Semibold"))
+        font.setPointSize(10)
+        font.setBold(False)
+        font.setWeight(50)
+        self.lstStatutJoueurs.setFont(font)
+        self.lstStatutJoueurs.setFrameShape(QtGui.QFrame.WinPanel)
+        self.lstStatutJoueurs.setObjectName(_fromUtf8("lstStatutJoueurs"))
+        self.verticalLayout.addWidget(self.lstStatutJoueurs)
+        self.label_2 = QtGui.QLabel(self.tabJoueurs)
+        font = QtGui.QFont()
+        font.setItalic(True)
+        self.label_2.setFont(font)
+        self.label_2.setWordWrap(False)
+        self.label_2.setObjectName(_fromUtf8("label_2"))
+        self.verticalLayout.addWidget(self.label_2)
+        self.tabStatutAppli.addTab(self.tabJoueurs, _fromUtf8(""))
+        self.tabFichiers = QtGui.QWidget()
+        self.tabFichiers.setObjectName(_fromUtf8("tabFichiers"))
+        self.gridLayout = QtGui.QGridLayout(self.tabFichiers)
+        self.gridLayout.setObjectName(_fromUtf8("gridLayout"))
+        self.repReceptionFichiers = QtGui.QPushButton(self.tabFichiers)
+        self.repReceptionFichiers.setMinimumSize(QtCore.QSize(85, 23))
+        self.repReceptionFichiers.setMaximumSize(QtCore.QSize(181, 16777215))
+        self.repReceptionFichiers.setObjectName(_fromUtf8("repReceptionFichiers"))
+        self.gridLayout.addWidget(self.repReceptionFichiers, 1, 0, 1, 1)
+        self.envoiFichier = QtGui.QPushButton(self.tabFichiers)
+        self.envoiFichier.setMinimumSize(QtCore.QSize(86, 23))
+        self.envoiFichier.setMaximumSize(QtCore.QSize(180, 16777215))
+        self.envoiFichier.setObjectName(_fromUtf8("envoiFichier"))
+        self.gridLayout.addWidget(self.envoiFichier, 1, 1, 1, 1)
+        self.listFichiers = QtGui.QTreeWidget(self.tabFichiers)
+        self.listFichiers.setMinimumSize(QtCore.QSize(177, 78))
+        self.listFichiers.setMaximumSize(QtCore.QSize(369, 16777215))
+        self.listFichiers.setBaseSize(QtCore.QSize(0, 0))
+        self.listFichiers.setFrameShape(QtGui.QFrame.WinPanel)
+        self.listFichiers.setIndentation(2)
+        self.listFichiers.setColumnCount(3)
+        self.listFichiers.setObjectName(_fromUtf8("listFichiers"))
+        self.listFichiers.header().setDefaultSectionSize(28)
+        self.listFichiers.header().setMinimumSectionSize(27)
+        self.gridLayout.addWidget(self.listFichiers, 0, 0, 1, 2)
+        self.tabStatutAppli.addTab(self.tabFichiers, _fromUtf8(""))
+        self.layoutPanneauDroite.addWidget(self.tabStatutAppli)
+        self.layoutPanneauDroite.setStretch(0, 1)
+        self.layoutPanneauDroite.setStretch(1, 7)
+        self.layoutPanneauDroite.setStretch(2, 1)
+        self.layoutPanneauDroite.setStretch(3, 1)
+        self.layoutPanneauDroite.setStretch(4, 10)
+        self.layoutPanneauDroite.setStretch(5, 1)
+        self.layoutPanneauDroite.setStretch(6, 1)
+        self.horizontalLayout.addLayout(self.layoutPanneauDroite)
+        principal.setCentralWidget(self.baseWidget)
+        self.menubar = QtGui.QMenuBar(principal)
+        self.menubar.setGeometry(QtCore.QRect(0, 0, 882, 21))
+        self.menubar.setObjectName(_fromUtf8("menubar"))
+        self.menuFichier = QtGui.QMenu(self.menubar)
+        self.menuFichier.setObjectName(_fromUtf8("menuFichier"))
+        self.menuEditer = QtGui.QMenu(self.menubar)
+        self.menuEditer.setObjectName(_fromUtf8("menuEditer"))
+        self.menuAide = QtGui.QMenu(self.menubar)
+        self.menuAide.setObjectName(_fromUtf8("menuAide"))
+        principal.setMenuBar(self.menubar)
+        self.statusbar = QtGui.QStatusBar(principal)
+        self.statusbar.setObjectName(_fromUtf8("statusbar"))
+        principal.setStatusBar(self.statusbar)
+        self.actionOuvrir = QtGui.QAction(principal)
+        self.actionOuvrir.setObjectName(_fromUtf8("actionOuvrir"))
+        self.actionEnregistrer = QtGui.QAction(principal)
+        self.actionEnregistrer.setObjectName(_fromUtf8("actionEnregistrer"))
+        self.actionQuitter = QtGui.QAction(principal)
+        self.actionQuitter.setObjectName(_fromUtf8("actionQuitter"))
+        self.actionA_propos_de_D_Monde = QtGui.QAction(principal)
+        self.actionA_propos_de_D_Monde.setObjectName(_fromUtf8("actionA_propos_de_D_Monde"))
+        self.actionParam_tres = QtGui.QAction(principal)
+        self.actionParam_tres.setObjectName(_fromUtf8("actionParam_tres"))
+        self.actionLexique = QtGui.QAction(principal)
+        self.actionLexique.setObjectName(_fromUtf8("actionLexique"))
+        self.menuFichier.addAction(self.actionOuvrir)
+        self.menuFichier.addAction(self.actionEnregistrer)
+        self.menuFichier.addSeparator()
+        self.menuFichier.addAction(self.actionQuitter)
+        self.menuEditer.addAction(self.actionParam_tres)
+        self.menuAide.addAction(self.actionA_propos_de_D_Monde)
+        self.menuAide.addAction(self.actionLexique)
+        self.menubar.addAction(self.menuFichier.menuAction())
+        self.menubar.addAction(self.menuEditer.menuAction())
+        self.menubar.addAction(self.menuAide.menuAction())
+
+        self.retranslateUi(principal)
+        self.tabWidget.setCurrentIndex(0)
+        self.tabStatutAppli.setCurrentIndex(1)
+        QtCore.QMetaObject.connectSlotsByName(principal)
+
+    def retranslateUi(self, principal):
+        principal.setWindowTitle(_translate("principal", "D-Monde", None))
+        self.newW.setText(_translate("principal", "Nouvelle", None))
+        self.ligne.setText(_translate("principal", "Ligne", None))
+        self.texte.setText(_translate("principal", "Texte", None))
+        self.plusJeton.setText(_translate("principal", "+", None))
+        self.moinsJeton.setText(_translate("principal", "-", None))
+        self.label_4.setText(_translate("principal", "Jetons", None))
+        self.label_5.setText(_translate("principal", "Fenetres", None))
+        self.butStatut.setText(_translate("principal", "Statut", None))
+        self.butType.setText(_translate("principal", "Type", None))
+        self.tabWidget.setTabText(self.tabWidget.indexOf(self.Combats_tab), _translate("principal", "Combats", None))
+        self.points.setText(_translate("principal", "Points", None))
+        self.itineraire.setText(_translate("principal", "Itinéraire", None))
+        self.texte_2.setText(_translate("principal", "Texte", None))
+        self.dessin.setText(_translate("principal", "Dessin", None))
+        self.supp.setText(_translate("principal", "Supprimer", None))
+        self.tabWidget.setTabText(self.tabWidget.indexOf(self.Monde_tab), _translate("principal", "Monde", None))
+        self.tabWidget.setTabText(self.tabWidget.indexOf(self.Groupe_tab), _translate("principal", "Groupe", None))
+        self.label.setText(_translate("principal", "Evenements", None))
+        self.d20.setText(_translate("principal", "D20", None))
+        self.d100.setText(_translate("principal", "D100", None))
+        self.inJetDes.setPlaceholderText(_translate("principal", "Autre lancer (ex: 1d4+6d6)", None))
+        self.label_3.setText(_translate("principal", "Chat", None))
+        self.chatVoc.setText(_translate("principal", "Chat vocal", None))
+        self.inChat.setPlaceholderText(_translate("principal", "Entrez votre message...", None))
+        self.txtStatutCoPseudo.setText(_translate("principal", "Pseudo : ", None))
+        self.txtStatutCoServeur.setText(_translate("principal", "Serveur : Aucun serveur", None))
+        self.txtStatutCoServeurVoc.setText(_translate("principal", "Serveur vocal : Aucun serveur vocal", None))
+        self.txtStatutCoDebits.setText(_translate("principal", "Débits : E 0 ko/s  -  R 0 ko/s", None))
+        self.txtStatutCoEcranCo.setText(_translate("principal", "Ecran de connexion", None))
+        self.tabStatutAppli.setTabText(self.tabStatutAppli.indexOf(self.tabConnexion), _translate("principal", "Connexion", None))
+        self.label_2.setText(_translate("principal", "Double-cliquer pour ouvrir un chat privé", None))
+        self.tabStatutAppli.setTabText(self.tabStatutAppli.indexOf(self.tabJoueurs), _translate("principal", "Joueurs", None))
+        self.repReceptionFichiers.setText(_translate("principal", "Rep. recept.", None))
+        self.envoiFichier.setText(_translate("principal", "Envoi fichier", None))
+        self.listFichiers.headerItem().setText(0, _translate("principal", "E/R", None))
+        self.listFichiers.headerItem().setText(1, _translate("principal", "%", None))
+        self.listFichiers.headerItem().setText(2, _translate("principal", "Fichier", None))
+        self.tabStatutAppli.setTabText(self.tabStatutAppli.indexOf(self.tabFichiers), _translate("principal", "Fichiers", None))
+        self.menuFichier.setTitle(_translate("principal", "Fichier", None))
+        self.menuEditer.setTitle(_translate("principal", "Editer", None))
+        self.menuAide.setTitle(_translate("principal", "Aide", None))
+        self.actionOuvrir.setText(_translate("principal", "Ouvrir", None))
+        self.actionEnregistrer.setText(_translate("principal", "Enregistrer", None))
+        self.actionQuitter.setText(_translate("principal", "Quitter", None))
+        self.actionA_propos_de_D_Monde.setText(_translate("principal", "A propos de DéMonde...", None))
+        self.actionParam_tres.setText(_translate("principal", "Paramètres", None))
+        self.actionLexique.setText(_translate("principal", "Lexique", None))
+
+
+if __name__ == "__main__":
+    import sys
+    app = QtGui.QApplication(sys.argv)
+    principal = QtGui.QMainWindow()
+    ui = Ui_principal()
+    ui.setupUi(principal)
+    principal.show()
+    sys.exit(app.exec_())
+

interface_qt8_2/envoiFichier.ui

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>envoiFichiers</class>
+ <widget class="QWidget" name="envoiFichiers">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>543</width>
+    <height>422</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Envoi de fichiers</string>
+  </property>
+  <widget class="QPushButton" name="pushButton">
+   <property name="geometry">
+    <rect>
+     <x>180</x>
+     <y>30</y>
+     <width>151</width>
+     <height>31</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Envoyer un fichier</string>
+   </property>
+  </widget>
+  <widget class="QTreeWidget" name="treeWidget">
+   <property name="geometry">
+    <rect>
+     <x>20</x>
+     <y>80</y>
+     <width>501</width>
+     <height>281</height>
+    </rect>
+   </property>
+   <property name="columnCount">
+    <number>2</number>
+   </property>
+   <column>
+    <property name="text">
+     <string>Fichier</string>
+    </property>
+   </column>
+   <column>
+    <property name="text">
+     <string>Statut</string>
+    </property>
+   </column>
+   <item>
+    <property name="text">
+     <string>Nouvel élément</string>
+    </property>
+    <item>
+     <property name="text">
+      <string>Nouveau sous-élément</string>
+     </property>
+    </item>
+    <item>
+     <property name="text">
+      <string>Nouveau sous-élément</string>
+     </property>
+    </item>
+   </item>
+  </widget>
+  <widget class="QPushButton" name="pushButton_2">
+   <property name="geometry">
+    <rect>
+     <x>350</x>
+     <y>370</y>
+     <width>151</width>
+     <height>21</height>
+    </rect>
+   </property>
+   <property name="text">
+    <string>Annuler l'envoi</string>
+   </property>
+  </widget>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

interface_qt8_2/lancer.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+"""lancer de des"""
+from random import *
+from operator import add
+
+def de(faces):
+    """resultat d'un de avec nbre de faces en parametre"""
+    return randint(1,faces)
+   
+def jet(expr):
+    """effectue un jet de de a partir d'expressions de type '1d20+3' -
+    retourne un resultat chiffre et un resultat detaille."""
+    decoupage = lancer = []
+    estDe = False
+    nb = res = 0
+    resDetaille = signe = tmp = ""
+
+    #on decoupe la chaine en se basant sur tout ce qui n'est pas un chiffre:
+    if expr:
+        expr += " "
+        for car in expr:
+            try:
+                #le caractere est-il un chiffre? si oui, on le stocke dans tmp
+                tmp += str(int(car))
+            except:
+                #si ce n'est pas un chiffre, qu'est-ce?
+                if car.lower() == "d":
+                   estDe = True
+                   nb = int(tmp)
+                   lancer = []
+                   tmp = ""
+                   #on garde en memoire le nombre stocke dans tmp,
+                   #puis on attend le prochain tmp pour effectuer le jet de de
+                else:
+                   if estDe:
+                       #on lance le de
+                       i = 0
+                       while i < nb:
+                           lancer.append(de(int(tmp)))
+                           i+=1
+                       decoupage.append(lancer)
+                       decoupage.append(car)
+                       estDe = False
+                       tmp = ""
+                   else:    
+                       decoupage.append(tmp)
+                       if car != " ":
+                           decoupage.append(car)
+                       tmp = ""
+
+        decoupage.append(tmp)
+        #on calcule ensuite tout ca:
+        for elt in decoupage:
+            if type(elt) == list:
+              elt = int(sum(elt[:])) 
+            try:
+               elt = int(elt)
+               if signe == "-":
+                   elt = -1 * elt
+               res += elt    
+            except:
+               signe = elt      
+
+        #on met en forme le resultat detaille
+        for elt in decoupage:
+           if type(elt) == list:
+               elt = map(str, elt) 
+               elt = ",".join(elt)
+           resDetaille += " "+str(elt)        
+        resDetaille = resDetaille.replace(" ","")
+    
+    return (res, resDetaille)
+
+
+if __name__ == "__main__":
+# si lancement direct:
+    while True:
+        lancer = jet(raw_input(" > "))
+        print("{} ({})".format(lancer[0], lancer[1]))
+  
+

interface_qt8_2/lecture.py

@@ -0,0 +1,72 @@
+# -*-coding:Latin-1 -*
+"""lecture d'un flux audio mp3"""
+from time import sleep
+from threading import Thread
+
+#modules complémentaires
+import pymedia.audio.sound as sound
+import pymedia.audio.acodec as acodec
+
+class Lecture(Thread):
+    """instance de lecture audio d'un flux mp3"""
+    def __init__(self, identifiant, cparams, debug):
+        """création du fil de lecture"""
+        self.Terminated = False
+        Thread.__init__(self)
+        self.debug = debug
+        self.dec = acodec.Decoder(cparams)
+        self.sortie = sound.Output( cparams["sample_rate"], 1, sound.AFMT_S16_LE, 0 )
+        if self.debug:
+            self.recept = open( "{}.mp3".format(identifiant), 'wb' )
+   
+    def lire(self, recu):
+       """reception des donnees a lire"""
+       retour = ""
+       if recu:
+            son_decode = self.dec.decode(recu)
+            if self.debug:
+                self.recept.write(recu) 
+            if son_decode:
+                self.sortie.play(son_decode.data) 
+       
+    def run(self):
+        """boucle vide"""
+        while not self.Terminated:
+            sleep(0.1)   
+
+    def stop(self):
+        """Fermeture du fil de lecture"""
+        print("Fin de la lecture\n")
+        self.Terminated = True
+        if self.debug:
+           self.recept.close()
+
+
+if __name__ == "__main__":
+# si lancement direct:
+   micro = sound.Input( 22050, 1, sound.AFMT_S16_LE, 0 ) 
+   micro.start()
+   cparams= { 'id': acodec.getCodecID( 'mp3' ),
+              'bitrate': 32000,
+              'sample_rate': 22050,
+              'channels': 1 }
+   ac = acodec.Encoder( cparams )
+   le = Lecture("test_lecture", cparams, False)
+   le.start()
+   i = 0
+   
+   while True:
+      try:
+           i += 1
+           son = micro.getData()
+           if son and len(son):
+               son_encode = ac.encode(son)
+               print("".format(i))
+               for fr in son_encode:
+                   print(le.lire(fr))
+      except KeyboardInterrupt:
+         break
+
+   micro.stop()
+   le.stop()
+           

interface_qt8_2/mainwindow.ui

@@ -0,0 +1,1000 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>principal</class>
+ <widget class="QMainWindow" name="principal">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>882</width>
+    <height>623</height>
+   </rect>
+  </property>
+  <property name="minimumSize">
+   <size>
+    <width>882</width>
+    <height>623</height>
+   </size>
+  </property>
+  <property name="windowTitle">
+   <string>D-Monde</string>
+  </property>
+  <widget class="QWidget" name="baseWidget">
+   <layout class="QHBoxLayout" name="horizontalLayout">
+    <item>
+     <widget class="QTabWidget" name="tabWidget">
+      <property name="minimumSize">
+       <size>
+        <width>641</width>
+        <height>561</height>
+       </size>
+      </property>
+      <property name="currentIndex">
+       <number>0</number>
+      </property>
+      <widget class="QWidget" name="Combats_tab">
+       <attribute name="title">
+        <string>Combats</string>
+       </attribute>
+       <widget class="QFrame" name="frame_2">
+        <property name="geometry">
+         <rect>
+          <x>0</x>
+          <y>0</y>
+          <width>71</width>
+          <height>531</height>
+         </rect>
+        </property>
+        <property name="palette">
+         <palette>
+          <active>
+           <colorrole role="Button">
+            <brush brushstyle="SolidPattern">
+             <color alpha="255">
+              <red>170</red>
+              <green>170</green>
+              <blue>255</blue>
+             </color>
+            </brush>
+           </colorrole>
+           <colorrole role="Base">
+            <brush brushstyle="SolidPattern">
+             <color alpha="255">
+              <red>170</red>
+              <green>0</green>
+              <blue>0</blue>
+             </color>
+            </brush>
+           </colorrole>
+          </active>
+          <inactive>
+           <colorrole role="Button">
+            <brush brushstyle="SolidPattern">
+             <color alpha="255">
+              <red>170</red>
+              <green>170</green>
+              <blue>255</blue>
+             </color>
+            </brush>
+           </colorrole>
+           <colorrole role="Base">
+            <brush brushstyle="SolidPattern">
+             <color alpha="255">
+              <red>170</red>
+              <green>0</green>
+              <blue>0</blue>
+             </color>
+            </brush>
+           </colorrole>
+          </inactive>
+          <disabled>
+           <colorrole role="Button">
+            <brush brushstyle="SolidPattern">
+             <color alpha="255">
+              <red>170</red>
+              <green>170</green>
+              <blue>255</blue>
+             </color>
+            </brush>
+           </colorrole>
+           <colorrole role="Base">
+            <brush brushstyle="SolidPattern">
+             <color alpha="255">
+              <red>240</red>
+              <green>240</green>
+              <blue>240</blue>
+             </color>
+            </brush>
+           </colorrole>
+          </disabled>
+         </palette>
+        </property>
+        <property name="frameShape">
+         <enum>QFrame::StyledPanel</enum>
+        </property>
+        <property name="frameShadow">
+         <enum>QFrame::Raised</enum>
+        </property>
+        <widget class="QPushButton" name="newW">
+         <property name="geometry">
+          <rect>
+           <x>0</x>
+           <y>20</y>
+           <width>71</width>
+           <height>31</height>
+          </rect>
+         </property>
+         <property name="text">
+          <string>Nouvelle</string>
+         </property>
+        </widget>
+        <widget class="QPushButton" name="ligne">
+         <property name="geometry">
+          <rect>
+           <x>0</x>
+           <y>50</y>
+           <width>71</width>
+           <height>31</height>
+          </rect>
+         </property>
+         <property name="text">
+          <string>Ligne</string>
+         </property>
+        </widget>
+        <widget class="QPushButton" name="texte">
+         <property name="geometry">
+          <rect>
+           <x>0</x>
+           <y>80</y>
+           <width>71</width>
+           <height>31</height>
+          </rect>
+         </property>
+         <property name="text">
+          <string>Texte</string>
+         </property>
+        </widget>
+        <widget class="QPushButton" name="plusJeton">
+         <property name="geometry">
+          <rect>
+           <x>0</x>
+           <y>370</y>
+           <width>31</width>
+           <height>31</height>
+          </rect>
+         </property>
+         <property name="text">
+          <string>+</string>
+         </property>
+        </widget>
+        <widget class="QPushButton" name="moinsJeton">
+         <property name="geometry">
+          <rect>
+           <x>40</x>
+           <y>370</y>
+           <width>31</width>
+           <height>31</height>
+          </rect>
+         </property>
+         <property name="text">
+          <string>-</string>
+         </property>
+        </widget>
+        <widget class="QLabel" name="label_4">
+         <property name="geometry">
+          <rect>
+           <x>10</x>
+           <y>350</y>
+           <width>51</width>
+           <height>16</height>
+          </rect>
+         </property>
+         <property name="text">
+          <string>Jetons</string>
+         </property>
+        </widget>
+        <widget class="QLabel" name="label_5">
+         <property name="geometry">
+          <rect>
+           <x>10</x>
+           <y>0</y>
+           <width>51</width>
+           <height>16</height>
+          </rect>
+         </property>
+         <property name="text">
+          <string>Fenetres</string>
+         </property>
+        </widget>
+        <widget class="QLineEdit" name="nameJeton">
+         <property name="geometry">
+          <rect>
+           <x>0</x>
+           <y>400</y>
+           <width>71</width>
+           <height>20</height>
+          </rect>
+         </property>
+        </widget>
+        <widget class="QPushButton" name="butStatut">
+         <property name="geometry">
+          <rect>
+           <x>0</x>
+           <y>430</y>
+           <width>71</width>
+           <height>31</height>
+          </rect>
+         </property>
+         <property name="text">
+          <string>Statut</string>
+         </property>
+        </widget>
+        <widget class="QLineEdit" name="statut">
+         <property name="geometry">
+          <rect>
+           <x>0</x>
+           <y>460</y>
+           <width>71</width>
+           <height>20</height>
+          </rect>
+         </property>
+        </widget>
+        <widget class="QLineEdit" name="type">
+         <property name="geometry">
+          <rect>
+           <x>0</x>
+           <y>140</y>
+           <width>71</width>
+           <height>20</height>
+          </rect>
+         </property>
+         <property name="text">
+          <string/>
+         </property>
+        </widget>
+        <widget class="QPushButton" name="butType">
+         <property name="geometry">
+          <rect>
+           <x>0</x>
+           <y>110</y>
+           <width>71</width>
+           <height>31</height>
+          </rect>
+         </property>
+         <property name="text">
+          <string>Type</string>
+         </property>
+        </widget>
+       </widget>
+       <widget class="QGraphicsView" name="vuePlateau">
+        <property name="geometry">
+         <rect>
+          <x>80</x>
+          <y>10</y>
+          <width>551</width>
+          <height>521</height>
+         </rect>
+        </property>
+       </widget>
+      </widget>
+      <widget class="QWidget" name="Monde_tab">
+       <attribute name="title">
+        <string>Monde</string>
+       </attribute>
+       <widget class="QFrame" name="frame">
+        <property name="geometry">
+         <rect>
+          <x>0</x>
+          <y>0</y>
+          <width>71</width>
+          <height>531</height>
+         </rect>
+        </property>
+        <property name="palette">
+         <palette>
+          <active>
+           <colorrole role="Button">
+            <brush brushstyle="SolidPattern">
+             <color alpha="255">
+              <red>170</red>
+              <green>170</green>
+              <blue>255</blue>
+             </color>
+            </brush>
+           </colorrole>
+           <colorrole role="Base">
+            <brush brushstyle="SolidPattern">
+             <color alpha="255">
+              <red>170</red>
+              <green>0</green>
+              <blue>0</blue>
+             </color>
+            </brush>
+           </colorrole>
+          </active>
+          <inactive>
+           <colorrole role="Button">
+            <brush brushstyle="SolidPattern">
+             <color alpha="255">
+              <red>170</red>
+              <green>170</green>
+              <blue>255</blue>
+             </color>
+            </brush>
+           </colorrole>
+           <colorrole role="Base">
+            <brush brushstyle="SolidPattern">
+             <color alpha="255">
+              <red>170</red>
+              <green>0</green>
+              <blue>0</blue>
+             </color>
+            </brush>
+           </colorrole>
+          </inactive>
+          <disabled>
+           <colorrole role="Button">
+            <brush brushstyle="SolidPattern">
+             <color alpha="255">
+              <red>170</red>
+              <green>170</green>
+              <blue>255</blue>
+             </color>
+            </brush>
+           </colorrole>
+           <colorrole role="Base">
+            <brush brushstyle="SolidPattern">
+             <color alpha="255">
+              <red>240</red>
+              <green>240</green>
+              <blue>240</blue>
+             </color>
+            </brush>
+           </colorrole>
+          </disabled>
+         </palette>
+        </property>
+        <property name="frameShape">
+         <enum>QFrame::StyledPanel</enum>
+        </property>
+        <property name="frameShadow">
+         <enum>QFrame::Raised</enum>
+        </property>
+        <widget class="QPushButton" name="points">
+         <property name="geometry">
+          <rect>
+           <x>0</x>
+           <y>0</y>
+           <width>71</width>
+           <height>31</height>
+          </rect>
+         </property>
+         <property name="text">
+          <string>Points</string>
+         </property>
+        </widget>
+        <widget class="QPushButton" name="itineraire">
+         <property name="geometry">
+          <rect>
+           <x>0</x>
+           <y>30</y>
+           <width>71</width>
+           <height>31</height>
+          </rect>
+         </property>
+         <property name="text">
+          <string>Itinéraire</string>
+         </property>
+        </widget>
+        <widget class="QPushButton" name="texte_2">
+         <property name="geometry">
+          <rect>
+           <x>0</x>
+           <y>60</y>
+           <width>71</width>
+           <height>31</height>
+          </rect>
+         </property>
+         <property name="text">
+          <string>Texte</string>
+         </property>
+        </widget>
+        <widget class="QPushButton" name="dessin">
+         <property name="geometry">
+          <rect>
+           <x>0</x>
+           <y>90</y>
+           <width>71</width>
+           <height>31</height>
+          </rect>
+         </property>
+         <property name="text">
+          <string>Dessin</string>
+         </property>
+        </widget>
+        <widget class="QPushButton" name="supp">
+         <property name="geometry">
+          <rect>
+           <x>0</x>
+           <y>120</y>
+           <width>71</width>
+           <height>31</height>
+          </rect>
+         </property>
+         <property name="text">
+          <string>Supprimer</string>
+         </property>
+        </widget>
+       </widget>
+      </widget>
+      <widget class="QWidget" name="Groupe_tab">
+       <attribute name="title">
+        <string>Groupe</string>
+       </attribute>
+      </widget>
+     </widget>
+    </item>
+    <item>
+     <layout class="QVBoxLayout" name="layoutPanneauDroite" stretch="1,7,1,1,10,1,1">
+      <property name="sizeConstraint">
+       <enum>QLayout::SetFixedSize</enum>
+      </property>
+      <item>
+       <widget class="QLabel" name="label">
+        <property name="minimumSize">
+         <size>
+          <width>199</width>
+          <height>13</height>
+         </size>
+        </property>
+        <property name="maximumSize">
+         <size>
+          <width>369</width>
+          <height>16777215</height>
+         </size>
+        </property>
+        <property name="font">
+         <font>
+          <weight>75</weight>
+          <bold>true</bold>
+         </font>
+        </property>
+        <property name="text">
+         <string>Evenements</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QListWidget" name="listEvenement">
+        <property name="sizePolicy">
+         <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
+          <horstretch>20</horstretch>
+          <verstretch>20</verstretch>
+         </sizepolicy>
+        </property>
+        <property name="minimumSize">
+         <size>
+          <width>199</width>
+          <height>73</height>
+         </size>
+        </property>
+        <property name="maximumSize">
+         <size>
+          <width>369</width>
+          <height>16777215</height>
+         </size>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <layout class="QHBoxLayout" name="layoutDes" stretch="1,1,3">
+        <property name="spacing">
+         <number>3</number>
+        </property>
+        <property name="sizeConstraint">
+         <enum>QLayout::SetNoConstraint</enum>
+        </property>
+        <item>
+         <widget class="QPushButton" name="d20">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Ignored" vsizetype="Fixed">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="minimumSize">
+           <size>
+            <width>53</width>
+            <height>23</height>
+           </size>
+          </property>
+          <property name="maximumSize">
+           <size>
+            <width>72</width>
+            <height>16777215</height>
+           </size>
+          </property>
+          <property name="text">
+           <string>D20</string>
+          </property>
+          <property name="autoDefault">
+           <bool>false</bool>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="d100">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Ignored" vsizetype="Fixed">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="minimumSize">
+           <size>
+            <width>52</width>
+            <height>23</height>
+           </size>
+          </property>
+          <property name="maximumSize">
+           <size>
+            <width>72</width>
+            <height>16777215</height>
+           </size>
+          </property>
+          <property name="text">
+           <string>D100</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QLineEdit" name="inJetDes">
+          <property name="minimumSize">
+           <size>
+            <width>86</width>
+            <height>20</height>
+           </size>
+          </property>
+          <property name="maximumSize">
+           <size>
+            <width>217</width>
+            <height>16777215</height>
+           </size>
+          </property>
+          <property name="whatsThis">
+           <string/>
+          </property>
+          <property name="inputMask">
+           <string/>
+          </property>
+          <property name="placeholderText">
+           <string>Autre lancer (ex: 1d4+6d6)</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <layout class="QHBoxLayout" name="layoutEnTeteChat" stretch="0,1">
+        <item>
+         <widget class="QLabel" name="label_3">
+          <property name="minimumSize">
+           <size>
+            <width>10</width>
+            <height>23</height>
+           </size>
+          </property>
+          <property name="maximumSize">
+           <size>
+            <width>271</width>
+            <height>16777215</height>
+           </size>
+          </property>
+          <property name="font">
+           <font>
+            <weight>75</weight>
+            <bold>true</bold>
+           </font>
+          </property>
+          <property name="text">
+           <string>Chat</string>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QPushButton" name="chatVoc">
+          <property name="sizePolicy">
+           <sizepolicy hsizetype="Ignored" vsizetype="Fixed">
+            <horstretch>0</horstretch>
+            <verstretch>0</verstretch>
+           </sizepolicy>
+          </property>
+          <property name="minimumSize">
+           <size>
+            <width>64</width>
+            <height>23</height>
+           </size>
+          </property>
+          <property name="maximumSize">
+           <size>
+            <width>90</width>
+            <height>16777215</height>
+           </size>
+          </property>
+          <property name="text">
+           <string>Chat vocal</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </item>
+      <item>
+       <widget class="QListWidget" name="listAffichage">
+        <property name="minimumSize">
+         <size>
+          <width>199</width>
+          <height>96</height>
+         </size>
+        </property>
+        <property name="maximumSize">
+         <size>
+          <width>369</width>
+          <height>16777215</height>
+         </size>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QLineEdit" name="inChat">
+        <property name="minimumSize">
+         <size>
+          <width>199</width>
+          <height>20</height>
+         </size>
+        </property>
+        <property name="maximumSize">
+         <size>
+          <width>369</width>
+          <height>16777215</height>
+         </size>
+        </property>
+        <property name="placeholderText">
+         <string>Entrez votre message...</string>
+        </property>
+       </widget>
+      </item>
+      <item>
+       <widget class="QTabWidget" name="tabStatutAppli">
+        <property name="minimumSize">
+         <size>
+          <width>201</width>
+          <height>151</height>
+         </size>
+        </property>
+        <property name="maximumSize">
+         <size>
+          <width>369</width>
+          <height>16777215</height>
+         </size>
+        </property>
+        <property name="currentIndex">
+         <number>1</number>
+        </property>
+        <widget class="QWidget" name="tabConnexion">
+         <attribute name="title">
+          <string>Connexion</string>
+         </attribute>
+         <layout class="QVBoxLayout" name="verticalLayout_2">
+          <item>
+           <widget class="QLabel" name="txtStatutCoPseudo">
+            <property name="minimumSize">
+             <size>
+              <width>179</width>
+              <height>13</height>
+             </size>
+            </property>
+            <property name="maximumSize">
+             <size>
+              <width>16777215</width>
+              <height>18</height>
+             </size>
+            </property>
+            <property name="text">
+             <string>Pseudo : </string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QLabel" name="txtStatutCoServeur">
+            <property name="minimumSize">
+             <size>
+              <width>179</width>
+              <height>13</height>
+             </size>
+            </property>
+            <property name="maximumSize">
+             <size>
+              <width>16777215</width>
+              <height>18</height>
+             </size>
+            </property>
+            <property name="text">
+             <string>Serveur : Aucun serveur</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QLabel" name="txtStatutCoServeurVoc">
+            <property name="minimumSize">
+             <size>
+              <width>179</width>
+              <height>13</height>
+             </size>
+            </property>
+            <property name="maximumSize">
+             <size>
+              <width>16777215</width>
+              <height>17</height>
+             </size>
+            </property>
+            <property name="text">
+             <string>Serveur vocal : Aucun serveur vocal</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QLabel" name="txtStatutCoDebits">
+            <property name="minimumSize">
+             <size>
+              <width>179</width>
+              <height>0</height>
+             </size>
+            </property>
+            <property name="maximumSize">
+             <size>
+              <width>16777215</width>
+              <height>18</height>
+             </size>
+            </property>
+            <property name="text">
+             <string>Débits : E 0 ko/s  -  R 0 ko/s</string>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QPushButton" name="txtStatutCoEcranCo">
+            <property name="minimumSize">
+             <size>
+              <width>179</width>
+              <height>23</height>
+             </size>
+            </property>
+            <property name="maximumSize">
+             <size>
+              <width>16777215</width>
+              <height>23</height>
+             </size>
+            </property>
+            <property name="text">
+             <string>Ecran de connexion</string>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+        <widget class="QWidget" name="tabJoueurs">
+         <attribute name="title">
+          <string>Joueurs</string>
+         </attribute>
+         <layout class="QVBoxLayout" name="verticalLayout">
+          <item>
+           <widget class="QListWidget" name="lstStatutJoueurs">
+            <property name="minimumSize">
+             <size>
+              <width>177</width>
+              <height>0</height>
+             </size>
+            </property>
+            <property name="font">
+             <font>
+              <family>Segoe UI Semibold</family>
+              <pointsize>10</pointsize>
+              <weight>50</weight>
+              <bold>false</bold>
+             </font>
+            </property>
+            <property name="frameShape">
+             <enum>QFrame::WinPanel</enum>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QLabel" name="label_2">
+            <property name="font">
+             <font>
+              <italic>true</italic>
+             </font>
+            </property>
+            <property name="text">
+             <string>Double-cliquer pour ouvrir un chat privé</string>
+            </property>
+            <property name="wordWrap">
+             <bool>false</bool>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+        <widget class="QWidget" name="tabFichiers">
+         <attribute name="title">
+          <string>Fichiers</string>
+         </attribute>
+         <layout class="QGridLayout" name="gridLayout">
+          <item row="1" column="0">
+           <widget class="QPushButton" name="repReceptionFichiers">
+            <property name="minimumSize">
+             <size>
+              <width>85</width>
+              <height>23</height>
+             </size>
+            </property>
+            <property name="maximumSize">
+             <size>
+              <width>181</width>
+              <height>16777215</height>
+             </size>
+            </property>
+            <property name="text">
+             <string>Rep. recept.</string>
+            </property>
+           </widget>
+          </item>
+          <item row="1" column="1">
+           <widget class="QPushButton" name="envoiFichier">
+            <property name="minimumSize">
+             <size>
+              <width>86</width>
+              <height>23</height>
+             </size>
+            </property>
+            <property name="maximumSize">
+             <size>
+              <width>180</width>
+              <height>16777215</height>
+             </size>
+            </property>
+            <property name="text">
+             <string>Envoi fichier</string>
+            </property>
+           </widget>
+          </item>
+          <item row="0" column="0" colspan="2">
+           <widget class="QTreeWidget" name="listFichiers">
+            <property name="minimumSize">
+             <size>
+              <width>177</width>
+              <height>78</height>
+             </size>
+            </property>
+            <property name="maximumSize">
+             <size>
+              <width>369</width>
+              <height>16777215</height>
+             </size>
+            </property>
+            <property name="baseSize">
+             <size>
+              <width>0</width>
+              <height>0</height>
+             </size>
+            </property>
+            <property name="frameShape">
+             <enum>QFrame::WinPanel</enum>
+            </property>
+            <property name="indentation">
+             <number>2</number>
+            </property>
+            <property name="columnCount">
+             <number>3</number>
+            </property>
+            <attribute name="headerDefaultSectionSize">
+             <number>28</number>
+            </attribute>
+            <attribute name="headerMinimumSectionSize">
+             <number>27</number>
+            </attribute>
+            <column>
+             <property name="text">
+              <string>E/R</string>
+             </property>
+            </column>
+            <column>
+             <property name="text">
+              <string>%</string>
+             </property>
+            </column>
+            <column>
+             <property name="text">
+              <string>Fichier</string>
+             </property>
+            </column>
+           </widget>
+          </item>
+         </layout>
+        </widget>
+       </widget>
+      </item>
+     </layout>
+    </item>
+   </layout>
+  </widget>
+  <widget class="QMenuBar" name="menubar">
+   <property name="geometry">
+    <rect>
+     <x>0</x>
+     <y>0</y>
+     <width>882</width>
+     <height>21</height>
+    </rect>
+   </property>
+   <widget class="QMenu" name="menuFichier">
+    <property name="title">
+     <string>Fichier</string>
+    </property>
+    <addaction name="actionOuvrir"/>
+    <addaction name="actionEnregistrer"/>
+    <addaction name="separator"/>
+    <addaction name="actionQuitter"/>
+   </widget>
+   <widget class="QMenu" name="menuEditer">
+    <property name="title">
+     <string>Editer</string>
+    </property>
+    <addaction name="actionParam_tres"/>
+   </widget>
+   <widget class="QMenu" name="menuAide">
+    <property name="title">
+     <string>Aide</string>
+    </property>
+    <addaction name="actionA_propos_de_D_Monde"/>
+    <addaction name="actionLexique"/>
+   </widget>
+   <addaction name="menuFichier"/>
+   <addaction name="menuEditer"/>
+   <addaction name="menuAide"/>
+  </widget>
+  <widget class="QStatusBar" name="statusbar"/>
+  <action name="actionOuvrir">
+   <property name="text">
+    <string>Ouvrir</string>
+   </property>
+  </action>
+  <action name="actionEnregistrer">
+   <property name="text">
+    <string>Enregistrer</string>
+   </property>
+  </action>
+  <action name="actionQuitter">
+   <property name="text">
+    <string>Quitter</string>
+   </property>
+  </action>
+  <action name="actionA_propos_de_D_Monde">
+   <property name="text">
+    <string>A propos de DéMonde...</string>
+   </property>
+  </action>
+  <action name="actionParam_tres">
+   <property name="text">
+    <string>Paramètres</string>
+   </property>
+  </action>
+  <action name="actionLexique">
+   <property name="text">
+    <string>Lexique</string>
+   </property>
+  </action>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

interface_qt8_2/plateau.py

@@ -0,0 +1,82 @@
+from test_graphiques import Ui_Form
+import sys, os, time
+from PyQt4 import QtCore,QtGui, QtOpenGL
+
+class Plateau(QtGui.QWidget):
+    def __init__(self):
+        QtGui.QWidget.__init__(self)
+        self.ui = Ui_Form()
+        self.ui.setupUi(self)
+
+        self.scene = QtGui.QGraphicsScene()
+        self.ui.view.setScene(self.scene)
+        self.scene.setSceneRect(0,0,self.ui.view.width(),self.ui.view.height())
+        self.ui.view.setViewport(QtOpenGL.QGLWidget())
+        self.cases = {}
+        
+        self.majQuadrillage(10,10)
+        self.nouveauPion()
+
+
+    def majQuadrillage(self, x, y):
+        #autre essai avec des rectancgles
+        if x > 0 and y > 0 and x == int(x) and y == int(y):
+            i = 1
+            lPlateau = self.ui.view.width()
+            hPlateau = self.ui.view.height()
+            self.cCase = int(lPlateau / x)  #cote de la case
+            
+            pinceau = QtGui.QPen()
+            pinceau.setColor(QtGui.QColor(85, 85, 85, 85))
+            pinceau.setWidth(1)
+            
+            #cree les cases
+            for i in range(x):
+                for j in range(y):
+                    self.cases[(i,j)] = QtGui.QGraphicsRectItem(i*self.cCase, j*self.cCase, self.cCase, self.cCase)
+                    self.cases[(i,j)].setPen(pinceau)
+                    self.scene.addItem(self.cases[(i,j)])
+
+
+    def nouveauPion(self):
+        #creation d'un pion
+        pinceau = QtGui.QPen()
+        pinceau.setColor(QtGui.QColor(0, 0, 0, 120))
+        pinceau.setWidth(2)
+        self.pion = QtGui.QGraphicsEllipseItem(0, 0, self.cCase, self.cCase)
+        self.pion.setPen(pinceau)
+        self.pion.setFlag(QtGui.QGraphicsItem.ItemIsMovable)
+        self.pion.setFlag(QtGui.QGraphicsItem.ItemIsFocusable)
+        self.pion.setBrush(QtGui.QColor(255, 0, 0, 150))
+
+        #options graphiques
+        painter = QtGui.QPainter()
+        painter.setRenderHints(QtGui.QPainter.Antialiasing, True)
+        self.pion.paint(painter, 1)
+
+
+        #ombre
+        self.shadow = QtGui.QGraphicsDropShadowEffect() 
+        self.shadow.setColor(QtGui.QColor(50, 50, 50, 200)) 
+        self.shadow.setXOffset(1) 
+        self.shadow.setYOffset(1) 
+        self.shadow.setBlurRadius(3) 
+        self.pion.setGraphicsEffect(self.shadow)
+        self.shadow.setEnabled(True)
+
+        #recentrage
+        #self.pion.mousePressEvent(self.test())
+        self.pion.setAcceptHoverEvents(True)
+        #self.pion.mouseReleaseEvent(self.test())
+        self.scene.addItem(self.pion)
+    
+
+
+def main():
+    app = QtGui.QApplication(sys.argv)
+    window = Main()
+    window.show()
+    sys.exit(app.exec_())  
+
+if __name__ == "__main__":
+    main()