iramuteq.org Git - iramuteq/blob - tree.py

   1 # -*- coding: utf-8 -*-
   2 #Author: Pierre Ratinaud
   3 #Copyright (c) 2012, Pierre Ratinaud
   4 #License: GNU GPL
   5
   6 import wx
   7 import os
   8 import webbrowser
   9 import wx.lib.agw.customtreectrl as CT
  10 import logging
  11 from openanalyse import OpenAnalyse
  12 from corpus import Corpus, copycorpus
  13 from tableau import Tableau, copymatrix
  14 from functions import DoConf, GetTxtProfile, TGen, BugReport
  15 from profile_segment import ProfileSegment, ProfilType
  16 from search_tools import SearchFrame
  17 from dialog import PrefSimpleFile, PrefExport
  18 from layout import open_antiprofil, TgenLayout
  19 from guifunct import TGenFrame
  20 from textaslexico import TgenSpec
  21 from textreinert import TgenProf
  22
  23 log = logging.getLogger('iramuteq.tree')
  24
  25 def buildmenu(menu, parent_menu):
  26     for i in range(parent_menu.GetMenuItemCount()) :
  27         item = parent_menu.FindItemByPosition(i)
  28         itemid = item.GetId()
  29         itemtext = item.GetText()
  30         itemicon = item.GetBitmap()
  31         nitem = wx.MenuItem(menu, itemid, itemtext)
  32         nitem.SetBitmap(itemicon)
  33         if item.IsSubMenu() :
  34             nmenu = wx.Menu()
  35             for val in item.GetSubMenu().GetMenuItems() :
  36                 itemid = val.GetId()
  37                 itemtext = val.GetText()
  38                 itemicon = val.GetBitmap()
  39                 nitem = wx.MenuItem(menu, itemid, itemtext)
  40                 nitem.SetBitmap(itemicon)
  41                 nmenu.AppendItem(nitem)
  42             menu.AppendMenu(-1, item.GetText(), nmenu)
  43         else :
  44             menu.AppendItem(nitem)
  45
  46 class InfoDialog ( wx.Dialog ):
  47
  48     def __init__( self, parent, txt, parametres ):
  49         wx.Dialog.__init__ ( self, parent, id = wx.ID_ANY, title = u"Informations", pos = wx.DefaultPosition, size = wx.DefaultSize, style = wx.DEFAULT_DIALOG_STYLE )
  50         if len(parametres) > 30 :
  51             nb = 4
  52         else :
  53             nb = 2
  54         self.SetSizeHintsSz( wx.Size( 500,200 ), wx.DefaultSize )
  55
  56         bSizer1 = wx.BoxSizer( wx.VERTICAL )
  57
  58         self.m_panel2 = wx.Panel( self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL )
  59         bSizer2 = wx.BoxSizer( wx.VERTICAL )
  60
  61         self.m_staticText4 = wx.StaticText( self.m_panel2, wx.ID_ANY, txt, wx.DefaultPosition, wx.DefaultSize, 0 )
  62         self.m_staticText4.Wrap( -1 )
  63         bSizer2.Add( self.m_staticText4, 0, wx.ALL, 5 )
  64
  65
  66         self.m_panel2.SetSizer( bSizer2 )
  67         self.m_panel2.Layout()
  68         bSizer2.Fit( self.m_panel2 )
  69         bSizer1.Add( self.m_panel2, 0, wx.EXPAND |wx.ALL, 5 )
  70
  71         self.m_panel1 = wx.Panel( self, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL )
  72
  73         fgSizer1 = wx.FlexGridSizer( 0, nb, 0, 0 )
  74         fgSizer1.SetFlexibleDirection( wx.BOTH )
  75         fgSizer1.SetNonFlexibleGrowMode( wx.FLEX_GROWMODE_SPECIFIED )
  76
  77         txtctrl = []
  78         for val in parametres :
  79             fgSizer1.Add( wx.StaticText( self.m_panel1, wx.ID_ANY, val[0], wx.DefaultPosition, wx.DefaultSize, 0 ), 0, wx.ALL, 0)
  80             #fgSizer1.Add( wx.StaticText( self.m_panel1, wx.ID_ANY, val[1], wx.DefaultPosition, wx.DefaultSize, 0 ), 0, wx.ALL, 0)
  81             txtctrl.append( wx.TextCtrl( self.m_panel1, wx.ID_ANY, val[1], wx.DefaultPosition, (450, 20), wx.TE_READONLY ) )
  82             txtctrl[-1].SetBackgroundColour('#DDE8EB')
  83             #wx.SystemSettings.GetColour(wx.SYS_COLOUR_GRAYTEXT))
  84             fgSizer1.Add( txtctrl[-1], 0, wx.ALL|wx.EXPAND, 0)
  85             #fgSizer1.Add( wx.StaticLine( self.m_panel1, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_HORIZONTAL ), 0, wx.EXPAND |wx.ALL, 0)
  86             #fgSizer1.Add( wx.StaticLine( self.m_panel1, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.LI_HORIZONTAL ), 0, wx.EXPAND|wx.ALL, 0)
  87
  88         self.m_panel1.SetSizer( fgSizer1 )
  89         self.m_panel1.Layout()
  90         fgSizer1.Fit( self.m_panel1 )
  91         bSizer1.Add( self.m_panel1, 0, wx.EXPAND|wx.ALL, 3 )
  92
  93         m_sdbSizer1 = wx.StdDialogButtonSizer()
  94         self.m_sdbSizer1OK = wx.Button( self, wx.ID_OK )
  95         m_sdbSizer1.AddButton( self.m_sdbSizer1OK )
  96         m_sdbSizer1.Realize();
  97
  98         bSizer1.Add( m_sdbSizer1, 0, wx.EXPAND, 5 )
  99
 100
 101         self.SetSizer( bSizer1 )
 102         self.Layout()
 103         bSizer1.Fit( self )
 104
 105         self.Centre( wx.BOTH )
 106
 107     def __del__( self ):
 108         pass
 109
 110
 111 class LeftTree(CT.CustomTreeCtrl):
 112
 113     def __init__(self, parent, id=wx.ID_ANY, pos=wx.DefaultPosition,
 114                  size=wx.DefaultSize,
 115                  style=wx.SUNKEN_BORDER|wx.WANTS_CHARS,
 116                  agwStyle=CT.TR_HIDE_ROOT|CT.TR_HAS_BUTTONS|CT.TR_HAS_VARIABLE_ROW_HEIGHT):
 117
 118         CT.CustomTreeCtrl.__init__(self, parent, id, pos, size, style, agwStyle)
 119         self.log = log
 120         alldata = dir(CT)
 121         treestyles = []
 122         events = []
 123         for data in alldata:
 124             if data.startswith("TR_"):
 125                 treestyles.append(data)
 126             elif data.startswith("EVT_"):
 127                 events.append(data)
 128         self.parent = parent
 129         self.ira = parent
 130         self.events = events
 131         self.styles = treestyles
 132         self.item = None
 133
 134
 135         self.il = wx.ImageList(16, 16)
 136         self.ild = {}
 137         for img in self.ira.images_analyses :
 138             self.ild[img] = self.il.Add(self.ira.images_analyses[img])
 139         self.SetImageList(self.il)
 140
 141         self.count = 0
 142         self.log = log
 143
 144         self.history = parent.history
 145         self.h = self.history.history
 146         self.root = self.AddRoot("Iramuteq")
 147
 148         if not(self.GetAGWWindowStyleFlag() & CT.TR_HIDE_ROOT):
 149             self.SetPyData(self.root, None)
 150             self.SetItemImage(self.root, 24, CT.TreeItemIcon_Normal)
 151             self.SetItemImage(self.root, 13, CT.TreeItemIcon_Expanded)
 152
 153         self.textroot = self.AppendItem(self.root, _(u'Textual corpus'))
 154         self.SetPyData(self.textroot, {'uuid': 'textroot'})
 155         self.SetItemImage(self.textroot, self.ild['textroot'], CT.TreeItemIcon_Normal)
 156         self.SetItemImage(self.textroot, self.ild['textroot'], CT.TreeItemIcon_Expanded)
 157
 158         for corpus in reversed(self.h) :
 159             child = self.AppendItem(self.textroot, corpus['corpus_name'])
 160             self.SetPyData(child, corpus)
 161             self.SetItemImage(child, self.ild['corpus'], CT.TreeItemIcon_Normal)
 162             self.SetItemImage(child, self.ild['corpus'], CT.TreeItemIcon_Expanded)
 163
 164             if 'analyses' in corpus :
 165                 for y in corpus['analyses'] :
 166                     last = self.AppendItem(child, y['name'], ct_type=0)
 167                     self.SetPyData(last, y)
 168                     if y['type'] in self.ild :
 169                         img = self.ild[y['type']]
 170                     else :
 171                         img = 24
 172                     self.SetItemImage(last, img, CT.TreeItemIcon_Normal)
 173                     self.SetItemImage(last, img, CT.TreeItemIcon_Expanded)
 174
 175         self.matroot = self.AppendItem(self.root, _(u'Matrix'))
 176         self.SetPyData(self.matroot, {'uuid': 'matroot'})
 177         self.SetItemImage(self.matroot, self.ild['matroot'], CT.TreeItemIcon_Normal)
 178         self.SetItemImage(self.matroot, self.ild['matroot'], CT.TreeItemIcon_Expanded)
 179
 180         orphmat = []
 181         for matrix in reversed(self.history.matrix) :
 182             if 'matrix_name' in matrix :
 183                 child = self.AppendItem(self.matroot, matrix['matrix_name'])
 184                 self.SetPyData(child, matrix)
 185                 self.SetItemImage(child, self.ild['matrix'], CT.TreeItemIcon_Normal)
 186                 self.SetItemImage(child, self.ild['matrix'], CT.TreeItemIcon_Expanded)
 187                 if 'analyses' in matrix :
 188                     for y in matrix['analyses'] :
 189                         last = self.AppendItem(child, y['name'], ct_type=0)
 190                         self.SetPyData(last, y)
 191                         if y['type'] in self.ild :
 192                             img = self.ild[y['type']]
 193                         else :
 194                             img = 24
 195                         self.SetItemImage(last, img, CT.TreeItemIcon_Normal)
 196                         self.SetItemImage(last, img, CT.TreeItemIcon_Expanded)
 197             else :
 198                 orphmat.append(matrix)
 199
 200         self.Bind(wx.EVT_LEFT_DCLICK, self.OnLeftDClick)
 201         #self.Bind(wx.EVT_IDLE, self.OnIdle)
 202
 203         self.eventdict = {'EVT_TREE_BEGIN_DRAG': self.OnBeginDrag, 'EVT_TREE_BEGIN_LABEL_EDIT': self.OnBeginEdit,
 204                           'EVT_TREE_BEGIN_RDRAG': self.OnBeginRDrag, 'EVT_TREE_DELETE_ITEM': self.OnDeleteItem,
 205                           'EVT_TREE_END_DRAG': self.OnEndDrag, 'EVT_TREE_END_LABEL_EDIT': self.OnEndEdit,
 206                           'EVT_TREE_ITEM_ACTIVATED': self.OnActivate, 'EVT_TREE_ITEM_CHECKED': self.OnItemCheck,
 207                           'EVT_TREE_ITEM_CHECKING': self.OnItemChecking, 'EVT_TREE_ITEM_COLLAPSED': self.OnItemCollapsed,
 208                           'EVT_TREE_ITEM_COLLAPSING': self.OnItemCollapsing, 'EVT_TREE_ITEM_EXPANDED': self.OnItemExpanded,
 209                           'EVT_TREE_ITEM_EXPANDING': self.OnItemExpanding, 'EVT_TREE_ITEM_GETTOOLTIP': self.OnToolTip,
 210                           'EVT_TREE_ITEM_MENU': self.OnItemMenu, 'EVT_TREE_ITEM_RIGHT_CLICK': self.OnRightDown,
 211                           'EVT_TREE_KEY_DOWN': self.OnKey, 'EVT_TREE_SEL_CHANGED': self.OnSelChanged,
 212                           'EVT_TREE_SEL_CHANGING': self.OnSelChanging, "EVT_TREE_ITEM_HYPERLINK": self.OnHyperLink}
 213
 214         mainframe = wx.GetTopLevelParent(self)
 215
 216         if not hasattr(mainframe, "leftpanel"):
 217             #self.Bind(CT.EVT_TREE_ITEM_EXPANDED, self.OnItemExpanded)
 218             #self.Bind(CT.EVT_TREE_ITEM_COLLAPSED, self.OnItemCollapsed)
 219             self.Bind(CT.EVT_TREE_SEL_CHANGED, self.OnSelChanged)
 220             self.Bind(CT.EVT_TREE_SEL_CHANGING, self.OnSelChanging)
 221             self.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)
 222             self.Bind(wx.EVT_RIGHT_UP, self.OnRightUp)
 223         else:
 224             for combos in mainframe.treeevents:
 225                 self.BindEvents(combos)
 226
 227         if hasattr(mainframe, "leftpanel"):
 228             self.ChangeStyle(mainframe.treestyles)
 229
 230         if not(self.GetAGWWindowStyleFlag() & CT.TR_HIDE_ROOT):
 231             self.SelectItem(self.root)
 232             self.Expand(self.root)
 233
 234
 235     def BindEvents(self, choice, recreate=False):
 236
 237         value = choice.GetValue()
 238         text = choice.GetLabel()
 239
 240         evt = "CT." + text
 241         binder = self.eventdict[text]
 242
 243         if value == 1:
 244             if evt == "CT.EVT_TREE_BEGIN_RDRAG":
 245                 self.Bind(wx.EVT_RIGHT_DOWN, None)
 246                 self.Bind(wx.EVT_RIGHT_UP, None)
 247             self.Bind(eval(evt), binder)
 248         else:
 249             self.Bind(eval(evt), None)
 250             if evt == "CT.EVT_TREE_BEGIN_RDRAG":
 251                 self.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)
 252                 self.Bind(wx.EVT_RIGHT_UP, self.OnRightUp)
 253
 254
 255     def ChangeStyle(self, combos):
 256
 257         style = 0
 258         for combo in combos:
 259             if combo.GetValue() == 1:
 260                 style = style | eval("CT." + combo.GetLabel())
 261
 262         if self.GetAGWWindowStyleFlag() != style:
 263             self.SetAGWWindowStyleFlag(style)
 264
 265
 266     def OnCompareItems(self, item1, item2):
 267
 268         t1 = self.GetItemText(item1)
 269         t2 = self.GetItemText(item2)
 270
 271
 272         if t1 < t2:
 273             return -1
 274         if t1 == t2:
 275             return 0
 276
 277         return 1
 278
 279
 280     def OnIdle(self, event):
 281
 282     #    if self.gauge:
 283     #        try:
 284     #            if self.gauge.IsEnabled() and self.gauge.IsShown():
 285     #                self.count = self.count + 1
 286
 287     #                if self.count >= 50:
 288     #                    self.count = 0
 289
 290     #                self.gauge.SetValue(self.count)
 291
 292     #        except:
 293     #            self.gauge = None
 294
 295         event.Skip()
 296
 297
 298     def CloseItem(self, itemParent = None, uuid = None) :
 299         if itemParent is None :
 300             itemParent = self.root
 301         child, cookie = self.GetFirstChild(itemParent)
 302         while child :
 303             pydata = self.GetPyData(child)
 304             if pydata['uuid'] == uuid :
 305                 self.SetItemBold(child, False)
 306                 break
 307             self.CloseItem(child, uuid)
 308             child, cookie = self.GetNextChild(itemParent, cookie)
 309
 310     def GiveFocus(self, itemParent = None, uuid = None, bold = False) :
 311         if itemParent is None :
 312             itemParent = self.root
 313         child, cookie = self.GetFirstChild(itemParent)
 314         while child :
 315             pydata = self.GetPyData(child)
 316             if pydata['uuid'] == uuid :
 317                 self.SelectItem(child)
 318                 if bold :
 319                     self.SetItemBold(child, True)
 320                 return
 321             self.GiveFocus(child, uuid, bold)
 322             child, cookie = self.GetNextChild(itemParent, cookie)
 323
 324     def IsInTree(self, itemParent = None, uuid = None) :
 325         if itemParent is None :
 326             itemParent = self.root
 327         child, cookie = self.GetFirstChild(itemParent)
 328
 329         while child :
 330             pydata = self.GetPyData(child)
 331             if pydata['uuid'] == uuid :
 332                 return True
 333             self.GiveFocus(child, uuid)
 334             child, cookie = self.GetNextChild(itemParent, cookie)
 335         return False
 336
 337
 338     def OnRightDown(self, event):
 339
 340         pt = event.GetPosition()
 341         item, flags = self.HitTest(pt)
 342
 343         if item:
 344             self.item = item
 345             #self.log.info("OnRightClick: %s, %s, %s" % (self.GetItemText(item), type(item), item.__class__) + "\n")
 346             self.SelectItem(item)
 347
 348
 349     def OnRightUp(self, event):
 350
 351         item = self.item
 352
 353         if not item:
 354             event.Skip()
 355             return
 356
 357         if not self.IsItemEnabled(item):
 358             event.Skip()
 359             return
 360
 361         # Item Text Appearance
 362         ishtml = self.IsItemHyperText(item)
 363         back = self.GetItemBackgroundColour(item)
 364         fore = self.GetItemTextColour(item)
 365         isbold = self.IsBold(item)
 366         font = self.GetItemFont(item)
 367
 368         # Icons On Item
 369         normal = self.GetItemImage(item, CT.TreeItemIcon_Normal)
 370         selected = self.GetItemImage(item, CT.TreeItemIcon_Selected)
 371         expanded = self.GetItemImage(item, CT.TreeItemIcon_Expanded)
 372         selexp = self.GetItemImage(item, CT.TreeItemIcon_SelectedExpanded)
 373
 374         # Enabling/Disabling Windows Associated To An Item
 375         haswin = self.GetItemWindow(item)
 376
 377         # Enabling/Disabling Items
 378         enabled = self.IsItemEnabled(item)
 379
 380         # Generic Item's Info
 381         children = self.GetChildrenCount(item)
 382         itemtype = self.GetItemType(item)
 383         text = self.GetItemText(item)
 384         pydata = self.GetPyData(item)
 385         self.pydata = pydata
 386
 387         self.current = item
 388         self.itemdict = {"ishtml": ishtml, "back": back, "fore": fore, "isbold": isbold,
 389                          "font": font, "normal": normal, "selected": selected, "expanded": expanded,
 390                          "selexp": selexp, "haswin": haswin, "children": children,
 391                          "itemtype": itemtype, "text": text, "pydata": pydata, "enabled": enabled}
 392
 393         if not item in [self.textroot, self.matroot] :
 394             menu = wx.Menu()
 395             info = menu.Append(wx.ID_ANY, _(u"Informations").decode('utf8'))
 396             rename = menu.Append(wx.ID_ANY, _(u"Rename").decode('utf8'))
 397             menu.AppendSeparator()
 398
 399             if 'corpus_name' in pydata :
 400                 buildmenu(menu, self.parent.text_menu)
 401                 menu.AppendSeparator()
 402             elif 'matrix_name' in pydata :
 403                 buildmenu(menu, self.parent.matrix_menu)
 404                 menu.AppendSeparator()
 405             elif pydata.get('type', False) == 'alceste' and pydata['uuid'] in self.parent.history.opened :
 406                 openmenu = wx.Menu()
 407                 antipro = openmenu.Append(wx.ID_ANY, _(u"Antiprofiles").decode('utf8'))
 408                 menu.AppendMenu(wx.ID_ANY, _(u"Open ...").decode('utf8'), openmenu)
 409
 410                 profsr = menu.Append(wx.ID_ANY, _(u"Repeated segments profiles").decode('utf8'))
 411                 profgram = menu.Append(wx.ID_ANY, _(u"POS profiles").decode('utf8'))
 412                 tgen = menu.Append(wx.ID_ANY, _(u"Tgen Editor").decode('utf8'))
 413                 computetgen = menu.Append(wx.ID_ANY, _(u"Compute Tgen").decode('utf8'))
 414                 export_corpus = menu.Append(wx.ID_ANY, _(u"Export corpus").decode('utf8'))
 415                 colored = menu.Append(wx.ID_ANY, _(u"Colored corpus").decode('utf8'))
 416                 navig = menu.Append(wx.ID_ANY, _(u"Navigator").decode('utf8'))
 417                 statclasse = menu.Append(wx.ID_ANY, _(u"Clusters statistics").decode('utf8'))
 418                 rapport = menu.Append(wx.ID_ANY, _(u"Report").decode('utf8'))
 419                 export_classes = menu.Append(wx.ID_ANY, _(u"Export clusters").decode('utf8'))
 420                 subcorpusfromcl = menu.Append(wx.ID_ANY, _(u"Sub corpus from clusters").decode('utf8'))
 421                 menu.AppendSeparator()
 422                 self.Bind(wx.EVT_MENU, self.OpenAntipro, antipro)
 423                 self.Bind(wx.EVT_MENU, self.OnProfSR, profsr)
 424                 self.Bind(wx.EVT_MENU, self.OnProfGram, profgram)
 425                 self.Bind(wx.EVT_MENU, self.OnTgenEditor, tgen)
 426                 self.Bind(wx.EVT_MENU, self.OnTgenCompute, computetgen)
 427                 self.Bind(wx.EVT_MENU, self.OnExportCorpus, export_corpus)
 428                 self.Bind(wx.EVT_MENU, self.OnColored, colored)
 429                 self.Bind(wx.EVT_MENU, self.OnNavig, navig)
 430                 self.Bind(wx.EVT_MENU, self.StatClasse, statclasse)
 431                 self.Bind(wx.EVT_MENU, self.OnRapport, rapport)
 432                 self.Bind(wx.EVT_MENU, self.OnExportClasses, export_classes)
 433                 self.Bind(wx.EVT_MENU, self.OnSubCorpusFromClusters, subcorpusfromcl)
 434             elif pydata.get('type', False) == 'stat'  and pydata['uuid'] in self.parent.history.opened :
 435                 export_dictionary =  menu.Append(wx.ID_ANY, _(u"Export dictionary").decode('utf8'))
 436                 export_lems =  menu.Append(wx.ID_ANY, _(u"Export lemma dictionary").decode('utf8'))
 437                 self.Bind(wx.EVT_MENU, self.OnExportDictionary, export_dictionary)
 438                 self.Bind(wx.EVT_MENU, self.OnExportLems, export_lems)
 439                 menu.AppendSeparator()
 440             elif pydata.get('type', False) == 'spec'  and pydata['uuid'] in self.parent.history.opened :
 441                 tgen = menu.Append(wx.ID_ANY, _(u"Tgen Editor").decode('utf8'))
 442                 computetgen = menu.Append(wx.ID_ANY, _(u"Compute Tgen").decode('utf8'))
 443                 self.Bind(wx.EVT_MENU, self.OnTgenEditor, tgen)
 444                 self.Bind(wx.EVT_MENU, self.OnTgenCompute, computetgen)
 445                 menu.AppendSeparator()
 446             elif pydata.get('type', False) == 'reinertmatrix' and pydata['uuid'] in self.parent.history.opened :
 447                 openmenu = wx.Menu()
 448                 antipro = openmenu.Append(wx.ID_ANY, _(u"antiprofiles").decode('utf8'))
 449                 rapport = menu.Append(wx.ID_ANY, _(u"Report").decode('utf8'))
 450                 menu.AppendMenu(wx.ID_ANY, _(u"Open ...").decode('utf8'), openmenu)
 451                 self.Bind(wx.EVT_MENU, self.OpenAntipro, antipro)
 452                 self.Bind(wx.EVT_MENU, self.OnRapport, rapport)
 453
 454
 455             itemdelete = menu.Append(wx.ID_ANY, _(u"Delete from history").decode('utf8'))
 456             #item11 = menu.Append(wx.ID_ANY, "Prepend An Item")
 457             #item12 = menu.Append(wx.ID_ANY, "Append An Item")
 458
 459             #self.Bind(wx.EVT_MENU, self.OnItemBackground, item1)
 460             #self.Bind(wx.EVT_MENU, self.OnItemForeground, item2)
 461             #self.Bind(wx.EVT_MENU, self.OnItemBold, item3)
 462             #self.Bind(wx.EVT_MENU, self.OnItemFont, item4)
 463             #self.Bind(wx.EVT_MENU, self.OnItemHyperText, item5)
 464             #self.Bind(wx.EVT_MENU, self.OnEnableWindow, item6)
 465             #self.Bind(wx.EVT_MENU, self.OnDisableItem, item7)
 466             #self.Bind(wx.EVT_MENU, self.OnItemIcons, item8)
 467             self.Bind(wx.EVT_MENU, self.OnItemInfo, info)
 468             self.Bind(wx.EVT_MENU, self.OnRename, rename)
 469             self.Bind(wx.EVT_MENU, self.OnItemDelete, itemdelete)
 470             #self.Bind(wx.EVT_MENU, self.OnItemPrepend, item11)
 471             #self.Bind(wx.EVT_MENU, self.OnItemAppend, item12)
 472
 473             self.PopupMenu(menu)
 474             menu.Destroy()
 475
 476     def getcorpus(self):
 477         busy = wx.BusyInfo(_("Please wait...Reading corpus").decode('utf8'), self.parent)
 478         wx.SafeYield()
 479         if self.pydata['uuid'] in self.parent.history.openedcorpus :
 480             corpus = copycorpus(self.parent.history.openedcorpus[self.pydata['uuid']])
 481         elif 'corpus_name' in self.pydata :
 482             corpus = Corpus(self.parent, parametres = DoConf(self.pydata['ira']).getoptions('corpus'), read = True)
 483         else :
 484             cuuid = self.pydata['corpus']
 485             if cuuid in self.parent.history.openedcorpus :
 486                 corpus = copycorpus(self.parent.history.openedcorpus[cuuid])
 487             else :
 488                 irapath = self.parent.history.corpus[cuuid]['ira']
 489                 corpus = Corpus(self.parent, parametres = DoConf(irapath).getoptions('corpus'), read = True)
 490         del busy
 491         return corpus
 492
 493     def getmatrix(self):
 494         if 'matrix_name' in self.pydata :
 495             matrix = Tableau(self.parent, parametres = DoConf(self.pydata['ira']).getoptions('matrix'))
 496             matrix.open()
 497             return copymatrix(matrix)
 498         else :
 499             cuuid = self.pydata['matrix']
 500             matrix = Tableau(self.parent, parametres = DoConf(self.history.matrixanalyse[cuuid]['ira']).getoptions('matrix'))
 501             matrix.open()
 502             return copymatrix(matrix)
 503
 504     def OnSpec(self, evt) :
 505         self.parent.OnTextSpec(evt, self.getcorpus())
 506
 507     def OnStat(self, evt) :
 508         self.parent.OnTextStat(evt, self.getcorpus())
 509
 510     def OnReinert(self, evt) :
 511         self.parent.OnTextReinert(evt, self.getcorpus())
 512
 513     def OnPam(self, evt) :
 514         self.parent.OnPamSimple(evt, self.getcorpus())
 515
 516     def OnSimiTxt(self, evt) :
 517         self.parent.OnSimiTxt(evt, self.getcorpus())
 518
 519     def OnWordCloud(self, evt) :
 520         self.parent.OnWordCloud(evt, self.getcorpus())
 521
 522 #    def OnFreq(self, evt):
 523 #        self.parent.OnFreq(evt, self.getmatrix())
 524
 525 #    def OnChiSquare(self, evt):
 526 #        self.parent.OnChi2(evt, self.getmatrix())
 527
 528 #    def OnSimiTab(self, evt):
 529 #        self.parent.OnSimiTab(evt, self.getmatrix())
 530
 531 #    def OnProto(self, evt):
 532 #        self.parent.OnProto(evt, self.getmatrix())
 533
 534 #    def OnSplitFromVar(self, evt):
 535 #        self.parent.OnSplitVar(evt, self.getmatrix())
 536
 537 #    def OnCHDReinert(self, evt):
 538 #        self.parent.OnCHDReinert(evt, self.getmatrix())
 539
 540     #def OnSubTextFromMeta(self, evt):
 541     #    self.parent.OnSubText(self.getcorpus(), parametres = {'frommeta' : True})
 542
 543     #def OnSubTextFromTheme(self, evt):
 544     #    self.parent.OnSubText(self.getcorpus(), parametres = {'fromtheme' : True})
 545
 546     def OnProfSR(self, evt) :
 547         ProfileSegment(self.parent, self.page.dictpathout, self.page.parametres, self.page.corpus)
 548
 549     def OnProfGram(self, evt) :
 550         ProfilType(self.parent, self.page.corpus, self.page.parametres)
 551
 552     def OnExportCorpus(self, evt) :
 553         dial = PrefExport(self, self.parent)
 554         dial.fbb.SetValue(os.path.join(os.path.dirname(self.page.dictpathout['ira']), 'export_corpus.txt'))
 555         dial.CenterOnParent()
 556         res = dial.ShowModal()
 557         if res == wx.ID_OK :
 558             if dial.radio_type.GetSelection() == 0 : alc = True
 559             else : alc = False
 560             if dial.radio_lem.GetSelection() == 0 : lem = True
 561             else : lem = False
 562             if self.page.parametres['classif_mode'] != 2 :
 563                 uci = False
 564             else :
 565                 uci = True
 566             self.page.corpus.export_corpus_classes(dial.fbb.GetValue(), alc = alc, lem = lem, uci = uci)
 567             msg = u"Fini !"
 568             dial.Destroy()
 569             dlg = wx.MessageDialog(self.parent, msg, u"Export", wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
 570             dlg.CenterOnParent()
 571             dlg.ShowModal()
 572             dlg.Destroy()
 573
 574     def OnColored(self, evt) :
 575         dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.html', 'title': _(u"Colored corpus").decode('utf8')})
 576         dial.fbb.SetValue(os.path.join(os.path.dirname(self.page.dictpathout['ira']), 'corpus_couleur.html'))
 577         dial.CenterOnParent()
 578         res = dial.ShowModal()
 579         if res == wx.ID_OK :
 580             fileout = dial.fbb.GetValue()
 581             dial.Destroy()
 582             if self.page.parametres['classif_mode'] != 2 :
 583                 uci = False
 584             else :
 585                 uci = True
 586             txt = self.page.corpus.make_colored_corpus(uci = uci)
 587             with open(fileout, 'w') as f :
 588                 f.write(txt)
 589             msg = ' !\n'.join([_(u"Done").decode('utf8'), _(u"Open in a web browser ?").decode('utf8')])
 590             dlg = wx.MessageDialog(self.parent, msg, u"Corpus en couleur", wx.NO | wx.YES | wx.NO_DEFAULT | wx.ICON_QUESTION)
 591             dlg.CenterOnParent()
 592             if dlg.ShowModal() == wx.ID_YES :
 593                 webbrowser.open(fileout)
 594             dlg.Destroy()
 595
 596     def OnNavig(self, evt):
 597         if 'FrameSearch' not in dir(self.page) :
 598             self.page.FrameSearch = SearchFrame(self.parent, -1, _(u"Search ...").decode('utf8'), self.page.corpus)
 599         self.page.FrameSearch.Show()
 600
 601     def StatClasse(self, evt):
 602         dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.csv', 'title': _(u"Clusters statistics").decode('utf8')})
 603         dial.fbb.SetValue( os.path.join(os.path.dirname(self.page.dictpathout['ira']), 'stat_par_classe.csv'))
 604         dial.CenterOnParent()
 605         res = dial.ShowModal()
 606         if res == wx.ID_OK :
 607             fileout = dial.fbb.GetValue()
 608             dial.Destroy()
 609             self.page.corpus.get_stat_by_cluster(fileout)
 610             msg = u"Fini !"
 611             dlg = wx.MessageDialog(self.parent, msg, _(u"Clusters statistics").decode('utf8'), wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
 612             dlg.CenterOnParent()
 613             if dlg.ShowModal() == wx.ID_OK :
 614                 dlg.Destroy()
 615
 616     def OpenAntipro(self, evt) :
 617         find = False
 618         for i in range(0, self.page.TabChdSim.GetPageCount()) :
 619             page = self.page.TabChdSim.GetPage(i)
 620             if self.page.TabChdSim.GetPageText(i) == _(u"Antiprofiles").decode('utf8') :
 621                 self.page.TabChdSim.SetSelection(i)
 622                 find = True
 623                 break
 624         if not find :
 625             open_antiprofil(self.page, self.page.dictpathout['ANTIPRO_OUT'], self.parent.syscoding)
 626             self.page.TabChdSim.SetSelection(self.page.TabChdSim.GetPageCount() - 1)
 627
 628     def OnRapport(self, evt) :
 629         dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.txt', 'title': _(u"Report").decode('utf8')})
 630         dial.fbb.SetValue(self.page.dictpathout['rapport'])
 631         dial.CenterOnParent()
 632         res = dial.ShowModal()
 633         if res == wx.ID_OK :
 634             fileout = dial.fbb.GetValue()
 635             dial.Destroy()
 636             with open(fileout, 'w') as f :
 637                 f.write(self.page.debtext + '\n' + GetTxtProfile(self.page.DictProfile, self.page.cluster_size))
 638             msg = u"Fini !"
 639             dlg = wx.MessageDialog(self.parent, msg, _(u"Report").decode('utf8'), wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
 640             dlg.CenterOnParent()
 641             dlg.ShowModal()
 642             dlg.Destroy()
 643         else :
 644             dial.Destroy()
 645
 646     def OnExportDictionary(self, evt) :
 647         corpus = self.page.corpus
 648         corpus.export_dictionary(self.page.pathout['dictionary.csv'], self.parent.syscoding)
 649         log.info('export dictionary %s' % self.page.pathout['dictionary.csv'])
 650         dial = wx.MessageDialog(self.parent, self.page.pathout['dictionary.csv'], 'Export', wx.OK)
 651         dial.ShowModal()
 652         dial.Destroy()
 653
 654     def OnExportLems(self, evt) :
 655         corpus = self.page.corpus
 656         corpus.export_lems(self.page.pathout['lemmes.csv'], self.parent.syscoding)
 657         log.info('export lemmes %s' % self.page.pathout['lemmes.csv'])
 658         dial = wx.MessageDialog(self.parent, self.page.pathout['lemmes.csv'], 'Export', wx.OK)
 659         dial.ShowModal()
 660         dial.Destroy()
 661
 662     def OnTgenEditor(self, evt):
 663         corpus = self.page.corpus
 664         tgenpath = os.path.join(self.page.parametres['pathout'], 'tgen.csv')
 665         tgen = TGen(path = tgenpath, encoding = self.parent.syscoding)
 666         if os.path.exists(tgenpath) :
 667             tgen.read(tgenpath)
 668         if isinstance(evt, list) :
 669             i = 0
 670             while 'tgen%i' %i in tgen.tgen :
 671                 i += 1
 672             tgenname = 'tgen%i' %i
 673             tgen.tgen[tgenname] = evt
 674         tgenframe = TGenFrame(self.parent, corpus, tgen)
 675         tgenframe.Show()
 676         if isinstance(evt, list) :
 677             tgenframe.OnNewTgen(None, tgen = tgenname)
 678
 679     def OnTgenCompute(self, evt):
 680         corpus = self.page.corpus
 681         tgenpath = os.path.join(self.page.parametres['pathout'], 'tgen.csv')
 682         if not os.path.exists(tgenpath) :
 683             message = wx.MessageDialog(self.parent, _(u"No TGen yet !"), style = wx.ICON_EXCLAMATION | wx.OK)
 684             message.ShowModal()
 685             message.Destroy()
 686         else :
 687             self.page.parametres['tgenpath'] = tgenpath
 688             tgen = TGen(path = tgenpath, encoding = self.parent.syscoding)
 689             if self.page.parametres['type'] == 'spec' :
 690                 self.page.parametres['etoiles'] = self.page.etoiles
 691                 TgenSpec(self.parent, corpus, self.page.parametres)
 692             elif self.page.parametres['type'] == 'alceste' :
 693                 TgenProf(self.parent, corpus, self.page.parametres, self.page.cluster_size)
 694             TgenLayout(self.page)
 695
 696     def OnExportClasses(self, event):
 697         corpus = self.page.corpus
 698         if self.page.parametres['classif_mode'] != 2 :
 699             uci = False
 700         else :
 701             uci = True
 702         busy = wx.BusyInfo(_("Please wait...").decode('utf8'), self.parent)
 703         wx.SafeYield()
 704         for i in range(1, self.page.parametres['clnb'] + 1) :
 705             corpus.export_classe(self.page.pathout['classe_%i_export.txt' % i], i, uci = uci)
 706         del busy
 707         dial = wx.MessageDialog(self, self.page.pathout['classe_x_export.txt'], u"Export", wx.OK|wx.ICON_INFORMATION)
 708         dial.ShowModal()
 709         dial.Destroy()
 710
 711     def OnSubCorpusFromClusters(self, evt):
 712         self.parent.OnSubText(evt, corpus = self.getcorpus(), parametres = {'fromclusters' : True, 'clnb': self.page.parametres['clnb'], 'lc' : self.page.corpus.lc})
 713
 714     def OnRename(self, event):
 715         pydata = self.itemdict['pydata']
 716         if 'matrix_name' in pydata :
 717             name = 'matrix_name'
 718         elif 'corpus_name' in pydata :
 719             name = 'corpus_name'
 720         else :
 721             name = 'name'
 722         oldname = pydata[name]
 723         dlg = wx.TextEntryDialog(self, "Please Enter The New Item Name", 'Item Naming', oldname)
 724         if dlg.ShowModal() == wx.ID_OK:
 725             newname = dlg.GetValue()
 726             dlg.Destroy()
 727             pydata[name] = newname
 728             Totconf = DoConf(configfile=pydata['ira'])
 729             conf = Totconf.getoptions()
 730             conf[name] = newname
 731             Totconf.makeoptions(Totconf.getsections(), [conf])
 732             self.history.update(pydata)
 733             self.SetItemText(self.current, newname)
 734             self.EnsureVisible(self.current)
 735
 736     def OnItemBackground(self, event):
 737
 738         colourdata = wx.ColourData()
 739         colourdata.SetColour(self.itemdict["back"])
 740         dlg = wx.ColourDialog(self, colourdata)
 741
 742         dlg.GetColourData().SetChooseFull(True)
 743
 744         if dlg.ShowModal() == wx.ID_OK:
 745             data = dlg.GetColourData()
 746             col1 = data.GetColour().Get()
 747             self.SetItemBackgroundColour(self.current, col1)
 748         dlg.Destroy()
 749
 750
 751     def OnItemForeground(self, event):
 752
 753         colourdata = wx.ColourData()
 754         colourdata.SetColour(self.itemdict["fore"])
 755         dlg = wx.ColourDialog(self, colourdata)
 756
 757         dlg.GetColourData().SetChooseFull(True)
 758
 759         if dlg.ShowModal() == wx.ID_OK:
 760             data = dlg.GetColourData()
 761             col1 = data.GetColour().Get()
 762             self.SetItemTextColour(self.current, col1)
 763         dlg.Destroy()
 764
 765
 766     def OnItemBold(self, event):
 767
 768         self.SetItemBold(self.current, not self.itemdict["isbold"])
 769
 770
 771     def OnItemFont(self, event):
 772
 773         data = wx.FontData()
 774         font = self.itemdict["font"]
 775
 776         if font is None:
 777             font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
 778
 779         data.SetInitialFont(font)
 780
 781         dlg = wx.FontDialog(self, data)
 782
 783         if dlg.ShowModal() == wx.ID_OK:
 784             data = dlg.GetFontData()
 785             font = data.GetChosenFont()
 786             self.SetItemFont(self.current, font)
 787
 788         dlg.Destroy()
 789
 790
 791     def OnItemHyperText(self, event):
 792
 793         self.SetItemHyperText(self.current, not self.itemdict["ishtml"])
 794
 795
 796     def OnEnableWindow(self, event):
 797
 798         enable = self.GetItemWindowEnabled(self.current)
 799         self.SetItemWindowEnabled(self.current, not enable)
 800
 801
 802     def OnDisableItem(self, event):
 803
 804         self.EnableItem(self.current, False)
 805
 806
 807     def OnItemIcons(self, event):
 808
 809         bitmaps = [self.itemdict["normal"], self.itemdict["selected"],
 810                    self.itemdict["expanded"], self.itemdict["selexp"]]
 811
 812         wx.BeginBusyCursor()
 813         dlg = TreeIcons(self, -1, bitmaps=bitmaps)
 814         wx.EndBusyCursor()
 815         dlg.ShowModal()
 816
 817
 818     def SetNewIcons(self, bitmaps):
 819
 820         self.SetItemImage(self.current, bitmaps[0], CT.TreeItemIcon_Normal)
 821         self.SetItemImage(self.current, bitmaps[1], CT.TreeItemIcon_Selected)
 822         self.SetItemImage(self.current, bitmaps[2], CT.TreeItemIcon_Expanded)
 823         self.SetItemImage(self.current, bitmaps[3], CT.TreeItemIcon_SelectedExpanded)
 824
 825
 826     def OnItemInfo(self, event):
 827
 828         itemtext = self.itemdict["text"]
 829         numchildren = str(self.itemdict["children"])
 830         itemtype = self.itemdict["itemtype"]
 831         pydata = self.itemdict['pydata']
 832         #if 'analyses' in pydata :
 833         #    toshow = dict([[val, pydata[val]] for val in pydata if val not in['analyses', 'isload']])
 834         #else :
 835         toshow = pydata['ira']
 836         toshow = DoConf(toshow).getoptions()
 837         txt = DoConf().totext(toshow)
 838         parametres = [val.split('\t\t:') for val in txt.splitlines()]
 839         parametres.sort()
 840
 841         if itemtype == 0:
 842             itemtype = "Normal"
 843         elif itemtype == 1:
 844             itemtype = "CheckBox"
 845         else:
 846             itemtype = "RadioButton"
 847
 848         dlg = InfoDialog(self, itemtext, parametres)
 849         dlg.CenterOnParent()
 850         dlg.ShowModal()
 851         dlg.Destroy()
 852
 853
 854
 855     def OnItemDelete(self, event):
 856
 857         strs = "Are You Sure You Want To Delete Item " + self.GetItemText(self.current) + "?"
 858         dlg = wx.MessageDialog(None, strs, 'Deleting Item', wx.OK | wx.CANCEL | wx.ICON_QUESTION)
 859
 860         if dlg.ShowModal() in [wx.ID_NO, wx.ID_CANCEL]:
 861             dlg.Destroy()
 862             return
 863
 864         dlg.Destroy()
 865
 866         pydata = self.itemdict['pydata']
 867         if 'corpus_name' in pydata :
 868             self.history.delete(pydata, True)
 869         else :
 870             self.history.delete(pydata)
 871         self.DeleteChildren(self.current)
 872         self.Delete(self.current)
 873         self.current = None
 874
 875
 876
 877     def OnItemPrepend(self, event):
 878
 879         dlg = wx.TextEntryDialog(self, "Please Enter The New Item Name", 'Item Naming', 'Python')
 880
 881         if dlg.ShowModal() == wx.ID_OK:
 882             newname = dlg.GetValue()
 883             newitem = self.PrependItem(self.current, newname)
 884             self.EnsureVisible(newitem)
 885
 886         dlg.Destroy()
 887
 888     def AddAnalyse(self, parametres, itemParent = None, bold = True) :
 889         uuid = parametres.get('corpus', None)
 890         if uuid is not None :
 891             if itemParent is None :
 892                 itemParent = self.textroot
 893             child, cookie = self.GetFirstChild(itemParent)
 894             corpus = None
 895             while child :
 896                 pydata = self.GetPyData(child)
 897                 if pydata['uuid'] == uuid :
 898                     corpus = child
 899                     break
 900                 self.GiveFocus(child, uuid)
 901                 child, cookie = self.GetNextChild(itemParent, cookie)
 902             #item = self.AppendItem(child, parametres['name'])
 903             if corpus is not None :
 904                 item = self.AppendItem(corpus, parametres['name'])
 905             else :
 906                 item = self.AppendItem(self.textroot, parametres['name'])
 907         else :
 908             item = self.AppendItem(self.matroot, parametres['name'])
 909         self.SetPyData(item, parametres)
 910         if parametres['type'] in self.ild :
 911             img = self.ild[parametres['type']]
 912         else :
 913             img = 24
 914         self.SetItemImage(item, img, CT.TreeItemIcon_Normal)
 915         self.SetItemImage(item, 13, CT.TreeItemIcon_Expanded)
 916         self.SetItemBold(item, bold)
 917         self.SelectItem(item)
 918
 919     def AddMatAnalyse(self, parametres, itemParent = None, bold = True) :
 920         uuid = parametres.get('matrix', None)
 921         if uuid is not None :
 922             if itemParent is None :
 923                 itemParent = self.matroot
 924             child, cookie = self.GetFirstChild(itemParent)
 925             matrix = None
 926             while child :
 927                 pydata = self.GetPyData(child)
 928                 if pydata['uuid'] == uuid :
 929                     matrix = child
 930                     break
 931                 self.GiveFocus(child, uuid)
 932                 child, cookie = self.GetNextChild(itemParent, cookie)
 933             #item = self.AppendItem(child, parametres['name'])
 934             if matrix is not None :
 935                 item = self.AppendItem(matrix, parametres['name'])
 936             else :
 937                 item = self.AppendItem(self.matroot, parametres['name'])
 938         self.SetPyData(item, parametres)
 939         if parametres['type'] in self.ild :
 940             img = self.ild[parametres['type']]
 941         else :
 942             img = 24
 943         self.SetItemImage(item, img, CT.TreeItemIcon_Normal)
 944         self.SetItemImage(item, 13, CT.TreeItemIcon_Expanded)
 945         self.SetItemBold(item, bold)
 946         self.SelectItem(item)
 947
 948     def OnItemAppend(self, item, select = True):
 949         if 'corpus_name' in item :
 950             child = self.InsertItem(self.textroot, 0, item['corpus_name'])
 951         else :
 952             child = self.InsertItem(self.matroot, 0, item['matrix_name'])
 953         self.SetPyData(child, item)
 954         if item['type'] in self.ild :
 955             img = self.ild[item['type']]
 956         else :
 957             img = 24
 958         self.SetItemImage(child, img, CT.TreeItemIcon_Normal)
 959         self.SetItemImage(child, img, CT.TreeItemIcon_Expanded)
 960         if select :
 961             self.history.addtab(item)
 962             self.SetItemBold(child, True)
 963             self.SelectItem(child)
 964
 965         #dlg = wx.TextEntryDialog(self, "Please Enter The New Item Name", 'Item Naming', 'Python')
 966
 967         #if dlg.ShowModal() == wx.ID_OK:
 968         #    newname = dlg.GetValue()
 969         #    newitem = self.AppendItem(self.current, newname)
 970         #    self.EnsureVisible(newitem)
 971
 972
 973         #dlg.Destroy()
 974
 975
 976     def OnBeginEdit(self, event):
 977
 978         #self.log.info("OnBeginEdit" + "\n")
 979         # show how to prevent edit...
 980         item = event.GetItem()
 981         if item and self.GetItemText(item) == "The Root Item":
 982             wx.Bell()
 983             #self.log.info("You can't edit this one..." + "\n")
 984
 985             # Lets just see what's visible of its children
 986             cookie = 0
 987             root = event.GetItem()
 988             (child, cookie) = self.GetFirstChild(root)
 989
 990             while child:
 991                 #self.log.info("Child [%s] visible = %d" % (self.GetItemText(child), self.IsVisible(child)) + "\n")
 992                 (child, cookie) = self.GetNextChild(root, cookie)
 993
 994             event.Veto()
 995
 996
 997     def OnEndEdit(self, event):
 998
 999         #self.log.info("OnEndEdit: %s %s" %(event.IsEditCancelled(), event.GetLabel()))
1000         # show how to reject edit, we'll not allow any digits
1001         for x in event.GetLabel():
1002             if x in string.digits:
1003                 #self.log.info(", You can't enter digits..." + "\n")
1004                 event.Veto()
1005                 return
1006
1007         self.log.info("\n")
1008
1009
1010     def OnLeftDClick(self, event):
1011         pt = event.GetPosition()
1012         item, flags = self.HitTest(pt)
1013         if item is not None :
1014             pydata = self.GetPyData(item)
1015             if pydata['uuid'] in self.parent.history.opened :
1016                 for i in range(self.parent.nb.GetPageCount()) :
1017                     page = self.parent.nb.GetPage(i)
1018                     if 'parametres' in dir(page) :
1019                         if page.parametres['uuid'] == pydata['uuid'] :
1020                             self.parent.nb.SetSelection(i)
1021                             break
1022             elif pydata['uuid'] in ['textroot', 'matroot'] :
1023                 pass
1024             else :
1025                 if os.path.exists(pydata['ira']) :
1026                     busy = wx.BusyInfo(_("Please wait..."), self.parent)
1027                     wx.SafeYield()
1028                     try :
1029                         OpenAnalyse(self.parent, pydata)
1030                         del busy
1031                         self.SetItemBold(item, True)
1032                         self.OnSelChanged(pydata = pydata)
1033                     except :
1034                         del busy
1035                         BugReport(self.ira)
1036                 else :
1037                     wx.MessageBox(_(u"This file does not exist : %s" % pydata['ira']).decode('utf8'), 'Information', wx.ICON_EXCLAMATION | wx.STAY_ON_TOP )
1038         #if item and (flags & CT.TREE_HITTEST_ONITEMLABEL):
1039         #    if self.GetAGWWindowStyleFlag() & CT.TR_EDIT_LABELS:
1040         #        self.log.info("OnLeftDClick: %s (manually starting label edit)"% self.GetItemText(item) + "\n")
1041
1042                 #self.EditLabel(item)
1043         #    else:
1044         #        pydata = self.GetPyData(item)
1045         #        print pydata
1046         #        self.log.info("OnLeftDClick: Cannot Start Manual Editing, Missing Style TR_EDIT_LABELS\n")
1047
1048         event.Skip()
1049
1050
1051     def OnItemExpanded(self, event):
1052
1053         item = event.GetItem()
1054         if item:
1055             self.log.info("OnItemExpanded: %s" % self.GetItemText(item) + "\n")
1056
1057
1058     def OnItemExpanding(self, event):
1059
1060         item = event.GetItem()
1061         if item:
1062             self.log.info("OnItemExpanding: %s" % self.GetItemText(item) + "\n")
1063
1064         event.Skip()
1065
1066
1067     def OnItemCollapsed(self, event):
1068
1069         item = event.GetItem()
1070         if item:
1071             self.log.info("OnItemCollapsed: %s" % self.GetItemText(item) + "\n")
1072
1073
1074     def OnItemCollapsing(self, event):
1075
1076         item = event.GetItem()
1077         if item:
1078             self.log.info("OnItemCollapsing: %s" % self.GetItemText(item) + "\n")
1079
1080         event.Skip()
1081
1082
1083     def OnSelChanged(self, event = None, pydata = None):
1084         if event is not None :
1085             item = event.GetItem()
1086             pydata = self.GetPyData(item)
1087
1088         if pydata is not None :
1089             if 'corpus_name' in pydata or 'corpus' in pydata :
1090                 self.ira.ShowMenu('text', True)
1091                 self.ira.ShowMenu('matrix', False)
1092             if 'matrix_name' in pydata or 'matrix' in pydata:
1093                 self.ira.ShowMenu('text', False)
1094                 self.ira.ShowMenu('matrix', True)
1095             self.pydata = pydata
1096             if pydata['uuid'] in self.parent.history.opened :
1097                 for i in range(self.parent.nb.GetPageCount()) :
1098                     self.page = self.parent.nb.GetPage(i)
1099                     if 'parametres' in dir(self.page) :
1100                         if self.page.parametres['uuid'] == pydata['uuid'] :
1101                             self.parent.nb.SetSelection(i)
1102                             break
1103         if event is not None :
1104             event.Skip()
1105
1106
1107     def OnSelChanging(self, event):
1108
1109         item = event.GetItem()
1110         olditem = event.GetOldItem()
1111
1112         if item:
1113             if not olditem:
1114                 olditemtext = "None"
1115             else:
1116                 olditemtext = self.GetItemText(olditem)
1117             #self.log.info("OnSelChanging: From %s" % olditemtext + " To %s" % self.GetItemText(item) + "\n")
1118
1119         event.Skip()
1120
1121
1122     def OnBeginDrag(self, event):
1123
1124         self.item = event.GetItem()
1125         if self.item:
1126             self.log.info("Beginning Drag..." + "\n")
1127
1128             event.Allow()
1129
1130
1131     def OnBeginRDrag(self, event):
1132
1133         self.item = event.GetItem()
1134         if self.item:
1135             self.log.info("Beginning Right Drag..." + "\n")
1136
1137             event.Allow()
1138
1139
1140     def OnEndDrag(self, event):
1141
1142         self.item = event.GetItem()
1143         if self.item:
1144             self.log.info("Ending Drag!" + "\n")
1145
1146         event.Skip()
1147
1148
1149     def OnDeleteItem(self, event):
1150
1151         item = event.GetItem()
1152
1153         if not item:
1154             return
1155
1156         self.log.info("Deleting Item: %s" % self.GetItemText(item) + "\n")
1157         event.Skip()
1158
1159
1160     def OnItemCheck(self, event):
1161
1162         item = event.GetItem()
1163         self.log.info("Item " + self.GetItemText(item) + " Has Been Checked!\n")
1164         event.Skip()
1165
1166
1167     def OnItemChecking(self, event):
1168
1169         item = event.GetItem()
1170         self.log.info("Item " + self.GetItemText(item) + " Is Being Checked...\n")
1171         event.Skip()
1172
1173
1174     def OnToolTip(self, event):
1175
1176         item = event.GetItem()
1177         if item:
1178             event.SetToolTip(wx.ToolTip(self.GetItemText(item)))
1179
1180
1181     def OnItemMenu(self, event):
1182
1183         item = event.GetItem()
1184         if item:
1185             self.log.info("OnItemMenu: %s" % self.GetItemText(item) + "\n")
1186
1187         event.Skip()
1188
1189
1190     def OnKey(self, event):
1191
1192         keycode = event.GetKeyCode()
1193         keyname = keyMap.get(keycode, None)
1194
1195         if keycode == wx.WXK_BACK:
1196             self.log.info("OnKeyDown: HAHAHAHA! I Vetoed Your Backspace! HAHAHAHA\n")
1197             return
1198
1199         if keyname is None:
1200             if "unicode" in wx.PlatformInfo:
1201                 keycode = event.GetUnicodeKey()
1202                 if keycode <= 127:
1203                     keycode = event.GetKeyCode()
1204                 keyname = "\"" + unichr(event.GetUnicodeKey()) + "\""
1205                 if keycode < 27:
1206                     keyname = "Ctrl-%s" % chr(ord('A') + keycode-1)
1207
1208             elif keycode < 256:
1209                 if keycode == 0:
1210                     keyname = "NUL"
1211                 elif keycode < 27:
1212                     keyname = "Ctrl-%s" % chr(ord('A') + keycode-1)
1213                 else:
1214                     keyname = "\"%s\"" % chr(keycode)
1215             else:
1216                 keyname = "unknown (%s)" % keycode
1217
1218         self.log.info("OnKeyDown: You Pressed '" + keyname + "'\n")
1219
1220         event.Skip()
1221
1222
1223     def OnActivate(self, event):
1224
1225         if self.item:
1226             self.log.info("OnActivate: %s" % self.GetItemText(self.item) + "\n")
1227
1228         event.Skip()
1229
1230
1231     def OnHyperLink(self, event):
1232
1233         item = event.GetItem()
1234         if item:
1235             self.log.info("OnHyperLink: %s" % self.GetItemText(self.item) + "\n")
1236
1237
1238     def OnTextCtrl(self, event):
1239
1240         char = chr(event.GetKeyCode())
1241         self.log.info("EDITING THE TEXTCTRL: You Wrote '" + char + \
1242                        "' (KeyCode = " + str(event.GetKeyCode()) + ")\n")
1243         event.Skip()
1244
1245
1246     def OnComboBox(self, event):
1247
1248         selection = event.GetEventObject().GetValue()
1249         self.log.info("CHOICE FROM COMBOBOX: You Chose '" + selection + "'\n")
1250         event.Skip()