# -*- coding: iso-8859-1 -*-
# Copyright 20003 - 2008: Julien Bourdaillet (julien.bourdaillet@lip6.fr), Jean-Gabriel Ganascia (jean-gabriel.ganascia@lip6.fr)
# This file is part of MEDITE.
#
#    MEDITE is free software; you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation; either version 2 of the License, or
#    (at your option) any later version.
#
#    MEDITE is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with Foobar; if not, write to the Free Software
#    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
#----------------------------------------------------------------------------
# Nom:          Medite.py
# Objet:        Classe correspondant à l'interface medite du logiciel
#----------------------------------------------------------------------------
import sys,wx 

#from wxPython.wx import *
#import Utile
from Utile.constantesDonnees import *
from Utile.constantesGUI  import *
from Utile.exceptionsDonnees import *
from Utile.decodage import *

from GUI.FormulairesMenuDossiers import *
from GUI.FormulairesMenuGenetique import *
from GUI.FormulairesMenuMedite import *
from GUI.FormulairesMenuInformations import *
from GUI.MainPanel import MainPanel
from GUI.TreePanel import TreePanel
from GUI.MainToolBar import MainToolBar

from Donnees.planTravail import *

import  constantes
import MediteAppli.synthetic
from Controleurs.cMedite import *

from Controleurs.cInformations import *
from Controleurs.cTravail import *
import Controleurs.FInfoManager
import Controleurs.DGManager
import profile

import MediteAppli.synthetic

#---------------------------------------------------------------------------
#Classe principale pour la creation de l'interface
class MediteFrame(wx.Frame):
    def __init__(self, parent, ID, title):
        wx.Frame.__init__(self, parent, ID, title,
                         wx.DefaultPosition,wx.Size(900, 700),style=wx.DEFAULT_FRAME_STYLE|wx.FULL_REPAINT_ON_RESIZE)
                                
        self.CreateStatusBar()
        self.SetStatusText(u'Bienvenue sur Medite')

        #Menu Dossier
        mDossier = wx.Menu()
        smNouveauDossier=wx.Menu()
        smNouveauDossier.Append(ID_ADD_AUTEUR, 'Auteur',u'Cr\xe9er un nouvel auteur.')
        smNouveauDossier.Append(ID_ADD_OEUVRE, 'Oeuvre',u'Cr\xe9er une nouvelle oeuvre.')
        mDossier.AppendMenu(ID_NOUVEAU_DOSSIER, 'Nouveau', smNouveauDossier)
        mDossier.AppendSeparator()
        smSupprimerDossier=wx.Menu()
        smSupprimerDossier.Append(ID_SUPP_AUTEUR, 'Auteur','Supprimer un auteur.')
        smSupprimerDossier.Append(ID_SUPP_OEUVRE, 'Oeuvre','Supprimer une oeuvre.')
        mDossier.AppendMenu(ID_SUPPRIMER_DOSSIER, 'Supprimer', smSupprimerDossier)
        mDossier.AppendSeparator()
        mDossier.Append(ID_QUITTER, 'Quitter','Quitter MEDITE.')


        #Menu Genetique
        mGenetique = wx.Menu()
        mGenetique.Append(ID_CHARGER_DG, u'Charger Dossier G\xe9n\xe9tique', u'Charger le dossier g\xe9n\xe9tique sur lequel vous voulez travailler')
        mGenetique.AppendSeparator()
        smCreerGenetique=wx.Menu()
        smCreerGenetique.Append(ID_CREER_VERSION, u'Version',u'Cr\xe9er un nouveau dossier version.')
        smCreerGenetique.Append(ID_CREER_ETAT, u'Etat',u'Cr\xe9er un nouvel état.')
        mGenetique.AppendMenu(ID_CREER_GENE, u'Cr\xe9er', smCreerGenetique)
        mGenetique.Append(ID_IMPORTER_TEXTES, u'Importer r\xe9pertoire de textes', u'Importer un r\xe9pertoire de textes dans un dossier g\xe9n\xe9tique')
        mGenetique.AppendSeparator()
        smSupprimerGenetique=wx.Menu()
        smSupprimerGenetique.Append(ID_SUPP_VERSION, 'Version','Supprimer un dossier version.')
        smSupprimerGenetique.Append(ID_SUPP_ETAT, 'Etat',u'Supprimer un état.')
        mGenetique.AppendMenu(ID_SUPPRIMER_GENE, u'Supprimer', smSupprimerGenetique)

        #Menu Informations
        self.mInformations = wx.Menu()
        self.mInformations.Append(ID_CHARGER_INFOS, 'Charger Informations', u'Charger les informations concernant deux états')
        self.mInformations.Enable(ID_CHARGER_INFOS,False)
#        self.smInformations=wx.Menu()
#        self.smInformations.Append(ID_INFOS_DG, u'Dossier G\xe9n\xe9tique',u'Informe des tansformations enregistr\xe9es pour le dossier g\xe9n\xe9tique charg\xe9.')
#        self.smInformations.Append(ID_INFOS_CPLE, 'Etats',u'Informe des transformations enregistr\xe9es pour le couple d\'états charg\xe9s.')
#        self.mInformations.AppendMenu(ID_INFOS, 'Informations', self.smInformations)
        self.mInformations.AppendSeparator()
        self.smEnregistrer=wx.Menu()
        self.smEnregistrer.Append(ID_ADD_TRANSFOS, 'Transformations',u'Enregistrer les transformations de deux états.')
        self.smEnregistrer.Enable(ID_ADD_TRANSFOS,False)
        self.smEnregistrer.Append(ID_ADD_COMMENT, 'Commentaire',u'Enregistrer le commentaire de deux états.')
        self.smEnregistrer.Enable(ID_ADD_COMMENT,False)
        self.smEnregistrer.Append(ID_ADD_TRANSFOS_COMMENT, 'Transformations et Commentaire',u'Enregistrer les transformations et le commentaire de deux états.')
        self.smEnregistrer.Enable(ID_ADD_TRANSFOS_COMMENT,False)
        self.smEnregistrer.AppendSeparator()
        self.smEnregistrer.Append(ID_ADD_ALL_TRANSFOS, 'Toutes les Transformations et Commentaires', u'Enregistrer les transformations et commentaires de toutes les comparaisons')
        self.mInformations.AppendMenu(ID_ENREGISTRER, 'Enregistrer', self.smEnregistrer)
        self.mInformations.AppendSeparator()
        self.smSupprimerInformations=wx.Menu()
        self.smSupprimerInformations.Append(ID_SUPP_TRANSFOS_COMMENT, 'Informations',u"Supprimer les transformations et le commentaire d\'un couple d\'états")
        self.smSupprimerInformations.Append(ID_SUPP_COMMENT, 'Commentaire','Supprimer un commentaire.')
        self.smSupprimerInformations.AppendSeparator()
        self.smSupprimerInformations.Append(ID_SUPP_ALL_TRANSFOS, 'Supprimer toutes les transformations et commentaires',u'Supprimer les transformations et commentaires de toutes les comparaisons')
        self.mInformations.AppendMenu(ID_SUPPRIMER_INFOS, 'Supprimer', self.smSupprimerInformations)
        self.mInformations.AppendSeparator()
        self.smChargerInformations=wx.Menu()
        self.smChargerInformations.Append(ID_LOAD_ALL_TRANSFOS_COMMENT, 'Informations',u'Charger les transformations et commentaires de toutes les comparaisons enregistrées')
        self.mInformations.AppendMenu(ID_LOAD_INFOS, 'Charger', self.smChargerInformations)

        #Menu Medite
        self.mMedite = wx.Menu()
        self.smOuvrir=wx.Menu()
        self.smOuvrir.Append(ID_SOURCE, 'Etat Source',u'Ouvrir un état source.')
        self.smOuvrir.Enable(ID_SOURCE, False)
        self.smOuvrir.Append(ID_CIBLE, 'Etat Cible',u'Ouvrir un état cible.')
        self.smOuvrir.Enable(ID_CIBLE, False)
        self.mMedite.AppendMenu(ID_OUVRIR, 'Ouvrir', self.smOuvrir)
        self.mMedite.AppendSeparator()
        self.mMedite.Append(ID_EXECUTER, u'Ex\xe9cuter Medite', u'Appliquer Medite sur les deux états charg\xe9s')
        self.mMedite.Enable(ID_EXECUTER, False)
        self.mMedite.AppendSeparator()
        self.mMedite.Append(ID_EXECUTERALL, u'Ex\xe9cuter toutes les Comparaisons', u"Exécute toutes les comparaisons entre les états de l\'arbre des versions.")
        self.mMedite.Enable(ID_EXECUTERALL, False)
        self.mMedite.AppendSeparator()
        self.mMedite.Append(ID_LAUNCH_STAT, u'Etiquetage', u"Lancer l'étiquetage morpho-syntaxique.")
        self.mMedite.Enable(ID_LAUNCH_STAT, True)
        
        # Menu Comparaison
        self.mComparaison = wx.Menu()
        self.mComparaison.Append(ID_NEWCOMP,"Nouvelle Comparaison","Ouvre un nouvel onglet de comparaison")
