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