X-Git-Url: http://iramuteq.org/git?p=iramuteq;a=blobdiff_plain;f=layout.py;h=a7d7b2e340c053a8dfed3c05e532c2bfca8f5a6b;hp=b2eeb4ed10fbd1904c7da5663a113558fb071e44;hb=93cbfaab587c5d7f16874c270dee5d4a2f885074;hpb=7007f89913612375b1f1d34c71193ba8257f5091

diff --git a/layout.py b/layout.py
index b2eeb4e..a7d7b2e 100644
--- a/layout.py
+++ b/layout.py
@@ -2,18 +2,17 @@
 # -*- coding: utf-8 -*-
 #Author: Pierre Ratinaud
 #Copyright (c) 2008-2009 Pierre Ratinaud
-#Lisense: GNU/GPL
+#License: GNU/GPL
 
 import os
 import wx
 import wx.lib.hyperlink as hl
-if wx.__version__ >= '2.11' :
-    import wx.lib.agw.aui as aui
-else :
-    import aui
+import wx.lib.agw.aui as aui
+import wx.lib.agw.labelbook as LB
+from wx.lib.agw.fmresources import *
 from chemins import ConstructPathOut, ChdTxtPathOut, FFF, ffr, PathOut, StatTxtPathOut, simipath
 from ConfigParser import ConfigParser
-from functions import ReadProfileAsDico, GetTxtProfile, read_list_file, ReadList, exec_rcode, print_liste, BugReport, DoConf, indices_simi, check_Rresult, progressbar
+from functions import ReadProfileAsDico, GetTxtProfile, read_list_file, ReadList, exec_rcode, print_liste, BugReport, DoConf, indices_simi, check_Rresult, progressbar, normpath_win32, TGen
 from ProfList import ProfListctrlPanel
 from guiparam3d import param3d, simi3d
 from PrintRScript import write_afc_graph, print_simi3d, PrintSimiScript
@@ -22,9 +21,11 @@ from functions import ReadList
 from listlex import *
 from Liste import *
 from search_tools import SearchFrame
-from dialog import PrefGraph, PrefExport, PrefSimpleFile, PrefDendro
+from dialog import PrefGraph, PrefExport, PrefSimpleFile, PrefDendro, SimpleDialog
 from guifunct import SelectColumn, PrepSimi, PrefSimi
+from webexport import WebExport
 from corpus import Corpus
+from sheet import MySheet
 import datetime
 import sys
 import tempfile
@@ -45,7 +46,7 @@ class GraphPanelAfc(wx.Panel):
         self.coding = coding
         self.itempath = itempath
         self.parent = self.GetParent()#parent
-        self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "courier"))
+        self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
         self.labels = []
         self.listimg = []
         self.buts = []
@@ -63,11 +64,15 @@ class GraphPanelAfc(wx.Panel):
         for i in range(0,len(list_graph)):
             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
                 filename, ext = os.path.splitext(list_graph[i][0])
-                if ext == '.svg' :
+                if ext == '.svg' or ext == '.html':
                     self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, os.path.join(self.dirout,list_graph[i][0]), URL=os.path.join(self.dirout,list_graph[i][0])))
                 else :
                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
-                self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
+                if os.path.exists(os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')) :
+                    txt = _(u"List of not plotted points : ").decode('utf8') + '%s' % os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')
+                else :
+                    txt = ''
+                self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1] + txt))
                 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = `i - b`))
             else :
                 todel.append(i)
@@ -97,7 +102,7 @@ class GraphPanelAfc(wx.Panel):
               'alpha' : 10,
               'clnb' : clnb,
               'svg' : 0,
-            }
+               }
 
         self.__set_properties()
         self.__do_layout()
@@ -106,6 +111,7 @@ class GraphPanelAfc(wx.Panel):
         self.panel_1.EnableScrolling(True,True)
         #self.panel_1.SetSize((1000,1000))
         self.panel_1.SetScrollRate(20, 20)
+        self.panel_1.SetFocus()
 
     def __do_layout(self):    
         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
@@ -124,7 +130,7 @@ class GraphPanelAfc(wx.Panel):
     def on_delete_image(self, event) :
         image_id = int(event.GetEventObject().GetName())
         image_path = self.list_graph[image_id][0]
-        message = 'This file will be delete : %s.\nAre you sure ?' % os.path.join(self.dirout, image_path)
+        message = _(u'This file will be delete : ') + '%s.\n' % os.path.join(self.dirout, image_path) + _('Are you sure ?')
         dial = wx.MessageDialog(self, message, style = wx.YES_NO)
         res = dial.ShowModal()
         if res == wx.ID_YES :
@@ -149,9 +155,6 @@ class GraphPanelAfc(wx.Panel):
 
     def afc_graph(self,event):
         #dirout = os.path.dirname(self.Dict['ira'])
-        while os.path.exists(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+'.png')):
-            self.afcnb +=1
-        self.fileout = ffr(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+'.png'))
         dial = PrefGraph(self.parent,-1,self.param,'')
         dial.CenterOnParent()
         val = dial.ShowModal()
@@ -160,7 +163,20 @@ class GraphPanelAfc(wx.Panel):
                 svg = 0
             else :
                 svg = 1
-            self.param = {'typegraph' : dial.choicetype.GetSelection(),
+            typegraph = dial.choicetype.GetSelection()
+            if svg :
+                typefile = '.svg'
+            else :
+                typefile = '.png'
+            if self.clnb <= 3 and typegraph == 1 :
+                typegraph = 2
+            if typegraph == 2:
+                typefile = '.gexf'
+            while os.path.exists(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile)):
+                self.afcnb +=1
+            self.fileout = ffr(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile))
+
+            self.param = {'typegraph' : typegraph,
                           'width' : dial.spin1.GetValue(),
                           'height' : dial.spin2.GetValue(),
                           'what' : dial.choice1.GetSelection(),
@@ -190,7 +206,7 @@ class GraphPanelAfc(wx.Panel):
             self.RscriptsPath = self.ira.RscriptsPath
             txt = """
             load("%s")
-            """ % self.DictPathOut['RData']
+            """ % ffr(self.DictPathOut['RData'])
             if self.itempath == 'liste_graph_afcf' :
                 txt += """
                 afc <- afcf
@@ -209,7 +225,7 @@ class GraphPanelAfc(wx.Panel):
                 f.write(txt)
             pid = exec_rcode(self.ira.RPath, filetmp)
             check_Rresult(self.ira, pid)
-            if self.param['typegraph'] == 0 :
+            if self.param['typegraph'] in [0,2] :
                 txt = 'Variables '
                 if self.param['qui'] == 0 : value = u'actives'
                 if self.param['qui'] == 1 : value = u'supplémentaires'
@@ -228,12 +244,22 @@ class GraphPanelAfc(wx.Panel):
                 if self.param['svg'] :
                     filename, ext = os.path.splitext(self.fileout)
                     self.fileout = filename + '.svg'
+                if self.param['typegraph'] == 2 :
+                    parametres = {'gexffile' :  self.fileout,
+                                  'titre': 'Le titre',
+                                  'nodemin': self.param['txt_min'],
+                                  'nodemax': self.param['txt_max'],
+                                  'bargraphw' : 60*int(self.param['clnb']),
+                    }
+                    web = WebExport(self.ira, parametres)
+                    self.fileout = web.exportafc()              
                 self.list_graph.append([os.path.basename(self.fileout), txt])
                 print_liste(self.DictPathOut[self.itempath], self.list_graph)
-                if not self.param['svg'] :
-                    self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(self.fileout, wx.BITMAP_TYPE_ANY)))
-                else :
+                if self.param['svg'] or self.param['typegraph'] == 2:
                     self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, self.fileout, URL=self.fileout))
