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, open_folder
  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 = wx.MenuItem(menu, wx.ID_ANY, _(u"Informations").decode('utf8'))
 396             info.SetBitmap(wx.ArtProvider_GetBitmap(wx.ART_INFORMATION, size = (16,16)))
 397             menu.AppendItem(info)
 398
 399             rename = wx.MenuItem(menu, wx.ID_ANY, _(u"Rename").decode('utf8'))
 400             rename.SetBitmap(wx.ArtProvider_GetBitmap(wx.ART_TIP, size = (16,16)))
 401             menu.AppendItem(rename)
 402
 403             openfolder = wx.MenuItem(menu, wx.ID_ANY, _(u"Open directory").decode('utf8'))
 404             openfolder.SetBitmap(wx.ArtProvider_GetBitmap(wx.ART_FOLDER_OPEN, size = (16,16)))
 405             menu.AppendItem(openfolder)
 406
 407             menu.AppendSeparator()
 408
 409             if 'corpus_name' in pydata :
 410                 buildmenu(menu, self.parent.text_menu)
 411                 menu.AppendSeparator()
 412             elif 'matrix_name' in pydata :
 413                 buildmenu(menu, self.parent.matrix_menu)
 414                 menu.AppendSeparator()
 415             elif pydata.get('type', False) == 'alceste' and pydata['uuid'] in self.parent.history.opened :
 416                 openmenu = wx.Menu()
 417                 antipro = openmenu.Append(wx.ID_ANY, _(u"Antiprofiles").decode('utf8'))
 418                 menu.AppendMenu(wx.ID_ANY, _(u"Open ...").decode('utf8'), openmenu)
 419
 420                 profsr = menu.Append(wx.ID_ANY, _(u"Repeated segments profiles").decode('utf8'))
 421                 profgram = menu.Append(wx.ID_ANY, _(u"POS profiles").decode('utf8'))
 422                 tgen = menu.Append(wx.ID_ANY, _(u"Tgen Editor").decode('utf8'))
 423                 computetgen = menu.Append(wx.ID_ANY, _(u"Compute Tgen").decode('utf8'))
 424                 export_corpus = menu.Append(wx.ID_ANY, _(u"Export corpus").decode('utf8'))
 425                 colored = menu.Append(wx.ID_ANY, _(u"Colored corpus").decode('utf8'))
 426                 navig = menu.Append(wx.ID_ANY, _(u"Navigator").decode('utf8'))
 427                 statclasse = menu.Append(wx.ID_ANY, _(u"Clusters statistics").decode('utf8'))
 428                 rapport = menu.Append(wx.ID_ANY, _(u"Report").decode('utf8'))
 429                 export_classes = menu.Append(wx.ID_ANY, _(u"Export clusters").decode('utf8'))
 430                 subcorpusfromcl = menu.Append(wx.ID_ANY, _(u"Sub corpus from clusters").decode('utf8'))
 431                 menu.AppendSeparator()
 432                 self.Bind(wx.EVT_MENU, self.OpenAntipro, antipro)
 433                 self.Bind(wx.EVT_MENU, self.OnProfSR, profsr)
 434                 self.Bind(wx.EVT_MENU, self.OnProfGram, profgram)
 435                 self.Bind(wx.EVT_MENU, self.OnTgenEditor, tgen)
 436                 self.Bind(wx.EVT_MENU, self.OnTgenCompute, computetgen)
 437                 self.Bind(wx.EVT_MENU, self.OnExportCorpus, export_corpus)
 438                 self.Bind(wx.EVT_MENU, self.OnColored, colored)
 439                 self.Bind(wx.EVT_MENU, self.OnNavig, navig)
 440                 self.Bind(wx.EVT_MENU, self.StatClasse, statclasse)
 441                 self.Bind(wx.EVT_MENU, self.OnRapport, rapport)
 442                 self.Bind(wx.EVT_MENU, self.OnExportClasses, export_classes)
 443                 self.Bind(wx.EVT_MENU, self.OnSubCorpusFromClusters, subcorpusfromcl)
 444             elif pydata.get('type', False) == 'stat'  and pydata['uuid'] in self.parent.history.opened :
 445                 export_dictionary =  menu.Append(wx.ID_ANY, _(u"Export dictionary").decode('utf8'))
 446                 export_lems =  menu.Append(wx.ID_ANY, _(u"Export lemma dictionary").decode('utf8'))
 447                 self.Bind(wx.EVT_MENU, self.OnExportDictionary, export_dictionary)
 448                 self.Bind(wx.EVT_MENU, self.OnExportLems, export_lems)
 449                 menu.AppendSeparator()
 450             elif pydata.get('type', False) == 'spec'  and pydata['uuid'] in self.parent.history.opened :
 451                 tgen = menu.Append(wx.ID_ANY, _(u"Tgen Editor").decode('utf8'))
 452                 computetgen = menu.Append(wx.ID_ANY, _(u"Compute Tgen").decode('utf8'))
 453                 self.Bind(wx.EVT_MENU, self.OnTgenEditor, tgen)
 454                 self.Bind(wx.EVT_MENU, self.OnTgenCompute, computetgen)
 455                 menu.AppendSeparator()
 456             elif pydata.get('type', False) == 'reinertmatrix' and pydata['uuid'] in self.parent.history.opened :
 457                 openmenu = wx.Menu()
 458                 antipro = openmenu.Append(wx.ID_ANY, _(u"antiprofiles").decode('utf8'))
 459                 rapport = menu.Append(wx.ID_ANY, _(u"Report").decode('utf8'))
 460                 menu.AppendMenu(wx.ID_ANY, _(u"Open ...").decode('utf8'), openmenu)
 461                 self.Bind(wx.EVT_MENU, self.OpenAntipro, antipro)
 462                 self.Bind(wx.EVT_MENU, self.OnRapport, rapport)
 463
 464             itemdelete = wx.MenuItem(menu, wx.ID_ANY, _(u"Delete from history").decode('utf8'))
 465             itemdelete.SetBitmap(wx.ArtProvider_GetBitmap(wx.ART_DELETE, size = (16,16)))
 466             menu.AppendItem(itemdelete)
 467             #item11 = menu.Append(wx.ID_ANY, "Prepend An Item")
 468             #item12 = menu.Append(wx.ID_ANY, "Append An Item")
 469
 470             #self.Bind(wx.EVT_MENU, self.OnItemBackground, item1)
 471             #self.Bind(wx.EVT_MENU, self.OnItemForeground, item2)
 472             #self.Bind(wx.EVT_MENU, self.OnItemBold, item3)
 473             #self.Bind(wx.EVT_MENU, self.OnItemFont, item4)
 474             #self.Bind(wx.EVT_MENU, self.OnItemHyperText, item5)
 475             #self.Bind(wx.EVT_MENU, self.OnEnableWindow, item6)
 476             #self.Bind(wx.EVT_MENU, self.OnDisableItem, item7)
 477             #self.Bind(wx.EVT_MENU, self.OnItemIcons, item8)
 478             self.Bind(wx.EVT_MENU, self.OnItemInfo, info)
 479             self.Bind(wx.EVT_MENU, self.OnRename, rename)
 480             self.Bind(wx.EVT_MENU, self.OnItemDelete, itemdelete)
 481             self.Bind(wx.EVT_MENU, self.OnOpenFolder, openfolder)
 482             #self.Bind(wx.EVT_MENU, self.OnItemPrepend, item11)
 483             #self.Bind(wx.EVT_MENU, self.OnItemAppend, item12)
 484
 485             self.PopupMenu(menu)
 486             menu.Destroy()
 487
 488     def getcorpus(self):
 489         busy = wx.BusyInfo(_("Please wait...Reading corpus").decode('utf8'), self.parent)
 490         wx.SafeYield()
 491         if self.pydata['uuid'] in self.parent.history.openedcorpus :
 492             corpus = copycorpus(self.parent.history.openedcorpus[self.pydata['uuid']])
 493         elif 'corpus_name' in self.pydata :
 494             corpus = Corpus(self.parent, parametres = DoConf(self.pydata['ira']).getoptions('corpus'), read = True)
 495         else :
 496             cuuid = self.pydata['corpus']
 497             if cuuid in self.parent.history.openedcorpus :
 498                 corpus = copycorpus(self.parent.history.openedcorpus[cuuid])
 499             else :
 500                 irapath = self.parent.history.corpus[cuuid]['ira']
 501                 corpus = Corpus(self.parent, parametres = DoConf(irapath).getoptions('corpus'), read = True)
 502         del busy
 503         return corpus
 504
 505     def getmatrix(self):
 506         if 'matrix_name' in self.pydata :
 507             matrix = Tableau(self.parent, parametres = DoConf(self.pydata['ira']).getoptions('matrix'))
 508             matrix.open()
 509             return copymatrix(matrix)
 510         else :
 511             cuuid = self.pydata['matrix']
 512             matrix = Tableau(self.parent, parametres = DoConf(self.history.matrixanalyse[cuuid]['ira']).getoptions('matrix'))
 513             matrix.open()
 514             return copymatrix(matrix)
 515
 516     def OnSpec(self, evt) :
 517         self.parent.OnTextSpec(evt, self.getcorpus())
 518
 519     def OnStat(self, evt) :
 520         self.parent.OnTextStat(evt, self.getcorpus())
 521
 522     def OnReinert(self, evt) :
 523         self.parent.OnTextReinert(evt, self.getcorpus())
 524
 525     def OnPam(self, evt) :
 526         self.parent.OnPamSimple(evt, self.getcorpus())
 527
 528     def OnSimiTxt(self, evt) :
 529         self.parent.OnSimiTxt(evt, self.getcorpus())
 530
 531     def OnWordCloud(self, evt) :
 532         self.parent.OnWordCloud(evt, self.getcorpus())
 533
 534 #    def OnFreq(self, evt):
 535 #        self.parent.OnFreq(evt, self.getmatrix())
 536
 537 #    def OnChiSquare(self, evt):
 538 #        self.parent.OnChi2(evt, self.getmatrix())
 539
 540 #    def OnSimiTab(self, evt):
 541 #        self.parent.OnSimiTab(evt, self.getmatrix())
 542
 543 #    def OnProto(self, evt):
 544 #        self.parent.OnProto(evt, self.getmatrix())
 545
 546 #    def OnSplitFromVar(self, evt):
 547 #        self.parent.OnSplitVar(evt, self.getmatrix())
 548
 549 #    def OnCHDReinert(self, evt):
 550 #        self.parent.OnCHDReinert(evt, self.getmatrix())
 551
 552     #def OnSubTextFromMeta(self, evt):
 553     #    self.parent.OnSubText(self.getcorpus(), parametres = {'frommeta' : True})
 554
 555     #def OnSubTextFromTheme(self, evt):
 556     #    self.parent.OnSubText(self.getcorpus(), parametres = {'fromtheme' : True})
 557
 558     def OnProfSR(self, evt) :
 559         ProfileSegment(self.parent, self.page.dictpathout, self.page.parametres, self.page.corpus)
 560
 561     def OnProfGram(self, evt) :
 562         ProfilType(self.parent, self.page.corpus, self.page.parametres)
 563
 564     def OnExportCorpus(self, evt) :
 565         dial = PrefExport(self, self.parent)
 566         dial.fbb.SetValue(os.path.join(os.path.dirname(self.page.dictpathout['ira']), 'export_corpus.txt'))
 567         dial.CenterOnParent()
 568         res = dial.ShowModal()
 569         if res == wx.ID_OK :
 570             if dial.radio_type.GetSelection() == 0 : alc = True
 571             else : alc = False
 572             if dial.radio_lem.GetSelection() == 0 : lem = True
 573             else : lem = False
 574             if self.page.parametres['classif_mode'] != 2 :
 575                 uci = False
 576             else :
 577                 uci = True
 578             self.page.corpus.export_corpus_classes(dial.fbb.GetValue(), alc = alc, lem = lem, uci = uci)
 579             msg = u"Fini !"
 580             dial.Destroy()
 581             dlg = wx.MessageDialog(self.parent, msg, u"Export", wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
 582             dlg.CenterOnParent()
 583             dlg.ShowModal()
 584             dlg.Destroy()
 585
 586     def OnColored(self, evt) :
 587         dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.html', 'title': _(u"Colored corpus").decode('utf8')})
 588         dial.fbb.SetValue(os.path.join(os.path.dirname(self.page.dictpathout['ira']), 'corpus_couleur.html'))
 589         dial.CenterOnParent()
 590         res = dial.ShowModal()
 591         if res == wx.ID_OK :
 592             fileout = dial.fbb.GetValue()
 593             dial.Destroy()
 594             if self.page.parametres['classif_mode'] != 2 :
 595                 uci = False
 596             else :
 597                 uci = True
 598             txt = self.page.corpus.make_colored_corpus(uci = uci)
 599             with open(fileout, 'w') as f :
 600                 f.write(txt)
 601             msg = ' !\n'.join([_(u"Done").decode('utf8'), _(u"Open in a web browser ?").decode('utf8')])
 602             dlg = wx.MessageDialog(self.parent, msg, u"Corpus en couleur", wx.NO | wx.YES | wx.NO_DEFAULT | wx.ICON_QUESTION)
 603             dlg.CenterOnParent()
 604             if dlg.ShowModal() == wx.ID_YES :
 605                 webbrowser.open(fileout)
 606             dlg.Destroy()
 607
 608     def OnNavig(self, evt):
 609         if 'FrameSearch' not in dir(self.page) :
 610             self.page.FrameSearch = SearchFrame(self.parent, -1, _(u"Search ...").decode('utf8'), self.page.corpus)
 611         self.page.FrameSearch.Show()
 612
 613     def StatClasse(self, evt):
 614         dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.csv', 'title': _(u"Clusters statistics").decode('utf8')})
 615         dial.fbb.SetValue( os.path.join(os.path.dirname(self.page.dictpathout['ira']), 'stat_par_classe.csv'))
 616         dial.CenterOnParent()
 617         res = dial.ShowModal()
 618         if res == wx.ID_OK :
 619             fileout = dial.fbb.GetValue()
 620             dial.Destroy()
 621             self.page.corpus.get_stat_by_cluster(fileout)
 622             msg = u"Fini !"
 623             dlg = wx.MessageDialog(self.parent, msg, _(u"Clusters statistics").decode('utf8'), wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
 624             dlg.CenterOnParent()
 625             if dlg.ShowModal() == wx.ID_OK :
 626                 dlg.Destroy()
 627
 628     def OpenAntipro(self, evt) :
 629         find = False
 630         for i in range(0, self.page.TabChdSim.GetPageCount()) :
 631             page = self.page.TabChdSim.GetPage(i)
 632             if self.page.TabChdSim.GetPageText(i) == _(u"Antiprofiles").decode('utf8') :
 633                 self.page.TabChdSim.SetSelection(i)
 634                 find = True
 635                 break
 636         if not find :
 637             open_antiprofil(self.page, self.page.dictpathout['ANTIPRO_OUT'], self.parent.syscoding)
 638             self.page.TabChdSim.SetSelection(self.page.TabChdSim.GetPageCount() - 1)
 639
 640     def OnRapport(self, evt) :
 641         dial = PrefSimpleFile(self, self.parent, **{'mask' : '*.txt', 'title': _(u"Report").decode('utf8')})
 642         dial.fbb.SetValue(self.page.dictpathout['rapport'])
 643         dial.CenterOnParent()
 644         res = dial.ShowModal()
 645         if res == wx.ID_OK :
 646             fileout = dial.fbb.GetValue()
 647             dial.Destroy()
 648             with open(fileout, 'w') as f :
 649                 f.write(self.page.debtext + '\n' + GetTxtProfile(self.page.DictProfile, self.page.cluster_size))
 650             msg = u"Fini !"
 651             dlg = wx.MessageDialog(self.parent, msg, _(u"Report").decode('utf8'), wx.OK | wx.NO_DEFAULT | wx.ICON_INFORMATION)
 652             dlg.CenterOnParent()
 653             dlg.ShowModal()
 654             dlg.Destroy()
 655         else :
 656             dial.Destroy()
 657
 658     def OnExportDictionary(self, evt) :
 659         corpus = self.page.corpus
 660         corpus.export_dictionary(self.page.pathout['dictionary.csv'], self.parent.syscoding)
 661         log.info('export dictionary %s' % self.page.pathout['dictionary.csv'])
 662         dial = wx.MessageDialog(self.parent, self.page.pathout['dictionary.csv'], 'Export', wx.OK)
 663         dial.ShowModal()
 664         dial.Destroy()
 665
 666     def OnExportLems(self, evt) :
 667         corpus = self.page.corpus
 668         corpus.export_lems(self.page.pathout['lemmes.csv'], self.parent.syscoding)
 669         log.info('export lemmes %s' % self.page.pathout['lemmes.csv'])
 670         dial = wx.MessageDialog(self.parent, self.page.pathout['lemmes.csv'], 'Export', wx.OK)
 671         dial.ShowModal()
 672         dial.Destroy()
 673
 674     def OnTgenEditor(self, evt):
 675         corpus = self.page.corpus
 676         tgenpath = os.path.join(self.page.parametres['pathout'], 'tgen.csv')
 677         tgen = TGen(path = tgenpath, encoding = self.parent.syscoding)
 678         if os.path.exists(tgenpath) :
 679             tgen.read(tgenpath)
 680         if isinstance(evt, list) :
 681             i = 0
 682             while 'tgen%i' %i in tgen.tgen :
 683                 i += 1
 684             tgenname = 'tgen%i' %i
 685             tgen.tgen[tgenname] = evt
 686         tgenframe = TGenFrame(self.parent, corpus, tgen)
 687         tgenframe.Show()
 688         if isinstance(evt, list) :
 689             tgenframe.OnNewTgen(None, tgen = tgenname)
 690
 691     def OnTgenCompute(self, evt):
 692         corpus = self.page.corpus
 693         tgenpath = os.path.join(self.page.parametres['pathout'], 'tgen.csv')
 694         if not os.path.exists(tgenpath) :
 695             message = wx.MessageDialog(self.parent, _(u"No TGen yet !").decode('utf8'), style = wx.ICON_EXCLAMATION | wx.OK)
 696             message.ShowModal()
 697             message.Destroy()
 698         else :
 699             self.page.parametres['tgenpath'] = tgenpath
 700             tgen = TGen(path = tgenpath, encoding = self.parent.syscoding)
 701             if self.page.parametres['type'] == 'spec' :
 702                 self.page.parametres['etoiles'] = self.page.etoiles
 703                 TgenSpec(self.parent, corpus, self.page.parametres)
 704             elif self.page.parametres['type'] == 'alceste' :
 705                 TgenProf(self.parent, corpus, self.page.parametres, self.page.cluster_size)
 706             TgenLayout(self.page)
 707
 708     def OnExportClasses(self, event):
 709         corpus = self.page.corpus
 710         if self.page.parametres['classif_mode'] != 2 :
 711             uci = False
 712         else :
 713             uci = True
 714         busy = wx.BusyInfo(_("Please wait...").decode('utf8'), self.parent)
 715         wx.SafeYield()
 716         for i in range(1, self.page.parametres['clnb'] + 1) :
 717             corpus.export_classe(self.page.pathout['classe_%i_export.txt' % i], i, uci = uci)
 718         del busy
 719         dial = wx.MessageDialog(self, self.page.pathout['classe_x_export.txt'], u"Export", wx.OK|wx.ICON_INFORMATION)
 720         dial.ShowModal()
 721         dial.Destroy()
 722
 723     def OnSubCorpusFromClusters(self, evt):
 724         self.parent.OnSubText(evt, corpus = self.getcorpus(), parametres = {'fromclusters' : True, 'clnb': self.page.parametres['clnb'], 'lc' : self.page.corpus.lc})
 725
 726     def OnRename(self, event):
 727         pydata = self.itemdict['pydata']
 728         if 'matrix_name' in pydata :
 729             name = 'matrix_name'
 730         elif 'corpus_name' in pydata :
 731             name = 'corpus_name'
 732         else :
 733             name = 'name'
 734         oldname = pydata[name]
 735         dlg = wx.TextEntryDialog(self, _("New Name").decode('utf8'), _(u'Rename').decode('utf8'), oldname)
 736         if dlg.ShowModal() == wx.ID_OK:
 737             newname = dlg.GetValue()
 738             dlg.Destroy()
 739             pydata[name] = newname
 740             Totconf = DoConf(configfile=pydata['ira'])
 741             conf = Totconf.getoptions()
 742             conf[name] = newname
 743             Totconf.makeoptions(Totconf.getsections(), [conf])
 744             self.history.update(pydata)
 745             self.SetItemText(self.current, newname)
 746             self.EnsureVisible(self.current)
 747
 748     def OnOpenFolder(self, evt):
 749         try :
 750             open_folder(os.path.dirname(self.pydata['ira']))
 751         except :
 752             print 'cannot open folder %s' % self.pydata.get('ira', 'noirapath')
 753
 754     def OnItemBackground(self, event):
 755
 756         colourdata = wx.ColourData()
 757         colourdata.SetColour(self.itemdict["back"])
 758         dlg = wx.ColourDialog(self, colourdata)
 759
 760         dlg.GetColourData().SetChooseFull(True)
 761
 762         if dlg.ShowModal() == wx.ID_OK:
 763             data = dlg.GetColourData()
 764             col1 = data.GetColour().Get()
 765             self.SetItemBackgroundColour(self.current, col1)
 766         dlg.Destroy()
 767
 768
 769     def OnItemForeground(self, event):
 770
 771         colourdata = wx.ColourData()
 772         colourdata.SetColour(self.itemdict["fore"])
 773         dlg = wx.ColourDialog(self, colourdata)
 774
 775         dlg.GetColourData().SetChooseFull(True)
 776
 777         if dlg.ShowModal() == wx.ID_OK:
 778             data = dlg.GetColourData()
 779             col1 = data.GetColour().Get()
 780             self.SetItemTextColour(self.current, col1)
 781         dlg.Destroy()
 782
 783
 784     def OnItemBold(self, event):
 785
 786         self.SetItemBold(self.current, not self.itemdict["isbold"])
 787
 788
 789     def OnItemFont(self, event):
 790
 791         data = wx.FontData()
 792         font = self.itemdict["font"]
 793
 794         if font is None:
 795             font = wx.SystemSettings_GetFont(wx.SYS_DEFAULT_GUI_FONT)
 796
 797         data.SetInitialFont(font)
 798
 799         dlg = wx.FontDialog(self, data)
 800
 801         if dlg.ShowModal() == wx.ID_OK:
 802             data = dlg.GetFontData()
 803             font = data.GetChosenFont()
 804             self.SetItemFont(self.current, font)
 805
 806         dlg.Destroy()
 807
 808
 809     def OnItemHyperText(self, event):
 810
 811         self.SetItemHyperText(self.current, not self.itemdict["ishtml"])
 812
 813
 814     def OnEnableWindow(self, event):
 815
 816         enable = self.GetItemWindowEnabled(self.current)
 817         self.SetItemWindowEnabled(self.current, not enable)
 818
 819
 820     def OnDisableItem(self, event):
 821
 822         self.EnableItem(self.current, False)
 823
 824
 825     def OnItemIcons(self, event):
 826
 827         bitmaps = [self.itemdict["normal"], self.itemdict["selected"],
 828                    self.itemdict["expanded"], self.itemdict["selexp"]]
 829
 830         wx.BeginBusyCursor()
 831         dlg = TreeIcons(self, -1, bitmaps=bitmaps)
 832         wx.EndBusyCursor()
 833         dlg.ShowModal()
 834
 835
 836     def SetNewIcons(self, bitmaps):
 837
 838         self.SetItemImage(self.current, bitmaps[0], CT.TreeItemIcon_Normal)
 839         self.SetItemImage(self.current, bitmaps[1], CT.TreeItemIcon_Selected)
 840         self.SetItemImage(self.current, bitmaps[2], CT.TreeItemIcon_Expanded)
 841         self.SetItemImage(self.current, bitmaps[3], CT.TreeItemIcon_SelectedExpanded)
 842
 843
 844     def OnItemInfo(self, event):
 845
 846         itemtext = self.itemdict["text"]
 847         numchildren = str(self.itemdict["children"])
 848         itemtype = self.itemdict["itemtype"]
 849         pydata = self.itemdict['pydata']
 850         #if 'analyses' in pydata :
 851         #    toshow = dict([[val, pydata[val]] for val in pydata if val not in['analyses', 'isload']])
 852         #else :
 853         toshow = pydata['ira']
 854         toshow = DoConf(toshow).getoptions()
 855         txt = DoConf().totext(toshow)
 856         parametres = [val.split('\t\t:') for val in txt.splitlines()]
 857         parametres.sort()
 858
 859         if itemtype == 0:
 860             itemtype = "Normal"
 861         elif itemtype == 1:
 862             itemtype = "CheckBox"
 863         else:
 864             itemtype = "RadioButton"
 865
 866         dlg = InfoDialog(self, itemtext, parametres)
 867         dlg.CenterOnParent()
 868         dlg.ShowModal()
 869         dlg.Destroy()
 870
 871
 872
 873     def OnItemDelete(self, event):
 874
 875         strs = "Are You Sure You Want To Delete Item " + self.GetItemText(self.current) + "?"
 876         dlg = wx.MessageDialog(None, strs, 'Deleting Item', wx.OK | wx.CANCEL | wx.ICON_QUESTION)
 877
 878         if dlg.ShowModal() in [wx.ID_NO, wx.ID_CANCEL]:
 879             dlg.Destroy()
 880             return
 881
 882         dlg.Destroy()
 883
 884         pydata = self.itemdict['pydata']
 885         if 'corpus_name' in pydata :
 886             self.history.delete(pydata, True)
 887         else :
 888             self.history.delete(pydata)
 889         self.DeleteChildren(self.current)
 890         self.Delete(self.current)
 891         self.current = None
 892
 893
 894
 895     def OnItemPrepend(self, event):
 896
 897         dlg = wx.TextEntryDialog(self, "Please Enter The New Item Name", 'Item Naming', 'Python')
 898
 899         if dlg.ShowModal() == wx.ID_OK:
 900             newname = dlg.GetValue()
 901             newitem = self.PrependItem(self.current, newname)
 902             self.EnsureVisible(newitem)
 903
 904         dlg.Destroy()
 905
 906     def AddAnalyse(self, parametres, itemParent = None, bold = True) :
 907         uuid = parametres.get('corpus', None)
 908         if uuid is not None :
 909             if itemParent is None :
 910                 itemParent = self.textroot
 911             child, cookie = self.GetFirstChild(itemParent)
 912             corpus = None
 913             while child :
 914                 pydata = self.GetPyData(child)
 915                 if pydata['uuid'] == uuid :
 916                     corpus = child
 917                     break
 918                 self.GiveFocus(child, uuid)
 919                 child, cookie = self.GetNextChild(itemParent, cookie)
 920             #item = self.AppendItem(child, parametres['name'])
 921             if corpus is not None :
 922                 item = self.AppendItem(corpus, parametres['name'])
 923             else :
 924                 item = self.AppendItem(self.textroot, parametres['name'])
 925         else :
 926             item = self.AppendItem(self.matroot, parametres['name'])
 927         self.SetPyData(item, parametres)
 928         if parametres['type'] in self.ild :
 929             img = self.ild[parametres['type']]
 930         else :
 931             img = 24
 932         self.SetItemImage(item, img, CT.TreeItemIcon_Normal)
 933         self.SetItemImage(item, 13, CT.TreeItemIcon_Expanded)
 934         self.SetItemBold(item, bold)
 935         self.SelectItem(item)
 936
 937     def AddMatAnalyse(self, parametres, itemParent = None, bold = True) :
 938         uuid = parametres.get('matrix', None)
 939         if uuid is not None :
 940             if itemParent is None :
 941                 itemParent = self.matroot
 942             child, cookie = self.GetFirstChild(itemParent)
 943             matrix = None
 944             while child :
 945                 pydata = self.GetPyData(child)
 946                 if pydata['uuid'] == uuid :
 947                     matrix = child
 948                     break
 949                 self.GiveFocus(child, uuid)
 950                 child, cookie = self.GetNextChild(itemParent, cookie)
 951             #item = self.AppendItem(child, parametres['name'])
 952             if matrix is not None :
 953                 item = self.AppendItem(matrix, parametres['name'])
 954             else :
 955                 item = self.AppendItem(self.matroot, parametres['name'])
 956         self.SetPyData(item, parametres)
 957         if parametres['type'] in self.ild :
 958             img = self.ild[parametres['type']]
 959         else :
 960             img = 24
 961         self.SetItemImage(item, img, CT.TreeItemIcon_Normal)
 962         self.SetItemImage(item, 13, CT.TreeItemIcon_Expanded)
 963         self.SetItemBold(item, bold)
 964         self.SelectItem(item)
 965
 966     def OnItemAppend(self, item, select = True):
 967         if 'corpus_name' in item :
 968             child = self.InsertItem(self.textroot, 0, item['corpus_name'])
 969         else :
 970             child = self.InsertItem(self.matroot, 0, item['matrix_name'])
 971         self.SetPyData(child, item)
 972         if item['type'] in self.ild :
 973             img = self.ild[item['type']]
 974         else :
 975             img = 24
 976         self.SetItemImage(child, img, CT.TreeItemIcon_Normal)
 977         self.SetItemImage(child, img, CT.TreeItemIcon_Expanded)
 978         if select :
 979             self.history.addtab(item)
 980             self.SetItemBold(child, True)
 981             self.SelectItem(child)
 982
 983         #dlg = wx.TextEntryDialog(self, "Please Enter The New Item Name", 'Item Naming', 'Python')
 984
 985         #if dlg.ShowModal() == wx.ID_OK:
 986         #    newname = dlg.GetValue()
 987         #    newitem = self.AppendItem(self.current, newname)
 988         #    self.EnsureVisible(newitem)
 989
 990
 991         #dlg.Destroy()
 992
 993
 994     def OnBeginEdit(self, event):
 995
 996         #self.log.info("OnBeginEdit" + "\n")
 997         # show how to prevent edit...
 998         item = event.GetItem()
 999         if item and self.GetItemText(item) == "The Root Item":
1000             wx.Bell()
1001             #self.log.info("You can't edit this one..." + "\n")
1002
1003             # Lets just see what's visible of its children
1004             cookie = 0
1005             root = event.GetItem()
1006             (child, cookie) = self.GetFirstChild(root)
1007
1008             while child:
1009                 #self.log.info("Child [%s] visible = %d" % (self.GetItemText(child), self.IsVisible(child)) + "\n")
1010                 (child, cookie) = self.GetNextChild(root, cookie)
1011
1012             event.Veto()
1013
1014
1015     def OnEndEdit(self, event):
1016
1017         #self.log.info("OnEndEdit: %s %s" %(event.IsEditCancelled(), event.GetLabel()))
1018         # show how to reject edit, we'll not allow any digits
1019         for x in event.GetLabel():
1020             if x in string.digits:
1021                 #self.log.info(", You can't enter digits..." + "\n")
1022                 event.Veto()
1023                 return
1024
1025         self.log.info("\n")
1026
1027
1028     def OnLeftDClick(self, event):
1029         pt = event.GetPosition()
1030         item, flags = self.HitTest(pt)
1031         if item is not None :
1032             pydata = self.GetPyData(item)
1033             if pydata['uuid'] in self.parent.history.opened :
1034                 for i in range(self.parent.nb.GetPageCount()) :
1035                     page = self.parent.nb.GetPage(i)
1036                     if 'parametres' in dir(page) :
1037                         if page.parametres['uuid'] == pydata['uuid'] :
1038                             self.parent.nb.SetSelection(i)
1039                             break
1040             elif pydata['uuid'] in ['textroot', 'matroot'] :
1041                 pass
1042             else :
1043                 if os.path.exists(pydata['ira']) :
1044                     busy = wx.BusyInfo(_("Please wait..."), self.parent)
1045                     wx.SafeYield()
1046                     try :
1047                         OpenAnalyse(self.parent, pydata)
1048                         del busy
1049                         self.SetItemBold(item, True)
1050                         self.OnSelChanged(pydata = pydata)
1051                     except :
1052                         del busy
1053                         BugReport(self.ira)
1054                 else :
1055                     wx.MessageBox(_(u"This file does not exist : %s" % pydata['ira']).decode('utf8'), 'Information', wx.ICON_EXCLAMATION | wx.STAY_ON_TOP )
1056         #if item and (flags & CT.TREE_HITTEST_ONITEMLABEL):
1057         #    if self.GetAGWWindowStyleFlag() & CT.TR_EDIT_LABELS:
1058         #        self.log.info("OnLeftDClick: %s (manually starting label edit)"% self.GetItemText(item) + "\n")
1059
1060                 #self.EditLabel(item)
1061         #    else:
1062         #        pydata = self.GetPyData(item)
1063         #        print pydata
1064         #        self.log.info("OnLeftDClick: Cannot Start Manual Editing, Missing Style TR_EDIT_LABELS\n")
1065
1066         event.Skip()
1067
1068
1069     def OnItemExpanded(self, event):
1070
1071         item = event.GetItem()
1072         if item:
1073             self.log.info("OnItemExpanded: %s" % self.GetItemText(item) + "\n")
1074
1075
1076     def OnItemExpanding(self, event):
1077
1078         item = event.GetItem()
1079         if item:
1080             self.log.info("OnItemExpanding: %s" % self.GetItemText(item) + "\n")
1081
1082         event.Skip()
1083
1084
1085     def OnItemCollapsed(self, event):
1086
1087         item = event.GetItem()
1088         if item:
1089             self.log.info("OnItemCollapsed: %s" % self.GetItemText(item) + "\n")
1090
1091
1092     def OnItemCollapsing(self, event):
1093
1094         item = event.GetItem()
1095         if item:
1096             self.log.info("OnItemCollapsing: %s" % self.GetItemText(item) + "\n")
1097
1098         event.Skip()
1099
1100
1101     def OnSelChanged(self, event = None, pydata = None):
1102         if event is not None :
1103             item = event.GetItem()
1104             pydata = self.GetPyData(item)
1105
1106         if pydata is not None :
1107             if 'corpus_name' in pydata or 'corpus' in pydata :
1108                 self.ira.ShowMenu('matrix', False)
1109                 self.ira.ShowMenu('text', True)
1110             if 'matrix_name' in pydata or 'matrix' in pydata:
1111                 self.ira.ShowMenu('text', False)
1112                 self.ira.ShowMenu('matrix', True)
1113             if 'uuid' in pydata :
1114                 if pydata['uuid'] in ['textroot', 'matroot'] :
1115                     self.ira.ShowMenu('text', False)
1116                     self.ira.ShowMenu('matrix', False)
1117             self.pydata = pydata
1118             if pydata['uuid'] in self.parent.history.opened :
1119                 for i in range(self.parent.nb.GetPageCount()) :
1120                     self.page = self.parent.nb.GetPage(i)
1121                     if 'parametres' in dir(self.page) :
1122                         if self.page.parametres['uuid'] == pydata['uuid'] :
1123                             self.parent.nb.SetSelection(i)
1124                             break
1125         if event is not None :
1126             event.Skip()
1127
1128
1129     def OnSelChanging(self, event):
1130
1131         item = event.GetItem()
1132         olditem = event.GetOldItem()
1133
1134         if item:
1135             if not olditem:
1136                 olditemtext = "None"
1137             else:
1138                 olditemtext = self.GetItemText(olditem)
1139             #self.log.info("OnSelChanging: From %s" % olditemtext + " To %s" % self.GetItemText(item) + "\n")
1140
1141         event.Skip()
1142
1143
1144     def OnBeginDrag(self, event):
1145
1146         self.item = event.GetItem()
1147         if self.item:
1148             self.log.info("Beginning Drag..." + "\n")
1149
1150             event.Allow()
1151
1152
1153     def OnBeginRDrag(self, event):
1154
1155         self.item = event.GetItem()
1156         if self.item:
1157             self.log.info("Beginning Right Drag..." + "\n")
1158
1159             event.Allow()
1160
1161
1162     def OnEndDrag(self, event):
1163
1164         self.item = event.GetItem()
1165         if self.item:
1166             self.log.info("Ending Drag!" + "\n")
1167
1168         event.Skip()
1169
1170
1171     def OnDeleteItem(self, event):
1172
1173         item = event.GetItem()
1174
1175         if not item:
1176             return
1177
1178         self.log.info("Deleting Item: %s" % self.GetItemText(item) + "\n")
1179         event.Skip()
1180
1181
1182     def OnItemCheck(self, event):
1183
1184         item = event.GetItem()
1185         self.log.info("Item " + self.GetItemText(item) + " Has Been Checked!\n")
1186         event.Skip()
1187
1188
1189     def OnItemChecking(self, event):
1190
1191         item = event.GetItem()
1192         self.log.info("Item " + self.GetItemText(item) + " Is Being Checked...\n")
1193         event.Skip()
1194
1195
1196     def OnToolTip(self, event):
1197
1198         item = event.GetItem()
1199         if item:
1200             event.SetToolTip(wx.ToolTip(self.GetItemText(item)))
1201
1202
1203     def OnItemMenu(self, event):
1204
1205         item = event.GetItem()
1206         if item:
1207             self.log.info("OnItemMenu: %s" % self.GetItemText(item) + "\n")
1208
1209         event.Skip()
1210
1211
1212     def OnKey(self, event):
1213
1214         keycode = event.GetKeyCode()
1215         keyname = keyMap.get(keycode, None)
1216
1217         if keycode == wx.WXK_BACK:
1218             self.log.info("OnKeyDown: HAHAHAHA! I Vetoed Your Backspace! HAHAHAHA\n")
1219             return
1220
1221         if keyname is None:
1222             if "unicode" in wx.PlatformInfo:
1223                 keycode = event.GetUnicodeKey()
1224                 if keycode <= 127:
1225                     keycode = event.GetKeyCode()
1226                 keyname = "\"" + unichr(event.GetUnicodeKey()) + "\""
1227                 if keycode < 27:
1228                     keyname = "Ctrl-%s" % chr(ord('A') + keycode-1)
1229
1230             elif keycode < 256:
1231                 if keycode == 0:
1232                     keyname = "NUL"
1233                 elif keycode < 27:
1234                     keyname = "Ctrl-%s" % chr(ord('A') + keycode-1)
1235                 else:
1236                     keyname = "\"%s\"" % chr(keycode)
1237             else:
1238                 keyname = "unknown (%s)" % keycode
1239
1240         self.log.info("OnKeyDown: You Pressed '" + keyname + "'\n")
1241
1242         event.Skip()
1243
1244
1245     def OnActivate(self, event):
1246
1247         if self.item:
1248             self.log.info("OnActivate: %s" % self.GetItemText(self.item) + "\n")
1249
1250         event.Skip()
1251
1252
1253     def OnHyperLink(self, event):
1254
1255         item = event.GetItem()
1256         if item:
1257             self.log.info("OnHyperLink: %s" % self.GetItemText(self.item) + "\n")
1258
1259
1260     def OnTextCtrl(self, event):
1261
1262         char = chr(event.GetKeyCode())
1263         self.log.info("EDITING THE TEXTCTRL: You Wrote '" + char + \
1264                        "' (KeyCode = " + str(event.GetKeyCode()) + ")\n")
1265         event.Skip()
1266
1267
1268     def OnComboBox(self, event):
1269
1270         selection = event.GetEventObject().GetValue()
1271         self.log.info("CHOICE FROM COMBOBOX: You Chose '" + selection + "'\n")
1272         event.Skip()