#       self.mComparaison.AppendSeparator()
#       self.mComparaison.Append(ID_CLOSECOMP,"Ferme Comparaison",u"Ferme l'onglet de la comparaison courante mais ne supprime pas les éventuelles informations enregistrées")
#       self.mComparaison.Append(ID_CLOSEALLCOMP,"Ferme toutes les Comparaison",u"Ferme les onglets de toutes comparaisons mais ne supprime pas les éventuelles informations enregistrées")
        self.mComparaison.AppendSeparator()     
        self.mComparaison.Append(ID_DELCOMP,"Supprime Comparaison",u"Supprime la comparaison courante et ses éventuelles informations enregistrées")
        self.mComparaison.Append(ID_DELALLCOMP,"Supprime toutes les Comparaisons",u"Supprime toutes les comparaisons et leurs éventuelles informations enregistrées")

        #Menu Edit
        #self.mEdit = wx.Menu()
        self.mOperations = wx.Menu()
        #self.mEdit.Append(ID_UNDO,'Undo')
        #self.mEdit.Append(ID_REDO,'Redo')
        #self.mEdit.AppendSeparator()
        
        self.mOperations.Append(ID_INSERTION_MAN,'Insertion')
        self.mOperations.Append(ID_SUPPRESSION_MAN,'Suppression')
        self.mOperations.Append(ID_REMPLACEMENT_MAN,'Remplacement')
        self.mOperations.Append(ID_DEPLACEMENT_MAN,'Deplacement')
        self.mOperations.Append(ID_AUCUNE_MAN,'Aucune transformation')
        #self.mEdit.AppendMenu(0,'Operation',self.mOperations)

        # menu navigation
        self.mNavigation = wx.Menu()
        
        #Menu Aide
        mAide = wx.Menu()
        if wx.Platform == '__WXMSW__': 
                mAide.Append(ID_AIDE, 'Aide', 'Aide')
        mAide.Append(ID_APROPOS, 'A Propos de ...', 'A propos de ...')


        # Creation d'une barre de menu
        self.menu_bar = wx.MenuBar()
        #
        self.menu_bar.Append(mDossier, 'Dossier ')
        self.menu_bar.Append(mGenetique, u'G\xe9n\xe9tique')
        self.menu_bar.Append(self.mInformations, 'Informations')
        self.menu_bar.Append(self.mMedite, 'Medite')
        self.menu_bar.Append(self.mComparaison, 'Comparaison')
        #self.menu_bar.Append(self.mEdit,'Edit')
        self.menu_bar.Append(self.mOperations,'Transformation')
        self.menu_bar.Append(self.mNavigation, 'Navigation')
        self.menu_bar.Append(mAide, 'Aide')

        # set the menu bar (dit au systeme que c'est fait)
        self.SetMenuBar(self.menu_bar)

        #Creation de toolbar
        self.tb = MainToolBar(self)
        self.SetToolBar(self.tb)

        #Creation des instances des controleurs
        #self.cdon = CDonnees()
        #self.cdos = CDossierGenetique()
        self.cmed = CMedite()
        self.cinfos = CInformations()
        self.ctravail = CTravail()
        self.dgm = Controleurs.DGManager.DGManager()
        
        #Evenements sur Menu
###########################################################################
        
        wx.EVT_MENU(self,ID_AUCUNE_MAN,self.enleverChangement)
        wx.EVT_MENU(self,ID_INSERTION_MAN,self.ajouterInsertion)
        wx.EVT_MENU(self,ID_SUPPRESSION_MAN,self.ajouterSuppression)
        wx.EVT_MENU(self,ID_DEPLACEMENT_MAN,self.ajouterDeplacement)
        wx.EVT_MENU(self,ID_REMPLACEMENT_MAN,self.ajouterRemplacement)
        
##########################################################################
        wx.EVT_MENU(self, ID_ADD_AUTEUR, self.enregistrerAuteur)
        wx.EVT_MENU(self, ID_ADD_OEUVRE, self.enregistrerOeuvre)
        wx.EVT_MENU(self, ID_SUPP_AUTEUR, self.supprimerAuteur)
        wx.EVT_MENU(self, ID_SUPP_OEUVRE, self.supprimerOeuvre)
        wx.EVT_MENU(self, ID_QUITTER, self.quitter)
        wx.EVT_CLOSE(self, self.OnCloseWindow)


        wx.EVT_MENU(self, ID_CHARGER_DG, self.chargerDG)
        wx.EVT_MENU(self, ID_CREER_VERSION, self.creerDossierVersion)
        wx.EVT_MENU(self, ID_CREER_ETAT, self.creerEtat)
        wx.EVT_MENU(self, ID_SUPP_VERSION, self.supprimerDossierVersion)
        wx.EVT_MENU(self, ID_SUPP_ETAT, self.supprimerEtat)
        wx.EVT_MENU(self, ID_IMPORTER_TEXTES, self.importerRepertoire)

        wx.EVT_MENU(self, ID_CHARGER_INFOS, self.chargerInformations)
#        wx.EVT_MENU(self, ID_INFOS_DG, self.chargerInfosDG)
#        wx.EVT_MENU(self, ID_INFOS_CPLE, self.chargerInfosCple)
        wx.EVT_MENU(self, ID_ADD_TRANSFOS, self.enregistrerTransformations)
        wx.EVT_MENU(self, ID_ADD_COMMENT, self.enregistrerCommentaire)
        wx.EVT_MENU(self, ID_ADD_TRANSFOS_COMMENT, self.enregistrerInformations)
        wx.EVT_MENU(self, ID_ADD_ALL_TRANSFOS, self.enregistrerToutesInformations)
        wx.EVT_MENU(self, ID_SUPP_TRANSFOS_COMMENT, self.supprimerInformations)
        wx.EVT_MENU(self, ID_SUPP_COMMENT, self.supprimerCommentaire)
        wx.EVT_MENU(self, ID_SUPP_ALL_TRANSFOS, self.supprimerToutesInformations)
        wx.EVT_MENU(self, ID_LOAD_ALL_TRANSFOS_COMMENT, self.chargerInfosEtats)

        wx.EVT_MENU(self, ID_EXECUTER, self.executerMedite)
        wx.EVT_MENU(self, ID_EXECUTERALL, self.executerAll)
        wx.EVT_MENU(self, ID_SOURCE, self.ouvrirFicSource)
        wx.EVT_MENU(self, ID_CIBLE, self.ouvrirFicCible)
        wx.EVT_MENU(self, ID_LAUNCH_STAT, self.launchTagger)
        
        wx.EVT_MENU(self, ID_NEWCOMP, self.nouvelleComparaison)
#       wx.EVT_MENU(self, ID_CLOSECOMP, self.fermeComparaison)
#       wx.EVT_MENU(self, ID_CLOSEALLCOMP, self.fermeToutesComparaisons)
        wx.EVT_MENU(self, ID_DELCOMP, self.supprimeComparaison)
        wx.EVT_MENU(self, ID_DELALLCOMP, self.supprimeToutesComparaisons)
        
        wx.EVT_MENU(self, ID_AIDE, self.aide)
        wx.EVT_MENU(self, ID_APROPOS, self.aPropos)













                       

        ## Mise en place du plan de travail et des parametres (lissage, couleurs)
##        self.parDefaut()
        #self.miseEnPlacePlanTravailTOTAL()
        self.miseEnPlaceParametres()

        # Facade Panel principal
        self.nb = wx.Notebook(self)
        #self.nb.SetSize(size=wx.Size(900, 700))
        self.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, self.OnNBPageChanged, self.nb)
        #win = wx.Window(self.nb)
        self.createTreePanel()
        # ok
#       panelAnonyme=MainPanel(self.nb)
#       p2=MainPanel(self.nb)
#       self.nb.AddPage(panelAnonyme,"Comparaison")
#       self.nb.AddPage(p2,"Comparaison2")
        
        #self.panelMain = win.panelMain
        
        #self.sizer = wx.FlexGridSizer()#(wx.VERTICAL)
        #self.sizer.Add(self.nb)
        #self.SetSizer(self.sizer)                         
        #self.SetAutoLayout(True) 
        #self.Bind(wx.EVT_SIZE, self.OnSize)

        ###########################################################################
        ###SELECTION TEXT
        ###########################################################################


    ########################test##############
    def enableMenuTransformationsLeft(self,evt):
        self.mOperations.Enable(ID_INSERTION_MAN,False)
        self.mOperations.Enable(ID_SUPPRESSION_MAN,True)
        self.mOperations.Enable(ID_DEPLACEMENT_MAN,True)
        self.mOperations.Enable(ID_REMPLACEMENT_MAN,True)
        self.mOperations.Enable(ID_AUCUNE_MAN,True)

        self.menu_bar.EnableTop(5, True)
        
    def enableMenuTransformationsRight(self,evt):
        self.mOperations.Enable(ID_INSERTION_MAN,True)
        self.mOperations.Enable(ID_SUPPRESSION_MAN,False)
        self.mOperations.Enable(ID_DEPLACEMENT_MAN,True)
        self.mOperations.Enable(ID_REMPLACEMENT_MAN,True)
        self.mOperations.Enable(ID_AUCUNE_MAN,True)

        self.menu_bar.EnableTop(5, True)
        
    def disableMenuTransformations(self,evt):
##        self.mOperations.Enable(ID_INSERTION_MAN,False)
##        self.mOperations.Enable(ID_SUPPRESSION_MAN,False)
##        self.mOperations.Enable(ID_DEPLACEMENT_MAN,False)
##        self.mOperations.Enable(ID_REMPLACEMENT_MAN,False)
##        self.mOperations.Enable(ID_AUCUNE_MAN,False)
       
        self.menu_bar.EnableTop(5, False)



    def enleverChangement(self,evt):
##        self.noirSurBlanc()
##        self.affichageCouleur()
        panel=self.getCompPanel()
        panel.initialised = True
        selection = panel.textWindowRight.GetSelection()
        deb,fin=selection
        if deb<fin:
            transfo = panel.resultatTransfo
            transfo.enleverChangement(selection,2)
        
            self.affichageComparaison()
            
        selection = panel.textWindowLeft.GetSelection()
        deb,fin=selection
        if deb<fin:
            transfo = panel.resultatTransfo
            transfo.enleverChangement(selection,1)
        
            self.affichageComparaison() 
            
    def ajouterInsertion(self,evt):
        panel=self.getCompPanel()
        selection = panel.textWindowRight.GetSelection()
        deb,fin=selection
        if deb<fin:
            transfo = panel.resultatTransfo
            transfo.ajouterInsertion(selection)
        
            self.affichageComparaison() 
        
    def ajouterSuppression(self,evt):
        panel=self.getCompPanel()
        selection = panel.textWindowLeft.GetSelection()
        deb,fin=selection
        if deb<fin:
            transfo = panel.resultatTransfo
            transfo.ajouterSuppression(selection)
       
            self.affichageComparaison()

    def ajouterDeplacement(self,evt):
        panel=self.getCompPanel()
        selection = panel.textWindowLeft.GetSelection()
        deb,fin=selection
        if deb<fin:
            transfo = panel.resultatTransfo
            transfo.ajouterDeplacement(selection,1)
       
            self.affichageComparaison()

        selection = panel.textWindowRight.GetSelection()
        deb,fin=selection
        if deb<fin:
            transfo = panel.resultatTransfo
            transfo.ajouterDeplacement(selection,2)
       
            self.affichageComparaison()
            
    def ajouterRemplacement(self,evt):
        panel=self.getCompPanel()
        selection = panel.textWindowLeft.GetSelection()
        deb,fin=selection
        if deb<fin:
            transfo = panel.resultatTransfo
            transfo.ajouterRemplacement(selection,1)
       
            self.affichageComparaison()

        selection = panel.textWindowRight.GetSelection()
        deb,fin=selection
        if deb<fin:
            transfo = panel.resultatTransfo
            transfo.ajouterRemplacement(selection,2)
       
            self.affichageComparaison()
        
    # recharge le menu de Navigation
    def reloadNavMenu(self):
        if self.mNavigation.GetMenuItemCount():
            lItems = self.mNavigation.GetMenuItems()
            for item in lItems:
                self.mNavigation.Delete(item.GetId())
