correction encodage

[iramuteq] / layout.py

diff --git a/layout.py b/layout.py
index 7b89279..5fd493c 100644 (file)
--- a/layout.py
+++ b/layout.py
@@ -1,43 +1,63 @@
-#!/bin/env python

 # -*- coding: utf-8 -*-
 #Author: Pierre Ratinaud
 # -*- coding: utf-8 -*-
 #Author: Pierre Ratinaud

-#Copyright (c) 2008-2009 Pierre Ratinaud
+#Copyright (c) 2008-2020 Pierre Ratinaud
+#modification pour python 3 : Laurent Mérat, 6x7 - mai 2020

 #License: GNU/GPL
 
 #License: GNU/GPL
 

+#------------------------------------
+# import des modules python
+#------------------------------------

 import os
 import os

+import datetime
+import sys
+import tempfile
+from time import sleep
+import shutil
+import codecs
+import logging
+
+#------------------------------------
+# import des modules wx
+#------------------------------------

 import wx
 import wx

-import wx.lib.hyperlink as hl
+import wx.lib.agw.hyperlink as hl

 import wx.lib.agw.aui as aui
 import wx.lib.agw.labelbook as LB
 from wx.lib.agw.fmresources import *
 import wx.lib.agw.aui as aui
 import wx.lib.agw.labelbook as LB
 from wx.lib.agw.fmresources import *

+
+#------------------------------------
+# import des fichiers du projet
+#------------------------------------

 from chemins import ConstructPathOut, ChdTxtPathOut, FFF, ffr, PathOut, StatTxtPathOut, simipath
 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, normpath_win32, TGen
+from configparser import ConfigParser
+from functions import ReadProfileAsDico, GetTxtProfile, read_list_file, ReadList, exec_rcode, print_liste, BugReport, DoConf,\
+ indices_simi, check_Rresult, progressbar, normpath_win32, TGen, ReadList, launchcommand

 from ProfList import ProfListctrlPanel
 from guiparam3d import param3d, simi3d
 from PrintRScript import write_afc_graph, print_simi3d, PrintSimiScript
 from profile_segment import ProfileSegment
 from ProfList import ProfListctrlPanel
 from guiparam3d import param3d, simi3d
 from PrintRScript import write_afc_graph, print_simi3d, PrintSimiScript
 from profile_segment import ProfileSegment

-from functions import ReadList

 from listlex import *
 from Liste import *
 from search_tools import SearchFrame
 from listlex import *
 from Liste import *
 from search_tools import SearchFrame

-from dialog import PrefGraph, PrefExport, PrefSimpleFile, PrefDendro, SimpleDialog
-from guifunct import SelectColumn, PrepSimi, PrefSimi
+from dialog import PrefGraph, PrefExport, PrefSimpleFile, PrefDendro, SimpleDialog, ImageViewer
+from guifunct import SelectColumn, PrepSimi, PrefSimi, redosimi

 from webexport import WebExport
 from corpus import Corpus
 from sheet import MySheet
 from webexport import WebExport
 from corpus import Corpus
 from sheet import MySheet

-import datetime
-import sys
-import tempfile
-from time import sleep
-import shutil
-import codecs
-import logging
+from graph_to_json import GraphToJson
+
+
+import langue
+langue.run()
+
+

 
 log = logging.getLogger('iramuteq.layout')
 
 
 
 log = logging.getLogger('iramuteq.layout')
 
 

+

 class GraphPanelAfc(wx.Panel):
 class GraphPanelAfc(wx.Panel):

+

     def __init__(self, parent, dico, list_graph, clnb, itempath = 'liste_graph_afc', coding = sys.getdefaultencoding()):
         wx.Panel.__init__(self,parent)
         self.afcnb = 1
     def __init__(self, parent, dico, list_graph, clnb, itempath = 'liste_graph_afc', coding = sys.getdefaultencoding()):
         wx.Panel.__init__(self,parent)
         self.afcnb = 1


@@ -45,8 +65,8 @@ class GraphPanelAfc(wx.Panel):
         self.Dict = dico
         self.coding = coding
         self.itempath = itempath
         self.Dict = dico
         self.coding = coding
         self.itempath = itempath

-        self.parent = self.GetParent()#parent
-        self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
+        self.parent = self.GetParent()
+        self.SetFont(wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0, "Arial"))

         self.labels = []
         self.listimg = []
         self.buts = []
         self.labels = []
         self.listimg = []
         self.buts = []


@@ -67,19 +87,19 @@ class GraphPanelAfc(wx.Panel):
                 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 :
                 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.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY), name=repr(i-b)))