+
+                else :
+                    self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(self.fileout, wx.BITMAP_TYPE_ANY)))
                 self.sizer_3.Add( self.listimg[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
                 self.labels.append(wx.StaticText(self.panel_1,-1, txt))
                 self.sizer_3.Add(self.labels[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
@@ -243,6 +269,20 @@ class GraphPanelAfc(wx.Panel):
                 self.Layout()
     
                 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
+#             elif self.param['typegraph'] == 2 :
+#                 parametres = {'gexffile' :  self.fileout,
+#                               'titre': 'Le titre',
+#                               'nodemin': self.param['txt_min'],
+#                               'nodemax': self.param['txt_max'],
+#                               'bargraphw' : 60*int(self.param['clnb']),
+#                 }
+#                 web = WebExport(self.ira, parametres)
+#                 afcout = web.exportafc()
+#                 dial = SimpleDialog(self.ira) 
+#                 dial.link.SetLabel(afcout)
+#                 dial.link.SetURL(afcout)
+#                 dial.Layout()
+#                 dial.ShowModal()
             
 
 class GraphPanel(wx.ScrolledWindow):
@@ -251,21 +291,28 @@ class GraphPanel(wx.ScrolledWindow):
         self.Dict = dico
         self.txt = txt
         self.parent = parent
-        self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.FONTWEIGHT_BOLD, 0, "courier"))
+        self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
         self.labels = []
         self.listimg = []
         self.dirout = os.path.dirname(self.Dict['ira'])
         self.deb = wx.StaticText(self, -1, txt)
         for i in range(0,len(list_graph)):
             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
-                self.listimg.append(wx.StaticBitmap(self, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
+                filename, ext = os.path.splitext(list_graph[i][0])
+                if ext == '.svg' :
+                    self.listimg.append(hl.HyperLinkCtrl(self, -1, os.path.join(self.dirout,list_graph[i][0]), URL=os.path.join(self.dirout,list_graph[i][0])))
+                else :
+                    self.listimg.append(wx.StaticBitmap(self, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
                 self.labels.append(wx.StaticText(self, -1, list_graph[i][1]))
-                
+        self.Bind(wx.EVT_MOTION, self.onMouseMove) 
         self.__set_properties()
         self.__do_layout()
 
     def __set_properties(self):
+        self.EnableScrolling(True,True)
         self.SetScrollRate(20, 20)   
+        self.SetFocus()
+
 
     def __do_layout(self):
         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
@@ -278,6 +325,9 @@ class GraphPanel(wx.ScrolledWindow):
         self.sizer_2.Add(self.sizer_1, 1, wx.EXPAND, 0)
         self.SetSizer(self.sizer_1)
         self.sizer_1.Fit(self)
+
+    def onMouseMove(self, event):
+        self.SetFocus()
        
 
 def open_antiprofil(panel, AntiProfile, encoding) :
@@ -286,67 +336,84 @@ def open_antiprofil(panel, AntiProfile, encoding) :
     for i in range(0, panel.parametres['clnb']):
         tabantiprofile = ProfListctrlPanel(panel, panel, DictAnti[str(i + 1)], True, i + 1)
         panel.AntiProfNB.AddPage(tabantiprofile, 'classe %s' % str(i + 1))
-    panel.TabChdSim.AddPage(panel.AntiProfNB, 'Antiprofils')
+    panel.TabChdSim.AddPage(panel.AntiProfNB, _(u"Antiprofiles").decode('utf8'))
+
 
 
+def getlemgram(corpus, lem) :
+    if not lem[6] in corpus.lems :
+        return lem[5]
+    else :
+        return corpus.lems[lem[6]].gram
 
 class OpenCHDS():
     def __init__(self, parent, corpus, parametres, Alceste=False):
-       #sep = u'\n ' 
-       sep=' '
-       self.parent = parent
-       self.corpus = corpus
-       self.parametres = parametres
-       self.pathout = PathOut(parametres['ira'])
-       self.pathout.basefiles(ChdTxtPathOut)
-       DictPathOut = self.pathout 
-       self.DictPathOut = DictPathOut
-       self.dictpathout = DictPathOut
-       self.parent = parent
-
-       Profile = DictPathOut['PROFILE_OUT']
-       AntiProfile = DictPathOut['ANTIPRO_OUT']
-       self.encoding = self.corpus.parametres['syscoding']
-       if isinstance(self.corpus, Corpus) :
+        #sep = u'\n ' 
+        sep=' '
+        self.parent = parent
+        self.corpus = corpus
+        self.parametres = parametres
+        self.pathout = PathOut(parametres['ira'])
+        self.pathout.basefiles(ChdTxtPathOut)
+        DictPathOut = self.pathout 
+        self.DictPathOut = DictPathOut
+        self.dictpathout = DictPathOut
+        self.parent = parent
+
+        Profile = DictPathOut['PROFILE_OUT']
+        AntiProfile = DictPathOut['ANTIPRO_OUT']
+        self.encoding = self.parametres['encoding']
+        if isinstance(self.corpus, Corpus) :
             self.corpus.make_ucecl_from_R(self.pathout['uce'])
             corpname = self.corpus.parametres['corpus_name']
-       else :
-           corpname = self.corpus.parametres['name']
-
-       clnb = parametres['clnb']
-       dlg = progressbar(self, maxi = 4 + clnb) 
-       self.clnb = clnb 
-       print 'lecture des profils'
-       dlg.Update(2, u'lecture des profils')
- 
-       DictProfile = ReadProfileAsDico(Profile, Alceste, self.encoding)
-       self.DictProfile = DictProfile
-       self.cluster_size = []
-       #print 'lecture des antiprofils'
-       #DictAnti = ReadProfileAsDico(self, AntiProfile, Alceste, self.encoding)
-
-       panel = wx.Panel(parent, -1)
-       sizer1 = wx.BoxSizer(wx.VERTICAL)
-
-       if os.path.exists(DictPathOut['pre_rapport']):
-           with codecs.open(DictPathOut['pre_rapport'], 'r', self.encoding) as f :
+        else :
+            corpname = self.corpus.parametres['matrix_name']
+            if os.path.exists(self.pathout['analyse.db']) :
+                self.corpus.read_tableau(self.pathout['analyse.db'])
+
+        clnb = parametres['clnb']
+        dlg = progressbar(self, maxi = 4 + clnb) 
+        self.clnb = clnb 
+        print 'lecture des profils'
+        dlg.Update(2, _(u"Reading profiles").decode('utf8'))
+  
+        DictProfile = ReadProfileAsDico(Profile, Alceste, self.encoding)
+        self.DictProfile = DictProfile
+        self.cluster_size = []
+        clusternames = {}
+        for i in range(0, clnb) :
+            clusternames[i] = ' '.join([u'%i' % (i + 1), _(u'Cluster').decode('utf8'),  u'%i' % (i + 1)])
+        if os.path.exists(self.pathout['classes_names.txt']) :
+            with codecs.open(self.pathout['classes_names.txt'], 'r', self.parent.syscoding) as f :
+                clusternames_ = f.read()
+            clusternames_ =  dict([[i, ' '.join([`i + 1`, line])] for i, line in enumerate(clusternames_.splitlines())])
+            clusternames.update(clusternames_)
+        #print 'lecture des antiprofils'
+        #DictAnti = ReadProfileAsDico(self, AntiProfile, Alceste, self.encoding)
+
+        panel = wx.Panel(parent, -1)
+        sizer1 = wx.BoxSizer(wx.VERTICAL)
+
+        if os.path.exists(DictPathOut['pre_rapport']):
+            with codecs.open(DictPathOut['pre_rapport'], 'r', self.encoding) as f :
                 txt = f.read()
-           self.debtext = txt
-       else :
-           self.debtext = ''
+            self.debtext = txt
+        else :
+            self.debtext = ''
 #       panel.chd_toolbar = wx.ToolBar(panel, -1, wx.DefaultPosition, wx.DefaultSize, wx.TB_FLAT | wx.TB_NODIVIDER)
 #       panel.chd_toolbar.SetToolBitmapSize(wx.Size(16, 16))
 
-       if isinstance(self.corpus, Corpus) :
-           panel.corpus = self.corpus
-       else :
-           panel.tableau = self.corpus
-       panel.dictpathout = self.DictPathOut
-       panel.pathout = self.DictPathOut
-       panel.parent = self.parent
-       panel.DictProfile = self.DictProfile
-       panel.cluster_size = self.cluster_size
-       panel.debtext = self.debtext
+        if isinstance(self.corpus, Corpus) :
+            panel.corpus = self.corpus
+        else :
+            panel.tableau = self.corpus
+            #self.parent.tableau = panel.tableau
+        panel.dictpathout = self.DictPathOut
+        panel.pathout = self.DictPathOut
+        panel.parent = self.parent
+        panel.DictProfile = self.DictProfile
+        panel.cluster_size = self.cluster_size
+        panel.debtext = self.debtext
 
 #       self.ID_rapport = wx.NewId()
 #       #rap_img = wx.Image(os.path.join(self.parent.images_path,'icone_rap_16.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
@@ -357,176 +424,120 @@ class OpenCHDS():
 #       panel.chd_toolbar.Realize()
 #       sizer1.Add(panel.chd_toolbar,0, wx.EXPAND, 5)
 
-       #self.TabChdSim = wx.aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
-       notebook_flags =  aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT| wx.NO_BORDER
-       panel.TabChdSim = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
-       panel.TabChdSim.SetAGWWindowStyleFlag(notebook_flags)
-       panel.TabChdSim.SetArtProvider(aui.ChromeTabArt())
-       sizer1.Add(panel.TabChdSim,10, wx.EXPAND, 5)
-       panel.SetSizer(sizer1)
-       sizer1.Fit(panel)
+        #self.TabChdSim = wx.aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
+        notebook_flags =  aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT| wx.NO_BORDER
+        panel.TabChdSim = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
+        #panel.TabChdSim = LB.LabelBook(panel, -1, agwStyle = INB_TOP|INB_SHOW_ONLY_TEXT|INB_FIT_LABELTEXT)
+        panel.TabChdSim.SetAGWWindowStyleFlag(notebook_flags)
+        panel.TabChdSim.SetArtProvider(aui.ChromeTabArt())
+        sizer1.Add(panel.TabChdSim,10, wx.EXPAND, 5)
+        panel.SetSizer(sizer1)
+        sizer1.Fit(panel)
        
 
-       if isinstance(self.corpus, Corpus) :
-           panel.TabChdSim.corpus = corpus
-           panel.TabChdSim.corpus.dictpathout = self.DictPathOut
-       else :
-           panel.TabChdSim.tableau = corpus
-           panel.TabChdSim.tableau.dictpathout = self.DictPathOut
-       panel.parametres = self.parametres
-       self.panel = panel
+        if isinstance(self.corpus, Corpus) :
+            panel.TabChdSim.corpus = corpus
+            panel.TabChdSim.corpus.dictpathout = self.DictPathOut
+        else :
+            panel.TabChdSim.tableau = corpus
+            panel.TabChdSim.tableau.dictpathout = self.DictPathOut
+        panel.parametres = self.parametres
+        self.panel = panel
 
-       self.notenb = self.parent.nb.GetPageCount()
+        self.notenb = self.parent.nb.GetPageCount()
 
            
-       if os.path.exists(self.DictPathOut['liste_graph_chd']) :
-           list_graph = read_list_file(self.DictPathOut['liste_graph_chd'], self.encoding)
-           CHD = GraphPanelDendro(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
-           panel.TabChdSim.AddPage(CHD,'CHD')
+        if os.path.exists(self.DictPathOut['liste_graph_chd']) :
+            list_graph = read_list_file(self.DictPathOut['liste_graph_chd'], self.encoding)
+            CHD = GraphPanelDendro(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
+            panel.TabChdSim.AddPage(CHD,'CHD')
                
-       panel.ProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
-       panel.ProfNB.SetArtProvider(aui.ChromeTabArt())
-       #self.ProfNB.SetTabCtrlHeight(100)
-       #panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
-       if os.path.exists(DictPathOut['prof_seg']) :
+        panel.ProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
+        notebook_flags |= aui.AUI_NB_WINDOWLIST_BUTTON
+        panel.ProfNB.SetAGWWindowStyleFlag(notebook_flags)
+        #panel.ProfNB.SetArtProvider(aui.ChromeTabArt())
+        #panel.ProfNB = LB.LabelBook(panel, -1, agwStyle = INB_LEFT|INB_SHOW_ONLY_TEXT|INB_FIT_LABELTEXT)
+        #panel.ProfNB = wx.Listbook(self.parent, -1, style = wx.BK_DEFAULT)
+        #panel.ProfNB = wx.Treebook(self.parent, -1, style = wx.BK_DEFAULT)
+        #self.ProfNB.SetTabCtrlHeight(100)
+        #panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
+        if os.path.exists(DictPathOut['prof_seg']) :
             prof_seg = ReadProfileAsDico(DictPathOut['prof_seg'], False, self.encoding)
             self.prof_seg_nb = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
-       for i in range(0, clnb):
-            self.cluster_size.append(DictProfile[str(i + 1)][0][0:3]) 
+        for i in range(0, clnb):
+            self.cluster_size.append(DictProfile[str(i + 1)][0][0:3])
+            if isinstance(self.corpus, Corpus) :
+                DictProfile[str(i + 1)][1:] = [val[0:5] + [getlemgram(self.corpus, val)] + val[6:] for val in DictProfile[str(i + 1)][1:]]
             dlg.Update(3+i, 'Classe %i' %(i+1))
-            ind = '/'.join(DictProfile[str(i + 1)][0][0:2])
-            indpour = ' - '.join([ind, DictProfile[str(i + 1)][0][2]])
+            ind = '/'.join(DictProfile[str(i + 1)][0][0:2]).strip()
+            indpour = '\n'.join([ind, DictProfile[str(i + 1)][0][2]])
             self.tabprofile = ProfListctrlPanel(self.parent, self.panel, DictProfile[str(i + 1)], Alceste, i + 1)
             #self.tabantiprofile = ProfListctrlPanel(self.parent, self, DictAnti[str(i + 1)], Alceste, i + 1)
-            panel.ProfNB.AddPage(self.tabprofile, 'classe %s %s(%s%%)' % (str(i + 1), sep, indpour))
+            panel.ProfNB.AddPage(self.tabprofile, clusternames[i] + '\n%s%%' % indpour, True)
+            panel.ProfNB.SetPageTextColour(i, '#890909')
+            panel.ProfNB.SetRenamable(i, True)
             #panel.AntiProfNB.AddPage(self.tabantiprofile, 'classe %s' % str(i + 1))
             if os.path.exists(DictPathOut['prof_seg']) :
                 self.tab_prof_seg = ProfListctrlPanel(self.parent, self, prof_seg[str(i + 1)], False, i + 1)
-                self.prof_seg_nb.AddPage(self.tab_prof_seg, 'classe %i' % (i + 1))
-
-       if clnb > 2 :
-           self.TabAFC = aui.AuiNotebook(panel.TabChdSim, -1, wx.DefaultPosition)
-           log.info('read AFC') 
-           list_graph=read_list_file(DictPathOut['liste_graph_afc'], self.encoding)
-           self.tabAFCGraph = GraphPanelAfc(self.TabAFC, DictPathOut, list_graph, self.clnb, coding=self.encoding)
-           self.TabAFC.AddPage(self.tabAFCGraph, 'AFC')
-           
-           if os.path.exists(self.DictPathOut['afc_facteur']) :
-               dictrow, first = ReadList(self.DictPathOut['afc_facteur'], self.encoding)
-               self.TabAFC_facteur = ListForSpec(self.parent, parametres, dictrow, first)
-               #dictrow, first = ReadList(self.DictPathOut['afc_row'], self.encoding)
-               #self.TabAFC_ligne = ListForSpec(self.parent, self.parametres, dictrow, first)
-               #dictrow, first = ReadList(self.DictPathOut['afc_col'], self.encoding)
-               #self.TabAFC_colonne = ListForSpec(parent, self.parametres, dictrow, first)
-               self.TabAFC.AddPage(self.TabAFC_facteur, 'Facteurs')
-               #self.TabAFC.AddPage(self.TabAFC_colonne, u'Colonnes')
-               #self.TabAFC.AddPage(self.TabAFC_ligne, u'Lignes')
-           
-           sizer_3 = wx.BoxSizer(wx.VERTICAL)
-           self.parent.nb_panel_2 = wx.Panel(panel.TabChdSim, -1)
-           self.parent.button_simi = wx.Button(self.parent.nb_panel_2, -1, "Voyager")
-           self.parent.simi3dpanel = simi3d(self.parent.nb_panel_2, -1)
-           sizer_3.Add(self.parent.simi3dpanel, 1, wx.EXPAND, 0)
-           sizer_3.Add(self.parent.button_simi, 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
-           self.parent.nb_panel_2.SetSizer(sizer_3)
-           self.TabAFC.AddPage(self.parent.nb_panel_2, "graph 3D")
-           self.parent.Bind(wx.EVT_BUTTON, self.onsimi, self.parent.button_simi)
-       
-       panel.TabChdSim.AddPage(panel.ProfNB, 'Profils')
-       #panel.TabChdSim.AddPage(panel.AntiProfNB, 'Antiprofils')
-       dlg.Update(4 + self.clnb, 'Affichage...')
-       if clnb > 2 :
-           panel.TabChdSim.AddPage(self.TabAFC, 'AFC')
-       if os.path.exists(DictPathOut['prof_seg']) :
-           panel.TabChdSim.AddPage(self.prof_seg_nb, u'Profils des segments répétés')
-      
+                self.prof_seg_nb.AddPage(self.tab_prof_seg, _(u"Cluster").decode('utf8') + ' %i' % (i + 1))
+        panel.ProfNB.SetSelection(0)
+
+        if clnb > 2 :
+            self.TabAFC = aui.AuiNotebook(panel.TabChdSim, -1, wx.DefaultPosition)
+            log.info('read AFC') 
+            list_graph=read_list_file(DictPathOut['liste_graph_afc'], self.encoding)
+            self.tabAFCGraph = GraphPanelAfc(self.TabAFC, DictPathOut, list_graph, self.clnb, coding=self.encoding)
+            self.TabAFC.AddPage(self.tabAFCGraph, _(u"CA").decode('utf8'))
+            
+            if os.path.exists(self.DictPathOut['afc_facteur']) :
+                dictrow, first = ReadList(self.DictPathOut['afc_facteur'], self.encoding)
+                self.TabAFC_facteur = ListForSpec(self.parent, parametres, dictrow, first[1:])
+                #dictrow, first = ReadList(self.DictPathOut['afc_row'], self.encoding)
+                #self.TabAFC_ligne = ListForSpec(self.parent, self.parametres, dictrow, first)
+                #dictrow, first = ReadList(self.DictPathOut['afc_col'], self.encoding)
+                #self.TabAFC_colonne = ListForSpec(parent, self.parametres, dictrow, first)
+                self.TabAFC.AddPage(self.TabAFC_facteur, _(u"Factor").decode('utf8'))
+                #self.TabAFC.AddPage(self.TabAFC_colonne, u'Colonnes')
+                #self.TabAFC.AddPage(self.TabAFC_ligne, u'Lignes')
+            
+            sizer_3 = wx.BoxSizer(wx.VERTICAL)
+            self.parent.nb_panel_2 = wx.Panel(panel.TabChdSim, -1)
+            self.parent.button_simi = wx.Button(self.parent.nb_panel_2, -1, "Voyager")
+            self.parent.simi3dpanel = simi3d(self.parent.nb_panel_2, -1)
+            sizer_3.Add(self.parent.simi3dpanel, 1, wx.EXPAND, 0)
+            sizer_3.Add(self.parent.button_simi, 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
+            self.parent.nb_panel_2.SetSizer(sizer_3)
+            self.TabAFC.AddPage(self.parent.nb_panel_2, _(u"3D graph").decode('utf8'))
+            self.parent.Bind(wx.EVT_BUTTON, self.onsimi, self.parent.button_simi)
+              
+        panel.TabChdSim.AddPage(panel.ProfNB, _(u"Profiles").decode('utf8'))
+        #panel.TabChdSim.AddPage(panel.AntiProfNB, 'Antiprofils')
+        dlg.Update(4 + self.clnb, 'Affichage...')
+        if clnb > 2 :
+            panel.TabChdSim.AddPage(self.TabAFC, _(u"CA").decode('utf8'))
+        if os.path.exists(DictPathOut['prof_seg']) :
+            panel.TabChdSim.AddPage(self.prof_seg_nb, _(u"Repeated segments profiles").decode('utf8'))
+  
 #       panel.Bind(wx.EVT_BUTTON, self.ongetrapport, id = self.ID_rapport)
-       self.parent.nb.AddPage(panel, 'Classification - %s' % corpname)
-       self.parent.ShowTab(True)
-       self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)     
-       #for pane in self.parent._mgr.GetAllPanes() :
-       #     if isinstance(pane.window, aui.AuiNotebook):
-       #         nb = pane.window
-       #         nb.SetAGWWindowStyleFlag(notebook_flags)
-       #         nb.SetArtProvider(aui.ChromeTabArt())
-       dlg.Destroy() 
-       self.parent._mgr.Update()
+        if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenchi2.csv')) :
+            self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenchi2.csv')
+            TgenLayout(panel)
+        panel.TabChdSim.SetSelection(0)
+        self.parent.nb.AddPage(panel, _(u"Clustering").decode('utf8') + ' - %s' % corpname)
+        self.parent.ShowTab(True)
+        self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)     
+        #for pane in self.parent._mgr.GetAllPanes() :
+        #     if isinstance(pane.window, aui.AuiNotebook):
+        #         nb = pane.window
+        #         nb.SetAGWWindowStyleFlag(notebook_flags)
+        #         nb.SetArtProvider(aui.ChromeTabArt())
+        dlg.Destroy() 
+        self.parent._mgr.Update()
         
     def onsimi(self,event):
         outfile = print_simi3d(self)
         error = exec_rcode(self.parent.RPath, outfile, wait = True)
 
-#    def ongetrapport(self, event) :
-#        dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.txt', 'title': 'Rapport'})
-#        dial.fbb.SetValue(self.DictPathOut['rapport'])
-#        dial.CenterOnParent()
-#        res = dial.ShowModal()
-#        if res == wx.ID_OK :
-#            fileout = dial.fbb.GetValue()
-#            dial.Destroy()
-#            with open(fileout, 'w') as f :
-#                f.write(self.debtext + '\n' + GetTxtProfile(self.DictProfile, self.cluster_size))
-#            msg = u"Fini !"
-#            dlg = wx.MessageDialog(self.parent, msg, u"Rapport", wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
-#            dlg.CenterOnParent()
-#            dlg.ShowModal()
-#            dlg.Destroy()
-#        else :
-#            dial.Destroy()
-
-#    def on_export_classes(self, event) :
-#        corpus = self.parent.nb.GetPage(self.parent.nb.GetSelection()).corpus
-#        dial = PrefExport(self, self.parent)
-#        dial.fbb.SetValue(os.path.join(os.path.dirname(corpus.dictpathout['ira']), 'export_corpus.txt'))
-#        dial.CenterOnParent()
-#        res = dial.ShowModal()
-#        if res == wx.ID_OK :
-#            if dial.radio_type.GetSelection() == 0 : alc = True
-#            else : alc = False
-#            if dial.radio_lem.GetSelection() == 0 : lem = True
-#            else : lem = False
-#            self.corpus.export_corpus_classes(dial.fbb.GetValue(), alc = alc, lem = lem)
-#            msg = u"Fini !"
-#            dial.Destroy()
-#            dlg = wx.MessageDialog(self.parent, msg, u"Export", wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
-#            dlg.CenterOnParent()
-#            dlg.ShowModal()
-#            dlg.Destroy()
-
-#    def onprofseg(self, event):
-#        #try :
-#            print 'plus de bug profseg'
-#            print self.parametres
-#            corpus = self.parent.nb.GetPage(self.parent.nb.GetSelection()).corpus
-#            ProfileSegment(self.parent, self.dictpathout, self.parametres, corpus)
-#        #except :
-#        #    BugReport(self.parent)
-#
-#    def onproftype(self, event):
-#        try :
-#            corpus = self.parent.nb.GetPage(self.parent.nb.GetSelection()).corpus
-#            ProfilType(self.parent, corpus)
-#        except :
-#            BugReport(self.parent)
-#
-#    def oncolored(self,evt) :
-#        dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.html', 'title': 'Corpus en couleur'})
-#        dial.fbb.SetValue(os.path.join(os.path.dirname(self.corpus.dictpathout['ira']), 'corpus_couleur.html'))
-#        dial.CenterOnParent()
-#        res = dial.ShowModal()
-#        if res == wx.ID_OK :
-#            fileout = dial.fbb.GetValue()
-#            dial.Destroy()
-#            txt = self.corpus.make_colored_corpus()
-#            with open(fileout, 'w') as f :
-#                f.write(txt)
-#            msg = u"Fini !\nVoulez-vous ouvrir le corpus dans votre navigateur ?"
-#            dlg = wx.MessageDialog(self.parent, msg, u"Corpus en couleur", wx.NO | wx.YES | wx.NO_DEFAULT | wx.ICON_QUESTION)
-#            dlg.CenterOnParent()
-#            if dlg.ShowModal() == wx.ID_YES :
-#                webbrowser.open(fileout)
-#            dlg.Destroy()
-
     def onclusterstat(self, evt) :
         dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.csv', 'title': 'Stat par classe'})
         dial.fbb.SetValue( os.path.join(os.path.dirname(self.corpus.dictpathout['ira']), 'stat_par_classe.csv'))
@@ -535,10 +546,9 @@ class OpenCHDS():
         if res == wx.ID_OK :
             fileout = dial.fbb.GetValue()
             dial.Destroy()
-            print fileout
             self.corpus.get_stat_by_cluster(fileout)
             msg = u"Fini !"
-            dlg = wx.MessageDialog(self.parent, msg, u"Stat par classe", wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
+            dlg = wx.MessageDialog(self.parent, msg, _(u"Stat by cluster").decode('utf8'), wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
             dlg.CenterOnParent()
             if dlg.ShowModal() == wx.ID_OK :
                 dlg.Destroy()
@@ -547,13 +557,8 @@ class OpenCHDS():
     #    if 'FrameSearch' not in dir(self.panel) :
     #        self.panel.FrameSearch = SearchFrame(self.parent, -1, u"Rechercher...", self.corpus)
     #    self.panel.FrameSearch.Show()
-    
-        
 
 def PrintRapport(self, corpus, parametres, istxt = True):
-    #if sys.platform == 'win32':
-    #    sep = '\r\n'
-    #else:
     sep = '\n'
     txt = """
 +-+-+-+-+-+-+-+-+
@@ -564,40 +569,126 @@ def PrintRapport(self, corpus, parametres, istxt = True):
 """ % datetime.datetime.now().ctime()
     if istxt :
         totocc = corpus.gettotocc()
-        txt += u'nombre de textes: %i%s' % (corpus.getucinb(), sep)
-        txt += u'nombre de segments de textes: %i%s' % (corpus.getucenb(), sep)
-        txt += u'nombre de formes: %i%s' % (len(corpus.formes), sep)
-        txt += u'nombre d\'occurrences: %i%s' % (totocc, sep)
-        txt += u'moyenne d\'occurrences par forme: %f%s' % (float(totocc) / float(len(self.corpus.formes)), sep)
-        txt += u'nombre de lemmes: %i%s' % (len(corpus.lems), sep)
-        txt += u'nombre de formes actives: %i%s' % (corpus.getactivesnb(1), sep)
-        txt += u'nombre de formes supplémentaires: %i%s' % (corpus.getactivesnb(2), sep)
-        txt += u'nombre de formes actives de fréquence >= %i: %i%s' % (parametres['eff_min_forme'], parametres['nbactives'], sep)
-        txt += u'moyenne d\'occurrences par uce :%f%s' % (float(totocc) / float(corpus.getucenb()), sep)
+        txt += ': '.join([_(u'Number of texts').decode('utf8'),  u'%i%s' % (corpus.getucinb(), sep)])
+        txt += ': '.join([_(u'Number of text segments').decode('utf8'),  '%i%s' % (corpus.getucenb(), sep)])
+        txt += ': '.join([_(u'Number of forms').decode('utf8'), '%i%s' % (len(corpus.formes), sep)])
+        txt += ': '.join([_(u'Number of occurrences').decode('utf8'), '%i%s' % (totocc, sep)])
+        #txt += u'moyenne d\'occurrences par forme: %f%s' % (float(totocc) / float(len(self.corpus.formes)), sep)
+        txt += ': '.join([_(u'Number of lemmas').decode('utf8'), '%i%s' % (len(corpus.lems), sep)])
+        txt += ': '.join([_(u'Number of active forms').decode('utf8'), '%i%s' % (corpus.getactivesnb(1), sep)])
+        txt += ': '.join([_(u'Number of supplementary forms').decode('utf8'), '%i%s' % (corpus.getactivesnb(2), sep)])
+        txt += ' >= '.join([_(u'Number of active forms with a frequency').decode('utf8'), '%i: %i%s' % (parametres['eff_min_forme'], parametres['nbactives'], sep)])
+        txt += ': '.join([_(u'Mean of forms by segment').decode('utf8'), '%f%s' % (float(totocc) / float(corpus.getucenb()), sep)])
         if 'tailleuc1' in parametres :
             if parametres['classif_mode'] == 0 :
-                txt += u'taille rst1 / rst2: %i / %i - %i / %i%s' % (parametres['tailleuc1'], parametres['tailleuc2'], parametres['lenuc1'], parametres['lenuc2'], sep)
+                txt += ': '.join([_(u'Size of rst1 / rst2').decode('utf8'), '%i / %i - %i / %i%s' % (parametres['tailleuc1'], parametres['tailleuc2'], parametres['lenuc1'], parametres['lenuc2'], sep)])
     else :
         self.Ucenb = self.nbind
-        txt += u'nombre d\'individus : %i%s' % (self.nbind, sep)
-        txt += u'nombre de classes : %i%s' % (self.clnb, sep)
+        txt += ': '.join([_(u'Number of lines').decode('utf8'), '%i%s' % (self.nbind, sep)])
+        txt += ': '.join([_(u'Number of clusters').decode('utf8'), '%i%s' % (self.clnb, sep)])
     if istxt :
-        txt += u'nombre de classes : %i%s' % (parametres['clnb'], sep)
+        txt += ': '.join([_(u'Number of clusters').decode('utf8'), '%i%s' % (parametres['clnb'], sep)])
         if parametres['classif_mode'] == 0 or parametres['classif_mode'] == 1 :
-            txt += u'%i segments classés sur %i (%.2f%%)%s' % (sum([len(cl) for cl in corpus.lc]), corpus.getucenb(), (float(sum([len(cl) for cl in corpus.lc])) / float(corpus.getucenb())) * 100, sep)
+            txt += ' '.join(['%i' % sum([len(cl) for cl in corpus.lc]), _(u'segments classified on').decode('utf8'), '%i (%.2f%%)%s' % (corpus.getucenb(), (float(sum([len(cl) for cl in corpus.lc])) / float(corpus.getucenb())) * 100, sep)])
         elif self.parametres['classif_mode'] == 2 :
-            txt += u'%i textes classés sur %i (%.2f%%)%s' % (sum([len(cl) for cl in corpus.lc]), corpus.getucinb(), (float(sum([len(cl) for cl in corpus.lc]))) / float(corpus.getucinb()) * 100, sep)
+            txt += ' '.join([u'%i' % sum([len(cl) for cl in corpus.lc]), _(u'texts classified on').decode('utf8'), '%i (%.2f%%)%s' % (corpus.getucinb(), (float(sum([len(cl) for cl in corpus.lc]))) / float(corpus.getucinb()) * 100, sep)])
     else :
-        txt += u'%i uce classées sur %i (%.2f%%)%s' % (self.ucecla, self.Ucenb, (float(self.ucecla) / float(self.Ucenb)) * 100, sep)
+        txt += ' '.join(['%i' % self.ucecla, _(u'line classified on').decode('utf8'), '%i (%.2f%%)%s' % (self.Ucenb, (float(self.ucecla) / float(self.Ucenb)) * 100, sep)])
  
-    txt += """
-###########################
-temps d'analyse : %s
-###########################
-""" % parametres.get('time', '')
+    txt += ''.join([sep, u'###########################', sep, _(u'time').decode('utf8'), ' : %s' % parametres.get('time', ''), sep, u'###########################', sep])
+
     with open(self.pathout['pre_rapport'], 'w') as f :
         f.write(txt)
 
+
+class SashList(wx.Panel) :
+    def __init__(self, parent) :
+        wx.Panel.__init__(self, parent, -1)
+        self.parent=parent
+        winids = []
+        #self.gparent=gparent
+        #self.dlist=dlist
+        #self.first = first
+        #self.menu = menu        
+        # A window to the left of the client window
+        #self.listlex = listlex
+        self.leftwin1 =  wx.SashLayoutWindow(
+                self, -1, wx.DefaultPosition, (200, 300), 
+                wx.NO_BORDER|wx.SW_3D
+                )
+
+        self.leftwin1.SetDefaultSize((120, 1000))
+        self.leftwin1.SetOrientation(wx.LAYOUT_VERTICAL)
+        self.leftwin1.SetAlignment(wx.LAYOUT_LEFT)
+        self.leftwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
+        self.leftwin1.SetSashVisible(wx.SASH_RIGHT, True)
+        self.leftwin1.SetExtraBorderSize(10)
+        
+        #textWindow = wx.TextCtrl(
+        #                leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize, 
+        #                wx.TE_MULTILINE|wx.SUNKEN_BORDER
+        #                )
+
+        #textWindow.SetValue("A sub window")
+
+        self.leftWindow1 = self.leftwin1
+        winids.append(self.leftwin1.GetId())
+        
+        rightwin1 =  wx.SashLayoutWindow(
+                self, -1, wx.DefaultPosition, (200, 300), 
+                wx.NO_BORDER|wx.SW_3D
+                )
+
+        rightwin1.SetDefaultSize((120, 1000))
+        rightwin1.SetOrientation(wx.LAYOUT_VERTICAL)
+        rightwin1.SetAlignment(wx.LAYOUT_LEFT)
+        rightwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
+        rightwin1.SetSashVisible(wx.SASH_RIGHT, True)
+        rightwin1.SetExtraBorderSize(10)
+        #textWindow = wx.TextCtrl(
+        #                leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize, 
+        #                wx.TE_MULTILINE|wx.SUNKEN_BORDER
+        #                )
+
+        #textWindow.SetValue("A sub window")
+
+        self.rightwin1 = rightwin1
+        winids.append(rightwin1.GetId())
+
+class TgenLayout :
+    def __init__(self, page):
+        self.page = page
+        parametres = self.page.parametres
+        ira = wx.GetApp().GetTopWindow()
+        tgenpath = os.path.join(parametres['pathout'], 'tgen.csv')
+        self.page.tgens, etoiles =  ReadList(parametres['tgenspec'], ira.syscoding, sep="\t")
+        tgen = TGen(path = tgenpath, encoding = parametres['encoding'])
+        tgen.read()
+        tgentab = False
+        gparent = None
+        if 'TabChdSim' in dir(page) :
+            page = page.TabChdSim
+        for i in range(page.GetPageCount()) :
+            tab = page.GetPage(i)
+            if 'gparent' in dir(tab) :
+                if tab.gparent is not None :
+                    gparent = tab.gparent
+            if 'tgen' in dir(tab) :
+                if tab.tgen :
+                    tgentab = tab
+                    break
+                
+        if tgentab :
+            self.page.tgentab.RefreshData(self.page.tgens)
+            self.page.tgentab.tgens = tgen.tgen
+            page.SetSelection(i)
+        else :
+            self.page.tgentab = ListForSpec(ira, gparent, self.page.tgens, etoiles[1:])
+            self.page.tgentab.tgen = True
+            self.page.tgentab.tgens = tgen.tgen
+            page.AddPage(self.page.tgentab, _(u'Tgens Specificities').decode('utf8'))
+            page.SetSelection(page.GetPageCount() - 1)
+
 class dolexlayout :
     def __init__(self, ira, corpus, parametres):
         self.pathout = PathOut(dirout = parametres['pathout'])
@@ -609,41 +700,56 @@ class dolexlayout :
         self.parametres = parametres
 
         self.DictSpec, first = ReadList(self.dictpathout['tablespecf'], self.corpus.parametres['syscoding'])
+        if os.path.exists(self.pathout['banalites.csv']) :
+            self.dictban, firstban = ReadList(self.pathout['banalites.csv'], self.corpus.parametres['syscoding'])
         self.DictType, firstt = ReadList(self.dictpathout['tablespect'], self.corpus.parametres['syscoding'])
         self.DictEff, firsteff = ReadList(self.dictpathout['tableafcm'], self.corpus.parametres['syscoding'])
         self.DictEffType, firstefft = ReadList(self.dictpathout['tabletypem'], self.corpus.parametres['syscoding'])
         self.DictEffRelForme, firsteffrelf = ReadList(self.dictpathout['eff_relatif_forme'], self.corpus.parametres['syscoding']) 
         self.DictEffRelType, firsteffrelt = ReadList(self.dictpathout['eff_relatif_type'], self.corpus.parametres['syscoding'])    
+        self.etoiles = firsteff[1:]
+        #sash = SashList(ira.nb)
+        
         
         self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
         self.TabStat.parametres = parametres
-        self.ListPan = ListForSpec(ira, self.parent, self.DictSpec, first)
-        self.ListPant = ListForSpec(ira, self.parent, self.DictType, firstt)
-        self.ListPanEff = ListForSpec(ira, self.parent, self.DictEff, firsteff)
-        self.ListPanEffType = ListForSpec(ira, self.parent, self.DictEffType, firstefft)
-        self.ListPanEffRelForme = ListForSpec(ira, self.parent, self.DictEffRelForme, firsteffrelf)
-        self.ListPanEffRelType = ListForSpec(ira, self.parent, self.DictEffRelType, firsteffrelt)
+        self.ListPan = ListForSpec(ira, self, self.DictSpec, self.etoiles)
+        if os.path.exists(self.pathout['banalites.csv']) :
+            self.listban = ListForSpec(ira, self, self.dictban, ['eff'] + self.etoiles, usefirst = True)
+        #self.ListPan2 = ListForSpec(sash.rightwin1, self, self.DictSpec, first)
+        self.ListPant = ListForSpec(ira, self, self.DictType, self.etoiles)
+        self.ListPanEff = ListForSpec(ira, self, self.DictEff, self.etoiles)
+        self.ListPanEffType = ListForSpec(ira, self, self.DictEffType, self.etoiles)
+        self.ListPanEffRelForme = ListForSpec(ira, self, self.DictEffRelForme, self.etoiles)
+        self.ListPanEffRelType = ListForSpec(ira, self, self.DictEffRelType, self.etoiles)
         
-        self.TabStat.AddPage(self.ListPan, u'formes') 
-        self.TabStat.AddPage(self.ListPant, u'Types')
-        self.TabStat.AddPage(self.ListPanEff, u'Effectifs formes')
-        self.TabStat.AddPage(self.ListPanEffType, u'Effectifs Type')
-        self.TabStat.AddPage(self.ListPanEffRelForme, u'Effectifs relatifs formes')
-        self.TabStat.AddPage(self.ListPanEffRelType, u'Effectifs relatifs Type')
+        self.TabStat.AddPage(self.ListPan, _(u'Forms').decode('utf8')) 
+        if os.path.exists(self.pathout['banalites.csv']) :
+            self.TabStat.AddPage(self.listban, _(u'Banal forms').decode('utf8'))
+        self.TabStat.AddPage(self.ListPant, _(u'POS').decode('utf8'))
+        self.TabStat.AddPage(self.ListPanEff, _(u'Forms frequencies').decode('utf8'))
+        self.TabStat.AddPage(self.ListPanEffType, _(u'POS frequencies').decode('utf8'))
+        self.TabStat.AddPage(self.ListPanEffRelForme, _(u'Forms relative frequencies').decode('utf8'))
+        self.TabStat.AddPage(self.ListPanEffRelType, _(u'POS relative frequencies').decode('utf8'))
         if self.parametres['clnb'] > 2 :
-           self.TabAFC = aui.AuiNotebook(self.TabStat, -1, wx.DefaultPosition)
-           list_graph=read_list_file(self.dictpathout['liste_graph_afcf'], encoding = self.encoding)
-           self.tabAFCGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afcf', coding = self.encoding)
-           self.TabAFC.AddPage(self.tabAFCGraph, 'AFC formes')
-           list_graph=read_list_file(self.dictpathout['liste_graph_afct'], encoding = self.encoding)
-           self.tabAFCTGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afct', coding=self.encoding)
-           self.TabAFC.AddPage(self.tabAFCTGraph, 'AFC type')
-           self.TabStat.AddPage(self.TabAFC, 'AFC')
-           
+            self.TabAFC = aui.AuiNotebook(self.TabStat, -1, wx.DefaultPosition)
+            list_graph=read_list_file(self.dictpathout['liste_graph_afcf'], encoding = self.encoding)
+            self.tabAFCGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afcf', coding = self.encoding)
+            self.TabAFC.AddPage(self.tabAFCGraph, _(u'CA forms').decode('utf8'))
+            list_graph=read_list_file(self.dictpathout['liste_graph_afct'], encoding = self.encoding)
+            self.tabAFCTGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afct', coding=self.encoding)
+            self.TabAFC.AddPage(self.tabAFCTGraph, _(u'CA POS').decode('utf8'))
+            self.TabStat.AddPage(self.TabAFC, _(u'CA').decode('utf8'))
         
-        ira.nb.AddPage(self.TabStat, u'Spécificités')
+        ira.nb.AddPage(self.TabStat, ' - '.join([_(u'Specificities').decode('utf8'), self.parametres['name']]))
+        self.ira = ira
         
         self.TabStat.corpus = self.corpus
+        self.TabStat.etoiles = self.etoiles
+        if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenspec.csv')) :
+            self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenspec.csv')
+            TgenLayout(self.TabStat)
+        self.TabStat.SetSelection(0)
         ira.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
         ira.ShowAPane("Tab_content")
 
@@ -655,20 +761,28 @@ class StatLayout:
         self.read_result()
         self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
         self.TabStat.parametres = parametres
+        self.TabStat.corpus = corpus
+        self.TabStat.pathout = self.pathout
 #        CHD = GraphPanel(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
-         #      panel.TabChdSim.AddPage(CHD,'CHD')
+        #      panel.TabChdSim.AddPage(CHD,'CHD')
 
         #self.TabStatTot = wx.TextCtrl(self.TabStat, -1, style=wx.NO_BORDER | wx.TE_MULTILINE | wx.TE_RICH2)
         list_graph = [['zipf.png', 'zipf']]
         self.TabStatTot = GraphPanel(ira.nb, self.pathout, list_graph, self.result['glob'])
-        #self.TabStatTot.write(self.result['glob'])
-        self.TabStat.AddPage(self.TabStatTot, 'global')
+        self.TabStat.AddPage(self.TabStatTot, _(u'Abstract').decode('utf8'))
+        
+        dictlabel = {'total' : _(u'Total').decode('utf8'),
+                     u'formes_actives' : _(u'Actives forms').decode('utf8'),
+                     u'formes_supplémentaires': _(u'Supplementary forms').decode('utf8'),
+                     u'hapax' : _(u'Hapax').decode('utf8'),
+                     }
+        
         for item in self.result:
             if item != 'glob':
                 datam = [['forme', 'nb']]
                 self.ListPan = ListPanel(ira, self, self.result[item])
-                self.TabStat.AddPage(self.ListPan, item) 
-        ira.nb.AddPage(self.TabStat, 'Stat')
+                self.TabStat.AddPage(self.ListPan, dictlabel[item]) 
+        ira.nb.AddPage(self.TabStat, '%s' % parametres['name'])
         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
         ira.ShowAPane("Tab_content")
 
@@ -699,11 +813,19 @@ class GraphPanelDendro(wx.Panel):
         self.panel_1.SetBackgroundColour('white')
         self.deb = wx.StaticText(self.panel_1, -1, txt)
         dendro_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
+        dendro_liste_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro_liste.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
+        dendro_cloud_img= wx.Image(os.path.join(self.ira.images_path,'but_dendro_cloud.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
         self.butdendro = wx.BitmapButton(self, -1, dendro_img)
+        self.butdendrotexte = wx.BitmapButton(self, -1, dendro_liste_img)
+        self.butdendrocloud = wx.BitmapButton(self, -1, dendro_cloud_img)
         
         for i in range(0,len(list_graph)):
             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
-                self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
+                filename, ext = os.path.splitext(list_graph[i][0])
+                if ext == '.svg' :
+                    self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, os.path.join(self.dirout,list_graph[i][0]), URL=os.path.join(self.dirout,list_graph[i][0])))
+                else :
+                    self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
                 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
                 
         self.__set_properties()
@@ -713,13 +835,17 @@ class GraphPanelDendro(wx.Panel):
         self.panel_1.EnableScrolling(True,True)
         #self.panel_1.SetSize((1000,1000))
         self.panel_1.SetScrollRate(20, 20)
+        self.panel_1.SetFocus()
         self.Bind(wx.EVT_BUTTON, self.ondendro, self.butdendro)
+        self.Bind(wx.EVT_BUTTON, self.ondendrotexte, self.butdendrotexte)
+        self.Bind(wx.EVT_BUTTON, self.ondendrocloud, self.butdendrocloud)
         self.param = {'width' : 700,
                        'height': 500,
                        'type_dendro': 0,
                        'color_nb': 0,
                        'taille_classe' : True,
-                       'type_tclasse' : 0
+                       'type_tclasse' : 0,
+                       'svg' : 0
                      }
         self.type_dendro = [ u"phylogram", u"cladogram", u"fan", u"unrooted", u"radial" ]
 
@@ -728,11 +854,15 @@ class GraphPanelDendro(wx.Panel):
         self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
         self.sizer_3.Add(self.deb)
-        self.sizer_2.Add(self.butdendro, 0, 0, 0)
+        self.sizer_1.Add(self.butdendro, 0, 0, 0)
+        self.sizer_1.Add(self.butdendrotexte, 0, 0, 0)
+        self.sizer_1.Add(self.butdendrocloud, 0, 0, 0)
+
         for i in range(0, len(self.listimg)):
             self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
             self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
         self.panel_1.SetSizer(self.sizer_3)
+        self.sizer_2.Add(self.sizer_1, 0, wx.EXPAND, 0)
         self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
         self.SetSizer(self.sizer_2) 
 
@@ -743,11 +873,16 @@ class GraphPanelDendro(wx.Panel):
         self.param['color_nb'] = dial.m_radioBox1.GetSelection()
         self.param['taille_classe'] = dial.m_checkBox1.GetValue()
         self.param['type_tclasse'] = dial.m_radioBox2.GetSelection()
+        self.param['svg'] = dial.choice_format.GetSelection()
 
-    def make_dendro(self) :
-        while os.path.exists(os.path.join(self.dirout, 'dendrogamme_' + str(self.graphnb)+'.png')) :
+    def make_dendro(self, dendro = 'simple') :
+        if self.param['svg'] :
+            typefile = '.svg'
+        else :
+            typefile = '.png'
+        while os.path.exists(os.path.join(self.dirout, 'dendrogramme_' + str(self.graphnb)+typefile)) :
             self.graphnb += 1
-        fileout = ffr(os.path.join(self.dirout,'dendrogamme_' + str(self.graphnb)+'.png'))
+        fileout = ffr(os.path.join(self.dirout,'dendrogramme_' + str(self.graphnb)+typefile))
         width = self.param['width']
         height = self.param['height']
         type_dendro = self.type_dendro[self.param['type_dendro']]
@@ -763,6 +898,10 @@ class GraphPanelDendro(wx.Panel):
             histo='FALSE'
         else :
             histo = 'TRUE'
+        if self.param['svg'] :
+            svg = 'TRUE'
+        else :
+            svg = 'FALSE'
         dendro_path = self.dictpathout['Rdendro']
         classe_path = self.dictpathout['uce']
         txt = """
@@ -771,18 +910,50 @@ class GraphPanelDendro(wx.Panel):
         source("%s")
         classes <- read.csv2("%s", row.names=1)
         classes <- classes[,1]
-        open_file_graph("%s", width=%i, height=%i)
-        plot.dendropr(tree.cut1$tree.cl, classes, type.dendro="%s", histo=%s, bw=%s, lab=NULL, tclasse=%s)
-        """ % (ffr(dendro_path), ffr(self.ira.RscriptsPath['Rgraph']), ffr(classe_path), ffr(fileout), width, height, type_dendro, histo, bw, tclasse)
-        
+        """ % (ffr(dendro_path), ffr(self.ira.RscriptsPath['Rgraph']),  ffr(classe_path))
+        if dendro == 'simple' :
+            txt += """
+            open_file_graph("%s", width=%i, height=%i)
+            plot.dendropr(tree.cut1$tree.cl, classes, type.dendro="%s", histo=%s, bw=%s, lab=NULL, tclasse=%s)
+            """ % (ffr(fileout), width, height, type_dendro, histo, bw, tclasse)
+        elif dendro == 'texte' :
+            txt += """
+            load("%s")
+            source("%s")
+            if (is.null(debsup)) {
+                debsup <- debet
+            }
+            chistable <- chistabletot[1:(debsup-1),]
+            open_file_graph("%s", width=%i, height=%i, svg = %s)
+            plot.dendro.prof(tree.cut1$tree.cl, classes, chistable, nbbycl = 60, type.dendro="%s", bw=%s, lab=NULL)
+            """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, svg, type_dendro, bw)
+        elif dendro == 'cloud' :
+            txt += """
+            load("%s")
+            source("%s")
+            if (is.null(debsup)) {
+                debsup <- debet
+            }
+            chistable <- chistabletot[1:(debsup-1),]
+            open_file_graph("%s", width=%i, height=%i, svg=%s)
+            plot.dendro.cloud(tree.cut1$tree.cl, classes, chistable, nbbycl = 300, type.dendro="%s", bw=%s, lab=NULL)
+            """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, svg, type_dendro, bw)
+
+
         tmpfile = tempfile.mktemp()
         with open(tmpfile, 'w') as f :
             f.write(txt)
+        busy = wx.BusyInfo(_("Please wait...").decode('utf8'), self.parent)
+        wx.SafeYield()
         error = exec_rcode(self.ira.RPath, tmpfile, wait=True) 
+        del busy
         check_Rresult(self.ira, error)
         self.list_graph.append([fileout, 'Dendrogramme CHD1 - %s' %  type_dendro])
         print_liste(self.dictpathout['liste_graph_chd'], self.list_graph)
-        self.sizer_3.Add(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
+        if self.param['svg'] :
+            self.sizer_3.Add(hl.HyperLinkCtrl(self.panel_1, -1, fileout, URL=fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
+        else :
+            self.sizer_3.Add(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
         self.sizer_3.Add(wx.StaticText(self.panel_1,-1, 'Dendrogramme CHD1 - %s' %  type_dendro), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
         self.sizer_3.Fit(self.panel_1)
         self.Layout()
@@ -795,8 +966,20 @@ class GraphPanelDendro(wx.Panel):
         if val == wx.ID_OK :
             self.make_param(dial)
             self.make_dendro()
+    
+    def ondendrotexte(self, evt):
+        dial = PrefDendro(self.ira, self.param)
+        val = dial.ShowModal()
+        if val == wx.ID_OK :
+            self.make_param(dial)
+            self.make_dendro(dendro = 'texte')
 
-
+    def ondendrocloud(self, evt):
+        dial = PrefDendro(self.ira, self.param)
+        val = dial.ShowModal()
+        if val == wx.ID_OK :
+            self.make_param(dial)
+            self.make_dendro(dendro = 'cloud')
 
 class OpenCorpus :
     def __init__(self, ira, parametres) :
@@ -807,6 +990,16 @@ class OpenCorpus :
         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
         ira.ShowAPane("Tab_content")
 
+class MatLayout :
+    def __init__(self, ira, matrix):
+        #self.parent.content = self.csvtable
+        self.sheet = MySheet(ira.nb)
+        ira.nb.AddPage(self.sheet, matrix.parametres['matrix_name'])
+        self.sheet.Populate(matrix.csvtable)
+        self.sheet.parametres = matrix.parametres
+        ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
+        ira.ShowAPane("Tab_content")
+
 class CopusPanel(wx.Panel) :
     def __init__(self, parent, parametres) :
         wx.Panel.__init__ ( self, parent, id = wx.ID_ANY, pos = wx.DefaultPosition, size = wx.Size( 500,300 ), style = wx.TAB_TRAVERSAL )
@@ -816,7 +1009,7 @@ class CopusPanel(wx.Panel) :
         fgSizer5.SetNonFlexibleGrowMode( wx.FLEX_GROWMODE_SPECIFIED )        
         self.fgSizer5 = fgSizer5
         
-        self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Description du corpus", wx.DefaultPosition, wx.DefaultSize, 0 )
+        self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, _(u"Description of corpus").decode('utf8'), wx.DefaultPosition, wx.DefaultSize, 0 )
 
         self.m_staticText18.Wrap( -1 )
         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
@@ -833,8 +1026,13 @@ class CopusPanel(wx.Panel) :
         self.m_staticText21.Wrap( -1 )
         fgSizer5.Add( self.m_staticText21, 0, wx.ALL, 5 )
 
-        description = {'lang' : u'langue',
-                        'encoding' : u'encodage'}
+        description = {'lang' : _(u'Language').decode('utf8'),
+                       'encoding' : _(u'Characters set').decode('utf8'),
+                       'ucinb' : _(u'Number of texts').decode('utf8'),
+                       'ucenb' : _(u'Number of text segments').decode('utf8'),
+                       'formesnb' : _(u'Number of forms').decode('utf8'),
+                       'hapax' : _(u'Number of hapax').decode('utf8'),
+                      }
 
         keys = ['lang', 'encoding', 'originalpath', 'pathout', 'date', 'time']
 
@@ -867,7 +1065,7 @@ class CopusPanel(wx.Panel) :
 
     def addkeys(self, keys, description) :
         for key in keys :
-            option = self.parametres.get(key,u'non défnini')
+            option = self.parametres.get(key,u'non défini')
             if isinstance(option, int) :
                 option = `option`
             text = wx.StaticText( self, wx.ID_ANY, description.get(key, key), wx.DefaultPosition, wx.DefaultSize, 0 )
@@ -892,23 +1090,17 @@ class DefaultTextLayout :
 
 class WordCloudLayout(DefaultTextLayout):
     def dolayout(self):
-        #self.dictpathout = parent.corpus.dictpathout
-        #self.pathout = os.path.dirname(filename)
-        #self.corpus = parent.corpus
-    #    self.read_result()
         self.pathout.basefiles(simipath)
         self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
-#        if os.path.exists(self.pathout['liste_graph']) :
-#            list_graph = read_list_file(self.pathout['liste_graph'])
-#        else : 
-#            list_graph = [['','']]
-        list_graph = [['nuage_1.png', 'Nuage']]
+        if self.parametres['svg'] :
+            list_graph = [['nuage_1.svg', 'Nuage']]
+        else :
+            list_graph = [['nuage_1.png', 'Nuage']]
         self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, list_graph)
-        #self.TabStatTot.write(self.result['glob'])
         self.Tab.AddPage(self.TabStatTot, 'Nuage')
         self.Tab.corpus = self.corpus
         self.Tab.parametres = self.parametres
-        self.ira.nb.AddPage(self.Tab, 'WordCloud %s' % self.parametres.get('corpus_name','corpus_name'))
+        self.ira.nb.AddPage(self.Tab, '%s' % self.parametres['name'])
         self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
         self.ira.ShowAPane("Tab_content")
 
@@ -931,7 +1123,7 @@ class SimiLayout(DefaultTextLayout) :
         self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
         self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
         self.tabsimi.AddPage(self.graphpan, 'Graph')
-        self.ira.nb.AddPage(self.tabsimi, 'Analyse de graph')
+        self.ira.nb.AddPage(self.tabsimi, _(u'Graph analysis').decode('utf8'))
         self.ira.ShowTab(True)
         self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
         
@@ -943,7 +1135,13 @@ class SimiLayout(DefaultTextLayout) :
             with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
                 self.actives = f.read()
             self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
-        dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
+        if os.path.exists(self.pathout['actives_nb.csv']) :
+            with open(self.pathout['actives_nb.csv'], 'r') as f :
+                act_nb = f.read()
+                act_nb = act_nb.splitlines()
+            dictcol = dict([[i, [self.actives[i], int(act_nb[i])]] for i, val in enumerate(self.actives)])
+        else :
+            dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
         #res = SelectColumn(self.ira, dictcol, self.actives, self.pathout['selected.csv'], selected = selected, dlg = True) 
         #if res.ok :
         prep = PrepSimi(self.ira, self, self.parametres,self.pathout['selected.csv'], self.actives, indices_simi, wordlist = dictcol, selected = selected)
@@ -954,10 +1152,21 @@ class SimiLayout(DefaultTextLayout) :
             script.make_script()
             pid = exec_rcode(self.ira.RPath, script.scriptout, wait = True)
             check_Rresult(self.ira, pid)
-            if self.parametres['type_graph'] == 1:
+            if self.parametres['type_graph'] in [1,3] :
                 if self.parametres['svg'] :
                     filename, ext = os.path.splitext(script.filename)
                     fileout = filename + '.svg'
+                elif self.parametres['type_graph'] == 3 :
+                    fileout = script.filename
+                    parametres = {'gexffile' :  fileout,
+                                  'dirout' : os.path.dirname(fileout),
+                                  'titre': 'Le titre',
+                                  #'nodemin': self.param['txt_min'],
+                                  #'nodemax': self.param['txt_max'],
+                                  #'bargraphw' : 60*int(self.param['clnb']),
+                    }
+                    web = WebExport(self.ira, parametres)
+                    fileout = web.exportsimi()                         
                 else :
                     fileout = script.filename
                 if os.path.exists(self.pathout['liste_graph']):
@@ -967,8 +1176,8 @@ class SimiLayout(DefaultTextLayout) :
                     graph_simi = [[os.path.basename(fileout), script.txtgraph]]
                 print_liste(self.pathout['liste_graph'], graph_simi)
             DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
-            if self.parametres['type_graph'] == 1:
-                if self.parametres['svg'] :
+            if self.parametres['type_graph'] in [1,3] :
+                if self.parametres['svg'] or self.parametres['type_graph'] == 3 :
                     self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
                 else :
                     self.graphpan.sizer_3.Add(wx.StaticBitmap(self.graphpan.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
@@ -985,20 +1194,28 @@ class SimiLayout(DefaultTextLayout) :
         txt = """
         library(igraph)
         load("%s")
+        source("%s")
         fileout <- "%s"
         graph <- graph.simi$graph
         V(graph)$x <- graph.simi$layout[,1]
         V(graph)$y <- graph.simi$layout[,2]
-        V(graph)$weight <- graph.simi$label.cex
-        V(graph)$colors <- vertex.label.color
-        E(graph)$weigth <- graph.simi$we.width
+        if (length(graph.simi$label.cex == 1)) {
+            V(graph)$weight <- graph.simi$eff
+        } else {
+            V(graph)$weight <- graph.simi$label.cex
+        }
+        V(graph)$color <- vertex.label.color
+        V(graph)$frequences <- graph.simi$mat.eff
+        V(graph)$label <- as.character(graph.simi$v.label)
+        E(graph)$weight <- graph.simi$we.width
         write.graph(graph, fileout, format = 'graphml')
-        """ % (self.pathout['RData.RData'], fileout)
+        #saveAsGEXF(graph, filepath = fileout)
+        """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
         filetmp = tempfile.mktemp()
         with open(filetmp, 'w') as f :
             f.write(txt)
         exec_rcode(self.ira.RPath, filetmp)
-        mss = wx.MessageDialog(self.ira, fileout, u'Fichier exporté', wx.OK)
+        mss = wx.MessageDialog(self.ira, fileout, _(u'File exported').decode('utf8'), wx.OK)
         mss.CenterOnParent()
         mss.ShowModal()
         mss.Destroy()
@@ -1010,11 +1227,54 @@ class DefaultMatLayout :
         self.parent = parent
         self.tableau = tableau
         self.parametres = parametres
+        if os.path.exists(self.pathout['analyse.db']) :
+            self.tableau.read_tableau(self.pathout['analyse.db'])
         self.dolayout()
+        self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
+        self.ira.ShowAPane("Tab_content")
 
     def dolayout(self) :
         pass
 
+class FreqLayout(DefaultMatLayout) :
+    def dolayout(self) :
+        self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
+        res = normpath_win32(self.pathout['resultats.html']).replace('\\','/')
+        self.tab.LoadPage(res)
+        self.tab.parametres = self.parametres
+        self.ira.nb.AddPage(self.tab, ' - '.join([_(u"Frequency").decode('utf8'), self.parametres['name']]))
+
+
+class Chi2Layout(DefaultMatLayout) :
+    def dolayout(self):
+        self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
+        if "gtk2" in wx.PlatformInfo:
+            self.tab.SetStandardFonts()
+        res = normpath_win32(self.pathout['resultats-chi2.html']).replace('\\','/')
+        self.tab.LoadPage(res)
+        self.tab.parametres = self.parametres
+        self.ira.nb.AddPage(self.tab, ' - '.join([u"Chi2", self.parametres['name']]))
+        #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
+        #self.ira.ShowAPane("Tab_content")  
+
+
+class ProtoLayout(DefaultMatLayout) :
+    def dolayout(self) :
+        list_graph = [['proto.png', _(u'Prototypical analysis').decode('utf8')]]
+        #self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
+        #if self.parametres['svg'] :
+        #    list_graph = [['nuage_1.svg', 'Nuage']]
+        #else :
+        #    list_graph = [['nuage_1.png', 'Nuage']]
+        self.TabProto = GraphPanel(self.ira.nb, self.pathout, list_graph)
+        #self.Tab.AddPage(self.TabProto, 'Analyse Prototypique')
+        #self.Tab.corpus = self.corpus
+        self.TabProto.parametres = self.parametres
+        self.ira.nb.AddPage(self.TabProto, ' - '.join([_(u'Prototypical analysis').decode('utf8'), self.parametres['name']]))
+        #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
+        #self.ira.ShowAPane("Tab_content")
+
+
 class SimiMatLayout(DefaultMatLayout) :
     def dolayout(self):
         self.pathout.basefiles(simipath)
@@ -1032,9 +1292,9 @@ class SimiMatLayout(DefaultMatLayout) :
         self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
         self.tabsimi.AddPage(self.graphpan, 'Graph')
         self.tabsimi.parametres = self.parametres
-        self.parent.nb.AddPage(self.tabsimi, 'Analyse de graph')
-        self.parent.ShowTab(True)
-        self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
+        self.parent.nb.AddPage(self.tabsimi, ' - '.join([_(u'Graph analysis').decode('utf8'), self.parametres['name']]))
+        #self.parent.ShowTab(True)
+        #self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
 
     def redosimi(self,evt) :
         with open(self.pathout['selected.csv'],'r') as f :
@@ -1044,7 +1304,11 @@ class SimiMatLayout(DefaultMatLayout) :
         #    with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
         #        self.actives = f.read()
         #    self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
-        actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
+        try :
+            actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
+        except :
+            actives = [[val, self.tableau.actives[val]] for val in self.tableau.actives]
+
         #self.tableau.make_listactives()
         actives = dict([[i, val] for i, val in enumerate(actives)])
         #dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
@@ -1077,6 +1341,7 @@ class SimiMatLayout(DefaultMatLayout) :
                     fileout = filename + '.svg'
                 else :
                     fileout = self.script.filename
+                fileout = normpath_win32(fileout)
                 if os.path.exists(self.pathout['liste_graph']):
                     graph_simi = read_list_file(self.pathout['liste_graph'])
                     graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
@@ -1088,7 +1353,7 @@ class SimiMatLayout(DefaultMatLayout) :
                 if self.parametres['svg'] :
                     self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
                 else :
-                    self.graphpan.sizer_3.Add(wx.StaticBitmap(self.graphpan.panel_1, -1, wx.Bitmap(self.script.filename, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
+                    self.graphpan.sizer_3.Add(wx.StaticBitmap(self.graphpan.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
                 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, self.script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
                 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
                 self.graphpan.Layout()
@@ -1136,13 +1401,14 @@ class SimiMatLayout(DefaultMatLayout) :
                           'halo' : self.dial.halo.GetValue(),
                           'com' : self.dial.comcheck.GetValue(),
                           'communities' : self.dial.choix_com.GetSelection(),
+                          'edgecurved' : self.dial.check_curved.GetValue(),
                           }        
         if 'cexfromchi' in self.parametres :
             paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
         if 'sfromchi' in self.parametres :
             paramsimi['sfromchi'] = self.dial.checki.GetValue()
         if 'vlabcolor' in self.parametres :
-           paramsimi['vlabcolor'] = self.parametres['vlabcolor']
+            paramsimi['vlabcolor'] = self.parametres['vlabcolor']
         if 'check_bystar' in dir(self.dial) :
             paramsimi['bystar'] = self.dial.check_bystar.GetValue()
             paramsimi['stars'] = self.parametres['stars']
@@ -1170,20 +1436,29 @@ class SimiMatLayout(DefaultMatLayout) :
         txt = """
         library(igraph)
         load("%s")
+        source("%s")
         fileout <- "%s"
         graph <- graph.simi$graph
         V(graph)$x <- graph.simi$layout[,1]
         V(graph)$y <- graph.simi$layout[,2]
-        V(graph)$weight <- graph.simi$label.cex
-        V(graph)$colors <- vertex.label.color
-        E(graph)$weigth <- graph.simi$we.width
+        if (length(graph.simi$label.cex == 1)) {
+            V(graph)$weight <- graph.simi$mat.eff
+        } else {
+            V(graph)$weight <- graph.simi$label.cex
+        }
+        V(graph)$color <- vertex.label.color
+        V(graph)$frequences <- graph.simi$mat.eff
+        V(graph)$fprop <- graph.simi$mat.eff/nrow(dm)
+        V(graph)$label <- as.character(graph.simi$v.label)
+        E(graph)$weight <- graph.simi$we.width
         write.graph(graph, fileout, format = 'graphml')
-        """ % (self.pathout['RData.RData'], fileout)
+        #saveAsGEXF(graph, filepath = fileout)
+        """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
         filetmp = tempfile.mktemp()
         with open(filetmp, 'w') as f :
             f.write(txt)
         exec_rcode(self.ira.RPath, filetmp)
-        mss = wx.MessageDialog(self.ira, fileout, u'Fichier exporté', wx.OK)
+        mss = wx.MessageDialog(self.ira, fileout, _(u'File exported').decode('utf8'), wx.OK)
         mss.CenterOnParent()
         mss.ShowModal()
         mss.Destroy()
@@ -1209,12 +1484,12 @@ class GraphPanelSimi(wx.Panel):
         for i in range(0,len(list_graph)):
             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
                 filename, ext = os.path.splitext(list_graph[i][0])
-                if ext == '.svg' :
+                if ext in ['.svg', '.html'] :
                     self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, os.path.join(self.dirout,list_graph[i][0]), URL=os.path.join(self.dirout,list_graph[i][0])))
                 else :
                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
                 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
-                
+        self.panel_1.Bind(wx.EVT_MOTION, self.onMouseMove) 
         self.__set_properties()
         self.__do_layout()
 
@@ -1222,6 +1497,7 @@ class GraphPanelSimi(wx.Panel):
         self.panel_1.EnableScrolling(True,True)
         #self.panel_1.SetSize((1000,1000))
         self.panel_1.SetScrollRate(20, 20)
+        self.panel_1.SetFocus()
 
     def __do_layout(self):    
         self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
@@ -1236,3 +1512,6 @@ class GraphPanelSimi(wx.Panel):
         self.sizer_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
         self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 0)
         self.SetSizer(self.sizer_1) 
+
+    def onMouseMove(self, event):
+        self.panel_1.SetFocus()