#           i = 1
#           while i<self.mNavigation.GetMenuItemCount():
#               sys.stderr.write("i = "+str(i)+"\n")
#               sys.stderr.flush()
#               self.mNavigation.Remove(i)
#               i+=1
            #self.mNavigation.Destroy()
            #self.mNavigation = wx.Menu()
        #navMenu = wx.Menu()
        i = 0
        while i<self.nb.GetPageCount():
            self.mNavigation.Append(ID_NAVMENU+i, str(self.nb.GetPage(i).getTitre()),'')
            #sys.stderr.write('x'+self.nb.GetPage(i).getTitre()+'x\n')
            wx.EVT_MENU(self, ID_NAVMENU+i, self.selectPage)
            i+=1
        #self.mNavigation.AppendMenu(ID_NAVMENU, 'Ouvrir', self.smOuvrir)

    def selectPage(self,event):
        self.nb.SetSelection(event.GetId()-ID_NAVMENU)
        
    def getMainPanel(self):
        """ Pointe sur le MainPanel associé à l'onglet courant du notebook """
        return self.nb.GetPage(self.nb.GetSelection())
        
    def getCompPanel(self):
        """ Pointe sur le ComparaisonPanel associé à l'onglet courant du notebook """
        return self.getMainPanel().getComparaisonPanel()
        
    def getPlanTravail(self):
        """ Pointe sur le plan de travail associé à l'onglet courant """
        return self.getMainPanel().planTravail 
        
    def OnNBPageChanged(self,event):
        """ Changement de pane, gestion des menus """
        if self.getMainPanel().isTreePanel():
            self.disableMenuDGCharge()
            self.disableMenuArbre()
            self.disableMenuTransformations(event)
        elif self.getPlanTravail().getAuteur() != '' and self.getPlanTravail().getOeuvre() != '':
            self.enableMenuDGCharge()
            self.enableMenuArbre()
            #self.enableMenuTransformations()
        else:
            self.disableMenuDGCharge()
            self.enableMenuArbre()
            #self.enableMenuTransformations()
     
    def OnSize(self, event):
        wx.Frame.OnSize(self,event)
        wx.LayoutAlgorithm().LayoutFrame(self)
        
        
    def enableMenuArbre(self):
        """ Autorise les menus interdits lorque l'on quitte le treePanel """
        #self.mComparaison.Enable(ID_NEWCOMP,True)
        self.mComparaison.Enable(ID_DELCOMP,True)
        self.mComparaison.Enable(ID_DELALLCOMP,True)
        #self.mComparaison.Enable(ID_CLOSECOMP,True)
        #self.mComparaison.Enable(ID_CLOSEALLCOMP,True)
        self.menu_bar.EnableTop(2, True)
        self.menu_bar.EnableTop(3, True)
        
    def disableMenuArbre(self):
        """ Interdit certains menus lorsque l'on est sur le treepanel """
        #self.mComparaison.Enable(ID_NEWCOMP,False)
        self.mComparaison.Enable(ID_DELCOMP,False)
        self.mComparaison.Enable(ID_DELALLCOMP,False)
        #self.mComparaison.Enable(ID_CLOSECOMP,False)
        #self.mComparaison.Enable(ID_CLOSEALLCOMP,False)
        self.menu_bar.EnableTop(2, False)
        self.menu_bar.EnableTop(3, False)
        
    def nouvelleComparaison(self,event):
        """ Crée une nouvelle de comparaison """
        newplan = PlanTravail("","","","","","",Parametres())  
        self.listePlanTravail.appendPlanTravail(newplan)
        newpanel=MainPanel(self.nb,newplan)
        newpanel.initialised = False
        # chargement du dossier génétique comme dans FormulaireMenuGenetique
        if self.DGLoaded:
            newpanel.getComparaisonPanel().textInfoAuteur.SetLabel(self.DGAuteur)
            newpanel.getComparaisonPanel().textInfoOeuvre.SetLabel(self.DGOeuvre)
            ### Mise a jour du plan de travail
            newpanel.getComparaisonPanel().planTravail.setAuteur(self.DGAuteur)
            newpanel.getComparaisonPanel().planTravail.setOeuvre(self.DGOeuvre)
            newpanel.getComparaisonPanel().planTravail.setVersionSource('')
            newpanel.getComparaisonPanel().planTravail.setEtatSource('')
            newpanel.getComparaisonPanel().planTravail.setVersionCible('')
            newpanel.getComparaisonPanel().planTravail.setEtatCible('')
            self.disableMenuDGCharge()
            self.enableMenuDGCharge()
        # ajout de la page
        self.nb.AddPage(newpanel,newplan.getEtatSource()+"-"+newplan.getEtatCible())
        self.nb.SetSelection(self.nb.GetPageCount()-1)
        self.reloadNavMenu()
        
    # supprime le panel courant
    def supprimeComparaison(self,event):
        plan = self.getPlanTravail()
        # demande de suppression des infos enregistrées dans informations.xml
#       if ((self.getCompPanel().initialised) and 
#           self.cinfos.existeInformations(self.getPlanTravail()):
#           phrase = u"Voulez-vous supprimer les informations enregistrées associées à cette comparaison ?"
#            dlg = wx.MessageDialog(self,phrase,"Suppression",wx.YES|wx.CANCEL)
#           res = dlg.ShowModal() 
#           dlg.Destroy()
#           if res == wx.ID_CANCEL:
#               return
#           elif res == wx.ID_YES:
#               self.cinfos.supprimerInformations(self.getPlanTravail())       

        if ((self.getCompPanel().initialised) and self.cinfos.existeInformations(self.getPlanTravail())):
            self.cinfos.supprimerInformations(self.getPlanTravail())                                                    
        # suppression de l'onglet et de son plan de travail associé
        self.nb.DeletePage(self.nb.GetSelection())
        self.listePlanTravail.deletePlanTravail(plan)
        self.reloadNavMenu()

    # supprime tous les panels de comparaison
    def supprimeToutesComparaisons(self,event): 
        while self.nb.GetPageCount() != 1:
            self.nb.SetSelection(self.nb.GetPageCount()-1)
            self.supprimeComparaison(None)
        self.nouvelleComparaison(None)

    # supprime le panel courant
#    def fermeComparaison(self,event):
#       plan = self.getPlanTravail()
#       # suppression de l'onglet et de son plan de travail associé
#       self.nb.DeletePage(self.nb.GetSelection())
#       self.listePlanTravail.deletePlanTravail(plan)
#       self.reloadNavMenu()    
#       
#    # supprime tous les panels de comparaison
#    def fermeToutesComparaisons(self,event): 
#       while self.nb.GetPageCount() != 1:
#           self.nb.SetSelection(self.nb.GetPageCount()-1)
#           self.fermeComparaison(NULL)
#       self.nouvelleComparaison(NULL)
        
    def createTreePanel(self):
        self.treePanel = TreePanel(self.nb, self)
        self.nb.InsertPage(0,self.treePanel,"Arbre")
        
    def quitter(self, event):
        self.Close(True)
        
    def OnCloseWindow(self, event):
        text='Voulez vous vraiment quitter MEDITE ?'
        dlg = wx.MessageDialog(self, text, 'Quitter',wx.YES_NO)
        if dlg.ShowModal() == wx.ID_YES:
            dlg.Destroy()
            self.enregistrerPlanTravailTOTAL()
            self.enregistrerToutesInformations(None)
            self.Destroy()
        else :
            dlg.Destroy()

    def enregistrerPlanTravailTOTAL(self):
        """ Enregistrement de tout le plan de travail (plan, parametres, couleurs) """
        try:
            self.ctravail.enregistrerListePlans(self.listePlanTravail)
            self.ctravail.enregistrerCouleurs(self.couleursTransfo)
            self.ctravail.enregistrerParametres(self.parametres)
        except Exception,e: 
            sys.stderr.write(str(e))  
            traceback.print_exc()
            sys.stderr.flush()

    def launchTagger(self, evt):
        """ Etiquetage """
        self.SetCursor(wx.HOURGLASS_CURSOR)
        if self.getCompPanel().initialised == True:
            try:
                tagger = MediteAppli.synthetic.TaggerExtension(self.getCompPanel().resultatTransfo)
                frequencyMatrix = tagger.run()
                textMatrix = MediteAppli.synthetic.TextFrequencyMatrix(self.getCompPanel().resultatTransfo)
                self.getMainPanel().addStatPanel(frequencyMatrix,textMatrix)
            except Exception,e1:
                traceback.print_exc()
                sys.stderr.flush()
                dlg=wx.MessageDialog(self,str(e1),"Erreur",wx.OK)
                dlg.ShowModal()
                dlg.Destroy()
        self.SetCursor(wx.STANDARD_CURSOR)
        
    # Mise en place du plan de travail et des parametres (lissage, couleurs)
    #def miseEnPlacePlanTravailTOTAL(self):
    def miseEnPlaceParametres(self):
        # chargement plan de travail
#        try :
#            self.planTravail = self.ctravail.chargerPlan()
#            if self.planTravail.getAuteur() != '' and self.planTravail.getOeuvre() != '':
#                self.enableMenuDGCharge()
#        except FichierNonTrouve, eFNT :
#            self.planTravail = PlanTravail("","","","","","")   #auteur,oeuvre,versSource,etatS,verCible,etatC
        # chargement couleurs
        try :
            self.couleursTransfo = self.ctravail.chargerCouleurs()
        except FichierNonTrouve, eFNT :
            self.couleursTransfo = self.ctravail.chargerCouleursDefaut()
        # chargement parametres
        try :
            self.parametres = self.ctravail.chargerParametres()
            #sys.stderr.write("param = "+self.parametres.toString())
        except FichierNonTrouve, eFNT:
            self.parametres = self.ctravail.chargerParametresDefaut()


    # Mise en place du plan de travail, des couleurs et des parametres par defaut