+                    self.listimg[-1].Bind(wx.EVT_RIGHT_DOWN, self.onrightclick)

                 if os.path.exists(os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')) :
                 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')
+                    txt = _("List of not plotted points : ") + '%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))
                 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`))
+                self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = repr(i - b)))

             else :
                 todel.append(i)
                 b += 1
         self.list_graph = [graph for i, graph in enumerate(self.list_graph) if i not in todel]
             else :
                 todel.append(i)
                 b += 1
         self.list_graph = [graph for i, graph in enumerate(self.list_graph) if i not in todel]

-                
-        self.param = { 'typegraph' : 0, 
+        self.param = { 'typegraph' : 0,

               'width' : 800,
               'height' : 800,
               'what' : 0,
               'width' : 800,
               'height' : 800,
               'what' : 0,


@@ -90,7 +110,7 @@ class GraphPanelAfc(wx.Panel):
               'select_nb' : 50,
               'select_chi' : 4,
               'nbchic' : 30,
               'select_nb' : 50,
               'select_chi' : 4,
               'nbchic' : 30,

-              'over' : 0, 
+              'over' : 0,

               'cex_txt' : 0,
               'txt_min' : 5,
               'txt_max' : 40,
               'cex_txt' : 0,
               'txt_min' : 5,
               'txt_max' : 40,


@@ -103,7 +123,6 @@ class GraphPanelAfc(wx.Panel):
               'clnb' : clnb,
               'svg' : 0,
                }
               'clnb' : clnb,
               'svg' : 0,
                }

-

         self.__set_properties()
         self.__do_layout()
 
         self.__set_properties()
         self.__do_layout()
 


@@ -113,7 +132,7 @@ class GraphPanelAfc(wx.Panel):
         self.panel_1.SetScrollRate(20, 20)
         self.panel_1.SetFocus()
 
         self.panel_1.SetScrollRate(20, 20)
         self.panel_1.SetFocus()
 

-    def __do_layout(self):    
+    def __do_layout(self):

         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
         self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
         self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)


@@ -125,12 +144,12 @@ class GraphPanelAfc(wx.Panel):
             self.Bind(wx.EVT_BUTTON, self.on_delete_image, self.buts[i])
         self.panel_1.SetSizer(self.sizer_3)
         self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
             self.Bind(wx.EVT_BUTTON, self.on_delete_image, self.buts[i])
         self.panel_1.SetSizer(self.sizer_3)
         self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)

-        self.SetSizer(self.sizer_2) 
+        self.SetSizer(self.sizer_2)

 
     def on_delete_image(self, event) :
         image_id = int(event.GetEventObject().GetName())
         image_path = self.list_graph[image_id][0]
 
     def on_delete_image(self, event) :
         image_id = int(event.GetEventObject().GetName())
         image_path = self.list_graph[image_id][0]

-        message = _(u'This file will be delete : ') + '%s.\n' % os.path.join(self.dirout, image_path) + _('Are you sure ?')
+        message = _('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 :
         dial = wx.MessageDialog(self, message, style = wx.YES_NO)
         res = dial.ShowModal()
         if res == wx.ID_YES :


@@ -143,7 +162,8 @@ class GraphPanelAfc(wx.Panel):
             oldbut = self.buts.pop(image_id)
             oldbut.Show(False)
             for i, but in enumerate(self.buts) :
             oldbut = self.buts.pop(image_id)
             oldbut.Show(False)
             for i, but in enumerate(self.buts) :

-                but.SetName(`i`)
+                but.SetName(repr(i))
+                self.listimg[i].SetName(repr(i))

             todel = self.list_graph.pop(image_id)
             os.remove(os.path.join(self.dirout, todel[0]))
             print_liste(self.Dict[self.itempath], self.list_graph)
             todel = self.list_graph.pop(image_id)
             os.remove(os.path.join(self.dirout, todel[0]))
             print_liste(self.Dict[self.itempath], self.list_graph)


@@ -151,7 +171,14 @@ class GraphPanelAfc(wx.Panel):
             self.Layout()
         else :
             dial.Destroy()
             self.Layout()
         else :
             dial.Destroy()

-        
+
+    def onrightclick(self, event):
+        image_id = int(event.GetEventObject().GetName())
+        image_path = self.list_graph[image_id][0]
+        viewer = ImageViewer(self, {'tmpgraph' : os.path.join(self.dirout,image_path), 'svg': 'FALSE', 'wildcard': '*.*'}, self.labels[image_id].GetLabelText(), self.listimg[image_id].GetSize())
+        viewer.Show()
+        #print image_path
+        #print self.labels[image_id].GetLabelText()

 
     def afc_graph(self,event):
         #dirout = os.path.dirname(self.Dict['ira'])
 
     def afc_graph(self,event):
         #dirout = os.path.dirname(self.Dict['ira'])


@@ -172,6 +199,8 @@ class GraphPanelAfc(wx.Panel):
                 typegraph = 2
             if typegraph == 2:
                 typefile = '.gexf'
                 typegraph = 2
             if typegraph == 2:
                 typefile = '.gexf'

+            if typegraph == 3 :
+                typefile = ''

             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))
             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))


@@ -187,7 +216,7 @@ class GraphPanelAfc(wx.Panel):
                           'select_nb' : dial.spin_nb.GetValue(),
                           'select_chi' : dial.spin_chi.GetValue(),
                           'nbchic' : dial.spin_nbchic.GetValue(),
                           'select_nb' : dial.spin_nb.GetValue(),
                           'select_chi' : dial.spin_chi.GetValue(),
                           'nbchic' : dial.spin_nbchic.GetValue(),

-                          'over' : dial.check3.GetValue(), 
+                          'over' : dial.check3.GetValue(),

                           'cex_txt' : dial.check4.GetValue(),
                           'txt_min' : dial.spin_min.GetValue(),
                           'txt_max' : dial.spin_max.GetValue(),
                           'cex_txt' : dial.check4.GetValue(),
                           'txt_min' : dial.spin_min.GetValue(),
                           'txt_max' : dial.spin_max.GetValue(),


@@ -212,7 +241,7 @@ class GraphPanelAfc(wx.Panel):
                 afc <- afcf
                 afc_table <- afcf_table
                 chistabletot <- specfp
                 afc <- afcf
                 afc_table <- afcf_table
                 chistabletot <- specfp

-                """ 
+                """

             elif self.itempath == 'liste_graph_afct' :
                 txt +="""
                 afc <- afct
             elif self.itempath == 'liste_graph_afct' :
                 txt +="""
                 afc <- afct


@@ -225,21 +254,21 @@ class GraphPanelAfc(wx.Panel):
                 f.write(txt)
             pid = exec_rcode(self.ira.RPath, filetmp)
             check_Rresult(self.ira, pid)
                 f.write(txt)
             pid = exec_rcode(self.ira.RPath, filetmp)
             check_Rresult(self.ira, pid)

-            if self.param['typegraph'] in [0,2] :
+            if self.param['typegraph'] != 1 :

                 txt = 'Variables '
                 txt = 'Variables '

-                if self.param['qui'] == 0 : value = u'actives'
-                if self.param['qui'] == 1 : value = u'supplémentaires'
-                if self.param['qui'] == 2 : value = u'étoilées'
-                if self.param['qui'] == 3 : value = u'classes'
+                if self.param['qui'] == 0 : value = 'actives'
+                if self.param['qui'] == 1 : value = 'supplémentaires'
+                if self.param['qui'] == 2 : value = 'étoilées'
+                if self.param['qui'] == 3 : value = 'classes'

                 txt += value + ' - '
                 txt += value + ' - '

-                if self.param['what'] == 0 : value = u'Coordonnées'
-                if self.param['what'] == 1 : value = u'Corrélations'
-                txt += value + u' - facteur %i / %i' % (self.param['facteur'][0], self.param['facteur'][1])
-                if self.param['do_select_nb'] : txt += u' - sélection de %i variables' % self.param['select_nb']
-                if self.param['do_select_chi'] : txt += u' - sélection des variables avec chi2 > %i ' % self.param['select_chi']
-                if self.param['over'] : txt += u' - Eviter les recouvrements'
-                if self.param['cex_txt'] : txt += u' - taille du texte proportionnel à la masse'
-                if self.param['tchi'] : txt += u' - taille du texte proportionnel au chi2 d\'association'
+                if self.param['what'] == 0 : value = 'Coordonnées'
+                if self.param['what'] == 1 : value = 'Corrélations'
+                txt += value + ' - facteur %i / %i' % (self.param['facteur'][0], self.param['facteur'][1])
+                if self.param['do_select_nb'] : txt += ' - sélection de %i variables' % self.param['select_nb']
+                if self.param['do_select_chi'] : txt += ' - sélection des variables avec chi2 > %i ' % self.param['select_chi']
+                if self.param['over'] : txt += ' - Eviter les recouvrements'
+                if self.param['cex_txt'] : txt += ' - taille du texte proportionnel à la masse'
+                if self.param['tchi'] : txt += ' - taille du texte proportionnel au chi2 d\'association'

                 #list_graph = read_list_file(self.DictPathOut[self.itempath], self.coding)
                 if self.param['svg'] :
                     filename, ext = os.path.splitext(self.fileout)
                 #list_graph = read_list_file(self.DictPathOut[self.itempath], self.coding)
                 if self.param['svg'] :
                     filename, ext = os.path.splitext(self.fileout)


@@ -252,46 +281,54 @@ class GraphPanelAfc(wx.Panel):
                                   'bargraphw' : 60*int(self.param['clnb']),
                     }
                     web = WebExport(self.ira, parametres)
                                   '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])
+                    self.fileout = web.exportafc()
+                if self.param['typegraph'] == 3 :
+                    fileout = os.path.join(os.path.basename(self.fileout), 'index.html')
+                else :
+                    fileout = os.path.basename(self.fileout)
+                self.list_graph.append([fileout, txt])

                 print_liste(self.DictPathOut[self.itempath], self.list_graph)
                 if self.param['svg'] or self.param['typegraph'] == 2:
                     self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, self.fileout, URL=self.fileout))
                 print_liste(self.DictPathOut[self.itempath], self.list_graph)
                 if self.param['svg'] or self.param['typegraph'] == 2:
                     self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, self.fileout, URL=self.fileout))

-
+                elif self.param['typegraph'] == 3 :
+                    fileout = os.path.join(self.fileout,'index.html')
+                    self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, fileout, URL=fileout))

                 else :
                 else :

-                    self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(self.fileout, wx.BITMAP_TYPE_ANY)))
+                    self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(self.fileout, wx.BITMAP_TYPE_ANY), name=repr(len(self.list_graph) - 1)))
+                    self.listimg[-1].Bind(wx.EVT_RIGHT_DOWN, self.onrightclick)

                 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)
                 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)

-                self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = `len(self.list_graph) - 1`))
+                self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = repr(len(self.list_graph) - 1)))

                 self.sizer_3.Add(self.buts[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
                 self.sizer_3.Fit(self.panel_1)
                 self.Layout()
                 self.sizer_3.Add(self.buts[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
                 self.sizer_3.Fit(self.panel_1)
                 self.Layout()

-    
+

                 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
                 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()
-            
+    #       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):
 
 class GraphPanel(wx.ScrolledWindow):

+

     def __init__(self, parent, dico, list_graph, txt = '', style = wx.TAB_TRAVERSAL):
         wx.ScrolledWindow.__init__(self, parent, style = style)
         self.Dict = dico
         self.txt = txt
         self.parent = parent
     def __init__(self, parent, dico, list_graph, txt = '', style = wx.TAB_TRAVERSAL):
         wx.ScrolledWindow.__init__(self, parent, style = style)
         self.Dict = dico
         self.txt = txt
         self.parent = parent

-        self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
+        self.SetFont(wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0, "Arial"))

         self.labels = []
         self.listimg = []
         self.dirout = os.path.dirname(self.Dict['ira'])
         self.labels = []
         self.listimg = []
         self.dirout = os.path.dirname(self.Dict['ira'])


@@ -304,21 +341,20 @@ class GraphPanel(wx.ScrolledWindow):
                 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]))
                 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.Bind(wx.EVT_MOTION, self.onMouseMove)

         self.__set_properties()
         self.__do_layout()
 
     def __set_properties(self):
         self.EnableScrolling(True,True)
         self.__set_properties()
         self.__do_layout()
 
     def __set_properties(self):
         self.EnableScrolling(True,True)

-        self.SetScrollRate(20, 20)   
+        self.SetScrollRate(20, 20)

         self.SetFocus()
 
         self.SetFocus()
 

-

     def __do_layout(self):
         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
         self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
         self.sizer_3 = wx.BoxSizer(wx.HORIZONTAL)
     def __do_layout(self):
         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
         self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
         self.sizer_3 = wx.BoxSizer(wx.HORIZONTAL)

-        self.sizer_1.Add(self.deb)   
+        self.sizer_1.Add(self.deb)

         for i in range(0, len(self.listimg)):
             self.sizer_1.Add(self.listimg[i], 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
             self.sizer_1.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
         for i in range(0, len(self.listimg)):
             self.sizer_1.Add(self.listimg[i], 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
             self.sizer_1.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)


@@ -328,17 +364,18 @@ class GraphPanel(wx.ScrolledWindow):
 
     def onMouseMove(self, event):
         self.SetFocus()
 
     def onMouseMove(self, event):
         self.SetFocus()

-       

 
 

-def open_antiprofil(panel, AntiProfile, encoding) :
-    DictAnti = ReadProfileAsDico(AntiProfile, True, encoding)
+def open_antiprofil(panel, AntiProfile, encoding, title = _("Antiprofiles"), translation = False, lems=None) :
+    if not translation :
+        DictAnti = ReadProfileAsDico(AntiProfile, True, encoding)
+    else :
+        DictAnti = AntiProfile

     panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
     for i in range(0, panel.parametres['clnb']):
     panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
     for i in range(0, panel.parametres['clnb']):

-        tabantiprofile = ProfListctrlPanel(panel, panel, DictAnti[str(i + 1)], True, i + 1)
+        tabantiprofile = ProfListctrlPanel(panel.parent, panel, DictAnti[str(i + 1)], True, i + 1, translation = translation)
+        tabantiprofile.lems = lems

         panel.AntiProfNB.AddPage(tabantiprofile, 'classe %s' % str(i + 1))
         panel.AntiProfNB.AddPage(tabantiprofile, 'classe %s' % str(i + 1))

-    panel.TabChdSim.AddPage(panel.AntiProfNB, _(u"Antiprofiles").decode('utf8'))
-
-
+    panel.TabChdSim.AddPage(panel.AntiProfNB, title)

 
 def getlemgram(corpus, lem) :
     if not lem[6] in corpus.lems :
 
 def getlemgram(corpus, lem) :
     if not lem[6] in corpus.lems :


@@ -346,23 +383,23 @@ def getlemgram(corpus, lem) :
     else :
         return corpus.lems[lem[6]].gram
 
     else :
         return corpus.lems[lem[6]].gram
 

+

 class OpenCHDS():
 class OpenCHDS():

+

     def __init__(self, parent, corpus, parametres, Alceste=False):
     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)
         sep=' '
         self.parent = parent
         self.corpus = corpus
         self.parametres = parametres
         self.pathout = PathOut(parametres['ira'])
         self.pathout.basefiles(ChdTxtPathOut)

-        DictPathOut = self.pathout 
+        DictPathOut = self.pathout

         self.DictPathOut = DictPathOut
         self.dictpathout = DictPathOut
         self.DictPathOut = DictPathOut
         self.dictpathout = DictPathOut

-        self.parent = parent
-
+        self.Alceste = Alceste

         Profile = DictPathOut['PROFILE_OUT']
         AntiProfile = DictPathOut['ANTIPRO_OUT']
         Profile = DictPathOut['PROFILE_OUT']
         AntiProfile = DictPathOut['ANTIPRO_OUT']

-        self.encoding = self.parametres['encoding']
+#        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']
         if isinstance(self.corpus, Corpus) :
             self.corpus.make_ucecl_from_R(self.pathout['uce'])
             corpname = self.corpus.parametres['corpus_name']


@@ -370,39 +407,36 @@ class OpenCHDS():
             corpname = self.corpus.parametres['matrix_name']
             if os.path.exists(self.pathout['analyse.db']) :
                 self.corpus.read_tableau(self.pathout['analyse.db'])
             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']
         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)
+        dlg = progressbar(self, maxi = 4 + clnb)
+        self.clnb = clnb
+        print('lecture des profils')
+        dlg.Update(2, _("Reading profiles"))
+        DictProfile = ReadProfileAsDico(Profile, Alceste)

         self.DictProfile = DictProfile
         self.cluster_size = []
         clusternames = {}
         for i in range(0, clnb) :
         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)])
+            clusternames[i] = ' '.join(['%i' % (i + 1), _('Cluster'),  '%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()
         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_ =  dict([[i, ' '.join([repr(i + 1), line])] for i, line in enumerate(clusternames_.splitlines())])

             clusternames.update(clusternames_)
             clusternames.update(clusternames_)

-        #print 'lecture des antiprofils'

         #DictAnti = ReadProfileAsDico(self, AntiProfile, Alceste, self.encoding)
         #DictAnti = ReadProfileAsDico(self, AntiProfile, Alceste, self.encoding)

-
+        #
+        # preparation de l'affichage
+        #

         panel = wx.Panel(parent, -1)
         sizer1 = wx.BoxSizer(wx.VERTICAL)
         panel = wx.Panel(parent, -1)
         sizer1 = wx.BoxSizer(wx.VERTICAL)

-

         if os.path.exists(DictPathOut['pre_rapport']):
         if os.path.exists(DictPathOut['pre_rapport']):

-            with codecs.open(DictPathOut['pre_rapport'], 'r', self.encoding) as f :
+            with codecs.open(DictPathOut['pre_rapport'], 'r') as f :

                 txt = f.read()
             self.debtext = txt
         else :
             self.debtext = ''
                 txt = f.read()
             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))
-
+    #   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 :
         if isinstance(self.corpus, Corpus) :
             panel.corpus = self.corpus
         else :


@@ -414,17 +448,14 @@ class OpenCHDS():
         panel.DictProfile = self.DictProfile
         panel.cluster_size = self.cluster_size
         panel.debtext = self.debtext
         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()
-#       #panel.chd_toolbar.AddLabelTool(self.ID_rapport, "rapport", rap_img, shortHelp=u"Produire le rapport", longHelp=u"Exporter un rapport en texte simple")
-#       butrap = wx.Button(panel.chd_toolbar, self.ID_rapport, u"Rapport ")
-#       panel.chd_toolbar.AddControl(butrap)
-#       
-#       panel.chd_toolbar.Realize()
-#       sizer1.Add(panel.chd_toolbar,0, wx.EXPAND, 5)
-
-        #self.TabChdSim = wx.aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
+    #   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()
+    #   #panel.chd_toolbar.AddLabelTool(self.ID_rapport, "rapport", rap_img, shortHelp=u"Produire le rapport", longHelp=u"Exporter un rapport en texte simple")
+    #   butrap = wx.Button(panel.chd_toolbar, self.ID_rapport, u"Rapport ")
+    #   panel.chd_toolbar.AddControl(butrap)
+    #   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 = LB.LabelBook(panel, -1, agwStyle = INB_TOP|INB_SHOW_ONLY_TEXT|INB_FIT_LABELTEXT)
         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)


@@ -433,8 +464,6 @@ class OpenCHDS():
         sizer1.Add(panel.TabChdSim,10, wx.EXPAND, 5)
         panel.SetSizer(sizer1)
         sizer1.Fit(panel)
         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
         if isinstance(self.corpus, Corpus) :
             panel.TabChdSim.corpus = corpus
             panel.TabChdSim.corpus.dictpathout = self.DictPathOut


@@ -443,27 +472,23 @@ class OpenCHDS():
             panel.TabChdSim.tableau.dictpathout = self.DictPathOut
         panel.parametres = self.parametres
         self.panel = panel
             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']) :
         if os.path.exists(self.DictPathOut['liste_graph_chd']) :

-            list_graph = read_list_file(self.DictPathOut['liste_graph_chd'], self.encoding)
+            list_graph = read_list_file(self.DictPathOut['liste_graph_chd'])

             CHD = GraphPanelDendro(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
             panel.TabChdSim.AddPage(CHD,'CHD')
             CHD = GraphPanelDendro(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
             panel.TabChdSim.AddPage(CHD,'CHD')

-               
+    #    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.prof_seg_nb = aui.AuiNotebook(panel, -1, wx.DefaultPosition)

         panel.ProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
         notebook_flags |= aui.AUI_NB_WINDOWLIST_BUTTON
         panel.ProfNB.SetAGWWindowStyleFlag(notebook_flags)
         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])
             if isinstance(self.corpus, Corpus) :
         for i in range(0, clnb):
             self.cluster_size.append(DictProfile[str(i + 1)][0][0:3])
             if isinstance(self.corpus, Corpus) :


@@ -476,30 +501,27 @@ class OpenCHDS():
             panel.ProfNB.AddPage(self.tabprofile, clusternames[i] + '\n%s%%' % indpour, True)
             panel.ProfNB.SetPageTextColour(i, '#890909')
             panel.ProfNB.SetRenamable(i, True)
             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))
+    #       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)
             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, _(u"Cluster").decode('utf8') + ' %i' % (i + 1))
+                self.prof_seg_nb.AddPage(self.tab_prof_seg, _("Cluster") + ' %i' % (i + 1))

         panel.ProfNB.SetSelection(0)
         panel.ProfNB.SetSelection(0)

-

         if clnb > 2 :
             self.TabAFC = aui.AuiNotebook(panel.TabChdSim, -1, wx.DefaultPosition)
         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'))
-            
+            log.info('read AFC')
+            list_graph=read_list_file(DictPathOut['liste_graph_afc'])
+            self.tabAFCGraph = GraphPanelAfc(self.TabAFC, DictPathOut, list_graph, self.clnb)
+            self.TabAFC.AddPage(self.tabAFCGraph, _("CA"))

             if os.path.exists(self.DictPathOut['afc_facteur']) :
             if os.path.exists(self.DictPathOut['afc_facteur']) :

-                dictrow, first = ReadList(self.DictPathOut['afc_facteur'], self.encoding)
+                dictrow, first = ReadList(self.DictPathOut['afc_facteur'])

                 self.TabAFC_facteur = ListForSpec(self.parent, parametres, dictrow, first[1:])
                 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')
-            
+    #           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, _("Factor"))
+    #           self.TabAFC.AddPage(self.TabAFC_colonne, 'Colonnes')
+    #           self.TabAFC.AddPage(self.TabAFC_ligne, '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")
             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")


@@ -507,33 +529,47 @@ class OpenCHDS():
             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)
             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.TabAFC.AddPage(self.parent.nb_panel_2, _("3D graph"))

             self.parent.Bind(wx.EVT_BUTTON, self.onsimi, self.parent.button_simi)
             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')
+        panel.TabChdSim.AddPage(panel.ProfNB, _("Profiles"))
+    #   panel.TabChdSim.AddPage(panel.AntiProfNB, 'Antiprofils')

         dlg.Update(4 + self.clnb, 'Affichage...')
         if clnb > 2 :
         dlg.Update(4 + self.clnb, 'Affichage...')
         if clnb > 2 :

-            panel.TabChdSim.AddPage(self.TabAFC, _(u"CA").decode('utf8'))
+            panel.TabChdSim.AddPage(self.TabAFC, _("CA"))

         if os.path.exists(DictPathOut['prof_seg']) :
         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)
+            panel.TabChdSim.AddPage(self.prof_seg_nb, _("Repeated segments profiles"))
+    #   panel.Bind(wx.EVT_BUTTON, self.ongetrapport, id = self.ID_rapport)

         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)
         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)

+        if os.path.exists(self.dictpathout['translations.txt']) :
+            with codecs.open(self.dictpathout['translations.txt'], 'r', 'utf8') as f:
+                translist = f.read()
+            translist = [line.split('\t') for line in translist.splitlines()]
+            for line in translist :
+                self.opentrans(line)

         panel.TabChdSim.SetSelection(0)
         panel.TabChdSim.SetSelection(0)

-        self.parent.nb.AddPage(panel, _(u"Clustering").decode('utf8') + ' - %s' % corpname)
+        self.parent.nb.AddPage(panel, _("Clustering") + ' - %s' % corpname)

         self.parent.ShowTab(True)
         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.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()
         self.parent._mgr.Update()

-        
+
+    def opentrans(self, trans) :
+        prof = ReadProfileAsDico(self.dictpathout[trans[0]], False)
+        with codecs.open(self.dictpathout[trans[1]], 'r') as f :
+            lems = f.read()
+        lems = [line.split('\t') for line in lems.splitlines()]
+        lems = dict(lems)
+        open_antiprofil(self.panel, prof, 'utf8', title = trans[0], translation=True, lems=lems)
+        self.panel.lems = lems
+        self.panel.TabChdSim.SetSelection(self.panel.TabChdSim.GetPageCount() - 1)
+

     def onsimi(self,event):
         outfile = print_simi3d(self)
         error = exec_rcode(self.parent.RPath, outfile, wait = True)
     def onsimi(self,event):
         outfile = print_simi3d(self)
         error = exec_rcode(self.parent.RPath, outfile, wait = True)


@@ -547,15 +583,15 @@ class OpenCHDS():
             fileout = dial.fbb.GetValue()
             dial.Destroy()
             self.corpus.get_stat_by_cluster(fileout)
             fileout = dial.fbb.GetValue()
             dial.Destroy()
             self.corpus.get_stat_by_cluster(fileout)

-            msg = u"Fini !"
-            dlg = wx.MessageDialog(self.parent, msg, _(u"Stat by cluster").decode('utf8'), wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
+            msg = "Fini !"
+            dlg = wx.MessageDialog(self.parent, msg, _("Stat by cluster"), wx.OK | wx.ICON_INFORMATION)

             dlg.CenterOnParent()
             if dlg.ShowModal() == wx.ID_OK :
                 dlg.Destroy()
 
     #def onsearchf(self, evt) :
     #    if 'FrameSearch' not in dir(self.panel) :
             dlg.CenterOnParent()
             if dlg.ShowModal() == wx.ID_OK :
                 dlg.Destroy()
 
     #def onsearchf(self, evt) :
     #    if 'FrameSearch' not in dir(self.panel) :

-    #        self.panel.FrameSearch = SearchFrame(self.parent, -1, u"Rechercher...", self.corpus)
+    #        self.panel.FrameSearch = SearchFrame(self.parent, -1, "Rechercher...", self.corpus)

     #    self.panel.FrameSearch.Show()
 
 def PrintRapport(self, corpus, parametres, istxt = True):
     #    self.panel.FrameSearch.Show()
 
 def PrintRapport(self, corpus, parametres, istxt = True):


@@ -569,42 +605,40 @@ def PrintRapport(self, corpus, parametres, istxt = True):
 """ % datetime.datetime.now().ctime()
     if istxt :
         totocc = corpus.gettotocc()
 """ % 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 segments :%f%s' % (float(totocc) / float(corpus.getucenb()), sep)
+        txt += ': '.join([_('Number of texts'),  '%i%s' % (corpus.getucinb(), sep)])
+        txt += ': '.join([_('Number of text segments'),  '%i%s' % (corpus.getucenb(), sep)])
+        txt += ': '.join([_('Number of forms'), '%i%s' % (len(corpus.formes), sep)])
+        txt += ': '.join([_('Number of occurrences'), '%i%s' % (totocc, sep)])
+        #txt += 'moyenne d\'occurrences par forme: %f%s' % (float(totocc) / float(len(self.corpus.formes)), sep)
+        txt += ': '.join([_('Number of lemmas'), '%i%s' % (len(corpus.lems), sep)])
+        txt += ': '.join([_('Number of active forms'), '%i%s' % (corpus.getactivesnb(1), sep)])
+        txt += ': '.join([_('Number of supplementary forms'), '%i%s' % (corpus.getactivesnb(2), sep)])
+        txt += ' >= '.join([_('Number of active forms with a frequency'), '%i: %i%s' % (parametres['eff_min_forme'], parametres['nbactives'], sep)])
+        txt += ': '.join([_('Mean of forms by segment'), '%f%s' % (float(totocc) / float(corpus.getucenb()), sep)])

         if 'tailleuc1' in parametres :
             if parametres['classif_mode'] == 0 :
         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([_('Size of rst1 / rst2'), '%i / %i - %i / %i%s' % (parametres['tailleuc1'], parametres['tailleuc2'], parametres['lenuc1'], parametres['lenuc2'], sep)])

     else :
         self.Ucenb = self.nbind
     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([_('Number of lines'), '%i%s' % (self.nbind, sep)])
+        txt += ': '.join([_('Number of clusters'), '%i%s' % (self.clnb, sep)])

     if istxt :
     if istxt :

-        txt += u'nombre de classes : %i%s' % (parametres['clnb'], sep)
+        txt += ': '.join([_('Number of clusters'), '%i%s' % (parametres['clnb'], sep)])

         if parametres['classif_mode'] == 0 or parametres['classif_mode'] == 1 :
         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]), _('segments classified on'), '%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 :
         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(['%i' % sum([len(cl) for cl in corpus.lc]), _('texts classified on'), '%i (%.2f%%)%s' % (corpus.getucinb(), (float(sum([len(cl) for cl in corpus.lc]))) / float(corpus.getucinb()) * 100, sep)])

     else :
     else :

-        txt += u'%i segments classées sur %i (%.2f%%)%s' % (self.ucecla, self.Ucenb, (float(self.ucecla) / float(self.Ucenb)) * 100, sep)
- 
-    txt += """
-###########################
-temps d'analyse : %s
-###########################
-""" % parametres.get('time', '')
+        txt += ' '.join(['%i' % self.ucecla, _('line classified on'), '%i (%.2f%%)%s' % (self.Ucenb, (float(self.ucecla) / float(self.Ucenb)) * 100, sep)])
+
+    txt += ''.join([sep, '###########################', sep, _('time'), ' : %s' % parametres.get('time', ''), sep, '###########################', sep])
+    # ecriture du resultat dans le fichier

     with open(self.pathout['pre_rapport'], 'w') as f :
         f.write(txt)
 
 
 class SashList(wx.Panel) :
     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
     def __init__(self, parent) :
         wx.Panel.__init__(self, parent, -1)
         self.parent=parent


@@ -612,36 +646,30 @@ class SashList(wx.Panel) :
         #self.gparent=gparent
         #self.dlist=dlist
         #self.first = first
         #self.gparent=gparent
         #self.dlist=dlist
         #self.first = first

-        #self.menu = menu        
+        #self.menu = menu

         # A window to the left of the client window
         #self.listlex = listlex
         self.leftwin1 =  wx.SashLayoutWindow(
         # A window to the left of the client window
         #self.listlex = listlex
         self.leftwin1 =  wx.SashLayoutWindow(

-                self, -1, wx.DefaultPosition, (200, 300), 
+                self, -1, wx.DefaultPosition, (200, 300),

                 wx.NO_BORDER|wx.SW_3D
                 )
                 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)
         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(
         #textWindow = wx.TextCtrl(

-        #                leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize, 
+        #                leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,

         #                wx.TE_MULTILINE|wx.SUNKEN_BORDER
         #                )
         #                wx.TE_MULTILINE|wx.SUNKEN_BORDER
         #                )

-

         #textWindow.SetValue("A sub window")
         #textWindow.SetValue("A sub window")

-

         self.leftWindow1 = self.leftwin1
         winids.append(self.leftwin1.GetId())
         self.leftWindow1 = self.leftwin1
         winids.append(self.leftwin1.GetId())

-        

         rightwin1 =  wx.SashLayoutWindow(
         rightwin1 =  wx.SashLayoutWindow(

-                self, -1, wx.DefaultPosition, (200, 300), 
+                self, -1, wx.DefaultPosition, (200, 300),

                 wx.NO_BORDER|wx.SW_3D
                 )
                 wx.NO_BORDER|wx.SW_3D
                 )

-

         rightwin1.SetDefaultSize((120, 1000))
         rightwin1.SetOrientation(wx.LAYOUT_VERTICAL)
         rightwin1.SetAlignment(wx.LAYOUT_LEFT)
         rightwin1.SetDefaultSize((120, 1000))
         rightwin1.SetOrientation(wx.LAYOUT_VERTICAL)
         rightwin1.SetAlignment(wx.LAYOUT_LEFT)


@@ -649,24 +677,28 @@ class SashList(wx.Panel) :
         rightwin1.SetSashVisible(wx.SASH_RIGHT, True)
         rightwin1.SetExtraBorderSize(10)
         #textWindow = wx.TextCtrl(
         rightwin1.SetSashVisible(wx.SASH_RIGHT, True)
         rightwin1.SetExtraBorderSize(10)
         #textWindow = wx.TextCtrl(

-        #                leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize, 
+        #                leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize,

         #                wx.TE_MULTILINE|wx.SUNKEN_BORDER
         #                )
         #                wx.TE_MULTILINE|wx.SUNKEN_BORDER
         #                )

-

         #textWindow.SetValue("A sub window")
         #textWindow.SetValue("A sub window")

-

         self.rightwin1 = rightwin1
         winids.append(rightwin1.GetId())
 
         self.rightwin1 = rightwin1
         winids.append(rightwin1.GetId())
 

+

 class TgenLayout :
 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")
     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 = TGen(path = tgenpath, encoding = 'UTF-8')

         tgen.read()
         tgen.read()

+        tgenlempath = os.path.join(parametres['pathout'], 'tgenlemchi2.csv')
+        if os.path.exists(tgenlempath) :
+            self.page.parametres['tgenlemspec'] = tgenlempath
+            self.page.tgenlem, etoiles = ReadList(self.page.parametres['tgenlemspec'], ira.syscoding, sep="\t")

         tgentab = False
         gparent = None
         if 'TabChdSim' in dir(page) :
         tgentab = False
         gparent = None
         if 'TabChdSim' in dir(page) :


@@ -680,19 +712,23 @@ class TgenLayout :
                 if tab.tgen :
                     tgentab = tab
                     break
                 if tab.tgen :
                     tgentab = tab
                     break

-                

         if tgentab :
             self.page.tgentab.RefreshData(self.page.tgens)
             self.page.tgentab.tgens = tgen.tgen
         if tgentab :
             self.page.tgentab.RefreshData(self.page.tgens)
             self.page.tgentab.tgens = tgen.tgen

+            self.page.tgentab.tgenlem = self.page.tgenlem

             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.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')
+            if os.path.exists(tgenlempath) :
+                self.page.tgentab.tgenlem = self.page.tgenlem
+            page.AddPage(self.page.tgentab, _('Tgens Specificities'))

             page.SetSelection(page.GetPageCount() - 1)
 
             page.SetSelection(page.GetPageCount() - 1)
 

+

 class dolexlayout :
 class dolexlayout :

+

     def __init__(self, ira, corpus, parametres):
         self.pathout = PathOut(dirout = parametres['pathout'])
         self.corpus = corpus
     def __init__(self, ira, corpus, parametres):
         self.pathout = PathOut(dirout = parametres['pathout'])
         self.corpus = corpus


@@ -701,19 +737,16 @@ class dolexlayout :
         self.parent = ira
         self.encoding = self.corpus.parametres['syscoding']
         self.parametres = parametres
         self.parent = ira
         self.encoding = self.corpus.parametres['syscoding']
         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.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.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.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, self.DictSpec, self.etoiles)
         self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
         self.TabStat.parametres = parametres
         self.ListPan = ListForSpec(ira, self, self.DictSpec, self.etoiles)


@@ -725,28 +758,25 @@ class dolexlayout :
         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.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.ListPan, _('Forms'))

         if os.path.exists(self.pathout['banalites.csv']) :
         if os.path.exists(self.pathout['banalites.csv']) :

-            self.TabStat.AddPage(self.listban, u'banalités')
-        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.listban, _('Banal forms'))
+        self.TabStat.AddPage(self.ListPant, _('POS'))
+        self.TabStat.AddPage(self.ListPanEff, _('Forms frequencies'))
+        self.TabStat.AddPage(self.ListPanEffType, _('POS frequencies'))
+        self.TabStat.AddPage(self.ListPanEffRelForme, _('Forms relative frequencies'))
+        self.TabStat.AddPage(self.ListPanEffRelType, _('POS relative frequencies'))

         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)
         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')
+            self.TabAFC.AddPage(self.tabAFCGraph, _('CA forms'))

             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)
             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')
-        
-        ira.nb.AddPage(self.TabStat, u'Spécificités')
+            self.TabAFC.AddPage(self.tabAFCTGraph, _('CA POS'))
+            self.TabStat.AddPage(self.TabAFC, _('CA'))
+        ira.nb.AddPage(self.TabStat, ' - '.join([_('Specificities'), self.parametres['name']]))

         self.ira = ira
         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.TabStat.corpus = self.corpus
         self.TabStat.etoiles = self.etoiles
         if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenspec.csv')) :


@@ -756,43 +786,52 @@ class dolexlayout :
         ira.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
         ira.ShowAPane("Tab_content")
 
         ira.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
         ira.ShowAPane("Tab_content")
 

+

 class StatLayout:
 class StatLayout:

+

     def __init__(self, ira, corpus, parametres):
         self.pathout = PathOut(dirout = parametres['pathout'])
         self.corpus = corpus
         self.ira = ira
     def __init__(self, ira, corpus, parametres):
         self.pathout = PathOut(dirout = parametres['pathout'])
         self.corpus = corpus
         self.ira = ira

-        self.read_result()
+        self.read_result() # qui va définir la propriété self.result
+        self.parametres = parametres

         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)
         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 = 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.TabStat.AddPage(self.TabStatTot, 'global')
+        self.TabStat.AddPage(self.TabStatTot, _('Abstract'))
+        dictlabel = {'total' : _('Total'),
+                     'formes_actives' : _('Actives forms'),
+                     'formes_supplémentaires': _('Supplementary forms'),
+                     'hapax' : _('Hapax'),
+                     }

         for item in self.result:
             if item != 'glob':
         for item in self.result:
             if item != 'glob':

-                datam = [['forme', 'nb']]
+                datam = [['forme', 'nb']] #???

                 self.ListPan = ListPanel(ira, self, self.result[item])
                 self.ListPan = ListPanel(ira, self, self.result[item])

-                self.TabStat.AddPage(self.ListPan, ' '.join(item.split('_'))) 
+                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")
 
     def read_result(self) :
         ira.nb.AddPage(self.TabStat, '%s' % parametres['name'])
         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
         ira.ShowAPane("Tab_content")
 
     def read_result(self) :

-        lcle = {'total' :u'total.csv', u'formes_actives':u'formes_actives.csv', u'formes_supplémentaires':u'formes_supplémentaires.csv', u'hapax': u'hapax.csv'}
+        lcle = {'total' :'total.csv', 'formes_actives':'formes_actives.csv', 'formes_supplémentaires':'formes_supplémentaires.csv', 'hapax': 'hapax.csv'}

         self.result = {}
         for key in lcle :
         self.result = {}
         for key in lcle :

-            with open(self.pathout[lcle[key]], 'r') as f :
+            with codecs.open(self.pathout[lcle[key]], 'r', sys.getdefaultencoding()) as f :

                 self.result[key] = [line.split(';') for line in f.read().splitlines()]
                 self.result[key] = dict([[i,[line[0],int(line[1]), line[2]]] for i, line in enumerate(self.result[key])])
         with open(self.pathout['glob.txt'], 'r') as f :
             self.result['glob'] = f.read()
 
                 self.result[key] = [line.split(';') for line in f.read().splitlines()]
                 self.result[key] = dict([[i,[line[0],int(line[1]), line[2]]] for i, line in enumerate(self.result[key])])
         with open(self.pathout['glob.txt'], 'r') as f :
             self.result['glob'] = f.read()
 

+

 class GraphPanelDendro(wx.Panel):
 class GraphPanelDendro(wx.Panel):

+

     def __init__(self,parent, dico, list_graph, txt=False):
         wx.Panel.__init__(self,parent)
         self.graphnb = 1
     def __init__(self,parent, dico, list_graph, txt=False):
         wx.Panel.__init__(self,parent)
         self.graphnb = 1


@@ -800,7 +839,7 @@ class GraphPanelDendro(wx.Panel):
         self.dirout = os.path.dirname(self.dictpathout['ira'])
         self.list_graph = list_graph
         self.parent = self.GetParent()#parent
         self.dirout = os.path.dirname(self.dictpathout['ira'])
         self.list_graph = list_graph
         self.parent = self.GetParent()#parent

-        self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
+        self.SetFont(wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0, "Arial")) #modifié

         self.labels = []
         self.listimg = []
         self.tabchd = self.parent.GetParent()
         self.labels = []
         self.listimg = []
         self.tabchd = self.parent.GetParent()


@@ -814,7 +853,6 @@ class GraphPanelDendro(wx.Panel):
         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)
         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])) :
                 filename, ext = os.path.splitext(list_graph[i][0])
         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])


@@ -823,7 +861,6 @@ class GraphPanelDendro(wx.Panel):
                 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]))
                 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()
         self.__do_layout()
 
         self.__set_properties()
         self.__do_layout()
 


@@ -843,9 +880,9 @@ class GraphPanelDendro(wx.Panel):
                        'type_tclasse' : 0,
                        'svg' : 0
                      }
                        'type_tclasse' : 0,
                        'svg' : 0
                      }

-        self.type_dendro = [ u"phylogram", u"cladogram", u"fan", u"unrooted", u"radial" ]
+        self.type_dendro = [ "phylogram", "cladogram", "fan", "unrooted", "radial" ]

 
 

-    def __do_layout(self):    
+    def __do_layout(self):

         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
         self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
         self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)


@@ -853,23 +890,28 @@ class GraphPanelDendro(wx.Panel):
         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)
         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)
         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) 
+        self.SetSizer(self.sizer_2)

 
     def make_param(self, dial):
         self.param['width'] = dial.m_spinCtrl2.GetValue()
         self.param['height'] = dial.m_spinCtrl1.GetValue()
         self.param['type_dendro'] = dial.m_choice1.GetSelection()
 
     def make_param(self, dial):
         self.param['width'] = dial.m_spinCtrl2.GetValue()
         self.param['height'] = dial.m_spinCtrl1.GetValue()
         self.param['type_dendro'] = dial.m_choice1.GetSelection()

-        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()
         self.param['svg'] = dial.choice_format.GetSelection()

+        if self.param['typedendro'] == 'classique' :
+            self.param['color_nb'] = dial.m_radioBox1.GetSelection()
+            self.param['taille_classe'] = dial.m_checkBox1.GetValue()
+            self.param['type_tclasse'] = dial.m_radioBox2.GetSelection()
+        if self.param.get('translation', False) :
+            if dial.trans.GetSelection() == 0 :
+                del self.param['translation']
+            else :
+                self.param['translation'] = self.param['translation'][dial.trans.GetSelection()-1][1]

 
     def make_dendro(self, dendro = 'simple') :
         if self.param['svg'] :
 
     def make_dendro(self, dendro = 'simple') :
         if self.param['svg'] :


@@ -909,9 +951,9 @@ class GraphPanelDendro(wx.Panel):
         """ % (ffr(dendro_path), ffr(self.ira.RscriptsPath['Rgraph']),  ffr(classe_path))
         if dendro == 'simple' :
             txt += """
         """ % (ffr(dendro_path), ffr(self.ira.RscriptsPath['Rgraph']),  ffr(classe_path))
         if dendro == 'simple' :
             txt += """

-            open_file_graph("%s", width=%i, height=%i)
+            open_file_graph("%s", width=%i, height=%i, svg=%s)

             plot.dendropr(tree.cut1$tree.cl, classes, type.dendro="%s", histo=%s, bw=%s, lab=NULL, tclasse=%s)
             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)
+            """ % (ffr(fileout), width, height, svg, type_dendro, histo, bw, tclasse)

         elif dendro == 'texte' :
             txt += """
             load("%s")
         elif dendro == 'texte' :
             txt += """
             load("%s")


@@ -920,9 +962,20 @@ class GraphPanelDendro(wx.Panel):
                 debsup <- debet
             }
             chistable <- chistabletot[1:(debsup-1),]
                 debsup <- debet
             }
             chistable <- chistabletot[1:(debsup-1),]

+            """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']))
+            if self.param.get('translation', False) :
+                txt += """
+                rn <- read.csv2("%s", header=FALSE, sep='\t')
+                rnchis <- row.names(chistable)
+                commun <- intersect(rnchis, unique(rn[,2]))
+                idrnchis <- sapply(commun, function(x) {which(rnchis==x)})
+                idrn <- sapply(commun, function(x) {which(as.vector(rn[,2])==x)[1]})
+                rownames(chistable)[idrnchis] <- as.vector(rn[idrn,1])
+                """ % ffr(self.param['translation'])
+            txt += """

             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)
             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)
+            """ % (ffr(fileout), width, height, svg, type_dendro, bw)

         elif dendro == 'cloud' :
             txt += """
             load("%s")
         elif dendro == 'cloud' :
             txt += """
             load("%s")


@@ -934,15 +987,16 @@ class GraphPanelDendro(wx.Panel):
             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)
             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()
         tmpfile = tempfile.mktemp()

+        # ecriture du fichier de script à éxécuter

         with open(tmpfile, 'w') as f :
             f.write(txt)
         with open(tmpfile, 'w') as f :
             f.write(txt)

-        busy = wx.BusyInfo(_("Please wait...").decode('utf8'), self.parent)
+        # dialogue d'attente
+        busy = wx.BusyInfo(_("Please wait..."), self.parent)

         wx.SafeYield()
         wx.SafeYield()

-        error = exec_rcode(self.ira.RPath, tmpfile, wait=True) 
+        error = exec_rcode(self.ira.RPath, tmpfile, wait=True)

         del busy
         del busy

+        # fin de l'attente

         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)
         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)


@@ -957,13 +1011,22 @@ class GraphPanelDendro(wx.Panel):
 
 
     def ondendro(self, evt):
 
 
     def ondendro(self, evt):

+        self.param['typedendro'] = 'classique'

         dial = PrefDendro(self.ira, self.param)
         val = dial.ShowModal()
         if val == wx.ID_OK :
             self.make_param(dial)
             self.make_dendro()
         dial = PrefDendro(self.ira, self.param)
         val = dial.ShowModal()
         if val == wx.ID_OK :
             self.make_param(dial)
             self.make_dendro()

-    
+

     def ondendrotexte(self, evt):
     def ondendrotexte(self, evt):

+        self.param['typedendro'] = 'texte'
+        if os.path.exists(self.dictpathout['translations.txt']) :
+            with codecs.open(self.dictpathout['translations.txt'], 'r', 'utf8') as f :
+                content = f.read()
+            print(content)
+            trans = [line.split('\t')[1] for line in content.splitlines()]
+            trans = [[val, self.dictpathout[val]] for val in trans]
+            self.param['translation'] = trans

         dial = PrefDendro(self.ira, self.param)
         val = dial.ShowModal()
         if val == wx.ID_OK :
         dial = PrefDendro(self.ira, self.param)
         val = dial.ShowModal()
         if val == wx.ID_OK :


@@ -971,13 +1034,16 @@ class GraphPanelDendro(wx.Panel):
             self.make_dendro(dendro = 'texte')
 
     def ondendrocloud(self, evt):
             self.make_dendro(dendro = 'texte')
 
     def ondendrocloud(self, evt):

+        self.param['typedendro'] = 'cloud'

         dial = PrefDendro(self.ira, self.param)
         val = dial.ShowModal()
         if val == wx.ID_OK :
             self.make_param(dial)
             self.make_dendro(dendro = 'cloud')
 
         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 :
 class OpenCorpus :

+

     def __init__(self, ira, parametres) :
         #self.text = wx.TextCtrl(ira, -1, "", wx.Point(0, 0), wx.Size(200, 200), wx.NO_BORDER | wx.TE_MULTILINE | wx.TE_RICH2 | wx.TE_READONLY)
         self.panel = CopusPanel(ira, parametres)
     def __init__(self, ira, parametres) :
         #self.text = wx.TextCtrl(ira, -1, "", wx.Point(0, 0), wx.Size(200, 200), wx.NO_BORDER | wx.TE_MULTILINE | wx.TE_RICH2 | wx.TE_READONLY)
         self.panel = CopusPanel(ira, parametres)


@@ -986,7 +1052,9 @@ class OpenCorpus :
         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
         ira.ShowAPane("Tab_content")
 
         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
         ira.ShowAPane("Tab_content")
 

+

 class MatLayout :
 class MatLayout :

+

     def __init__(self, ira, matrix):
         #self.parent.content = self.csvtable
         self.sheet = MySheet(ira.nb)
     def __init__(self, ira, matrix):
         #self.parent.content = self.csvtable
         self.sheet = MySheet(ira.nb)


@@ -996,95 +1064,86 @@ class MatLayout :
         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
         ira.ShowAPane("Tab_content")
 
         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
         ira.ShowAPane("Tab_content")
 

+

 class CopusPanel(wx.Panel) :
 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 )
         self.parametres = parametres
         fgSizer5 = wx.FlexGridSizer( 0, 2, 0, 0 )
         fgSizer5.SetFlexibleDirection( wx.BOTH )
     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 )
         self.parametres = parametres
         fgSizer5 = wx.FlexGridSizer( 0, 2, 0, 0 )
         fgSizer5.SetFlexibleDirection( wx.BOTH )

-        fgSizer5.SetNonFlexibleGrowMode( wx.FLEX_GROWMODE_SPECIFIED )        
+        fgSizer5.SetNonFlexibleGrowMode( wx.FLEX_GROWMODE_SPECIFIED )

         self.fgSizer5 = fgSizer5
         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, _("Description of corpus"), wx.DefaultPosition, wx.DefaultSize, 0 )

         self.m_staticText18.Wrap( -1 )
         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
         self.m_staticText18.Wrap( -1 )
         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )

-        
-        self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
+        self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, "", wx.DefaultPosition, wx.DefaultSize, 0 )

         self.m_staticText19.Wrap( -1 )
         fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
         self.m_staticText19.Wrap( -1 )
         fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )

-
-        self.m_staticText20 = wx.StaticText( self, wx.ID_ANY, u"Nom", wx.DefaultPosition, wx.DefaultSize, 0 )
+        self.m_staticText20 = wx.StaticText( self, wx.ID_ANY, "Nom", wx.DefaultPosition, wx.DefaultSize, 0 )

         self.m_staticText20.Wrap( -1 )
         fgSizer5.Add( self.m_staticText20, 0, wx.ALL, 5 )
         self.m_staticText20.Wrap( -1 )
         fgSizer5.Add( self.m_staticText20, 0, wx.ALL, 5 )

-        

         self.m_staticText21 = wx.StaticText( self, wx.ID_ANY, parametres['corpus_name'], wx.DefaultPosition, wx.DefaultSize, 0 )
         self.m_staticText21.Wrap( -1 )
         fgSizer5.Add( self.m_staticText21, 0, wx.ALL, 5 )
         self.m_staticText21 = wx.StaticText( self, wx.ID_ANY, parametres['corpus_name'], wx.DefaultPosition, wx.DefaultSize, 0 )
         self.m_staticText21.Wrap( -1 )
         fgSizer5.Add( self.m_staticText21, 0, wx.ALL, 5 )

-
-        description = {'lang' : u'langue',
-                       'encoding' : u'encodage',
-                       'ucinb' : u'Nombre de textes',
-                       'ucenb' : u'Nombre de segments de texte',
-                       'formesnb' : u'Nombre de formes',
-                       'hapax' : u'Nombre d\'hapax'
+        description = {'lang' : _('Language'),
+                       'encoding' : _('Characters set'),
+                       'ucinb' : _('Number of texts'),
+                       'ucenb' : _('Number of text segments'),
+                       'formesnb' : _('Number of forms'),
+                       'hapax' : _('Number of hapax'),

                       }
                       }

-

         keys = ['lang', 'encoding', 'originalpath', 'pathout', 'date', 'time']
         keys = ['lang', 'encoding', 'originalpath', 'pathout', 'date', 'time']

-

         self.addkeys(keys, description)
         self.addkeys(keys, description)

-
-        self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Paramètres", wx.DefaultPosition, wx.DefaultSize, 0 )
+        self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, "Paramètres", wx.DefaultPosition, wx.DefaultSize, 0 )

         self.m_staticText18.Wrap( -1 )
         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
         self.m_staticText18.Wrap( -1 )
         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )

-        
-        self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
+        self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, "", wx.DefaultPosition, wx.DefaultSize, 0 )

         self.m_staticText19.Wrap( -1 )
         fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
         self.m_staticText19.Wrap( -1 )
         fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )

-

         keys = ['ucemethod', 'ucesize', 'keep_caract', 'expressions']
         self.addkeys(keys, description)
         keys = ['ucemethod', 'ucesize', 'keep_caract', 'expressions']
         self.addkeys(keys, description)

-
-        self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Statistiques", wx.DefaultPosition, wx.DefaultSize, 0 )
+        self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, "Statistiques", wx.DefaultPosition, wx.DefaultSize, 0 )

         self.m_staticText18.Wrap( -1 )
         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
         self.m_staticText18.Wrap( -1 )
         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )

-        
-        self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
+        self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, "", wx.DefaultPosition, wx.DefaultSize, 0 )

         self.m_staticText19.Wrap( -1 )
         fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
         self.m_staticText19.Wrap( -1 )
         fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )

-

         keys = ['ucinb', 'ucenb', 'occurrences', 'formesnb', 'hapax']
         self.addkeys(keys, description)
         keys = ['ucinb', 'ucenb', 'occurrences', 'formesnb', 'hapax']
         self.addkeys(keys, description)

-

         self.SetSizer( fgSizer5 )
         self.Layout()
 
     def addkeys(self, keys, description) :
         for key in keys :
         self.SetSizer( fgSizer5 )
         self.Layout()
 
     def addkeys(self, keys, description) :
         for key in keys :

-            option = self.parametres.get(key,u'non défini')
+            option = self.parametres.get(key,'non défini')

             if isinstance(option, int) :
             if isinstance(option, int) :

-                option = `option`
+                option = repr(option)

             text = wx.StaticText( self, wx.ID_ANY, description.get(key, key), wx.DefaultPosition, wx.DefaultSize, 0 )
             text.Wrap( -1 )
             self.fgSizer5.Add( text, 0, wx.ALL, 5 )
             text = wx.StaticText( self, wx.ID_ANY, description.get(key, key), wx.DefaultPosition, wx.DefaultSize, 0 )
             text.Wrap( -1 )
             self.fgSizer5.Add( text, 0, wx.ALL, 5 )

-

             text = wx.StaticText( self, wx.ID_ANY, option, wx.DefaultPosition, wx.DefaultSize, 0 )
             text.Wrap( -1 )
             self.fgSizer5.Add( text, 0, wx.ALL, 5 )
 
             text = wx.StaticText( self, wx.ID_ANY, option, wx.DefaultPosition, wx.DefaultSize, 0 )
             text.Wrap( -1 )
             self.fgSizer5.Add( text, 0, wx.ALL, 5 )
 

+

 class DefaultTextLayout :
 class DefaultTextLayout :

-    def __init__(self, ira, corpus, parametres) :
+
+    def __init__(self, ira, corpus, parametres, cmd = False) :

         self.pathout = PathOut(dirout = parametres['pathout'])
         self.ira = ira
         self.parent = ira
         self.parametres = parametres
         self.corpus = corpus
         self.pathout = PathOut(dirout = parametres['pathout'])
         self.ira = ira
         self.parent = ira
         self.parametres = parametres
         self.corpus = corpus

+        self.cmd = cmd

         self.dolayout()
         self.dolayout()

-    
-    def dolayout(self) :
+
+    def dolayout(self, cmd) :

         log.info('no layout yet')
 
         log.info('no layout yet')
 

+

 class WordCloudLayout(DefaultTextLayout):
 class WordCloudLayout(DefaultTextLayout):

+

     def dolayout(self):
         self.pathout.basefiles(simipath)
         self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
     def dolayout(self):
         self.pathout.basefiles(simipath)
         self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)


@@ -1100,87 +1159,144 @@ class WordCloudLayout(DefaultTextLayout):
         self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
         self.ira.ShowAPane("Tab_content")
 
         self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
         self.ira.ShowAPane("Tab_content")
 

+
+class LabbeLayout(DefaultTextLayout):
+
+    def dolayout(self):
+        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']]
+        list_graph = [['labbe-tree.png', _('Ward clustering (method ward2)')],
+                     ['labbe-heatmap.png', _('Heatmap')],
+                     ['labbe-matrix.png', _('Matrix')]]
+        for val in list_graph :
+            #self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, [val])
+            self.Tab.AddPage(GraphPanel(self.Tab, self.pathout, [val]), val[1])
+        self.Tab.corpus = self.corpus
+        self.Tab.parametres = self.parametres
+        self.ira.nb.AddPage(self.Tab, '%s' % self.parametres['name'])
+        self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
+        self.ira.ShowAPane("Tab_content")
+
+
+def blender(self):
+    nodesfile = self.pathout['nodes.csv']
+    edgesfile = self.pathout['edges.csv']
+    jsonout = self.pathout.makenew('graphe_json', 'json')
+    txt = """
+    library(igraph)
+    load("%s")
+    source("%s")
+    """ % (ffr(self.pathout['RData.RData']), ffr(self.parent.RscriptsPath['Rgraph']))
+    txt += """
+    nodesf <- "%s"
+    edgesf <- "%s"
+    """ % (ffr(nodesfile), ffr(edgesfile))
+    txt += """
+    if ("communities" %in% names(graph.simi)) {
+        community = TRUE
+    } else {
+        community = FALSE
+    }
+    graph.to.file(graph.simi, nodesfile = nodesf, edgesfile = edgesf, community = community)
+    """
+    # ecriture du fichier de script à éxécuter
+    filetmp = tempfile.mktemp()
+    with open(filetmp, 'w') as f :
+        f.write(txt)
+    exec_rcode(self.ira.RPath, filetmp)
+    GraphToJson(nodesfile, edgesfile, jsonout)
+    # une fonction à ré-activer ???
+    # pour le moment, j'ai mis le module network_to_blender de coté
+    # launchcommand(['/home/pierre/prog/blender-2.73-linux-glibc211-x86_64/blender', '-P', os.path.join(self.ira.AppliPath, 'network_to_blender.py'), jsonout])
+
+

 class SimiLayout(DefaultTextLayout) :
 class SimiLayout(DefaultTextLayout) :

+

     def dolayout(self) :
         self.pathout.basefiles(simipath)
         self.actives = None
         self.indices = indices_simi
         if os.path.exists(self.pathout['liste_graph']) :
             list_graph = read_list_file(self.pathout['liste_graph'])
     def dolayout(self) :
         self.pathout.basefiles(simipath)
         self.actives = None
         self.indices = indices_simi
         if os.path.exists(self.pathout['liste_graph']) :
             list_graph = read_list_file(self.pathout['liste_graph'])

-        else : 
+        else :

             list_graph = [['','']]
             list_graph = [['','']]

-        notebook_flags =  aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
-        self.tabsimi = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
-        self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
-        self.tabsimi.SetArtProvider(aui.ChromeTabArt())
-        self.tabsimi.corpus = self.corpus
-        self.tabsimi.parametres = self.parametres
-        self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
-        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.ShowTab(True)
-        self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
-        
+        if not self.cmd :
+            notebook_flags =  aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
+            self.tabsimi = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
+            self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
+            self.tabsimi.SetArtProvider(aui.ChromeTabArt())
+            self.tabsimi.corpus = self.corpus
+            self.tabsimi.parametres = self.parametres
+            self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
+            self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
+            self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
+            self.graphpan.Bind(wx.EVT_BUTTON, self.blender, self.graphpan.butblender)
+            self.tabsimi.AddPage(self.graphpan, _('Graph'))
+            self.ira.nb.AddPage(self.tabsimi, _('Graph analysis'))
+            self.ira.ShowTab(True)
+            self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
+

     def redosimi(self, evt) :
     def redosimi(self, evt) :

-        with open(self.pathout['selected.csv'],'r') as f :
-            selected = f.read()
-        selected = [int(val) for val in selected.splitlines()]
-        if self.actives is None :
-            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()]
-        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)
-        if prep.val == wx.ID_OK :
-            self.parametres = prep.parametres
-
-            script = PrintSimiScript(self)
-            script.make_script()
-            pid = exec_rcode(self.ira.RPath, script.scriptout, wait = True)
-            check_Rresult(self.ira, pid)
-            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']):
-                    graph_simi = read_list_file(self.pathout['liste_graph'])
-                    graph_simi.append([os.path.basename(fileout), script.txtgraph])
-                else :
-                    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'] 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)
-                self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
-                self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
-                self.graphpan.Layout()
-                self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
+        redosimi(self, evt)
+   #      with open(self.pathout['selected.csv'],'r') as f :
+   #          selected = f.read()
+   #      selected = [int(val) for val in selected.splitlines()]
+   #      if self.actives is None :
+   #          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()]
+   #      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)
+   #      if prep.val == wx.ID_OK :
+   #          self.parametres = prep.parametres
+   #          script = PrintSimiScript(self)
+   #          script.make_script()
+   #          pid = exec_rcode(self.ira.RPath, script.scriptout, wait = True)
+   #          check_Rresult(self.ira, pid)
+   #          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']):
+   #                  graph_simi = read_list_file(self.pathout['liste_graph'])
+   #                  graph_simi.append([os.path.basename(fileout), script.txtgraph])
+   #              else :
+   #                  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'] 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)
+   #              self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
+   #              self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
+   #              self.graphpan.Layout()
+   #              self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))

 
     def export(self, evt) :
         nb = 1
 
     def export(self, evt) :
         nb = 1


@@ -1200,23 +1316,28 @@ class SimiLayout(DefaultTextLayout) :
         } else {
             V(graph)$weight <- graph.simi$label.cex
         }
         } else {
             V(graph)$weight <- graph.simi$label.cex
         }

-        V(graph)$color <- vertex.label.color
+        V(graph)$rcolor <- 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')
         #saveAsGEXF(graph, filepath = fileout)
         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')
         #saveAsGEXF(graph, filepath = fileout)

-        """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
+        """ % (ffr(self.pathout['RData.RData']), ffr(self.parent.RscriptsPath['simi']), fileout)

         filetmp = tempfile.mktemp()
         with open(filetmp, 'w') as f :
             f.write(txt)
         exec_rcode(self.ira.RPath, filetmp)
         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, _('File exported'), wx.OK)

         mss.CenterOnParent()
         mss.ShowModal()
         mss.Destroy()
 
         mss.CenterOnParent()
         mss.ShowModal()
         mss.Destroy()
 

+    def blender(self, evt):
+        blender(self)
+
+

 class DefaultMatLayout :
 class DefaultMatLayout :

+

     def __init__(self, parent, tableau, parametres) :
         self.pathout = PathOut(dirout = parametres['pathout'])
         self.ira = parent
     def __init__(self, parent, tableau, parametres) :
         self.pathout = PathOut(dirout = parametres['pathout'])
         self.ira = parent


@@ -1232,16 +1353,21 @@ class DefaultMatLayout :
     def dolayout(self) :
         pass
 
     def dolayout(self) :
         pass
 

+

 class FreqLayout(DefaultMatLayout) :
 class FreqLayout(DefaultMatLayout) :

+

     def dolayout(self) :
         self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
     def dolayout(self) :
         self.tab = wx.html.HtmlWindow(self.ira.nb, -1)

+        #self.tab = wx.html2.WebView.New(self)

         res = normpath_win32(self.pathout['resultats.html']).replace('\\','/')
         self.tab.LoadPage(res)
         res = normpath_win32(self.pathout['resultats.html']).replace('\\','/')
         self.tab.LoadPage(res)

+        #self.tab.LoadURL(res)

         self.tab.parametres = self.parametres
         self.tab.parametres = self.parametres

-        self.ira.nb.AddPage(self.tab, u"Fréquences")
+        self.ira.nb.AddPage(self.tab, ' - '.join([_("Frequency"), self.parametres['name']]))

 
 
 class Chi2Layout(DefaultMatLayout) :
 
 
 class Chi2Layout(DefaultMatLayout) :

+

     def dolayout(self):
         self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
         if "gtk2" in wx.PlatformInfo:
     def dolayout(self):
         self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
         if "gtk2" in wx.PlatformInfo:


@@ -1249,14 +1375,15 @@ class Chi2Layout(DefaultMatLayout) :
         res = normpath_win32(self.pathout['resultats-chi2.html']).replace('\\','/')
         self.tab.LoadPage(res)
         self.tab.parametres = self.parametres
         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", "%s" % self.parametres['name']]))
+        self.ira.nb.AddPage(self.tab, ' - '.join(["Chi2", self.parametres['name']]))

         #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
         #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)

-        #self.ira.ShowAPane("Tab_content")  
+        #self.ira.ShowAPane("Tab_content")

 
 
 class ProtoLayout(DefaultMatLayout) :
 
 
 class ProtoLayout(DefaultMatLayout) :

+

     def dolayout(self) :
     def dolayout(self) :

-        list_graph = [['proto.png', 'Analyse prototypique']]
+        list_graph = [['proto.png', _('Prototypical analysis')]]

         #self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
         #if self.parametres['svg'] :
         #    list_graph = [['nuage_1.svg', 'Nuage']]
         #self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
         #if self.parametres['svg'] :
         #    list_graph = [['nuage_1.svg', 'Nuage']]


@@ -1266,18 +1393,19 @@ class ProtoLayout(DefaultMatLayout) :
         #self.Tab.AddPage(self.TabProto, 'Analyse Prototypique')
         #self.Tab.corpus = self.corpus
         self.TabProto.parametres = self.parametres
         #self.Tab.AddPage(self.TabProto, 'Analyse Prototypique')
         #self.Tab.corpus = self.corpus
         self.TabProto.parametres = self.parametres

-        self.ira.nb.AddPage(self.TabProto, 'Analyse Prototypique - %s' % self.parametres['name'])
+        self.ira.nb.AddPage(self.TabProto, ' - '.join([_('Prototypical analysis'), self.parametres['name']]))

         #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
         #self.ira.ShowAPane("Tab_content")
 
 
 class SimiMatLayout(DefaultMatLayout) :
         #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
         #self.ira.ShowAPane("Tab_content")
 
 
 class SimiMatLayout(DefaultMatLayout) :

+

     def dolayout(self):
         self.pathout.basefiles(simipath)
         self.indices = indices_simi
         if os.path.exists(self.pathout['liste_graph']) :
             list_graph = read_list_file(self.pathout['liste_graph'])
     def dolayout(self):
         self.pathout.basefiles(simipath)
         self.indices = indices_simi
         if os.path.exists(self.pathout['liste_graph']) :
             list_graph = read_list_file(self.pathout['liste_graph'])

-        else : 
+        else :

             list_graph = [['','']]
         notebook_flags =  aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
         self.tabsimi = aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
             list_graph = [['','']]
         notebook_flags =  aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
         self.tabsimi = aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)


@@ -1286,9 +1414,10 @@ class SimiMatLayout(DefaultMatLayout) :
         self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
         self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
         self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
         self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
         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.graphpan.Bind(wx.EVT_BUTTON, self.blender, self.graphpan.butblender)
+        self.tabsimi.AddPage(self.graphpan, _('Graph'))

         self.tabsimi.parametres = self.parametres
         self.tabsimi.parametres = self.parametres

-        self.parent.nb.AddPage(self.tabsimi, 'Analyse de graph')
+        self.parent.nb.AddPage(self.tabsimi, ' - '.join([_('Graph analysis'), self.parametres['name']]))

         #self.parent.ShowTab(True)
         #self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
 
         #self.parent.ShowTab(True)
         #self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
 


@@ -1304,7 +1433,6 @@ class SimiMatLayout(DefaultMatLayout) :
             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]
             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)])
         #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)])


@@ -1322,7 +1450,7 @@ class SimiMatLayout(DefaultMatLayout) :
             self.column = [self.tableau.listactives.index(val) for val in indexes]
             self.column.sort()
             with open(self.pathout['selected.csv'], 'w') as f :
             self.column = [self.tableau.listactives.index(val) for val in indexes]
             self.column.sort()
             with open(self.pathout['selected.csv'], 'w') as f :

-                f.write('\n'.join([`val` for val in self.column]))
+                f.write('\n'.join([repr(val) for val in self.column]))

             self.make_param()
             self.dial.Destroy()
             self.script = PrintSimiScript(self)
             self.make_param()
             self.dial.Destroy()
             self.script = PrintSimiScript(self)


@@ -1343,7 +1471,7 @@ class SimiMatLayout(DefaultMatLayout) :
                     graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
                 else :
                     graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]
                     graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
                 else :
                     graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]

-                print_liste(self.pathout['liste_graph'], graph_simi)            
+                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'] :
             DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
             if self.parametres['type_graph'] == 1:
                 if self.parametres['svg'] :


@@ -1356,7 +1484,6 @@ class SimiMatLayout(DefaultMatLayout) :
                 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
         else :
             self.dial.Destroy()
                 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
         else :
             self.dial.Destroy()

-               

 
     def make_param(self) :
         if self.parametres['first'] :
 
     def make_param(self) :
         if self.parametres['first'] :


@@ -1364,7 +1491,6 @@ class SimiMatLayout(DefaultMatLayout) :
         else :
             keep_coord = self.dial.check_coord.GetValue()
         #self.select = self.dial.check_colch.GetValue()
         else :
             keep_coord = self.dial.check_coord.GetValue()
         #self.select = self.dial.check_colch.GetValue()

-

         paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
                           'layout' : self.dial.choice2.GetSelection(),
                           'type_graph' : self.dial.choice3.GetSelection(),
         paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
                           'layout' : self.dial.choice2.GetSelection(),
                           'type_graph' : self.dial.choice3.GetSelection(),


@@ -1397,7 +1523,8 @@ class SimiMatLayout(DefaultMatLayout) :
                           'halo' : self.dial.halo.GetValue(),
                           'com' : self.dial.comcheck.GetValue(),
                           'communities' : self.dial.choix_com.GetSelection(),
                           '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 :
         if 'cexfromchi' in self.parametres :
             paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
         if 'sfromchi' in self.parametres :


@@ -1413,17 +1540,17 @@ class SimiMatLayout(DefaultMatLayout) :
         if self.parametres['type_graph'] == 1 :
             graph = False
             wait = False
         if self.parametres['type_graph'] == 1 :
             graph = False
             wait = False

-        else : 
+        else :

             graph = True
             wait = True
         pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
         if self.parametres['type_graph'] == 1 :
             while pid.poll() == None :
             graph = True
             wait = True
         pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
         if self.parametres['type_graph'] == 1 :
             while pid.poll() == None :

-                dlg.Pulse(u'R ...')
+                dlg.Pulse('R ...')

                 sleep(0.2)
             check_Rresult(self.parent, pid)
                 sleep(0.2)
             check_Rresult(self.parent, pid)

-    
-    def export(self, evt) : 
+
+    def export(self, evt) :

         nb = 1
         while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
             nb +=1
         nb = 1
         while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
             nb +=1


@@ -1448,25 +1575,29 @@ class SimiMatLayout(DefaultMatLayout) :
         E(graph)$weight <- graph.simi$we.width
         write.graph(graph, fileout, format = 'graphml')
         #saveAsGEXF(graph, filepath = fileout)
         E(graph)$weight <- graph.simi$we.width
         write.graph(graph, fileout, format = 'graphml')
         #saveAsGEXF(graph, filepath = fileout)

-        """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
+        """ % (ffr(self.pathout['RData.RData']), ffr(self.parent.RscriptsPath['simi']), fileout)

         filetmp = tempfile.mktemp()
         with open(filetmp, 'w') as f :
             f.write(txt)
         exec_rcode(self.ira.RPath, filetmp)
         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, _('File exported'), wx.OK)

         mss.CenterOnParent()
         mss.ShowModal()
         mss.Destroy()
 
         mss.CenterOnParent()
         mss.ShowModal()
         mss.Destroy()
 

-        
+    def blender(self, evt):
+        blender(self)
+
+

 class GraphPanelSimi(wx.Panel):
 class GraphPanelSimi(wx.Panel):

+

     def __init__(self,parent, dico, list_graph):
         wx.Panel.__init__(self,parent)
         self.afcnb = 1
         self.Dict = dico
         self.dirout = os.path.dirname(self.Dict['ira'])
     def __init__(self,parent, dico, list_graph):
         wx.Panel.__init__(self,parent)
         self.afcnb = 1
         self.Dict = dico
         self.dirout = os.path.dirname(self.Dict['ira'])

-        self.parent = self.GetParent()#parent
-        self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "courier"))
+        self.parent = self.GetParent()
+        self.SetFont(wx.Font(10, wx.FONTFAMILY_DEFAULT, wx.FONTSTYLE_NORMAL, wx.FONTWEIGHT_NORMAL, 0, "courier")) #modifié

         self.labels = []
         self.listimg = []
         self.tabsimi = self.parent.GetParent()
         self.labels = []
         self.listimg = []
         self.tabsimi = self.parent.GetParent()


@@ -1476,6 +1607,10 @@ class GraphPanelSimi(wx.Panel):
         self.butafc = wx.BitmapButton(self, -1, afc_img)
         export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
         self.butexport = wx.BitmapButton(self, -1, export_img)
         self.butafc = wx.BitmapButton(self, -1, afc_img)
         export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
         self.butexport = wx.BitmapButton(self, -1, export_img)

+        blender_img = wx.Image(os.path.join(self.ira.images_path,'button_blender.png'), wx.BITMAP_TYPE_ANY)
+        blender_img.Rescale(32,32)
+        blender_img = blender_img.ConvertToBitmap()
+        self.butblender = wx.BitmapButton(self, -1, blender_img)

         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])
         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])


@@ -1484,7 +1619,7 @@ class GraphPanelSimi(wx.Panel):
                 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]))
                 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.panel_1.Bind(wx.EVT_MOTION, self.onMouseMove)

         self.__set_properties()
         self.__do_layout()
 
         self.__set_properties()
         self.__do_layout()
 


@@ -1494,19 +1629,21 @@ class GraphPanelSimi(wx.Panel):
         self.panel_1.SetScrollRate(20, 20)
         self.panel_1.SetFocus()
 
         self.panel_1.SetScrollRate(20, 20)
         self.panel_1.SetFocus()
 

-    def __do_layout(self):    
+    def __do_layout(self):

         self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
         self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
         self.sizer_2.Add(self.butafc, 0, 0, 0)
         self.sizer_2.Add(self.butexport, 0, 0, 0)
         self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
         self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
         self.sizer_2.Add(self.butafc, 0, 0, 0)
         self.sizer_2.Add(self.butexport, 0, 0, 0)

+        self.sizer_2.Add(self.butblender, 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_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
         self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 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_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) 
+        self.SetSizer(self.sizer_1)

 
     def onMouseMove(self, event):
         self.panel_1.SetFocus()
 
     def onMouseMove(self, event):
         self.panel_1.SetFocus()

+