translators
[iramuteq] / layout.py
1 #!/bin/env python
2 # -*- coding: utf-8 -*-
3 #Author: Pierre Ratinaud
4 #Copyright (c) 2008-2009 Pierre Ratinaud
5 #License: GNU/GPL
6
7 import os
8 import wx
9 import wx.lib.hyperlink as hl
10 import wx.lib.agw.aui as aui
11 import wx.lib.agw.labelbook as LB
12 from wx.lib.agw.fmresources import *
13 from chemins import ConstructPathOut, ChdTxtPathOut, FFF, ffr, PathOut, StatTxtPathOut, simipath
14 from ConfigParser import ConfigParser
15 from functions import ReadProfileAsDico, GetTxtProfile, read_list_file, ReadList, exec_rcode, print_liste, BugReport, DoConf, indices_simi, check_Rresult, progressbar, normpath_win32, TGen
16 from ProfList import ProfListctrlPanel
17 from guiparam3d import param3d, simi3d
18 from PrintRScript import write_afc_graph, print_simi3d, PrintSimiScript
19 from profile_segment import ProfileSegment
20 from functions import ReadList
21 from listlex import *
22 from Liste import *
23 from search_tools import SearchFrame
24 from dialog import PrefGraph, PrefExport, PrefSimpleFile, PrefDendro, SimpleDialog
25 from guifunct import SelectColumn, PrepSimi, PrefSimi
26 from webexport import WebExport
27 from corpus import Corpus
28 from sheet import MySheet
29 import datetime
30 import sys
31 import tempfile
32 from time import sleep
33 import shutil
34 import codecs
35 import logging
36
37 log = logging.getLogger('iramuteq.layout')
38
39
40 class GraphPanelAfc(wx.Panel):
41     def __init__(self, parent, dico, list_graph, clnb, itempath = 'liste_graph_afc', coding = sys.getdefaultencoding()):
42         wx.Panel.__init__(self,parent)
43         self.afcnb = 1
44         self.clnb = clnb
45         self.Dict = dico
46         self.coding = coding
47         self.itempath = itempath
48         self.parent = self.GetParent()#parent
49         self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
50         self.labels = []
51         self.listimg = []
52         self.buts = []
53         self.list_graph = list_graph
54         self.TabCHD = self.parent.GetParent()
55         self.nb = self.TabCHD.GetParent()
56         self.ira = self.nb.GetParent()
57         self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
58         afc_img = wx.Image(os.path.join(self.ira.images_path,'button_afc.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
59         self.butafc = wx.BitmapButton(self, -1, afc_img)
60         self.Bind(wx.EVT_BUTTON, self.afc_graph, self.butafc)
61         self.dirout = os.path.dirname(self.Dict['ira'])
62         b = 0
63         todel = []
64         for i in range(0,len(list_graph)):
65             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
66                 filename, ext = os.path.splitext(list_graph[i][0])
67                 if ext == '.svg' or ext == '.html':
68                     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])))
69                 else :
70                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
71                 if os.path.exists(os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')) :
72                     txt = _(u"List of not plotted points : ").decode('utf8') + '%s' % os.path.join(self.dirout,list_graph[i][0] + '_notplotted.csv')
73                 else :
74                     txt = ''
75                 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1] + txt))
76                 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = `i - b`))
77             else :
78                 todel.append(i)
79                 b += 1
80         self.list_graph = [graph for i, graph in enumerate(self.list_graph) if i not in todel]
81                 
82         self.param = { 'typegraph' : 0, 
83               'width' : 800,
84               'height' : 800,
85               'what' : 0,
86               'qui' : 0,
87               'do_select_nb' : 0,
88               'do_select_chi' : 0,
89               'do_select_chi_classe' : 0,
90               'select_nb' : 50,
91               'select_chi' : 4,
92               'nbchic' : 30,
93               'over' : 0, 
94               'cex_txt' : 0,
95               'txt_min' : 5,
96               'txt_max' : 40,
97               'tchi' : 0,
98               'tchi_min' : 5,
99               'tchi_max' : 40,
100               'taillecar' : 9,
101               'facteur' : [1,2,3],
102               'alpha' : 10,
103               'clnb' : clnb,
104               'svg' : 0,
105                }
106
107         self.__set_properties()
108         self.__do_layout()
109
110     def __set_properties(self):
111         self.panel_1.EnableScrolling(True,True)
112         #self.panel_1.SetSize((1000,1000))
113         self.panel_1.SetScrollRate(20, 20)
114         self.panel_1.SetFocus()
115
116     def __do_layout(self):    
117         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
118         self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
119         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
120         self.sizer_2.Add(self.butafc, 0, 0, 0)
121         for i in range(0, len(self.listimg)):
122             self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
123             self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
124             self.sizer_3.Add(self.buts[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
125             self.Bind(wx.EVT_BUTTON, self.on_delete_image, self.buts[i])
126         self.panel_1.SetSizer(self.sizer_3)
127         self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
128         self.SetSizer(self.sizer_2) 
129
130     def on_delete_image(self, event) :
131         image_id = int(event.GetEventObject().GetName())
132         image_path = self.list_graph[image_id][0]
133         message = _(u'This file will be delete : ') + '%s.\n' % os.path.join(self.dirout, image_path) + _('Are you sure ?')
134         dial = wx.MessageDialog(self, message, style = wx.YES_NO)
135         res = dial.ShowModal()
136         if res == wx.ID_YES :
137             dial.Destroy()
138             log.info('delete image %i' % image_id)
139             oldimg = self.listimg.pop(image_id)
140             oldimg.Destroy()
141             oldlab = self.labels.pop(image_id)
142             oldlab.Destroy()
143             oldbut = self.buts.pop(image_id)
144             oldbut.Show(False)
145             for i, but in enumerate(self.buts) :
146                 but.SetName(`i`)
147             todel = self.list_graph.pop(image_id)
148             os.remove(os.path.join(self.dirout, todel[0]))
149             print_liste(self.Dict[self.itempath], self.list_graph)
150             self.sizer_3.Fit(self.panel_1)
151             self.Layout()
152         else :
153             dial.Destroy()
154         
155
156     def afc_graph(self,event):
157         #dirout = os.path.dirname(self.Dict['ira'])
158         dial = PrefGraph(self.parent,-1,self.param,'')
159         dial.CenterOnParent()
160         val = dial.ShowModal()
161         if val == wx.ID_OK :
162             if dial.choix_format.GetSelection() == 0 :
163                 svg = 0
164             else :
165                 svg = 1
166             typegraph = dial.choicetype.GetSelection()
167             if svg :
168                 typefile = '.svg'
169             else :
170                 typefile = '.png'
171             if self.clnb <= 3 and typegraph == 1 :
172                 typegraph = 2
173             if typegraph == 2:
174                 typefile = '.gexf'
175             while os.path.exists(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile)):
176                 self.afcnb +=1
177             self.fileout = ffr(os.path.join(self.dirout,'graph_afc_'+str(self.afcnb)+typefile))
178
179             self.param = {'typegraph' : typegraph,
180                           'width' : dial.spin1.GetValue(),
181                           'height' : dial.spin2.GetValue(),
182                           'what' : dial.choice1.GetSelection(),
183                           'qui' : dial.choice2.GetSelection(),
184                           'do_select_nb' : dial.check1.GetValue(),
185                           'do_select_chi' : dial.check2.GetValue(),
186                           'do_select_chi_classe' : dial.check_chic.GetValue(),
187                           'select_nb' : dial.spin_nb.GetValue(),
188                           'select_chi' : dial.spin_chi.GetValue(),
189                           'nbchic' : dial.spin_nbchic.GetValue(),
190                           'over' : dial.check3.GetValue(), 
191                           'cex_txt' : dial.check4.GetValue(),
192                           'txt_min' : dial.spin_min.GetValue(),
193                           'txt_max' : dial.spin_max.GetValue(),
194                           'tchi' : dial.check_tchi.GetValue(),
195                           'tchi_min' : dial.spin_min_tchi.GetValue(),
196                           'tchi_max' : dial.spin_max_tchi.GetValue(),
197                           'taillecar' : dial.spin3.GetValue(),
198                           'facteur' : [dial.spin_f1.GetValue(),dial.spin_f2.GetValue(), dial.spin_f3.GetValue()],
199                           'clnb' : self.clnb,
200                           'film' : str(dial.film.GetValue()).upper(),
201                           'alpha' : dial.slider_sphere.GetValue(),
202                           'svg' : svg
203                         }
204             self.nb.parent = self.ira
205             self.DictPathOut = self.Dict
206             self.RscriptsPath = self.ira.RscriptsPath
207             txt = """
208             load("%s")
209             """ % ffr(self.DictPathOut['RData'])
210             if self.itempath == 'liste_graph_afcf' :
211                 txt += """
212                 afc <- afcf
213                 afc_table <- afcf_table
214                 chistabletot <- specfp
215                 """ 
216             elif self.itempath == 'liste_graph_afct' :
217                 txt +="""
218                 afc <- afct
219                 afc_table <- afct_table
220                 chistabletot <- spectp
221                 """
222             txt += write_afc_graph(self)
223             filetmp = tempfile.mktemp()
224             with open(filetmp, 'w') as f :
225                 f.write(txt)
226             pid = exec_rcode(self.ira.RPath, filetmp)
227             check_Rresult(self.ira, pid)
228             if self.param['typegraph'] in [0,2] :
229                 txt = 'Variables '
230                 if self.param['qui'] == 0 : value = u'actives'
231                 if self.param['qui'] == 1 : value = u'supplémentaires'
232                 if self.param['qui'] == 2 : value = u'étoilées'
233                 if self.param['qui'] == 3 : value = u'classes'
234                 txt += value + ' - '
235                 if self.param['what'] == 0 : value = u'Coordonnées'
236                 if self.param['what'] == 1 : value = u'Corrélations'
237                 txt += value + u' - facteur %i / %i' % (self.param['facteur'][0], self.param['facteur'][1])
238                 if self.param['do_select_nb'] : txt += u' - sélection de %i variables' % self.param['select_nb']
239                 if self.param['do_select_chi'] : txt += u' - sélection des variables avec chi2 > %i ' % self.param['select_chi']
240                 if self.param['over'] : txt += u' - Eviter les recouvrements'
241                 if self.param['cex_txt'] : txt += u' - taille du texte proportionnel à la masse'
242                 if self.param['tchi'] : txt += u' - taille du texte proportionnel au chi2 d\'association'
243                 #list_graph = read_list_file(self.DictPathOut[self.itempath], self.coding)
244                 if self.param['svg'] :
245                     filename, ext = os.path.splitext(self.fileout)
246                     self.fileout = filename + '.svg'
247                 if self.param['typegraph'] == 2 :
248                     parametres = {'gexffile' :  self.fileout,
249                                   'titre': 'Le titre',
250                                   'nodemin': self.param['txt_min'],
251                                   'nodemax': self.param['txt_max'],
252                                   'bargraphw' : 60*int(self.param['clnb']),
253                     }
254                     web = WebExport(self.ira, parametres)
255                     self.fileout = web.exportafc()              
256                 self.list_graph.append([os.path.basename(self.fileout), txt])
257                 print_liste(self.DictPathOut[self.itempath], self.list_graph)
258                 if self.param['svg'] or self.param['typegraph'] == 2:
259                     self.listimg.append(hl.HyperLinkCtrl(self.panel_1, -1, self.fileout, URL=self.fileout))
260
261                 else :
262                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(self.fileout, wx.BITMAP_TYPE_ANY)))
263                 self.sizer_3.Add( self.listimg[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
264                 self.labels.append(wx.StaticText(self.panel_1,-1, txt))
265                 self.sizer_3.Add(self.labels[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
266                 self.buts.append(wx.Button(self.panel_1, wx.ID_DELETE, name = `len(self.list_graph) - 1`))
267                 self.sizer_3.Add(self.buts[-1], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
268                 self.sizer_3.Fit(self.panel_1)
269                 self.Layout()
270     
271                 self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
272 #             elif self.param['typegraph'] == 2 :
273 #                 parametres = {'gexffile' :  self.fileout,
274 #                               'titre': 'Le titre',
275 #                               'nodemin': self.param['txt_min'],
276 #                               'nodemax': self.param['txt_max'],
277 #                               'bargraphw' : 60*int(self.param['clnb']),
278 #                 }
279 #                 web = WebExport(self.ira, parametres)
280 #                 afcout = web.exportafc()
281 #                 dial = SimpleDialog(self.ira) 
282 #                 dial.link.SetLabel(afcout)
283 #                 dial.link.SetURL(afcout)
284 #                 dial.Layout()
285 #                 dial.ShowModal()
286             
287
288 class GraphPanel(wx.ScrolledWindow):
289     def __init__(self, parent, dico, list_graph, txt = '', style = wx.TAB_TRAVERSAL):
290         wx.ScrolledWindow.__init__(self, parent, style = style)
291         self.Dict = dico
292         self.txt = txt
293         self.parent = parent
294         self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
295         self.labels = []
296         self.listimg = []
297         self.dirout = os.path.dirname(self.Dict['ira'])
298         self.deb = wx.StaticText(self, -1, txt)
299         for i in range(0,len(list_graph)):
300             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
301                 filename, ext = os.path.splitext(list_graph[i][0])
302                 if ext == '.svg' :
303                     self.listimg.append(hl.HyperLinkCtrl(self, -1, os.path.join(self.dirout,list_graph[i][0]), URL=os.path.join(self.dirout,list_graph[i][0])))
304                 else :
305                     self.listimg.append(wx.StaticBitmap(self, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
306                 self.labels.append(wx.StaticText(self, -1, list_graph[i][1]))
307         self.Bind(wx.EVT_MOTION, self.onMouseMove) 
308         self.__set_properties()
309         self.__do_layout()
310
311     def __set_properties(self):
312         self.EnableScrolling(True,True)
313         self.SetScrollRate(20, 20)   
314         self.SetFocus()
315
316
317     def __do_layout(self):
318         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
319         self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
320         self.sizer_3 = wx.BoxSizer(wx.HORIZONTAL)
321         self.sizer_1.Add(self.deb)   
322         for i in range(0, len(self.listimg)):
323             self.sizer_1.Add(self.listimg[i], 1, wx.ALIGN_CENTER_HORIZONTAL, 0)
324             self.sizer_1.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
325         self.sizer_2.Add(self.sizer_1, 1, wx.EXPAND, 0)
326         self.SetSizer(self.sizer_1)
327         self.sizer_1.Fit(self)
328
329     def onMouseMove(self, event):
330         self.SetFocus()
331        
332
333 def open_antiprofil(panel, AntiProfile, encoding) :
334     DictAnti = ReadProfileAsDico(AntiProfile, True, encoding)
335     panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
336     for i in range(0, panel.parametres['clnb']):
337         tabantiprofile = ProfListctrlPanel(panel, panel, DictAnti[str(i + 1)], True, i + 1)
338         panel.AntiProfNB.AddPage(tabantiprofile, 'classe %s' % str(i + 1))
339     panel.TabChdSim.AddPage(panel.AntiProfNB, _(u"Antiprofiles").decode('utf8'))
340
341
342
343 def getlemgram(corpus, lem) :
344     if not lem[6] in corpus.lems :
345         return lem[5]
346     else :
347         return corpus.lems[lem[6]].gram
348
349 class OpenCHDS():
350     def __init__(self, parent, corpus, parametres, Alceste=False):
351         #sep = u'\n ' 
352         sep=' '
353         self.parent = parent
354         self.corpus = corpus
355         self.parametres = parametres
356         self.pathout = PathOut(parametres['ira'])
357         self.pathout.basefiles(ChdTxtPathOut)
358         DictPathOut = self.pathout 
359         self.DictPathOut = DictPathOut
360         self.dictpathout = DictPathOut
361         self.parent = parent
362
363         Profile = DictPathOut['PROFILE_OUT']
364         AntiProfile = DictPathOut['ANTIPRO_OUT']
365         self.encoding = self.parametres['encoding']
366         if isinstance(self.corpus, Corpus) :
367             self.corpus.make_ucecl_from_R(self.pathout['uce'])
368             corpname = self.corpus.parametres['corpus_name']
369         else :
370             corpname = self.corpus.parametres['matrix_name']
371             if os.path.exists(self.pathout['analyse.db']) :
372                 self.corpus.read_tableau(self.pathout['analyse.db'])
373
374         clnb = parametres['clnb']
375         dlg = progressbar(self, maxi = 4 + clnb) 
376         self.clnb = clnb 
377         print 'lecture des profils'
378         dlg.Update(2, _(u"Reading profiles").decode('utf8'))
379   
380         DictProfile = ReadProfileAsDico(Profile, Alceste, self.encoding)
381         self.DictProfile = DictProfile
382         self.cluster_size = []
383         clusternames = {}
384         for i in range(0, clnb) :
385             clusternames[i] = ' '.join([u'%i' % (i + 1), _(u'Cluster').decode('utf8'),  u'%i' % (i + 1)])
386         if os.path.exists(self.pathout['classes_names.txt']) :
387             with codecs.open(self.pathout['classes_names.txt'], 'r', self.parent.syscoding) as f :
388                 clusternames_ = f.read()
389             clusternames_ =  dict([[i, ' '.join([`i + 1`, line])] for i, line in enumerate(clusternames_.splitlines())])
390             clusternames.update(clusternames_)
391         #print 'lecture des antiprofils'
392         #DictAnti = ReadProfileAsDico(self, AntiProfile, Alceste, self.encoding)
393
394         panel = wx.Panel(parent, -1)
395         sizer1 = wx.BoxSizer(wx.VERTICAL)
396
397         if os.path.exists(DictPathOut['pre_rapport']):
398             with codecs.open(DictPathOut['pre_rapport'], 'r', self.encoding) as f :
399                 txt = f.read()
400             self.debtext = txt
401         else :
402             self.debtext = ''
403 #       panel.chd_toolbar = wx.ToolBar(panel, -1, wx.DefaultPosition, wx.DefaultSize, wx.TB_FLAT | wx.TB_NODIVIDER)
404 #       panel.chd_toolbar.SetToolBitmapSize(wx.Size(16, 16))
405
406         if isinstance(self.corpus, Corpus) :
407             panel.corpus = self.corpus
408         else :
409             panel.tableau = self.corpus
410             #self.parent.tableau = panel.tableau
411         panel.dictpathout = self.DictPathOut
412         panel.pathout = self.DictPathOut
413         panel.parent = self.parent
414         panel.DictProfile = self.DictProfile
415         panel.cluster_size = self.cluster_size
416         panel.debtext = self.debtext
417
418 #       self.ID_rapport = wx.NewId()
419 #       #rap_img = wx.Image(os.path.join(self.parent.images_path,'icone_rap_16.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
420 #       #panel.chd_toolbar.AddLabelTool(self.ID_rapport, "rapport", rap_img, shortHelp=u"Produire le rapport", longHelp=u"Exporter un rapport en texte simple")
421 #       butrap = wx.Button(panel.chd_toolbar, self.ID_rapport, u"Rapport ")
422 #       panel.chd_toolbar.AddControl(butrap)
423 #       
424 #       panel.chd_toolbar.Realize()
425 #       sizer1.Add(panel.chd_toolbar,0, wx.EXPAND, 5)
426
427         #self.TabChdSim = wx.aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
428         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
429         panel.TabChdSim = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
430         #panel.TabChdSim = LB.LabelBook(panel, -1, agwStyle = INB_TOP|INB_SHOW_ONLY_TEXT|INB_FIT_LABELTEXT)
431         panel.TabChdSim.SetAGWWindowStyleFlag(notebook_flags)
432         panel.TabChdSim.SetArtProvider(aui.ChromeTabArt())
433         sizer1.Add(panel.TabChdSim,10, wx.EXPAND, 5)
434         panel.SetSizer(sizer1)
435         sizer1.Fit(panel)
436        
437
438         if isinstance(self.corpus, Corpus) :
439             panel.TabChdSim.corpus = corpus
440             panel.TabChdSim.corpus.dictpathout = self.DictPathOut
441         else :
442             panel.TabChdSim.tableau = corpus
443             panel.TabChdSim.tableau.dictpathout = self.DictPathOut
444         panel.parametres = self.parametres
445         self.panel = panel
446
447         self.notenb = self.parent.nb.GetPageCount()
448
449            
450         if os.path.exists(self.DictPathOut['liste_graph_chd']) :
451             list_graph = read_list_file(self.DictPathOut['liste_graph_chd'], self.encoding)
452             CHD = GraphPanelDendro(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
453             panel.TabChdSim.AddPage(CHD,'CHD')
454                
455         panel.ProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
456         notebook_flags |= aui.AUI_NB_WINDOWLIST_BUTTON
457         panel.ProfNB.SetAGWWindowStyleFlag(notebook_flags)
458         #panel.ProfNB.SetArtProvider(aui.ChromeTabArt())
459         #panel.ProfNB = LB.LabelBook(panel, -1, agwStyle = INB_LEFT|INB_SHOW_ONLY_TEXT|INB_FIT_LABELTEXT)
460         #panel.ProfNB = wx.Listbook(self.parent, -1, style = wx.BK_DEFAULT)
461         #panel.ProfNB = wx.Treebook(self.parent, -1, style = wx.BK_DEFAULT)
462         #self.ProfNB.SetTabCtrlHeight(100)
463         #panel.AntiProfNB = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
464         if os.path.exists(DictPathOut['prof_seg']) :
465             prof_seg = ReadProfileAsDico(DictPathOut['prof_seg'], False, self.encoding)
466             self.prof_seg_nb = aui.AuiNotebook(panel, -1, wx.DefaultPosition)
467         for i in range(0, clnb):
468             self.cluster_size.append(DictProfile[str(i + 1)][0][0:3])
469             if isinstance(self.corpus, Corpus) :
470                 DictProfile[str(i + 1)][1:] = [val[0:5] + [getlemgram(self.corpus, val)] + val[6:] for val in DictProfile[str(i + 1)][1:]]
471             dlg.Update(3+i, 'Classe %i' %(i+1))
472             ind = '/'.join(DictProfile[str(i + 1)][0][0:2]).strip()
473             indpour = '\n'.join([ind, DictProfile[str(i + 1)][0][2]])
474             self.tabprofile = ProfListctrlPanel(self.parent, self.panel, DictProfile[str(i + 1)], Alceste, i + 1)
475             #self.tabantiprofile = ProfListctrlPanel(self.parent, self, DictAnti[str(i + 1)], Alceste, i + 1)
476             panel.ProfNB.AddPage(self.tabprofile, clusternames[i] + '\n%s%%' % indpour, True)
477             panel.ProfNB.SetPageTextColour(i, '#890909')
478             panel.ProfNB.SetRenamable(i, True)
479             #panel.AntiProfNB.AddPage(self.tabantiprofile, 'classe %s' % str(i + 1))
480             if os.path.exists(DictPathOut['prof_seg']) :
481                 self.tab_prof_seg = ProfListctrlPanel(self.parent, self, prof_seg[str(i + 1)], False, i + 1)
482                 self.prof_seg_nb.AddPage(self.tab_prof_seg, _(u"Cluster").decode('utf8') + ' %i' % (i + 1))
483         panel.ProfNB.SetSelection(0)
484
485         if clnb > 2 :
486             self.TabAFC = aui.AuiNotebook(panel.TabChdSim, -1, wx.DefaultPosition)
487             log.info('read AFC') 
488             list_graph=read_list_file(DictPathOut['liste_graph_afc'], self.encoding)
489             self.tabAFCGraph = GraphPanelAfc(self.TabAFC, DictPathOut, list_graph, self.clnb, coding=self.encoding)
490             self.TabAFC.AddPage(self.tabAFCGraph, _(u"CA").decode('utf8'))
491             
492             if os.path.exists(self.DictPathOut['afc_facteur']) :
493                 dictrow, first = ReadList(self.DictPathOut['afc_facteur'], self.encoding)
494                 self.TabAFC_facteur = ListForSpec(self.parent, parametres, dictrow, first[1:])
495                 #dictrow, first = ReadList(self.DictPathOut['afc_row'], self.encoding)
496                 #self.TabAFC_ligne = ListForSpec(self.parent, self.parametres, dictrow, first)
497                 #dictrow, first = ReadList(self.DictPathOut['afc_col'], self.encoding)
498                 #self.TabAFC_colonne = ListForSpec(parent, self.parametres, dictrow, first)
499                 self.TabAFC.AddPage(self.TabAFC_facteur, _(u"Factor").decode('utf8'))
500                 #self.TabAFC.AddPage(self.TabAFC_colonne, u'Colonnes')
501                 #self.TabAFC.AddPage(self.TabAFC_ligne, u'Lignes')
502             
503             sizer_3 = wx.BoxSizer(wx.VERTICAL)
504             self.parent.nb_panel_2 = wx.Panel(panel.TabChdSim, -1)
505             self.parent.button_simi = wx.Button(self.parent.nb_panel_2, -1, "Voyager")
506             self.parent.simi3dpanel = simi3d(self.parent.nb_panel_2, -1)
507             sizer_3.Add(self.parent.simi3dpanel, 1, wx.EXPAND, 0)
508             sizer_3.Add(self.parent.button_simi, 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
509             self.parent.nb_panel_2.SetSizer(sizer_3)
510             self.TabAFC.AddPage(self.parent.nb_panel_2, _(u"3D graph").decode('utf8'))
511             self.parent.Bind(wx.EVT_BUTTON, self.onsimi, self.parent.button_simi)
512               
513         panel.TabChdSim.AddPage(panel.ProfNB, _(u"Profiles").decode('utf8'))
514         #panel.TabChdSim.AddPage(panel.AntiProfNB, 'Antiprofils')
515         dlg.Update(4 + self.clnb, 'Affichage...')
516         if clnb > 2 :
517             panel.TabChdSim.AddPage(self.TabAFC, _(u"CA").decode('utf8'))
518         if os.path.exists(DictPathOut['prof_seg']) :
519             panel.TabChdSim.AddPage(self.prof_seg_nb, _(u"Repeated segments profiles").decode('utf8'))
520   
521 #       panel.Bind(wx.EVT_BUTTON, self.ongetrapport, id = self.ID_rapport)
522         if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenchi2.csv')) :
523             self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenchi2.csv')
524             TgenLayout(panel)
525         panel.TabChdSim.SetSelection(0)
526         self.parent.nb.AddPage(panel, _(u"Clustering").decode('utf8') + ' - %s' % corpname)
527         self.parent.ShowTab(True)
528         self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)     
529         #for pane in self.parent._mgr.GetAllPanes() :
530         #     if isinstance(pane.window, aui.AuiNotebook):
531         #         nb = pane.window
532         #         nb.SetAGWWindowStyleFlag(notebook_flags)
533         #         nb.SetArtProvider(aui.ChromeTabArt())
534         dlg.Destroy() 
535         self.parent._mgr.Update()
536         
537     def onsimi(self,event):
538         outfile = print_simi3d(self)
539         error = exec_rcode(self.parent.RPath, outfile, wait = True)
540
541     def onclusterstat(self, evt) :
542         dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.csv', 'title': 'Stat par classe'})
543         dial.fbb.SetValue( os.path.join(os.path.dirname(self.corpus.dictpathout['ira']), 'stat_par_classe.csv'))
544         dial.CenterOnParent()
545         res = dial.ShowModal()
546         if res == wx.ID_OK :
547             fileout = dial.fbb.GetValue()
548             dial.Destroy()
549             self.corpus.get_stat_by_cluster(fileout)
550             msg = u"Fini !"
551             dlg = wx.MessageDialog(self.parent, msg, _(u"Stat by cluster").decode('utf8'), wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
552             dlg.CenterOnParent()
553             if dlg.ShowModal() == wx.ID_OK :
554                 dlg.Destroy()
555
556     #def onsearchf(self, evt) :
557     #    if 'FrameSearch' not in dir(self.panel) :
558     #        self.panel.FrameSearch = SearchFrame(self.parent, -1, u"Rechercher...", self.corpus)
559     #    self.panel.FrameSearch.Show()
560
561 def PrintRapport(self, corpus, parametres, istxt = True):
562     sep = '\n'
563     txt = """
564 +-+-+-+-+-+-+-+-+
565 |i|R|a|M|u|T|e|Q| - %s
566 +-+-+-+-+-+-+-+-+
567
568
569 """ % datetime.datetime.now().ctime()
570     if istxt :
571         totocc = corpus.gettotocc()
572         txt += ': '.join([_(u'Number of texts').decode('utf8'),  u'%i%s' % (corpus.getucinb(), sep)])
573         txt += ': '.join([_(u'Number of text segments').decode('utf8'),  '%i%s' % (corpus.getucenb(), sep)])
574         txt += ': '.join([_(u'Number of forms').decode('utf8'), '%i%s' % (len(corpus.formes), sep)])
575         txt += ': '.join([_(u'Number of occurrences').decode('utf8'), '%i%s' % (totocc, sep)])
576         #txt += u'moyenne d\'occurrences par forme: %f%s' % (float(totocc) / float(len(self.corpus.formes)), sep)
577         txt += ': '.join([_(u'Number of lemmas').decode('utf8'), '%i%s' % (len(corpus.lems), sep)])
578         txt += ': '.join([_(u'Number of active forms').decode('utf8'), '%i%s' % (corpus.getactivesnb(1), sep)])
579         txt += ': '.join([_(u'Number of supplementary forms').decode('utf8'), '%i%s' % (corpus.getactivesnb(2), sep)])
580         txt += ' >= '.join([_(u'Number of active forms with a frequency').decode('utf8'), '%i: %i%s' % (parametres['eff_min_forme'], parametres['nbactives'], sep)])
581         txt += ': '.join([_(u'Mean of forms by segment').decode('utf8'), '%f%s' % (float(totocc) / float(corpus.getucenb()), sep)])
582         if 'tailleuc1' in parametres :
583             if parametres['classif_mode'] == 0 :
584                 txt += ': '.join([_(u'Size of rst1 / rst2').decode('utf8'), '%i / %i - %i / %i%s' % (parametres['tailleuc1'], parametres['tailleuc2'], parametres['lenuc1'], parametres['lenuc2'], sep)])
585     else :
586         self.Ucenb = self.nbind
587         txt += ': '.join([_(u'Number of lines').decode('utf8'), '%i%s' % (self.nbind, sep)])
588         txt += ': '.join([_(u'Number of clusters').decode('utf8'), '%i%s' % (self.clnb, sep)])
589     if istxt :
590         txt += ': '.join([_(u'Number of clusters').decode('utf8'), '%i%s' % (parametres['clnb'], sep)])
591         if parametres['classif_mode'] == 0 or parametres['classif_mode'] == 1 :
592             txt += ' '.join(['%i' % sum([len(cl) for cl in corpus.lc]), _(u'segments classified on').decode('utf8'), '%i (%.2f%%)%s' % (corpus.getucenb(), (float(sum([len(cl) for cl in corpus.lc])) / float(corpus.getucenb())) * 100, sep)])
593         elif self.parametres['classif_mode'] == 2 :
594             txt += ' '.join([u'%i' % sum([len(cl) for cl in corpus.lc]), _(u'texts classified on').decode('utf8'), '%i (%.2f%%)%s' % (corpus.getucinb(), (float(sum([len(cl) for cl in corpus.lc]))) / float(corpus.getucinb()) * 100, sep)])
595     else :
596         txt += ' '.join(['%i' % self.ucecla, _(u'line classified on').decode('utf8'), '%i (%.2f%%)%s' % (self.Ucenb, (float(self.ucecla) / float(self.Ucenb)) * 100, sep)])
597  
598     txt += ''.join([sep, u'###########################', sep, _(u'time').decode('utf8'), ' : %s' % parametres.get('time', ''), sep, u'###########################', sep])
599
600     with open(self.pathout['pre_rapport'], 'w') as f :
601         f.write(txt)
602
603
604 class SashList(wx.Panel) :
605     def __init__(self, parent) :
606         wx.Panel.__init__(self, parent, -1)
607         self.parent=parent
608         winids = []
609         #self.gparent=gparent
610         #self.dlist=dlist
611         #self.first = first
612         #self.menu = menu        
613         # A window to the left of the client window
614         #self.listlex = listlex
615         self.leftwin1 =  wx.SashLayoutWindow(
616                 self, -1, wx.DefaultPosition, (200, 300), 
617                 wx.NO_BORDER|wx.SW_3D
618                 )
619
620         self.leftwin1.SetDefaultSize((120, 1000))
621         self.leftwin1.SetOrientation(wx.LAYOUT_VERTICAL)
622         self.leftwin1.SetAlignment(wx.LAYOUT_LEFT)
623         self.leftwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
624         self.leftwin1.SetSashVisible(wx.SASH_RIGHT, True)
625         self.leftwin1.SetExtraBorderSize(10)
626         
627         #textWindow = wx.TextCtrl(
628         #                leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize, 
629         #                wx.TE_MULTILINE|wx.SUNKEN_BORDER
630         #                )
631
632         #textWindow.SetValue("A sub window")
633
634         self.leftWindow1 = self.leftwin1
635         winids.append(self.leftwin1.GetId())
636         
637         rightwin1 =  wx.SashLayoutWindow(
638                 self, -1, wx.DefaultPosition, (200, 300), 
639                 wx.NO_BORDER|wx.SW_3D
640                 )
641
642         rightwin1.SetDefaultSize((120, 1000))
643         rightwin1.SetOrientation(wx.LAYOUT_VERTICAL)
644         rightwin1.SetAlignment(wx.LAYOUT_LEFT)
645         rightwin1.SetBackgroundColour(wx.Colour(0, 255, 0))
646         rightwin1.SetSashVisible(wx.SASH_RIGHT, True)
647         rightwin1.SetExtraBorderSize(10)
648         #textWindow = wx.TextCtrl(
649         #                leftwin1, -1, "", wx.DefaultPosition, wx.DefaultSize, 
650         #                wx.TE_MULTILINE|wx.SUNKEN_BORDER
651         #                )
652
653         #textWindow.SetValue("A sub window")
654
655         self.rightwin1 = rightwin1
656         winids.append(rightwin1.GetId())
657
658 class TgenLayout :
659     def __init__(self, page):
660         self.page = page
661         parametres = self.page.parametres
662         ira = wx.GetApp().GetTopWindow()
663         tgenpath = os.path.join(parametres['pathout'], 'tgen.csv')
664         self.page.tgens, etoiles =  ReadList(parametres['tgenspec'], ira.syscoding, sep="\t")
665         tgen = TGen(path = tgenpath, encoding = parametres['encoding'])
666         tgen.read()
667         tgentab = False
668         gparent = None
669         if 'TabChdSim' in dir(page) :
670             page = page.TabChdSim
671         for i in range(page.GetPageCount()) :
672             tab = page.GetPage(i)
673             if 'gparent' in dir(tab) :
674                 if tab.gparent is not None :
675                     gparent = tab.gparent
676             if 'tgen' in dir(tab) :
677                 if tab.tgen :
678                     tgentab = tab
679                     break
680                 
681         if tgentab :
682             self.page.tgentab.RefreshData(self.page.tgens)
683             self.page.tgentab.tgens = tgen.tgen
684             page.SetSelection(i)
685         else :
686             self.page.tgentab = ListForSpec(ira, gparent, self.page.tgens, etoiles[1:])
687             self.page.tgentab.tgen = True
688             self.page.tgentab.tgens = tgen.tgen
689             page.AddPage(self.page.tgentab, _(u'Tgens Specificities').decode('utf8'))
690             page.SetSelection(page.GetPageCount() - 1)
691
692 class dolexlayout :
693     def __init__(self, ira, corpus, parametres):
694         self.pathout = PathOut(dirout = parametres['pathout'])
695         self.corpus = corpus
696         self.dictpathout = StatTxtPathOut(parametres['pathout'])
697         #self.corpus.read_corpus_from_shelves(self.corpus.dictpathout['db'])
698         self.parent = ira
699         self.encoding = self.corpus.parametres['syscoding']
700         self.parametres = parametres
701
702         self.DictSpec, first = ReadList(self.dictpathout['tablespecf'], self.corpus.parametres['syscoding'])
703         if os.path.exists(self.pathout['banalites.csv']) :
704             self.dictban, firstban = ReadList(self.pathout['banalites.csv'], self.corpus.parametres['syscoding'])
705         self.DictType, firstt = ReadList(self.dictpathout['tablespect'], self.corpus.parametres['syscoding'])
706         self.DictEff, firsteff = ReadList(self.dictpathout['tableafcm'], self.corpus.parametres['syscoding'])
707         self.DictEffType, firstefft = ReadList(self.dictpathout['tabletypem'], self.corpus.parametres['syscoding'])
708         self.DictEffRelForme, firsteffrelf = ReadList(self.dictpathout['eff_relatif_forme'], self.corpus.parametres['syscoding']) 
709         self.DictEffRelType, firsteffrelt = ReadList(self.dictpathout['eff_relatif_type'], self.corpus.parametres['syscoding'])    
710         self.etoiles = firsteff[1:]
711         #sash = SashList(ira.nb)
712         
713         
714         self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
715         self.TabStat.parametres = parametres
716         self.ListPan = ListForSpec(ira, self, self.DictSpec, self.etoiles)
717         if os.path.exists(self.pathout['banalites.csv']) :
718             self.listban = ListForSpec(ira, self, self.dictban, ['eff'] + self.etoiles, usefirst = True)
719         #self.ListPan2 = ListForSpec(sash.rightwin1, self, self.DictSpec, first)
720         self.ListPant = ListForSpec(ira, self, self.DictType, self.etoiles)
721         self.ListPanEff = ListForSpec(ira, self, self.DictEff, self.etoiles)
722         self.ListPanEffType = ListForSpec(ira, self, self.DictEffType, self.etoiles)
723         self.ListPanEffRelForme = ListForSpec(ira, self, self.DictEffRelForme, self.etoiles)
724         self.ListPanEffRelType = ListForSpec(ira, self, self.DictEffRelType, self.etoiles)
725         
726         self.TabStat.AddPage(self.ListPan, _(u'Forms').decode('utf8')) 
727         if os.path.exists(self.pathout['banalites.csv']) :
728             self.TabStat.AddPage(self.listban, _(u'Banal forms').decode('utf8'))
729         self.TabStat.AddPage(self.ListPant, _(u'POS').decode('utf8'))
730         self.TabStat.AddPage(self.ListPanEff, _(u'Forms frequencies').decode('utf8'))
731         self.TabStat.AddPage(self.ListPanEffType, _(u'POS frequencies').decode('utf8'))
732         self.TabStat.AddPage(self.ListPanEffRelForme, _(u'Forms relative frequencies').decode('utf8'))
733         self.TabStat.AddPage(self.ListPanEffRelType, _(u'POS relative frequencies').decode('utf8'))
734         if self.parametres['clnb'] > 2 :
735             self.TabAFC = aui.AuiNotebook(self.TabStat, -1, wx.DefaultPosition)
736             list_graph=read_list_file(self.dictpathout['liste_graph_afcf'], encoding = self.encoding)
737             self.tabAFCGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afcf', coding = self.encoding)
738             self.TabAFC.AddPage(self.tabAFCGraph, _(u'CA forms').decode('utf8'))
739             list_graph=read_list_file(self.dictpathout['liste_graph_afct'], encoding = self.encoding)
740             self.tabAFCTGraph = GraphPanelAfc(self.TabAFC, self.dictpathout, list_graph, self.parametres['clnb'], itempath ='liste_graph_afct', coding=self.encoding)
741             self.TabAFC.AddPage(self.tabAFCTGraph, _(u'CA POS').decode('utf8'))
742             self.TabStat.AddPage(self.TabAFC, _(u'CA').decode('utf8'))
743         
744         ira.nb.AddPage(self.TabStat, ' - '.join([_(u'Specificities').decode('utf8'), self.parametres['name']]))
745         self.ira = ira
746         
747         self.TabStat.corpus = self.corpus
748         self.TabStat.etoiles = self.etoiles
749         if os.path.exists(os.path.join(self.parametres['pathout'], 'tgenspec.csv')) :
750             self.parametres['tgenspec'] = os.path.join(self.parametres['pathout'], 'tgenspec.csv')
751             TgenLayout(self.TabStat)
752         self.TabStat.SetSelection(0)
753         ira.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
754         ira.ShowAPane("Tab_content")
755
756 class StatLayout:
757     def __init__(self, ira, corpus, parametres):
758         self.pathout = PathOut(dirout = parametres['pathout'])
759         self.corpus = corpus
760         self.ira = ira
761         self.read_result()
762         self.TabStat = aui.AuiNotebook(ira.nb, -1, wx.DefaultPosition)
763         self.TabStat.parametres = parametres
764         self.TabStat.corpus = corpus
765         self.TabStat.pathout = self.pathout
766 #        CHD = GraphPanel(panel.TabChdSim, DictPathOut, list_graph, txt = self.debtext)
767         #      panel.TabChdSim.AddPage(CHD,'CHD')
768
769         #self.TabStatTot = wx.TextCtrl(self.TabStat, -1, style=wx.NO_BORDER | wx.TE_MULTILINE | wx.TE_RICH2)
770         list_graph = [['zipf.png', 'zipf']]
771         self.TabStatTot = GraphPanel(ira.nb, self.pathout, list_graph, self.result['glob'])
772         self.TabStat.AddPage(self.TabStatTot, _(u'Abstract').decode('utf8'))
773         
774         dictlabel = {'total' : _(u'Total').decode('utf8'),
775                      u'formes_actives' : _(u'Actives forms').decode('utf8'),
776                      u'formes_supplémentaires': _(u'Supplementary forms').decode('utf8'),
777                      u'hapax' : _(u'Hapax').decode('utf8'),
778                      }
779         
780         for item in self.result:
781             if item != 'glob':
782                 datam = [['forme', 'nb']]
783                 self.ListPan = ListPanel(ira, self, self.result[item])
784                 self.TabStat.AddPage(self.ListPan, dictlabel[item]) 
785         ira.nb.AddPage(self.TabStat, '%s' % parametres['name'])
786         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
787         ira.ShowAPane("Tab_content")
788
789     def read_result(self) :
790         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'}
791         self.result = {}
792         for key in lcle :
793             with open(self.pathout[lcle[key]], 'r') as f :
794                 self.result[key] = [line.split(';') for line in f.read().splitlines()]
795                 self.result[key] = dict([[i,[line[0],int(line[1]), line[2]]] for i, line in enumerate(self.result[key])])
796         with open(self.pathout['glob.txt'], 'r') as f :
797             self.result['glob'] = f.read()
798
799 class GraphPanelDendro(wx.Panel):
800     def __init__(self,parent, dico, list_graph, txt=False):
801         wx.Panel.__init__(self,parent)
802         self.graphnb = 1
803         self.dictpathout = dico
804         self.dirout = os.path.dirname(self.dictpathout['ira'])
805         self.list_graph = list_graph
806         self.parent = self.GetParent()#parent
807         self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "Arial"))
808         self.labels = []
809         self.listimg = []
810         self.tabchd = self.parent.GetParent()
811         self.ira = self.tabchd.GetParent()
812         self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
813         self.panel_1.SetBackgroundColour('white')
814         self.deb = wx.StaticText(self.panel_1, -1, txt)
815         dendro_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
816         dendro_liste_img = wx.Image(os.path.join(self.ira.images_path,'but_dendro_liste.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
817         dendro_cloud_img= wx.Image(os.path.join(self.ira.images_path,'but_dendro_cloud.png'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
818         self.butdendro = wx.BitmapButton(self, -1, dendro_img)
819         self.butdendrotexte = wx.BitmapButton(self, -1, dendro_liste_img)
820         self.butdendrocloud = wx.BitmapButton(self, -1, dendro_cloud_img)
821         
822         for i in range(0,len(list_graph)):
823             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
824                 filename, ext = os.path.splitext(list_graph[i][0])
825                 if ext == '.svg' :
826                     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])))
827                 else :
828                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
829                 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
830                 
831         self.__set_properties()
832         self.__do_layout()
833
834     def __set_properties(self):
835         self.panel_1.EnableScrolling(True,True)
836         #self.panel_1.SetSize((1000,1000))
837         self.panel_1.SetScrollRate(20, 20)
838         self.panel_1.SetFocus()
839         self.Bind(wx.EVT_BUTTON, self.ondendro, self.butdendro)
840         self.Bind(wx.EVT_BUTTON, self.ondendrotexte, self.butdendrotexte)
841         self.Bind(wx.EVT_BUTTON, self.ondendrocloud, self.butdendrocloud)
842         self.param = {'width' : 700,
843                        'height': 500,
844                        'type_dendro': 0,
845                        'color_nb': 0,
846                        'taille_classe' : True,
847                        'type_tclasse' : 0,
848                        'svg' : 0
849                      }
850         self.type_dendro = [ u"phylogram", u"cladogram", u"fan", u"unrooted", u"radial" ]
851
852     def __do_layout(self):    
853         self.sizer_1 = wx.BoxSizer(wx.VERTICAL)
854         self.sizer_2 = wx.BoxSizer(wx.HORIZONTAL)
855         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
856         self.sizer_3.Add(self.deb)
857         self.sizer_1.Add(self.butdendro, 0, 0, 0)
858         self.sizer_1.Add(self.butdendrotexte, 0, 0, 0)
859         self.sizer_1.Add(self.butdendrocloud, 0, 0, 0)
860
861         for i in range(0, len(self.listimg)):
862             self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
863             self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
864         self.panel_1.SetSizer(self.sizer_3)
865         self.sizer_2.Add(self.sizer_1, 0, wx.EXPAND, 0)
866         self.sizer_2.Add(self.panel_1, 1, wx.EXPAND, 0)
867         self.SetSizer(self.sizer_2) 
868
869     def make_param(self, dial):
870         self.param['width'] = dial.m_spinCtrl2.GetValue()
871         self.param['height'] = dial.m_spinCtrl1.GetValue()
872         self.param['type_dendro'] = dial.m_choice1.GetSelection()
873         self.param['color_nb'] = dial.m_radioBox1.GetSelection()
874         self.param['taille_classe'] = dial.m_checkBox1.GetValue()
875         self.param['type_tclasse'] = dial.m_radioBox2.GetSelection()
876         self.param['svg'] = dial.choice_format.GetSelection()
877
878     def make_dendro(self, dendro = 'simple') :
879         if self.param['svg'] :
880             typefile = '.svg'
881         else :
882             typefile = '.png'
883         while os.path.exists(os.path.join(self.dirout, 'dendrogramme_' + str(self.graphnb)+typefile)) :
884             self.graphnb += 1
885         fileout = ffr(os.path.join(self.dirout,'dendrogramme_' + str(self.graphnb)+typefile))
886         width = self.param['width']
887         height = self.param['height']
888         type_dendro = self.type_dendro[self.param['type_dendro']]
889         if self.param['taille_classe'] :
890             tclasse = 'TRUE'
891         else :
892             tclasse = 'FALSE'
893         if self.param['color_nb'] == 0 :
894             bw = 'FALSE'
895         else :
896             bw = 'TRUE'
897         if self.param['type_tclasse'] == 0 :
898             histo='FALSE'
899         else :
900             histo = 'TRUE'
901         if self.param['svg'] :
902             svg = 'TRUE'
903         else :
904             svg = 'FALSE'
905         dendro_path = self.dictpathout['Rdendro']
906         classe_path = self.dictpathout['uce']
907         txt = """
908         library(ape)
909         load("%s")
910         source("%s")
911         classes <- read.csv2("%s", row.names=1)
912         classes <- classes[,1]
913         """ % (ffr(dendro_path), ffr(self.ira.RscriptsPath['Rgraph']),  ffr(classe_path))
914         if dendro == 'simple' :
915             txt += """
916             open_file_graph("%s", width=%i, height=%i)
917             plot.dendropr(tree.cut1$tree.cl, classes, type.dendro="%s", histo=%s, bw=%s, lab=NULL, tclasse=%s)
918             """ % (ffr(fileout), width, height, type_dendro, histo, bw, tclasse)
919         elif dendro == 'texte' :
920             txt += """
921             load("%s")
922             source("%s")
923             if (is.null(debsup)) {
924                 debsup <- debet
925             }
926             chistable <- chistabletot[1:(debsup-1),]
927             open_file_graph("%s", width=%i, height=%i, svg = %s)
928             plot.dendro.prof(tree.cut1$tree.cl, classes, chistable, nbbycl = 60, type.dendro="%s", bw=%s, lab=NULL)
929             """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, svg, type_dendro, bw)
930         elif dendro == 'cloud' :
931             txt += """
932             load("%s")
933             source("%s")
934             if (is.null(debsup)) {
935                 debsup <- debet
936             }
937             chistable <- chistabletot[1:(debsup-1),]
938             open_file_graph("%s", width=%i, height=%i, svg=%s)
939             plot.dendro.cloud(tree.cut1$tree.cl, classes, chistable, nbbycl = 300, type.dendro="%s", bw=%s, lab=NULL)
940             """ % (ffr(self.dictpathout['RData.RData']), ffr(self.ira.RscriptsPath['Rgraph']), ffr(fileout), width, height, svg, type_dendro, bw)
941
942
943         tmpfile = tempfile.mktemp()
944         with open(tmpfile, 'w') as f :
945             f.write(txt)
946         busy = wx.BusyInfo(_("Please wait...").decode('utf8'), self.parent)
947         wx.SafeYield()
948         error = exec_rcode(self.ira.RPath, tmpfile, wait=True) 
949         del busy
950         check_Rresult(self.ira, error)
951         self.list_graph.append([fileout, 'Dendrogramme CHD1 - %s' %  type_dendro])
952         print_liste(self.dictpathout['liste_graph_chd'], self.list_graph)
953         if self.param['svg'] :
954             self.sizer_3.Add(hl.HyperLinkCtrl(self.panel_1, -1, fileout, URL=fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
955         else :
956             self.sizer_3.Add(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(fileout, wx.BITMAP_TYPE_ANY)), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
957         self.sizer_3.Add(wx.StaticText(self.panel_1,-1, 'Dendrogramme CHD1 - %s' %  type_dendro), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
958         self.sizer_3.Fit(self.panel_1)
959         self.Layout()
960         self.panel_1.Scroll(0,self.panel_1.GetScrollRange(wx.VERTICAL))
961
962
963     def ondendro(self, evt):
964         dial = PrefDendro(self.ira, self.param)
965         val = dial.ShowModal()
966         if val == wx.ID_OK :
967             self.make_param(dial)
968             self.make_dendro()
969     
970     def ondendrotexte(self, evt):
971         dial = PrefDendro(self.ira, self.param)
972         val = dial.ShowModal()
973         if val == wx.ID_OK :
974             self.make_param(dial)
975             self.make_dendro(dendro = 'texte')
976
977     def ondendrocloud(self, evt):
978         dial = PrefDendro(self.ira, self.param)
979         val = dial.ShowModal()
980         if val == wx.ID_OK :
981             self.make_param(dial)
982             self.make_dendro(dendro = 'cloud')
983
984 class OpenCorpus :
985     def __init__(self, ira, parametres) :
986         #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)
987         self.panel = CopusPanel(ira, parametres)
988         ira.nb.AddPage(self.panel, 'Description %s' % parametres['corpus_name'])
989         #self.text.write(DoConf().totext(parametres))
990         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
991         ira.ShowAPane("Tab_content")
992
993 class MatLayout :
994     def __init__(self, ira, matrix):
995         #self.parent.content = self.csvtable
996         self.sheet = MySheet(ira.nb)
997         ira.nb.AddPage(self.sheet, matrix.parametres['matrix_name'])
998         self.sheet.Populate(matrix.csvtable)
999         self.sheet.parametres = matrix.parametres
1000         ira.nb.SetSelection(ira.nb.GetPageCount() - 1)
1001         ira.ShowAPane("Tab_content")
1002
1003 class CopusPanel(wx.Panel) :
1004     def __init__(self, parent, parametres) :
1005         wx.Panel.__init__ ( self, parent, id = wx.ID_ANY, pos = wx.DefaultPosition, size = wx.Size( 500,300 ), style = wx.TAB_TRAVERSAL )
1006         self.parametres = parametres
1007         fgSizer5 = wx.FlexGridSizer( 0, 2, 0, 0 )
1008         fgSizer5.SetFlexibleDirection( wx.BOTH )
1009         fgSizer5.SetNonFlexibleGrowMode( wx.FLEX_GROWMODE_SPECIFIED )        
1010         self.fgSizer5 = fgSizer5
1011         
1012         self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, _(u"Description of corpus").decode('utf8'), wx.DefaultPosition, wx.DefaultSize, 0 )
1013
1014         self.m_staticText18.Wrap( -1 )
1015         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1016         
1017         self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1018         self.m_staticText19.Wrap( -1 )
1019         fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1020
1021         self.m_staticText20 = wx.StaticText( self, wx.ID_ANY, u"Nom", wx.DefaultPosition, wx.DefaultSize, 0 )
1022         self.m_staticText20.Wrap( -1 )
1023         fgSizer5.Add( self.m_staticText20, 0, wx.ALL, 5 )
1024         
1025         self.m_staticText21 = wx.StaticText( self, wx.ID_ANY, parametres['corpus_name'], wx.DefaultPosition, wx.DefaultSize, 0 )
1026         self.m_staticText21.Wrap( -1 )
1027         fgSizer5.Add( self.m_staticText21, 0, wx.ALL, 5 )
1028
1029         description = {'lang' : _(u'Language').decode('utf8'),
1030                        'encoding' : _(u'Characters set').decode('utf8'),
1031                        'ucinb' : _(u'Number of texts').decode('utf8'),
1032                        'ucenb' : _(u'Number of text segments').decode('utf8'),
1033                        'formesnb' : _(u'Number of forms').decode('utf8'),
1034                        'hapax' : _(u'Number of hapax').decode('utf8'),
1035                       }
1036
1037         keys = ['lang', 'encoding', 'originalpath', 'pathout', 'date', 'time']
1038
1039         self.addkeys(keys, description)
1040
1041         self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Paramètres", wx.DefaultPosition, wx.DefaultSize, 0 )
1042         self.m_staticText18.Wrap( -1 )
1043         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1044         
1045         self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1046         self.m_staticText19.Wrap( -1 )
1047         fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1048
1049         keys = ['ucemethod', 'ucesize', 'keep_caract', 'expressions']
1050         self.addkeys(keys, description)
1051
1052         self.m_staticText18 = wx.StaticText( self, wx.ID_ANY, u"Statistiques", wx.DefaultPosition, wx.DefaultSize, 0 )
1053         self.m_staticText18.Wrap( -1 )
1054         fgSizer5.Add( self.m_staticText18, 0, wx.ALL, 5 )
1055         
1056         self.m_staticText19 = wx.StaticText( self, wx.ID_ANY, u"", wx.DefaultPosition, wx.DefaultSize, 0 )
1057         self.m_staticText19.Wrap( -1 )
1058         fgSizer5.Add( self.m_staticText19, 0, wx.ALL, 5 )
1059
1060         keys = ['ucinb', 'ucenb', 'occurrences', 'formesnb', 'hapax']
1061         self.addkeys(keys, description)
1062
1063         self.SetSizer( fgSizer5 )
1064         self.Layout()
1065
1066     def addkeys(self, keys, description) :
1067         for key in keys :
1068             option = self.parametres.get(key,u'non défini')
1069             if isinstance(option, int) :
1070                 option = `option`
1071             text = wx.StaticText( self, wx.ID_ANY, description.get(key, key), wx.DefaultPosition, wx.DefaultSize, 0 )
1072             text.Wrap( -1 )
1073             self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1074
1075             text = wx.StaticText( self, wx.ID_ANY, option, wx.DefaultPosition, wx.DefaultSize, 0 )
1076             text.Wrap( -1 )
1077             self.fgSizer5.Add( text, 0, wx.ALL, 5 )
1078
1079 class DefaultTextLayout :
1080     def __init__(self, ira, corpus, parametres) :
1081         self.pathout = PathOut(dirout = parametres['pathout'])
1082         self.ira = ira
1083         self.parent = ira
1084         self.parametres = parametres
1085         self.corpus = corpus
1086         self.dolayout()
1087     
1088     def dolayout(self) :
1089         log.info('no layout yet')
1090
1091 class WordCloudLayout(DefaultTextLayout):
1092     def dolayout(self):
1093         self.pathout.basefiles(simipath)
1094         self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1095         if self.parametres['svg'] :
1096             list_graph = [['nuage_1.svg', 'Nuage']]
1097         else :
1098             list_graph = [['nuage_1.png', 'Nuage']]
1099         self.TabStatTot = GraphPanel(self.ira.nb, self.pathout, list_graph)
1100         self.Tab.AddPage(self.TabStatTot, 'Nuage')
1101         self.Tab.corpus = self.corpus
1102         self.Tab.parametres = self.parametres
1103         self.ira.nb.AddPage(self.Tab, '%s' % self.parametres['name'])
1104         self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1105         self.ira.ShowAPane("Tab_content")
1106
1107 class SimiLayout(DefaultTextLayout) :
1108     def dolayout(self) :
1109         self.pathout.basefiles(simipath)
1110         self.actives = None
1111         self.indices = indices_simi
1112         if os.path.exists(self.pathout['liste_graph']) :
1113             list_graph = read_list_file(self.pathout['liste_graph'])
1114         else : 
1115             list_graph = [['','']]
1116         notebook_flags =  aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1117         self.tabsimi = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1118         self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1119         self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1120         self.tabsimi.corpus = self.corpus
1121         self.tabsimi.parametres = self.parametres
1122         self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1123         self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1124         self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1125         self.tabsimi.AddPage(self.graphpan, 'Graph')
1126         self.ira.nb.AddPage(self.tabsimi, _(u'Graph analysis').decode('utf8'))
1127         self.ira.ShowTab(True)
1128         self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1129         
1130     def redosimi(self, evt) :
1131         with open(self.pathout['selected.csv'],'r') as f :
1132             selected = f.read()
1133         selected = [int(val) for val in selected.splitlines()]
1134         if self.actives is None :
1135             with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1136                 self.actives = f.read()
1137             self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1138         if os.path.exists(self.pathout['actives_nb.csv']) :
1139             with open(self.pathout['actives_nb.csv'], 'r') as f :
1140                 act_nb = f.read()
1141                 act_nb = act_nb.splitlines()
1142             dictcol = dict([[i, [self.actives[i], int(act_nb[i])]] for i, val in enumerate(self.actives)])
1143         else :
1144             dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1145         #res = SelectColumn(self.ira, dictcol, self.actives, self.pathout['selected.csv'], selected = selected, dlg = True) 
1146         #if res.ok :
1147         prep = PrepSimi(self.ira, self, self.parametres,self.pathout['selected.csv'], self.actives, indices_simi, wordlist = dictcol, selected = selected)
1148         if prep.val == wx.ID_OK :
1149             self.parametres = prep.parametres
1150
1151             script = PrintSimiScript(self)
1152             script.make_script()
1153             pid = exec_rcode(self.ira.RPath, script.scriptout, wait = True)
1154             check_Rresult(self.ira, pid)
1155             if self.parametres['type_graph'] in [1,3] :
1156                 if self.parametres['svg'] :
1157                     filename, ext = os.path.splitext(script.filename)
1158                     fileout = filename + '.svg'
1159                 elif self.parametres['type_graph'] == 3 :
1160                     fileout = script.filename
1161                     parametres = {'gexffile' :  fileout,
1162                                   'dirout' : os.path.dirname(fileout),
1163                                   'titre': 'Le titre',
1164                                   #'nodemin': self.param['txt_min'],
1165                                   #'nodemax': self.param['txt_max'],
1166                                   #'bargraphw' : 60*int(self.param['clnb']),
1167                     }
1168                     web = WebExport(self.ira, parametres)
1169                     fileout = web.exportsimi()                         
1170                 else :
1171                     fileout = script.filename
1172                 if os.path.exists(self.pathout['liste_graph']):
1173                     graph_simi = read_list_file(self.pathout['liste_graph'])
1174                     graph_simi.append([os.path.basename(fileout), script.txtgraph])
1175                 else :
1176                     graph_simi = [[os.path.basename(fileout), script.txtgraph]]
1177                 print_liste(self.pathout['liste_graph'], graph_simi)
1178             DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1179             if self.parametres['type_graph'] in [1,3] :
1180                 if self.parametres['svg'] or self.parametres['type_graph'] == 3 :
1181                     self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1182                 else :
1183                     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)
1184                 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1185                 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1186                 self.graphpan.Layout()
1187                 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1188
1189     def export(self, evt) :
1190         nb = 1
1191         while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1192             nb +=1
1193         fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1194         txt = """
1195         library(igraph)
1196         load("%s")
1197         source("%s")
1198         fileout <- "%s"
1199         graph <- graph.simi$graph
1200         V(graph)$x <- graph.simi$layout[,1]
1201         V(graph)$y <- graph.simi$layout[,2]
1202         if (length(graph.simi$label.cex == 1)) {
1203             V(graph)$weight <- graph.simi$eff
1204         } else {
1205             V(graph)$weight <- graph.simi$label.cex
1206         }
1207         V(graph)$color <- vertex.label.color
1208         V(graph)$frequences <- graph.simi$mat.eff
1209         V(graph)$label <- as.character(graph.simi$v.label)
1210         E(graph)$weight <- graph.simi$we.width
1211         write.graph(graph, fileout, format = 'graphml')
1212         #saveAsGEXF(graph, filepath = fileout)
1213         """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
1214         filetmp = tempfile.mktemp()
1215         with open(filetmp, 'w') as f :
1216             f.write(txt)
1217         exec_rcode(self.ira.RPath, filetmp)
1218         mss = wx.MessageDialog(self.ira, fileout, _(u'File exported').decode('utf8'), wx.OK)
1219         mss.CenterOnParent()
1220         mss.ShowModal()
1221         mss.Destroy()
1222
1223 class DefaultMatLayout :
1224     def __init__(self, parent, tableau, parametres) :
1225         self.pathout = PathOut(dirout = parametres['pathout'])
1226         self.ira = parent
1227         self.parent = parent
1228         self.tableau = tableau
1229         self.parametres = parametres
1230         if os.path.exists(self.pathout['analyse.db']) :
1231             self.tableau.read_tableau(self.pathout['analyse.db'])
1232         self.dolayout()
1233         self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1234         self.ira.ShowAPane("Tab_content")
1235
1236     def dolayout(self) :
1237         pass
1238
1239 class FreqLayout(DefaultMatLayout) :
1240     def dolayout(self) :
1241         self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1242         res = normpath_win32(self.pathout['resultats.html']).replace('\\','/')
1243         self.tab.LoadPage(res)
1244         self.tab.parametres = self.parametres
1245         self.ira.nb.AddPage(self.tab, ' - '.join([_(u"Frequency").decode('utf8'), self.parametres['name']]))
1246
1247
1248 class Chi2Layout(DefaultMatLayout) :
1249     def dolayout(self):
1250         self.tab = wx.html.HtmlWindow(self.ira.nb, -1)
1251         if "gtk2" in wx.PlatformInfo:
1252             self.tab.SetStandardFonts()
1253         res = normpath_win32(self.pathout['resultats-chi2.html']).replace('\\','/')
1254         self.tab.LoadPage(res)
1255         self.tab.parametres = self.parametres
1256         self.ira.nb.AddPage(self.tab, ' - '.join([u"Chi2", self.parametres['name']]))
1257         #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1258         #self.ira.ShowAPane("Tab_content")  
1259
1260
1261 class ProtoLayout(DefaultMatLayout) :
1262     def dolayout(self) :
1263         list_graph = [['proto.png', _(u'Prototypical analysis').decode('utf8')]]
1264         #self.Tab = aui.AuiNotebook(self.ira.nb, -1, wx.DefaultPosition)
1265         #if self.parametres['svg'] :
1266         #    list_graph = [['nuage_1.svg', 'Nuage']]
1267         #else :
1268         #    list_graph = [['nuage_1.png', 'Nuage']]
1269         self.TabProto = GraphPanel(self.ira.nb, self.pathout, list_graph)
1270         #self.Tab.AddPage(self.TabProto, 'Analyse Prototypique')
1271         #self.Tab.corpus = self.corpus
1272         self.TabProto.parametres = self.parametres
1273         self.ira.nb.AddPage(self.TabProto, ' - '.join([_(u'Prototypical analysis').decode('utf8'), self.parametres['name']]))
1274         #self.ira.nb.SetSelection(self.ira.nb.GetPageCount() - 1)
1275         #self.ira.ShowAPane("Tab_content")
1276
1277
1278 class SimiMatLayout(DefaultMatLayout) :
1279     def dolayout(self):
1280         self.pathout.basefiles(simipath)
1281         self.indices = indices_simi
1282         if os.path.exists(self.pathout['liste_graph']) :
1283             list_graph = read_list_file(self.pathout['liste_graph'])
1284         else : 
1285             list_graph = [['','']]
1286         notebook_flags =  aui.AUI_NB_DEFAULT_STYLE | aui.AUI_NB_TAB_EXTERNAL_MOVE | aui.AUI_NB_TAB_MOVE | aui.AUI_NB_TAB_FLOAT
1287         self.tabsimi = aui.AuiNotebook(self.parent.nb, -1, wx.DefaultPosition)
1288         self.tabsimi.SetAGWWindowStyleFlag(notebook_flags)
1289         self.tabsimi.SetArtProvider(aui.ChromeTabArt())
1290         self.graphpan = GraphPanelSimi(self.tabsimi, self.pathout, list_graph)
1291         self.graphpan.Bind(wx.EVT_BUTTON, self.redosimi, self.graphpan.butafc)
1292         self.graphpan.Bind(wx.EVT_BUTTON, self.export, self.graphpan.butexport)
1293         self.tabsimi.AddPage(self.graphpan, 'Graph')
1294         self.tabsimi.parametres = self.parametres
1295         self.parent.nb.AddPage(self.tabsimi, ' - '.join([_(u'Graph analysis').decode('utf8'), self.parametres['name']]))
1296         #self.parent.ShowTab(True)
1297         #self.parent.nb.SetSelection(self.parent.nb.GetPageCount() - 1)
1298
1299     def redosimi(self,evt) :
1300         with open(self.pathout['selected.csv'],'r') as f :
1301             selected = f.read()
1302         selected = [int(val) for val in selected.splitlines()]
1303         #if self.actives is None :
1304         #    with codecs.open(self.pathout['actives.csv'], 'r', self.parametres['encoding']) as f :
1305         #        self.actives = f.read()
1306         #    self.actives = self.actives.splitlines()#[act for act in self.actives.splitlines()]
1307         try :
1308             actives = [[val, self.tableau.actives[val][0]] for val in self.tableau.actives]
1309         except :
1310             actives = [[val, self.tableau.actives[val]] for val in self.tableau.actives]
1311
1312         #self.tableau.make_listactives()
1313         actives = dict([[i, val] for i, val in enumerate(actives)])
1314         #dictcol = dict([[i, [act, self.corpus.getlemeff(act)]] for i, act in enumerate(self.actives)])
1315         self.dial = PrefSimi(self.parent, -1, self.parametres, self.indices, wordlist = actives, selected = selected, actives = self.tableau.listactives)
1316         self.dial.CenterOnParent()
1317         self.val = self.dial.ShowModal()
1318         if self.val == wx.ID_OK :
1319             last = self.dial.listcol.GetFirstSelected()
1320             lastl = [self.dial.listcol.GetFirstSelected()]
1321             indexes = [self.dial.listcol.getColumnText(self.dial.listcol.GetFirstSelected(),0)]
1322             while self.dial.listcol.GetNextSelected(last) != -1:
1323                 last = self.dial.listcol.GetNextSelected(last)
1324                 lastl.append(last)
1325                 indexes.append(self.dial.listcol.getColumnText(last,0))
1326             self.column = [self.tableau.listactives.index(val) for val in indexes]
1327             self.column.sort()
1328             with open(self.pathout['selected.csv'], 'w') as f :
1329                 f.write('\n'.join([`val` for val in self.column]))
1330             self.make_param()
1331             self.dial.Destroy()
1332             self.script = PrintSimiScript(self)
1333             self.script.make_script()
1334             self.tmpfile = self.script.scriptout
1335             dlg = progressbar(self, maxi = 2)
1336             self.DoR(dlg)
1337             dlg.Destroy()
1338             if self.parametres['type_graph'] == 1:
1339                 if self.parametres['svg'] :
1340                     filename, ext = os.path.splitext(self.script.filename)
1341                     fileout = filename + '.svg'
1342                 else :
1343                     fileout = self.script.filename
1344                 fileout = normpath_win32(fileout)
1345                 if os.path.exists(self.pathout['liste_graph']):
1346                     graph_simi = read_list_file(self.pathout['liste_graph'])
1347                     graph_simi.append([os.path.basename(fileout), self.script.txtgraph])
1348                 else :
1349                     graph_simi = [[os.path.basename(fileout), self.script.txtgraph]]
1350                 print_liste(self.pathout['liste_graph'], graph_simi)            
1351             DoConf().makeoptions([self.parametres['type']], [self.parametres], self.pathout['Analyse.ira'])
1352             if self.parametres['type_graph'] == 1:
1353                 if self.parametres['svg'] :
1354                     self.graphpan.sizer_3.Add(hl.HyperLinkCtrl(self.graphpan.panel_1, -1, fileout, URL = fileout), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1355                 else :
1356                     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)
1357                 self.graphpan.sizer_3.Add(wx.StaticText(self.graphpan.panel_1,-1, self.script.txtgraph), 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1358                 self.graphpan.sizer_3.Fit(self.graphpan.panel_1)
1359                 self.graphpan.Layout()
1360                 self.graphpan.panel_1.Scroll(0,self.graphpan.panel_1.GetScrollRange(wx.VERTICAL))
1361         else :
1362             self.dial.Destroy()
1363                
1364
1365     def make_param(self) :
1366         if self.parametres['first'] :
1367             keep_coord = False
1368         else :
1369             keep_coord = self.dial.check_coord.GetValue()
1370         #self.select = self.dial.check_colch.GetValue()
1371
1372         paramsimi = {'coeff' : self.dial.choice1.GetSelection(),
1373                           'layout' : self.dial.choice2.GetSelection(),
1374                           'type_graph' : self.dial.choice3.GetSelection(),
1375                           'arbremax' : self.dial.check1.GetValue(),
1376                           'coeff_tv' : self.dial.check_s_size.GetValue(),
1377                           'coeff_tv_nb' : self.dial.spin_tv.GetValue(),
1378                           'tvprop' : self.dial.check2.GetValue(),
1379                           'tvmin' : self.dial.spin_tvmin.GetValue(),
1380                           'tvmax' : self.dial.spin_tvmax.GetValue(),
1381                           'coeff_te' : self.dial.check3.GetValue(),
1382                           'coeff_temin' : self.dial.spin_temin.GetValue(),
1383                           'coeff_temax' : self.dial.spin_temax.GetValue(),
1384                           'label_e' : self.dial.check_elab.GetValue(),
1385                           'label_v' : self.dial.check_vlab.GetValue(),
1386                           'vcex' : self.dial.check_vcex.GetValue(),
1387                           'vcexmin' : self.dial.spin_vcexmin.GetValue(),
1388                           'vcexmax' : self.dial.spin_vcexmax.GetValue(),
1389                           'cex' : self.dial.spin_cex.GetValue(),
1390                           'seuil_ok' : self.dial.check_seuil.GetValue(),
1391                           'seuil' : self.dial.spin_seuil.GetValue(),
1392                           'cols' : self.dial.cols.GetColour(),
1393                           'cola' : self.dial.cola.GetColour(),
1394                           'width' : self.dial.spin_width.GetValue(),
1395                           'height' : self.dial.spin_height.GetValue(),
1396                           'first' : False,
1397                           'keep_coord' : keep_coord,
1398                           'alpha' : self.dial.slider_sphere.GetValue(),
1399                           'film' : self.dial.film.GetValue(),
1400                           'svg' : self.dial.choix_format.GetSelection(),
1401                           'halo' : self.dial.halo.GetValue(),
1402                           'com' : self.dial.comcheck.GetValue(),
1403                           'communities' : self.dial.choix_com.GetSelection(),
1404                           'edgecurved' : self.dial.check_curved.GetValue(),
1405                           }        
1406         if 'cexfromchi' in self.parametres :
1407             paramsimi['cexfromchi'] = self.dial.checkit.GetValue()
1408         if 'sfromchi' in self.parametres :
1409             paramsimi['sfromchi'] = self.dial.checki.GetValue()
1410         if 'vlabcolor' in self.parametres :
1411             paramsimi['vlabcolor'] = self.parametres['vlabcolor']
1412         if 'check_bystar' in dir(self.dial) :
1413             paramsimi['bystar'] = self.dial.check_bystar.GetValue()
1414             paramsimi['stars'] = self.parametres['stars']
1415         self.parametres.update(paramsimi)
1416
1417     def DoR(self, dlg):
1418         if self.parametres['type_graph'] == 1 :
1419             graph = False
1420             wait = False
1421         else : 
1422             graph = True
1423             wait = True
1424         pid = exec_rcode(self.parent.RPath, self.tmpfile, wait = wait, graph = graph)
1425         if self.parametres['type_graph'] == 1 :
1426             while pid.poll() == None :
1427                 dlg.Pulse(u'R ...')
1428                 sleep(0.2)
1429             check_Rresult(self.parent, pid)
1430     
1431     def export(self, evt) : 
1432         nb = 1
1433         while os.path.exists(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml')):
1434             nb +=1
1435         fileout = ffr(os.path.join(self.pathout.dirout,'graph_'+str(nb)+'.graphml'))
1436         txt = """
1437         library(igraph)
1438         load("%s")
1439         source("%s")
1440         fileout <- "%s"
1441         graph <- graph.simi$graph
1442         V(graph)$x <- graph.simi$layout[,1]
1443         V(graph)$y <- graph.simi$layout[,2]
1444         if (length(graph.simi$label.cex == 1)) {
1445             V(graph)$weight <- graph.simi$mat.eff
1446         } else {
1447             V(graph)$weight <- graph.simi$label.cex
1448         }
1449         V(graph)$color <- vertex.label.color
1450         V(graph)$frequences <- graph.simi$mat.eff
1451         V(graph)$fprop <- graph.simi$mat.eff/nrow(dm)
1452         V(graph)$label <- as.character(graph.simi$v.label)
1453         E(graph)$weight <- graph.simi$we.width
1454         write.graph(graph, fileout, format = 'graphml')
1455         #saveAsGEXF(graph, filepath = fileout)
1456         """ % (self.pathout['RData.RData'], self.parent.RscriptsPath['simi'], fileout)
1457         filetmp = tempfile.mktemp()
1458         with open(filetmp, 'w') as f :
1459             f.write(txt)
1460         exec_rcode(self.ira.RPath, filetmp)
1461         mss = wx.MessageDialog(self.ira, fileout, _(u'File exported').decode('utf8'), wx.OK)
1462         mss.CenterOnParent()
1463         mss.ShowModal()
1464         mss.Destroy()
1465
1466         
1467 class GraphPanelSimi(wx.Panel):
1468     def __init__(self,parent, dico, list_graph):
1469         wx.Panel.__init__(self,parent)
1470         self.afcnb = 1
1471         self.Dict = dico
1472         self.dirout = os.path.dirname(self.Dict['ira'])
1473         self.parent = self.GetParent()#parent
1474         self.SetFont(wx.Font(10, wx.DEFAULT, wx.NORMAL, wx.NORMAL, 0, "courier"))
1475         self.labels = []
1476         self.listimg = []
1477         self.tabsimi = self.parent.GetParent()
1478         self.ira = self.tabsimi.GetParent()
1479         self.panel_1 = wx.ScrolledWindow(self, -1, style=wx.TAB_TRAVERSAL)
1480         afc_img = wx.Image(os.path.join(self.ira.images_path,'button_simi.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1481         self.butafc = wx.BitmapButton(self, -1, afc_img)
1482         export_img = wx.Image(os.path.join(self.ira.images_path,'button_export.jpg'), wx.BITMAP_TYPE_ANY).ConvertToBitmap()
1483         self.butexport = wx.BitmapButton(self, -1, export_img)
1484         for i in range(0,len(list_graph)):
1485             if os.path.exists(os.path.join(self.dirout,list_graph[i][0])) :
1486                 filename, ext = os.path.splitext(list_graph[i][0])
1487                 if ext in ['.svg', '.html'] :
1488                     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])))
1489                 else :
1490                     self.listimg.append(wx.StaticBitmap(self.panel_1, -1, wx.Bitmap(os.path.join(self.dirout,list_graph[i][0]), wx.BITMAP_TYPE_ANY)))
1491                 self.labels.append(wx.StaticText(self.panel_1, -1, list_graph[i][1]))
1492         self.panel_1.Bind(wx.EVT_MOTION, self.onMouseMove) 
1493         self.__set_properties()
1494         self.__do_layout()
1495
1496     def __set_properties(self):
1497         self.panel_1.EnableScrolling(True,True)
1498         #self.panel_1.SetSize((1000,1000))
1499         self.panel_1.SetScrollRate(20, 20)
1500         self.panel_1.SetFocus()
1501
1502     def __do_layout(self):    
1503         self.sizer_1 = wx.BoxSizer(wx.HORIZONTAL)
1504         self.sizer_2 = wx.BoxSizer(wx.VERTICAL)
1505         self.sizer_3 = wx.BoxSizer(wx.VERTICAL)
1506         self.sizer_2.Add(self.butafc, 0, 0, 0)
1507         self.sizer_2.Add(self.butexport, 0, 0, 0)
1508         for i in range(0, len(self.listimg)):
1509             self.sizer_3.Add(self.listimg[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1510             self.sizer_3.Add(self.labels[i], 0, wx.ALIGN_CENTER_HORIZONTAL, 0)
1511         self.panel_1.SetSizer(self.sizer_3)
1512         self.sizer_1.Add(self.sizer_2, 0, wx.EXPAND, 0)
1513         self.sizer_1.Add(self.panel_1, 1, wx.EXPAND, 0)
1514         self.SetSizer(self.sizer_1) 
1515
1516     def onMouseMove(self, event):
1517         self.panel_1.SetFocus()