#    def parDefaut(self):
#        #Variables concernant le dossier genetique courant
#        self.planTravail = PlanTravail("","","","","","")   #auteur,oeuvre,versSource,etatS,verCible,etatC
#        #couleurs des transformations
#        self.couleursTransfo = self.ctravail.chargerCouleursDefaut()
#        #parametres de lissage
#        self.parametres = self.ctravail.chargerParametresDefaut()
            
    # Methode qui ouvre une fenetre A propos        
    def aPropos(self, evt):
        text=u"                      MEDITE - Machine EDITE\n\n                     Etude Diachronomique et  \n           Interpr\xe9tative des Textes d'Ecrivains\n\n           Application imagin\xe9e et r\xe9alis\xe9e par\n\n        Jean-Gabriel Ganascia et Julien Bourdaillet\n\nJean-Gabriel@Ganascia.name - Julien.Bourdaillet@lip6.fr    \n\n                            Version 3.7"
        dlg = wx.MessageDialog(self, text, 'A propos...',wx.OK | wx.ICON_INFORMATION) 
        dlg.ShowModal() 
        dlg.Destroy()

    # Methode qui ouvre une fenetre d'aide
    def aide(self,evt):
        if 'win' in sys.platform:
            import wx.lib.iewin 
            self.newFenetre = wx.Frame(None, -6, 'aide')
            self.newFenetre.html = wx.lib.iewin.IEHtmlWindow(self.newFenetre, -1, style=wx.NO_FULL_REPAINT_ON_RESIZE)
            self.newFenetre.html.Navigate(os.path.join(constantes.REPMEDITE,'aide.html'))
            self.newFenetre.Show()

    # Methode qui appelle le formulaire de saisie pour enregistrer un auteur
    def enregistrerAuteur(self,evt):
        formulaire=FormAuteur(self,-1)
        formulaire.Show(True)

    # Methode qui appelle le formulaire de saisie pour enregitrer une oeuvre
    def enregistrerOeuvre(self,evt):
        feo = FormEnregistrerOeuvre(self)

    # Methode qui appelle le formulaire de saisie pour supprimer un auteur
    def supprimerAuteur(self,evt):
        fsa = FormSupprimerAuteur(self)

    # Methode qui appelle le formulaire de saisie pour supprimer une oeuvre
    def supprimerOeuvre(self,evt):
        formulaire=FormSupprimerOeuvre(self)
        formulaire.Show(1)

    # Methode qui rend actifs les menus et les boutons permettant d'ouvrir les fichiers source
    # et cible   
    def enableMenuDGCharge(self):
        self.smOuvrir.Enable(ID_SOURCE, True)
        self.tb.EnableTool(ID_SOURCE, True)
        self.smOuvrir.Enable(ID_CIBLE, True)
        self.tb.EnableTool(ID_CIBLE, True)  
        self.mMedite.Enable(ID_EXECUTER,True)
        self.tb.EnableTool(ID_EXECUTER,True)
        self.mMedite.Enable(ID_EXECUTERALL,True)
        
    def disableMenuDGCharge(self):
        self.smOuvrir.Enable(ID_SOURCE, False)
        self.tb.EnableTool(ID_SOURCE, False)
        self.smOuvrir.Enable(ID_CIBLE, False)
        self.tb.EnableTool(ID_CIBLE, False)  
        self.mMedite.Enable(ID_EXECUTER,False)
        self.tb.EnableTool(ID_EXECUTER,False)
        self.mMedite.Enable(ID_EXECUTERALL,False)
        
    # Methode qui rend inactifs les menus et les boutons permettant de charger ou d'enregistrer 
    # les informations, d'executer medite et reinitialise les variables du dossier genetique
    # courant ainsi que les fenêtres de visualisation
    def disableDGCharge(self):
        self.getPlanTravail().setVersionSource('')
        self.getPlanTravail().setEtatSource('')
        self.getPlanTravail().setVersionCible('')
        self.getPlanTravail().setEtatCible('')
        
        self.mInformations.Enable(ID_CHARGER_INFOS,False)
        self.smEnregistrer.Enable(ID_ADD_TRANSFOS, False)
        self.smEnregistrer.Enable(ID_ADD_COMMENT, False)
        self.smEnregistrer.Enable(ID_ADD_TRANSFOS_COMMENT, False)
        self.mMedite.Enable(ID_EXECUTER, False)
        self.tb.EnableTool(ID_EXECUTER, False)

        self.getCompPanel().textWindowLeft.SetValue(u"état source")
        self.getCompPanel().textWindowRight.SetValue(u"état cible")
        self.getCompPanel().textInfoVersionS.SetLabel("")
        self.getCompPanel().textInfoEtatS.SetLabel("")
        self.getCompPanel().textInfoVersionC.SetLabel("")
        self.getCompPanel().textInfoEtatC.SetLabel("")
        self.getCompPanel().transformations.SetValue("")

    # Methode qui appelle le formulaire de saisie pour charger DG        
    def chargerDG(self,evt):
        formulaire=FormChargerDG(self)
        formulaire.Show(True)
            
    # Methode qui appelle le formulaire de saisie pour creer un dossier version
    def creerDossierVersion(self,evt):
        formulaire=FormCreerVersion(self)
        formulaire.Show(True)
        
    # Methode qui appelle le formulaire de saisie pour creer un etat
    def creerEtat(self,evt):
        formulaire=FormCreerEtat(self)
        formulaire.Show(True)
        
    # Methode qui appelle le formulaire de saisie pour supprimer un dossier version
    def supprimerDossierVersion(self,evt):
        formulaire=FormSupprimerVersion(self)
        formulaire.Show(True)
        
    # Methode qui appelle le formulaire de saisie pour supprimer un état
    def supprimerEtat(self,evt):
        formulaire=FormSupprimerEtat(self)
        formulaire.Show(True)

    def importerRepertoire(self,evt):
        formulaire=FormImporterRepertoire(self)
        formulaire.Show(True)

        
    # Methode qui va charger les informations d'une comparaison des deux états ouverts
    # et va rendre inactifs les boutons et menus enregistrer les informations
    def chargerInformations(self,evt):
        try:
            self.__chargement(None)
        except InformationsNonTrouvees, eINT:
            dlg=wx.MessageDialog(self, u"Les informations n'ont pas \xe9t\xe9 trouv\xe9es !!","Attention",wx.OK)
            dlg.ShowModal()
            dlg.Destroy()

    # Methode qui va enregistrer les transformations, resultats de la comparaison des deux
    # états ouverts
    def enregistrerTransformations(self,evt):
        self.cinfos.enregistrerTransformations(self.getPlanTravail(),self.getCompPanel().resultatTransfo)

    # Methode qui enregistre le commentaire sur un couple d'états, edite par l'utilisateur
    # Le commentaire n'est pas enregistre si il est vide
    # Si un commentaire existe deja pour ce couple d'états, la methode appele le formulaire
    # de choix qui lui permet de choisir soit d'ecraser l'ancien commentaire par le nouveau
    # soit d'ajouter le nouveau a l'ancien commentaire
    # Si l'application n'a pas ete execute sur le couple d'états,
    # le commentaire n'est pas enregistre
    def enregistrerCommentaire(self,evt):
        if (self.getCompPanel().commentaire.GetValue()!=""):
            try:
                self.cinfos.enregistrerCommentaire(self.getPlanTravail(),self.getCompPanel().commentaire.GetValue())
            except CommentaireDejaExistant, eCDE:
                formulaire=FormEnregistrerCommentaire(self,eCDE.getCommentaire().getCommentaire(),
                                                      self.parametres)
                formulaire.Show(True)
            except InformationsNonTrouvees, eINT:
                self.__choixParametres()
##                msg = "Les transformations concernant les deux états n'ont pas \xe9t\xe9 enregistr\xe9"
##                msg += '\nPour enregistrer le commentaire vous devez cliquer, dans la barre de menu "Informations", sur "Enregistrer" puis sur " Transformations et Commentaire"'
##                dlg=wx.MessageDialog(self, msg,"Attention",wx.OK)
##                dlg.ShowModal()
##                dlg.Destroy()
        else:
            dlg=wx.MessageDialog(self, "Le commentaire est vide","Attention",wx.OK)
            dlg.ShowModal()
            dlg.Destroy()
        
    # Methode qui appelle le formulaire de saisie pour supprimer les informations d'un
    # couple d'états
    def supprimerInformations(self,evt):
        formulaire=FormSupprimerInformations(self, "Supprimer les informations")
        formulaire.Show(True)
    
    def supprimerToutesInformations(self,evt):
        page = self.nb.GetSelection()
        self.SetCursor(wx.HOURGLASS_CURSOR)
        max = self.nb.GetPageCount()
        i = 1
        while i < self.nb.GetPageCount() :
            self.nb.SetSelection(i)
            if self.getCompPanel().initialised == False:
                i+=1
                continue
            #try:
            self.cinfos.supprimerInformations(self.getPlanTravail())
            #finally:                                           
            i+=1
        self.nb.SetSelection(page) 
        self.SetCursor(wx.STANDARD_CURSOR)
        
    # Methode qui appelle le formulaire de saisie pour supprimer le commentaire d'un
    # couple de états
    def supprimerCommentaire(self,evt):
        formulaire=FormSupprimerCommentaire(self, "Supprimer Commentaire")
        formulaire.Show(True)

    # Methode qui permet d'enregistrer les transformations et le commentaire d'un
    # couple de états    
    def enregistrerInformations(self,evt):
        if self.getCompPanel().initialised == False:
            #sys.stderr.write("panel not init\n")
            sys.stderr.flush()
            return
        
        self.cinfos.enregistrerTransformations(self.getPlanTravail(),self.getCompPanel().resultatTransfo)
        if self.getCompPanel().commentaire.GetValue() !='' :
            try:    
                self.cinfos.enregistrerCommentaire(self.getPlanTravail(),self.getCompPanel().commentaire.GetValue())
            except AuteurNonTrouve, eANT:
                dlg=wx.MessageDialog(self, u"L'auteur n'a pas \xe9t\xe9 trouv\xe9!!","Attention",wx.OK)
                dlg.ShowModal()
                dlg.Destroy()
            except OeuvreNonTrouvee, eONT:
                dlg=wx.MessageDialog(self, u"L'oeuvre n'a pas \xe9t\xe9 trouv\xe9e!!","Attention",wx.OK)
                dlg.ShowModal()
                dlg.Destroy()
            except CommentaireDejaExistant, eCDE:
                if evt!=None:
                     formulaire=FormEnregistrerCommentaire(self,eCDE.getCommentaire().getCommentaire(),
                                                      self.parametres)
                     formulaire.Show(True)
                     
    def enregistrerToutesInformations(self,evt):
        page = self.nb.GetSelection()
        self.SetCursor(wx.HOURGLASS_CURSOR)
        
        i = 1
        while i < self.nb.GetPageCount():
            self.nb.SetSelection(i)
            self.enregistrerInformations(None)
            i+=1
        self.nb.SetSelection(page)   
        self.SetCursor(wx.STANDARD_CURSOR)
            
    # Methode qui rend actifs les boutons et menus Charger les informations,
    # enregistrer commentaire et executer medite apres l'ouverture d'un couple de états                
    def enableMenuEtatsOuverts(self):
        if ((self.getPlanTravail().getEtatSource() !="") & (self.getPlanTravail().getEtatCible() !="")):
            self.mInformations.Enable(ID_CHARGER_INFOS,True)
            self.smEnregistrer.Enable(ID_ADD_COMMENT, True)
            self.mMedite.Enable(ID_EXECUTER, True)
            self.tb.EnableTool(ID_EXECUTER, True)

    # Methode  qui appelle le formulaire de saisie pour ouvrir un état Source      
    def ouvrirFicSource(self,evt):
        #Mise en forme du texte
        formulaire=FormOuvrirFichier(self,u"Ouvrir un état Source","Source")
        formulaire.Show(1)

    # Methode qui appelle le formulaire de saisie pour ouvrir un état Cible    
    def ouvrirFicCible(self,evt):
        #Mise en forme du texte
        formulaire=FormOuvrirFichier(self,u"Ouvrir un état Cible","Cible")
        formulaire.Show(1)
        

        
    def executerAll(self,evt):
        if not self.DGLoaded:
            return
        
        self.SetCursor(wx.HOURGLASS_CURSOR)
        fim = Controleurs.FInfoManager.FInfoManager.FInfoManager(Controleurs.DGManager.Auteur(self.DGAuteur),Controleurs.DGManager.Oeuvre(self.DGOeuvre))
        lEtats = fim.getArbre().getListePlateEtats()
        while not lEtats == []:
            (etatS,versionS) = lEtats.pop(0)
            for (etatC, versionC) in lEtats:
                # création PlanTravail et Panel
                plan = PlanTravail(self.DGAuteur, self.DGOeuvre, versionS.getNom(), etatS.getNom(), versionC.getNom(), etatC.getNom(),self.parametres)
                self.listePlanTravail.appendPlanTravail(plan)
                panel=MainPanel(self.nb,plan)
                self.nb.AddPage(panel,plan.getEtatSource()+"-"+plan.getEtatCible())
                self.nb.SetSelection(self.nb.GetPageCount()-1)
                fontDefault=wx.Font(10,wx.DEFAULT,wx.NORMAL,wx.NORMAL,encoding=wx.FONTENCODING_ISO8859_1)
                # chargement état Source
                cheminS=self.dgm.getEtatPath(self.DGAuteur, self.DGOeuvre, versionS.getNom(), etatS.getNom())
                self.getCompPanel().textWindowLeft.SetStyle(0,0,wx.TextAttr(wx.BLACK,wx.WHITE,fontDefault))
                self.getCompPanel().textWindowLeft.SetValue(loadFile(cheminS))
                # chargement état cible
                cheminC=self.dgm.getEtatPath(self.DGAuteur, self.DGOeuvre, versionC.getNom(), etatC.getNom())
                self.getCompPanel().textWindowRight.SetStyle(0,0,wx.TextAttr(wx.BLACK,wx.WHITE,fontDefault))
                self.getCompPanel().textWindowRight.SetValue(loadFile(cheminC))
                self.getCompPanel().initialised = True
                self.executerMedite(None)
        self.reloadNavMenu()
        self.SetCursor(wx.STANDARD_CURSOR)

