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