#############################################################################################
##      INITIALISATION DES TEXTES                                                          ##
#############################################################################################
    def initialiserTextes(self,evt):
        self.enregistrerTransformations(evt)
        #self.chargerInformations(evt)
##        blocs=self.getCompPanel().resultatTransfo.getPairesBlocsDeplaces()
##        dep=self.getCompPanel().resultatTransfo.getListeDeplacements()
##        textConca = self.getCompPanel().resultatTransfo.getTextesConcatenes()
##        #paires = [ textConca[x[0][0]:x[0][1]] for x in blocs if dep.count(x[0][0]) > 1]
##        per1 = [(textConca[x[0][0]:x[0][1]],textConca[y[0][0]:y[0][1]]) for x in blocs for y in blocs if x[0]!=y[0] and x[1]==y[1]]
##        per2 = [(textConca[x[0][0]:x[0][1]],textConca[y[0][0]:y[0][1]]) for x in blocs for y in blocs if x[1]!=y[1] and x[0]==y[0]]
##        print blocs
##        print per1
##        print per2
        #print 'longueur deplacements : ',len(dep),'\n','longueur blocs : ',len(blocs),'\n'
    
        
##        self.__chargement(None)
##        self.noirSurBlanc()
##        self.affichageTransformations()
##        try :
##            max = 20
##            self.prog = wx.ProgressDialog('Attendre','Excecution de la comparaison',max,self,
##                                         style = wx.PD_AUTO_HIDE | wx.PD_APP_MODAL ) # | wxPD_ESTIMATED_TIME )
##        
##            count = 0
##            while count < (max-4)/2:
##                count = count + 2
##                #wxSleep(1)
##                self.prog.Update(count)
##                
##            #sys.stderr.write( 'pParametres = '+self.parametres.toString())
##            self.getPlanTravail().setParam(self.parametres)
##            self.getCompPanel().resultatTransfo = self.cmed.initialiser(self.getPlanTravail())
##            self.getCompPanel().initialised = True  
##            
##            self.prog.Update(10,"Affichage des transformations")
##            while count < max-2:
##                count = count + 2
##                #wxSleep(1)
##                self.prog.Update(count)
##            self.affichageComparaison()
##            
##            sys.stderr.flush()
##            self.prog.Update(max)
##            
##        except Exception, e:
##            #print e
##            self.prog.Update(max)
###           dlg=wx.MessageDialog(self,str(e),wx.OK)
###            dlg.ShowModal()
###            dlg.Destroy()
##            sys.stderr.write( str(e))  
##            traceback.print_exc()
##            sys.stderr.flush()
        
    # Methode qui appelle la méthode comparerEtats du controleur Medite afin de comparer
    # les deux états ouverts    
    def executerMedite(self,evt):
        logging.info('lancement comparaison')
        self.noirSurBlanc()
        try :
            max = 20
            self.prog = wx.ProgressDialog('Attendre','Excecution de la comparaison',max,self,
                                         style = wx.PD_AUTO_HIDE | wx.PD_APP_MODAL ) # | wxPD_ESTIMATED_TIME )
        
            count = 0
            while count < (max-4)/2:
                count = count + 2
                #wxSleep(1)
                self.prog.Update(count)
                
            #sys.stderr.write( 'pParametres = '+self.parametres.toString())
            self.getPlanTravail().setParam(self.parametres)
            self.getCompPanel().resultatTransfo = self.cmed.comparerEtats(self.getPlanTravail())
            self.getCompPanel().initialised = True  
            
            self.prog.Update(10,"Affichage des transformations")
            while count < max-2:
                count = count + 2
                #wxSleep(1)
                self.prog.Update(count)
            self.affichageComparaison()
            
            sys.stderr.flush()
            self.prog.Update(max)
            
        except Exception, e:
            #print e
            self.prog.Update(max)
#           dlg=wx.MessageDialog(self,str(e),wx.OK)
#            dlg.ShowModal()
#            dlg.Destroy()
            sys.stderr.write( str(e))  
            traceback.print_exc()
            sys.stderr.flush()

    def reverseString(self, chaine):
        if isinstance(chaine,unicode):
            uni = [c for c in chaine]
            uni.reverse()
            return ''.join(uni)
        else:  # str          
            uni = unicode(chaine, 'utf-8')
            uni = [c for c in uni]
            uni.reverse()
            uni = ''.join(uni) 
            return uni.encode('utf-8')
        
    # Methode qui permet d'afficher les resultats de la comparaison dans la fenetre Transformations
    def affichageTransformations(self, reverse=False):
        texteAffichage= []
        textConca = self.getCompPanel().resultatTransfo.getTextesConcatenes()
        #print "recharger affichageTransformations type(texte) ",type(textConca)#,unicode(textConca,'utf-8')
        ## liste des sequences de caracteres inseres
##        texteAffichage.append(" Insertions : \n")
##        for X in self.getCompPanel().resultatTransfo.getListeInsertions() :
##            chaine = [ ' - ', textConca[X[0]:X[1]], '\n']
##            #if reverse: 
##            #    chaine = self.reverseString(chaine) 
##            texteAffichage.extend(chaine)
##        ## liste des sequences de caracteres supprimes
##        texteAffichage+="\n Suppressions :\n"
##        for X in self.getCompPanel().resultatTransfo.getListeSuppressions():
##            chaine = [' - ', textConca[X[0]:X[1]], '\n']
##            #print chaine
##            #if reverse: 
##            #    chaine = self.reverseString(chaine) 
##            texteAffichage.extend(chaine)
##        ## liste des sequences de caracteres deplaces
        texteAffichage+="\n Deplacements : \n"
        ldRes = self.getCompPanel().resultatTransfo.getListeDeplacements()
        lg = len(ldRes)/2
        for X in ldRes[0:lg]:
            chaine = [' - ',textConca[X[0]:X[1]],'\n']
            #if reverse: 
            #    chaine = self.reverseString(chaine)
            texteAffichage.extend(chaine) 
        ## liste des sequences de caracteres remplaces
##        texteAffichage.append("\n Remplacements : \n")     
##        lrRes = self.getCompPanel().resultatTransfo.getListeRemplacements()
##        longueur = len(lrRes)/2
##        i = 0
##        for X in lrRes[0:longueur]:
##            #if reverse: 
##            #    chaine = self.reverseString(textConca[lrRes[i+longueur][0]:lrRes[i+longueur][1]]) + \
##            #             " <---- "+self.reverseString(" - "+textConca[lrRes[i][0]:lrRes[i][1]])+'\n'   
##            #else:
##            chaine = [" - ",textConca[lrRes[i][0]:lrRes[i][1]], " ----> ",textConca[lrRes[i+longueur][0]:lrRes[i+longueur][1]],'\n']
##            texteAffichage.extend(chaine)
##            i+=1
        #print "recharger affichageTransformations type(texteAffichage) ",type(texteAffichage)            
        return ''.join(texteAffichage)
        
    def affichageCouleur(self):
        """ Methode qui permet d'afficher les resultats de la comparaison sur le texte Source
        et Cible a l'aide couleur et de font
        Les insertions seront reperees par du texte Bleu sur le texte cible
        Les suppressions seront reperees par du texte Rouge sur le texte source
        Les deplacements seront reperes par du texte en gras et souligne dans les deux textes
        Les remplacements seront reperes par du texte en violine-rose dans les deux textes """

        try:
            lgSource = self.getCompPanel().resultatTransfo.getLgSource()
        except AttributeError:
            return # resultatTransfo n'existe pas donc pas de couleur à afficher
            
        #texte = self.getCompPanel().textWindowLeft.GetValue() + self.getCompPanel().textWindowRight.GetValue()
        texte = self.getCompPanel().resultatTransfo.getTextesConcatenes()
        #print "affichageCouleur type(texte) ",type(texte)
        chaine,y,enc = decode_string_heuristically(texte)
        #if isinstance(texte, unicode):
        if enc == 'utf-8':
            #print texte.encode('utf-8'),len(texte),len(texte.encode('utf-8'))
            backup = self.getCompPanel().resultatTransfo
            #print backup,backup.getTextesConcatenes()
            mapper = Utile.decodage.mapperUnicodeUtf(chaine, 'utf-8')#backup.getTextesConcatenes()) 
            res = mapper.utfToUniResultat(backup)             
            self.getCompPanel().resultatTransfo = res
            self.getCompPanel().resultatTransfoAffichageOnly = res
            self.affichageCouleur_()                    
            self.getCompPanel().resultatTransfo = backup
        else:
            self.getCompPanel().resultatTransfoAffichageOnly = self.getCompPanel().resultatTransfo
            self.affichageCouleur_()            
        
    def affichageCouleur_(self):            
        # Resultats de la comparaison sur les textes avec les couleurs
        lgSource = self.getCompPanel().resultatTransfo.getLgSource()
        self.getCompPanel().textWindowRight.Freeze()
        self.getCompPanel().textWindowLeft.Freeze()
        self.noirSurBlanc()
        #print "affichageCouleur type(self.getCompPanel().resultatTransfo.getTextesConcatenes()) ",type(self.getCompPanel().resultatTransfo.getTextesConcatenes())
        #print "affichageCouleur type(self.getCompPanel().textWindowLeft ",type(self.getCompPanel().textWindowLeft.GetValue())
        # Deplacements
        lSource = []
        lCible = []
        for X in self.getCompPanel().resultatTransfo.getListeDeplacements():
            if X[0]<lgSource:
                lSource.append((X[0],X[1]))
            else:
                lCible.append((X[0]-lgSource,X[1]-lgSource))
        #lSource.sort()
        #lCible.sort()
        
        if (self.couleursTransfo.getDeplacement() & 2)==2 : italic = wx.ITALIC
        else: italic = wx.NORMAL        
        if (self.couleursTransfo.getDeplacement() & 4)==4 : weight = wx.BOLD
        else: weight = wx.NORMAL
        if (self.couleursTransfo.getDeplacement() & 8)==8 : underline = True
        else: underline = False
        #fontDepl=wx.Font(10,wx.DEFAULT,italic,weight,underline,encoding=wx.FONTENCODING_ISO8859_1)
        fontDepl = self.getCompPanel().textWindowLeft.GetFont()
        fontDepl.SetStyle(italic)
        fontDepl.SetWeight(weight)
        fontDepl.SetUnderlined(underline)
        # insertions
        for X in self.getCompPanel().resultatTransfo.getListeInsertions():
            i1 = X[0] - lgSource
            if i1 < 0: i1 = 0
            i2 = X[1] - lgSource
            self.getCompPanel().textWindowRight.SetStyle(i1,i2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulInsert()))
        # suppressions
        for X in self.getCompPanel().resultatTransfo.getListeSuppressions():
            i1 = X[0] ; i2 = X[1]
            self.getCompPanel().textWindowLeft.SetStyle(i1,i2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulSupp()))
            
        # Remplacements
        for X in self.getCompPanel().resultatTransfo.getListeRemplacements():
            if X[0]<lgSource:# Texte Source
                i1 = X[0] ; i2 = X[1]
                self.getCompPanel().textWindowLeft.SetStyle(i1,i2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulRemp()))
            else: # texte Cible
                i1 = X[0] -  lgSource ; i2 = X[1] - lgSource
                self.getCompPanel().textWindowRight.SetStyle(i1,i2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulRemp()))
        #déplacements        
        for d1,d2 in lSource:
            textAttr = wx.TextAttr()
            res = self.getCompPanel().textWindowLeft.GetStyle(d1, textAttr)
            if res: textAttr.SetFont(fontDepl)
            else: textAttr = wx.TextAttr(font=fontDepl)
            self.getCompPanel().textWindowLeft.SetStyle(d1,d2,wx.TextAttr(font=fontDepl))
            
        for d1,d2 in lCible:
            textAttr = wx.TextAttr()
            res = self.getCompPanel().textWindowRight.GetStyle(d1, textAttr)
            if res: textAttr.SetFont(fontDepl)
            else: textAttr = wx.TextAttr(font=fontDepl)
            self.getCompPanel().textWindowRight.SetStyle(d1,d2,wx.TextAttr(font=fontDepl))
            
        self.getCompPanel().textWindowRight.Thaw()
        self.getCompPanel().textWindowLeft.Thaw()
        
    def affichageCouleur___(self):            
        # Resultats de la comparaison sur les textes avec les couleurs
        lgSource = self.getCompPanel().resultatTransfo.getLgSource()
        self.getCompPanel().textWindowRight.Freeze()
        self.getCompPanel().textWindowLeft.Freeze()
        #print "affichageCouleur type(self.getCompPanel().resultatTransfo.getTextesConcatenes()) ",type(self.getCompPanel().resultatTransfo.getTextesConcatenes())
        #print "affichageCouleur type(self.getCompPanel().textWindowLeft ",type(self.getCompPanel().textWindowLeft.GetValue())
        # Deplacements
        lSource = []
        lCible = []
        for X in self.getCompPanel().resultatTransfo.getListeDeplacements():
            if X[0]<lgSource:
                lSource.append((X[0],X[1]))
            else:
                lCible.append((X[0]-lgSource,X[1]-lgSource))
        lSource.sort()
        lCible.sort()
        
        if (self.couleursTransfo.getDeplacement() & 2)==2 : italic = wx.ITALIC
        else: italic = wx.NORMAL        
        if (self.couleursTransfo.getDeplacement() & 4)==4 : weight = wx.BOLD
        else: weight = wx.NORMAL
        if (self.couleursTransfo.getDeplacement() & 8)==8 : underline = True
        else: underline = False
        #fontDepl=wx.Font(10,wx.DEFAULT,italic,weight,underline,encoding=wx.FONTENCODING_ISO8859_1)
        fontDepl = self.getCompPanel().textWindowLeft.GetFont()
        fontDepl.SetStyle(italic)
        fontDepl.SetWeight(weight)
        fontDepl.SetUnderlined(underline)
        
        # Déplacements seuls
        for d1,d2 in lSource:
            self.getCompPanel().textWindowLeft.SetStyle(d1,d2,wx.TextAttr(font=fontDepl))
            #self.getCompPanel().textWindowLeft.SetStyle(d1, d2,0)
            #print d1,d2
        for d1,d2 in lCible:
            self.getCompPanel().textWindowRight.SetStyle(d1,d2,wx.TextAttr(font=fontDepl))
            #self.getCompPanel().textWindowRight.SetStyle(d1, d2,0)
            #print d1+lgSource,d2+lgSource
        # Insertions
        t=self.getCompPanel().resultatTransfo.getTextesConcatenes()
        #print lgSource,len(t)
        #print t
        for X in self.getCompPanel().resultatTransfo.getListeInsertions():
            #sys.stderr.write("INS3 : "+t[X[0]:X[1]]+"\n")
            #self.getCompPanel().textWindowRight.SetInsertionPoint(0)
            i1 = X[0]-lgSource
            if i1<0:i1=0
            i2 = X[1]-lgSource
            #sys.stderr.write("X="+str(X)+" / i1="+str(i1)+" / i2="+str(i2)+"\n")
            self.getCompPanel().textWindowRight.SetStyle(i1,i2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulInsert()))
            #self.getCompPanel().textWindowRight.SetStyle(i1, i2, 0)
            for d1,d2 in lCible: # Déplacements dans des insertions
                if ((i1<=d1<=i2) or (i1<=d2<=i2) or ((d1<=i1)and(d2>=i2))):
                    #sys.stderr.write("dep : "+t[d1:d2]+"\n")
                    if (d1<=i1):
                        if (d2<=i2):
                            self.getCompPanel().textWindowRight.SetStyle(i1,d2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulInsert(),fontDepl))
                            #self.getCompPanel().textWindowRight.SetStyle(i1, d2, 0)
                        else:
                            self.getCompPanel().textWindowRight.SetStyle(i1,i2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulInsert(),fontDepl))
                    else:
                        if(d2<=i2):
                            self.getCompPanel().textWindowRight.SetStyle(d1,d2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulInsert(),fontDepl))
                        else:
                            self.getCompPanel().textWindowRight.SetStyle(d1,i2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulInsert(),fontDepl))

        # Suppressions
        #t=self.getCompPanel().resultatTransfo.getTextesConcatenes()
        for X in self.getCompPanel().resultatTransfo.getListeSuppressions():
            #self.getCompPanel().textWindowLeft.SetInsertionPoint(0)
            i1 = X[0]
            i2 = X[1]
            self.getCompPanel().textWindowLeft.SetStyle(i1,i2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulSupp()))
            #self.getCompPanel().textWindowLeft.SetStyle(i1, i2, 0)
            for d1,d2 in lSource: # Déplacements dans Suppresion
                if ((i1<=d1<=i2) or (i1<=d2<=i2) or ((d1<=i1)and(d2>=i2))):
                    if (d1<=i1):
                        if (d2<=i2):
                            self.getCompPanel().textWindowLeft.SetStyle(i1,d2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulSupp(),fontDepl))
                            #self.getCompPanel().textWindowLeft.SetStyle(i1, d2, 0)
                        else:
                            self.getCompPanel().textWindowLeft.SetStyle(i1,i2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulSupp(),fontDepl))
                    else:
                        if(d2<=i2):
                            self.getCompPanel().textWindowLeft.SetStyle(d1,d2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulSupp(),fontDepl))
                        else:
                            self.getCompPanel().textWindowLeft.SetStyle(d1,i2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulSupp(),fontDepl))

        # Remplacements
        for X in self.getCompPanel().resultatTransfo.getListeRemplacements():
            if X[0]<lgSource:# Texte Source
                #self.getCompPanel().textWindowLeft.SetInsertionPoint(0)
                i1 = X[0]
                i2 = X[1]
                self.getCompPanel().textWindowLeft.SetStyle(i1,i2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulRemp()))
                for d1,d2 in lSource: # déplacement dans remplacement
                    if ((i1<=d1<=i2) or (i1<=d2<=i2) or ((d1<=i1)and(d2>=i2))):
                        if (d1<=i1):
                            if (d2<=i2):
                                self.getCompPanel().textWindowLeft.SetStyle(i1,d2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulRemp(),fontDepl))
                            else:
                                self.getCompPanel().textWindowLeft.SetStyle(i1,i2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulRemp(),fontDepl))
                        else:
                            if(d2<=i2):
                                self.getCompPanel().textWindowLeft.SetStyle(d1,d2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulRemp(),fontDepl))
                            else:
                                self.getCompPanel().textWindowLeft.SetStyle(d1,i2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulRemp(),fontDepl))
            else: # texte Cible
                #self.getCompPanel().textWindowRight.SetInsertionPoint(0)
                i1 = X[0]-lgSource
                i2 = X[1]-lgSource
                self.getCompPanel().textWindowRight.SetStyle(i1,i2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulRemp()))
                for d1,d2 in lCible: # déplacement dans remplacement
                    if ((i1<=d1<=i2) or (i1<=d2<=i2) or ((d1<=i1)and(d2>=i2))):
                        if (d1<=i1):
                            if (d2<=i2):
                                self.getCompPanel().textWindowRight.SetStyle(i1,d2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulRemp(),fontDepl))
                            else:
                                self.getCompPanel().textWindowRight.SetStyle(i1,i2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulRemp(),fontDepl))
                        else:
                            if(d2<=i2):
                                self.getCompPanel().textWindowRight.SetStyle(d1,d2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulRemp(),fontDepl))
                            else:
                                self.getCompPanel().textWindowRight.SetStyle(d1,i2,wx.TextAttr(self.couleursTransfo.getEcriture(),self.couleursTransfo.getCoulRemp(),fontDepl))
        
        self.getCompPanel().textWindowRight.Thaw()
        self.getCompPanel().textWindowLeft.Thaw()
        
    def affichageComparaison(self):
        #Listes des transformations affichees dans la fenetre transformations
        logging.debug('begin affichageTransformations') 
        trans = self.affichageTransformations()#reverse=True)
        logging.debug('fin affichageTransformations')
        chaine,num,encodage = decode_string_heuristically(trans)
        if encodage == 'utf-8':
            fontDefault=wx.Font(10,wx.DEFAULT,wx.NORMAL,wx.NORMAL,encoding=wx.FONTENCODING_UTF8)
        else:            
            fontDefault=wx.Font(10,wx.DEFAULT,wx.NORMAL,wx.NORMAL)
        #print "affichageComparaison type(chaine) ",type(chaine),len(chaine)                
        self.getCompPanel().transformations.SetDefaultStyle(wx.TextAttr(font=fontDefault))
        
        #s = unicode(self.getCompPanel().resultatTransfo.getTextesConcatenes(),'utf-8')
        #print s.encode('raw_unicode_escape')
        #print s[:25].encode('raw_unicode_escape')
        #s = self.reverseString(s[:25])
        #print s.encode('unicode_escape')
        #print "affichageComparaison type(chaine) ",type(chaine),len(chaine)
        #print "affichageComparaison type(trans) ",type(trans),len(trans)
        self.getCompPanel().transformations.Clear()
        self.getCompPanel().transformations.SetValue(chaine)
        
        logging.debug('begin affichageCouleur') 
        self.affichageCouleur()
        logging.debug('fin affichageCouleur') 
        #Rendre accessible les fonctionnalites enregistrer transformations et les informations
        self.smEnregistrer.Enable(ID_ADD_TRANSFOS, True)
        self.smEnregistrer.Enable(ID_ADD_TRANSFOS_COMMENT, True)

    def __chargerInfosEtats(self,event):
        self.SetCursor(wx.HOURGLASS_CURSOR)
        listeInfos = self.cinfos.rechercherLInformationsDG(self.DGAuteur, self.DGOeuvre)
        for infos in listeInfos: 
            plan = PlanTravail(self.DGAuteur, self.DGOeuvre,
                        infos.getVersionSource(), infos.getEtatSource(),
                        infos.getVersionCible(), infos.getEtatCible(),infos.getParametres())
            self.listePlanTravail.appendPlanTravail(plan)
            panel=MainPanel(self.nb,plan)
            self.nb.AddPage(panel,plan.getEtatSource()+"-"+plan.getEtatCible())
            if plan.getAuteur() != '' and plan.getOeuvre() != '':
                self.enableMenuDGCharge()
            self.nb.SetSelection(self.nb.GetPageCount()-1)
            self.rechargerEtats(infos)
            infos = None
        listeInfos = None
        self.reloadNavMenu()
        self.SetCursor(wx.STANDARD_CURSOR)
        
    def chargerInfosEtats(self,event):
        self.SetCursor(wx.HOURGLASS_CURSOR)
        #listeInfos = self.cinfos.rechercherLInformationsDG(self.DGAuteur, self.DGOeuvre)
        for infos in self.cinfos.generateLInformationsDG(self.DGAuteur, self.DGOeuvre): 
            plan = PlanTravail(self.DGAuteur, self.DGOeuvre,
                        infos.getVersionSource(), infos.getEtatSource(),
                        infos.getVersionCible(), infos.getEtatCible(),infos.getParametres())
            self.listePlanTravail.appendPlanTravail(plan)
            panel=MainPanel(self.nb,plan)
            self.nb.AddPage(panel,plan.getEtatSource()+"-"+plan.getEtatCible())
            if plan.getAuteur() != '' and plan.getOeuvre() != '':
                self.enableMenuDGCharge()
            self.nb.SetSelection(self.nb.GetPageCount()-1)
            self.rechargerEtats(infos)
            #infos = None
        #listeInfos = None
        self.reloadNavMenu()
        self.SetCursor(wx.STANDARD_CURSOR)
        
    def rechargerListeEtats(self):
        # chargement de la liste des plans de travail
        try :
            self.listePlanTravail = self.ctravail.chargerListePlans()
#            if self.planTravail.getAuteur() != '' and self.planTravail.getOeuvre() != '':
#                self.enableMenuDGCharge()
        except FichierNonTrouve, eFNT :
            # on crée une nouvelle liste dans laquelle ion insère un plan
            self.listePlanTravail = ListePlanTravail()
            plan = PlanTravail("","","","","","",Parametres())   #auteur,oeuvre,versSource,etatS,verCible,etatC
            self.listePlanTravail.appendPlanTravail(plan)
            panel=MainPanel(self.nb,plan)
            panel.initialised = False
            self.nb.AddPage(panel,plan.getEtatSource()+"-"+plan.getEtatCible())
            self.nb.SetSelection(self.nb.GetPageCount()-1)
            return
        #sys.stderr.write(self.listePlanTravail.toString())    
        if self.listePlanTravail.estVide() or self.listePlanTravail.getListe()[0].getAuteur()=='':
            self.DGLoaded = False
            # on crée une nouvelle liste dans laquelle on insère un plan
            self.listePlanTravail = ListePlanTravail()
            plan = PlanTravail("","","","","","",Parametres())   
            self.listePlanTravail.appendPlanTravail(plan)
            panel=MainPanel(self.nb,plan)
            panel.initialised = False
            self.nb.AddPage(panel,plan.getEtatSource()+"-"+plan.getEtatCible())
            self.nb.SetSelection(self.nb.GetPageCount()-1)
            return
        else:
            self.DGAuteur = self.listePlanTravail.getListe()[0].getAuteur()
            self.DGOeuvre = self.listePlanTravail.getListe()[0].getOeuvre()
            self.DGLoaded = True
            self.treePanel.initTree(self.DGAuteur,self.DGOeuvre)
        # création d'un panel par plan
        for plan in self.listePlanTravail.getListe():
            panel=MainPanel(self.nb,plan)
            self.nb.AddPage(panel,plan.getEtatSource()+"-"+plan.getEtatCible())
            if plan.getAuteur() != '' and plan.getOeuvre() != '':
                self.enableMenuDGCharge()
            self.nb.SetSelection(self.nb.GetPageCount()-1)
            self.rechargerEtats()
            self.getCompPanel().sizeF()
            self.getCompPanel().Refresh()
            self.nb.Refresh()
            self.Refresh()
            self.SendSizeEvent()
        self.reloadNavMenu()
            
    # fonction pour recharger les états du plan de travail enregistre
    def rechargerEtats(self, infos=None):
        vSource = self.getPlanTravail().getVersionSource()
        fSource = self.getPlanTravail().getEtatSource()
        vCible = self.getPlanTravail().getVersionCible()
        fCible = self.getPlanTravail().getEtatCible()

        fontDefault=wx.Font(10,wx.DEFAULT,wx.NORMAL,wx.NORMAL,encoding=wx.FONTENCODING_ISO8859_1)
        if vSource != '' and fSource !='':
            # source
            cheminS=self.dgm.getEtatPath(self.getPlanTravail().getAuteur(),
                    self.getPlanTravail().getOeuvre(),vSource,fSource)    
            self.getCompPanel().textWindowLeft.Clear()
            #self.getCompPanel().textWindowLeft.SetValue('')
            texte,enc = loadFile(cheminS,renvoieEnc=True)
            #print "recharger etat type(texte) ",type(texte),cheminS
            if enc == 'utf-8':
                #pass
                #print "uni"
                fontDefault=wx.Font(10,wx.DEFAULT,wx.NORMAL,wx.NORMAL,encoding=wx.FONTENCODING_UTF8)
                #self.getCompPanel().textWindowLeft.SetCodePage(wx.stc.STC_CP_UTF8)
            #self.getCompPanel().textWindowLeft.SetStyle(0,0,wx.TextAttr(wx.BLACK,wx.WHITE,fontDefault))
            self.getCompPanel().textWindowLeft.SetDefaultStyle(wx.TextAttr(font=fontDefault))
            #self.getCompPanel().textWindowLeft.LoadFile(cheminS)
            #self.getCompPanel().textWindowLeft.SetValue(loadFile(cheminS))
            
            self.getCompPanel().textWindowLeft.SetValue(texte)
            #self.getCompPanel().textWindowLeft.SetTextRaw(texte.encode('utf-8'))
            #self.getCompPanel().textWindowLeft.LoadFile(cheminS)
            #print loadFile(cheminS).encode('utf-8')
          
        if vCible !='' and fCible !='':
            # cible
            cheminC=self.dgm.getEtatPath(self.getPlanTravail().getAuteur(),
                    self.getPlanTravail().getOeuvre(),vCible,fCible)    
            self.getCompPanel().textWindowRight.Clear()                     
            if enc == 'utf-8':
                #pass
                fontDefault=wx.Font(10,wx.DEFAULT,wx.NORMAL,wx.NORMAL,encoding=wx.FONTENCODING_UTF8)
            #self.getCompPanel().textWindowRight.SetStyle(0,0,wx.TextAttr(wx.BLACK,wx.WHITE,fontDefault))
            #self.getCompPanel().textWindowRight.SetDefaultStyle(wx.TextAttr(wx.BLACK,wx.WHITE,fontDefault))
            self.getCompPanel().textWindowRight.SetDefaultStyle(wx.TextAttr(font=fontDefault))
            #self.getCompPanel().textWindowRight.LoadFile(cheminC)
            self.getCompPanel().textWindowRight.SetValue(loadFile(cheminC))
            #self.getCompPanel().textWindowRight.SetText(loadFile(cheminC))
            
        if vSource != '' and fSource !='' and vCible !='' and fCible !='':
            self.enableMenuEtatsOuverts()
#            dlg=wx.MessageDialog(self,"Nous cherchons les informations pour ce couple d'états","Attention",wx.OK)
#            dlg.ShowModal()
#            dlg.Destroy()
            self.__chargement(infos)
        else:
            self.getCompPanel().initialised = False

    ## fonction privee pour charger toutes les informations d'un couple d'états           
    def __chargement(self, infos):
##        # objet Informations déjà fourni, inutile de le rechercher
##        if infos != None:
##            self.__chargementUnique(infos)
##            return
##        if not self.getPlanTravail().getParam().isNull():
##            info2=self.cinfos.rechercherInformations(self.getPlanTravail())
##            if  info2 != None:
##                self.getCompPanel().initialised = True
##                self.__chargementUnique(info2)
##                return
        # 1ere etape : rechercher toutes les infos existantes pour le couple d'états charge
        liste=self.cinfos.rechercherToutesInformations(self.getPlanTravail())
        if len(liste) == 0:
            self.getCompPanel().initialised = False
#           self.getCompPanel().infosChargees=InformationsChargees(None, None, None)
#            dlg=wx.MessageDialog(self, u"Les informations n'ont pas \xe9t\xe9 trouv\xe9es !!","Attention",wx.OK)
#            dlg.ShowModal()
#            dlg.Destroy()           
        elif len(liste) == 1 :
#        else:
            self.getCompPanel().initialised = True
            self.__chargementUnique(liste[0])
        else :
            self.getCompPanel().initialised = True
            # 2eme etape : choix des parametres
            listeParam = []
            for i in liste :
                param = i.getParametres()
                lpara = '(%s,%s,%s,%s,%s,%s)'%(param.getp1(),param.getp2(),param.getp3(),param.getp4(),param.getp5(),param.getp6())
                listeParam.append(lpara)
                
            phrase = u"Il existe plusieurs informations concernant ces états.\n   Choisissez les param\xe8tres\n  (lg pivot, ratio, seuil, car/mot, casse, séparateur)"
            dlg = wx.SingleChoiceDialog(self,phrase,u"Choix des informations \xe0 charger",listeParam,
                                                  wx.OK|wx.CANCEL)
            if dlg.ShowModal() == wx.ID_OK:
                choix = dlg.GetStringSelection()
                n = 0
                for p in listeParam :
                    if choix == p :
                        self.__chargementUnique(liste[n])
                        return
                    else :
                        n+=1
                    
    # Methode privee pour le chargement definitif des infos
    def __chargementUnique(self, pInfos):
        logging.debug('begin chargement unique')
        try :
            #max = 20
            #self.progressChargement = wx.ProgressDialog('Attendre','Recherche des informations',max,self,
            #                                           style = wx.PD_AUTO_HIDE | wx.PD_APP_MODAL ) # | wxPD_ESTIMATED_TIME 
            #count = 0
            #while count < 8:
            #    count = count + 2
                #wxSleep(1)
            #    self.progressChargement.Update(count)           
            self.getCompPanel().infosChargees = pInfos
            #self.progressChargement.Update(10,"Affichage des transformations")
            #while count < max-4:
            #    count = count + 2
                #wxSleep(1)
            #    self.progressChargement.Update(count)
                
            self.getCompPanel().resultatTransfo = self.getCompPanel().infosChargees.getTransformations()
            self.getCompPanel().commentaire.SetValue(self.getCompPanel().infosChargees.getCommentaire().getCommentaire())
            self.getPlanTravail().setParam(self.getCompPanel().infosChargees.getParametres())
            self.getCompPanel().param.chargerParametres(self.getPlanTravail().getParam())
            logging.debug('begin affichageComparaison') 
            self.affichageComparaison()
            logging.debug('fin affichageComparaison') 
            #bbl = MediteAppli.synthetic.BiBlocListWD(self.getCompPanel().resultatTransfo,self.getPlanTravail())
            #bbl.print_html()  
            self.smEnregistrer.Enable(ID_ADD_TRANSFOS, False)
            self.smEnregistrer.Enable(ID_ADD_TRANSFOS_COMMENT, False)
            
            #while count < max :
            #    count = count + 2
                #wxSleep(1)
            #    self.progressChargement.Update(count)
            #self.progressChargement.Update(20)
                
        except InformationsNonTrouvees, eINT:
            pass
            #self.progressChargement.Update(20)
            #dlg=wx.MessageDialog(self, u"Les informations n'ont pas \xe9t\xe9 trouv\xe9es !!","Attention",wx.OK)
            #dlg.ShowModal()
            # dlg.Destroy()
        logging.debug('fin chargement unique')

    # Methode privee permettant le choix des parametres associes a un cple d'états
    # pour l'enregistrement d'un commentaire
    def __choixParametres(self):
        # 1ere etape : rechercher toutes les infos existantes pour le couple d'états charge
        liste=self.cinfos.rechercherToutesInformations(self.getPlanTravail())
        if len(liste) == 0:
            fake=1
#            dlg=wx.MessageDialog(self, u"Les informations n'ont pas \xe9t\xe9 trouv\xe9es !!","Attention",wx.OK)
#            dlg.ShowModal()
#            dlg.Destroy()
        else:
            # 2eme etape : choix des parametres
            listeParam = []
            for i in liste :
                param = i.getParametres()
                lpara = '(%s,%s,%s,%s,%s,%s)'%(param.getp1(),param.getp2(),param.getp3(),param.getp4(),param.getp5(),param.getp6())
                listeParam.append(lpara)
                
            phrase = u"Il existe plusieurs informations concernant ces états.\n   Choisissez les param\xe8tres\n  (lg pivot, ratio, seuil, car/mot, casse, séparateur)"
            dlg = wx.SingleChoiceDialog(self,phrase,u"Choix des informations \xe0 charger",listeParam,
                                                  wx.OK|wx.CANCEL)
            if dlg.ShowModal() == wx.ID_OK:
                choix = dlg.GetStringSelection()
                n = 0
                for p in listeParam :
                    if choix == p :
                        try:
                            planTravail=PlanTravail(self.getPlanTravail().getAuteur(),self.getPlanTravail().getOeuvre(),
                               self.getPlanTravail().getVersionSource(),self.getPlanTravail().getEtatSource(),
                               self.getPlanTravail().getVersionCible(),self.getPlanTravail().getEtatCible(),
                               liste[n].getParametres())
                            self.cinfos.enregistrerCommentaire(planTravail,self.getCompPanel().commentaire.GetValue())
                        except CommentaireDejaExistant, eCDE:
                            formulaire=FormEnregistrerCommentaire(self,eCDE.getCommentaire().getCommentaire(),
                                                                  liste[n].getParametres())
                            formulaire.Show(True)
                    else :
                        n+=1

    # Methode pour reafficher les états sans les transformations
    def noirSurBlanc(self):
        fontDefault=wx.Font(10,wx.DEFAULT,wx.NORMAL,wx.NORMAL,encoding=wx.FONTENCODING_ISO8859_1)
        texte = self.getCompPanel().textWindowLeft.GetValue()
        self.getCompPanel().textWindowLeft.Clear()#SetValue('')
        self.getCompPanel().textWindowLeft.SetStyle(0,0,wx.TextAttr(wx.BLACK,wx.WHITE,fontDefault))
        self.getCompPanel().textWindowLeft.SetValue(texte)
        
        texte = self.getCompPanel().textWindowRight.GetValue()
        self.getCompPanel().textWindowRight.Clear()#SetValue('')
        self.getCompPanel().textWindowRight.SetStyle(0,0,wx.TextAttr(wx.BLACK,wx.WHITE,fontDefault))
        self.getCompPanel().textWindowRight.SetValue(texte)
    def noirSurBlanc__(self):
        self.getCompPanel().textWindowLeft.StyleClearAll()
        self.getCompPanel().textWindowRight.StyleClearAll()
        
    def chargerInfosDG(self,evt):
        # 1ere etape : rechercher toutes les infos existantes pour le couple de états charge
        liste=self.cinfos.rechercherToutesInformationsDG(self.getPlanTravail().getAuteur(),
                                                       self.getPlanTravail().getOeuvre())
        if len(liste) == 0:
            dlg=wx.MessageDialog(self, u"Les informations n'ont pas \xe9t\xe9 trouv\xe9es !!","Attention",wx.OK)
            dlg.ShowModal()
            dlg.Destroy()
        else:
            # 2eme etape : visualiser les differentes informations
            listeInfos = []
            for i in liste :
                text = "(%s, %s)  (%s, %s)    (%s, %s, %s, %s)" %(i[0],i[1],i[2],i[3],i[4],i[5],i[6],i[7])
                listeInfos.append(text)
                
            phrase = u"Les informations concernant le dossier g\xe9n\xe9tique charg\xe9 sont les suivantes."
            phrase += "\n    (VS,FS)  (VC,FC)  (lg pivot, ratio, seuil, car/mot)"
            dlg = wx.SingleChoiceDialog(self,phrase,"Informations",listeInfos,wx.OK|wx.CANCEL)
            dlg.ShowModal()
        
    def chargerInfosCple(self,evt):
        # 1ere etape : rechercher toutes les infos existantes pour le couple de états charge
        liste=self.cinfos.rechercherToutesInformations(self.getPlanTravail())
        if len(liste) == 0:
            dlg=wx.MessageDialog(self, u"Les informations n'ont pas \xe9t\xe9 trouv\xe9es !!","Attention",wx.OK)
            dlg.ShowModal()
            dlg.Destroy()
        else:
            # 2eme etape : visualiser les differentes informations
            listeParam = []
            for i in liste :
                param = i.getParametres()
                lpara = '(%s,%s,%s)'%(param.getp1(),param.getp2(),param.getp3())
                listeParam.append(lpara)
                
            phrase = u"Les informations concernant les états charg\xe9s sont les suivantes."
            dlg = wx.SingleChoiceDialog(self,phrase,"Informations",listeParam,wx.OK|wx.CANCEL)
##            if
            dlg.ShowModal()
##            == wx.ID_OK:
##                return