AppFrame.py

Go to the documentation of this file.

#!/usr/bin/env python
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------

"""
This program will load and run one of the individual demos in this
directory within its own frame window.  Just specify the module name
on the command line.
"""

import wx
import wx.xrc  as  xrc
import images
import wx.lib.mixins.inspection
from wx.lib.mixins.treemixin import ExpansionState
import sys, os

import images
from tree import * 

#from GraphFrame import *
#from LogFrame   import *
from CfgFrame  import *

from libCatKernel import *

from tools import opj

from shell import *

#from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg as Canvas
#from matplotlib.backends.backend_wxagg import NavigationToolbar2Wx as Toolbar

global cat

_objectTypes = ["Overview", "demo", "Processus","Doc", "Data","Doc"]

_treeList = [
    ('Elements',  []),
    ('Processus', []),
    ('Data',      []),
    ('Documents', []),
    ('Libraries', []),
]

_windows = [
            ('App',[True,[0.01,0.04],[0.30,0.60]]),
#            ('Log',[False,[0.03,0.45],[0.90,0.50]]),
#            ('Cfg',[False,[0.41,0.01],[0.58,0.90]]),
            ('Gph',[False,[0.13,0.13],[0.75,0.75]])
            ]

#----------------------------------------------------------------------------
class AppFrame(wx.Frame):    
    overviewText = "CAT Main Window"
    def __init__(self, app, parent, title): 
        wx.Frame.__init__(self, parent, wx.NewId(), title, size=(500, 650))
        
        self.MB_CONF=wx.NewId()
        self.MB_GRAPH=wx.NewId()
        self.MB_LOG=wx.NewId()

        self.TB_CONF=wx.NewId()
        self.TB_GRAPH=wx.NewId()
        self.TB_LOG=wx.NewId()

        self.cfgpanels=list()
        self.objs=list()
        self.paths=list()

        global cat
        cat=app
        
        self.path=os.path.join(os.environ.get("CATPATH"),"CatPython","python")
        sizeX=wx.SystemSettings.GetMetric( wx.SYS_SCREEN_X );
        sizeY=wx.SystemSettings.GetMetric( wx.SYS_SCREEN_Y );
        self.makeMenuBar()
        self.makeToolBar()
        res=xrc.XmlResource(os.path.join(self.path,"xrc/AppPanel.xrc"))
        self.panel=res.LoadPanel(self, "AppPanel")
#        self.makeFrames()
        
        for window, items in _windows:
            show=items[0]
            Pt=wx.Point(items[1][0]*sizeX,items[1][1]*sizeY)
            Sz=wx.Size(items[2][0]*sizeX,items[2][1]*sizeY)
            if window=='App':
                self.Move(Pt)
                self.SetSize(Sz)
            # if window=='Cfg':
            #     self.cfgFrame.Move(Pt)
            #     self.cfgFrame.SetSize(Sz)
            #     self.cfgState=show
            #     self.cfgFrame.Show(show)
            #     self.toolBar.ToggleTool(self.TB_CONF, show)
            #     menuItem = self.menuBar.FindItemById(self.MB_CONF)
            #     menuItem.Check(show) 
                
            # if window=='Gph':
            #     self.gphFrame.Move(Pt)
            #     self.gphFrame.SetSize(Sz)
            #     self.gphState=show
            #     self.gphFrame.Show(show)
            #     self.toolBar.ToggleTool(self.TB_GRAPH, show)
            #     menuItem = self.menuBar.FindItemById(self.MB_GRAPH)
            #     menuItem.Check(show)

            # if window=='Log':
            #     self.logFrame.Move(Pt)
            #     self.logFrame.SetSize(Sz)
            #     self.logState=show
            #     self.logFrame.Show(show)
            #     self.toolBar.ToggleTool(self.TB_LOG, show)
            #     menuItem = self.menuBar.FindItemById(self.MB_LOG)
            #     menuItem.Check(show)
                
        self.treeContainer=xrc.XRCCTRL(self, 'TreePanel')
        self.vbox=wx.BoxSizer(wx.VERTICAL)
        
        self.tree=TreeCtrlPanel(self.treeContainer)

        self.vbox.Add(self.tree,1,wx.EXPAND)
        self.treeContainer.SetSizer( self.vbox )

#        self.tree
#        self.treeMap = {}

#        self.BuildTreeImageList()
        #self.tree.SetExpansionState(self.expansionState)
#        self.tree.Bind(wx.EVT_TREE_ITEM_EXPANDED, self.OnItemExpanded)
#        self.tree.Bind(wx.EVT_TREE_ITEM_COLLAPSED, self.OnItemCollapsed)
#        self.tree.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged)
#        self.tree.Bind(wx.EVT_LEFT_DOWN, self.OnTreeLeftDown)

        self.elementCombo=self.getControl("elementCombo")
        self.procCombo=self.getControl("procCombo")
        self.Bind(wx.EVT_COMBOBOX, self.updateCombo, id=xrc.XRCID("elementCombo"))        
        self.Bind(wx.EVT_BUTTON, self.onLoad, id=xrc.XRCID("openConfFile"))
        self.Bind(wx.EVT_BUTTON, self.onEdit, id=xrc.XRCID("onEdit"))
        self.Bind(wx.EVT_SPINCTRL, self.runCtrl, id=xrc.XRCID("runCtrl"))
        self.Bind(wx.EVT_SPINCTRL, self.eventCtrl, id=xrc.XRCID("eventCtrl"))
        self.Bind(wx.EVT_SPINCTRL, self.printFreq, id=xrc.XRCID("printFreq"))
        self.Bind(wx.EVT_SPINCTRL, self.plotFreq, id=xrc.XRCID("plotFreq"))
        self.Bind(wx.EVT_TEXT_ENTER, self.onEnter, id=xrc.XRCID("cmdline"))
        self.Bind(wx.EVT_BUTTON, self.onEnter, id=xrc.XRCID("onEnter"))
        self.Bind(wx.EVT_BUTTON, self.onExpand, id=xrc.XRCID("onExpand"))
        self.Bind(wx.EVT_BUTTON, self.onCollapse, id=xrc.XRCID("onCollapse"))
        self.Bind(wx.EVT_BUTTON, self.deleteHardware, id=xrc.XRCID("deleteHardware"))
        self.Bind(wx.EVT_TOGGLEBUTTON, self.onAutoCheck, id=xrc.XRCID("autoCheck"))
        self.Bind(wx.EVT_TOGGLEBUTTON, self.onStopOnError, id=xrc.XRCID("stoponerror"))
        self.Bind(wx.EVT_TOGGLEBUTTON, self.onLogCheck, id=xrc.XRCID("logCheck"))
        self.Bind(wx.EVT_TOGGLEBUTTON, self.onFileCheck, id=xrc.XRCID("fileCheck"))
        self.Bind(wx.EVT_COMBOBOX, self.updateOutputLevel, id=xrc.XRCID("outputLevel"))        
        self.update()
                
    def getControl(self, xmlid):
        '''Retrieves the given control (within a dialog) by its xmlid'''
        control = self.FindWindowById(xrc.XRCID(xmlid))
#        print xmlid
#        print xrc.XRCID(xmlid)
#        print control
        if control == None and self.GetMenuBar() != None:  # see if on the menubar
            control = self.GetMenuBar().FindItemById(xrc.XRCID(xmlid))
        assert control != None, 'Programming error: a control with xml id ' + xmlid + ' was not found.'
        return control
    
    def makeMenuBar(self):
        MB_FILE=wx.NewId()
        MB_CLOSE=wx.NewId()
        #
        file=wx.Menu()
        file.Append(MB_FILE,"&File","Open new configuration file")
        file.Append(MB_CLOSE,"&Close","Close configuration file")
        file.Append(wx.ID_EXIT, "E&xit", "Terminate the program")
        windows=wx.Menu()
#        windows.AppendCheckItem(self.MB_CONF,"&Configuration window","Configuration window")
#        windows.AppendCheckItem(self.MB_GRAPH,"&Graphic window","Graphic window")
#        windows.AppendCheckItem(self.MB_LOG,"&Log window","Log window")
        help=wx.Menu()
        help.Append(wx.ID_ABOUT, "&About","More information about this program")
        help.AppendSeparator()
        help.Append(wx.ID_HELP, "&Help", "CAT application help")
        self.menuBar=wx.MenuBar(wx.MB_DOCKABLE)
        self.menuBar.Append(file   , "&File")
        self.menuBar.Append(windows, "&Windows")
        self.menuBar.Append(help   , "&Help")
        self.SetMenuBar(self.menuBar)
        self.Bind(wx.EVT_MENU, self.onExit      , id=wx.ID_EXIT )
        self.Bind(wx.EVT_MENU, self.onAbout     , id=wx.ID_ABOUT )
        self.Bind(wx.EVT_MENU, self.onHelp      , id=wx.ID_HELP )
#        self.Bind(wx.EVT_MENU, self.onCheckGraph, id=self.MB_GRAPH )
#        self.Bind(wx.EVT_MENU, self.onCheckLog  , id=self.MB_LOG   )
#        self.Bind(wx.EVT_MENU, self.onCheckConf , id=self.MB_CONF  )
        self.Bind(wx.EVT_MENU, self.onLoad      , id=MB_FILE  )
        self.Bind(wx.EVT_MENU, self.onClose     , id=MB_CLOSE  )
        
    def makeToolBar(self):
        TB_OPEN=wx.NewId()
        TB_RELOAD=wx.NewId()
        TB_CONFIGURE=wx.NewId()
        TB_INIT=wx.NewId()
        TB_DELETE=wx.NewId()
        TB_START=wx.NewId()
        TB_SINGLE=wx.NewId()
        TB_EXIT=wx.NewId()
        #
        self.toolBar = self.CreateToolBar(wx.TB_DOCKABLE)
        self.toolBar.AddLabelTool(TB_OPEN  , '', wx.Bitmap(os.path.join(self.path,"xrc/icons/fileopen.png")))
        self.toolBar.AddLabelTool(TB_RELOAD, '', wx.Bitmap(os.path.join(self.path,"xrc/icons/reload.png")))
        self.toolBar.AddLabelTool(TB_CONFIGURE, '', wx.Bitmap(os.path.join(self.path,"xrc/icons/conf.png")))
        self.toolBar.AddLabelTool(TB_INIT, '', wx.Bitmap(os.path.join(self.path,"xrc/icons/init.png")))
        self.toolBar.AddLabelTool(TB_DELETE, '', wx.Bitmap(os.path.join(self.path,"xrc/icons/delete.png")))
        self.toolBar.AddSeparator()
#        self.toolBar.AddCheckLabelTool(self.TB_CONF, '', wx.Bitmap(os.path.join(self.path,"xrc/icons/config.png")))
        self.toolBar.AddCheckLabelTool(self.TB_GRAPH, '', wx.Bitmap(os.path.join(self.path,"xrc/icons/graph.png")))
#        self.toolBar.AddCheckLabelTool(self.TB_LOG, '', wx.Bitmap(os.path.join(self.path,"xrc/icons/log.png")))
        self.toolBar.AddSeparator()
        self.toolBar.AddLabelTool(TB_START, '', wx.Bitmap(os.path.join(self.path,"xrc/icons/start.png")))
        self.toolBar.AddLabelTool(TB_SINGLE, '', wx.Bitmap(os.path.join(self.path,"xrc/icons/single.png")))
        self.toolBar.AddSeparator()
        self.toolBar.AddLabelTool(wx.ID_EXIT, '', wx.Bitmap(os.path.join(self.path,"xrc/icons/exit.png")))
        self.toolBar.Realize()
        self.Bind(wx.EVT_TOOL, self.onExit      , id=wx.ID_EXIT)
#        self.Bind(wx.EVT_TOOL, self.onCheckGraph, id=self.TB_GRAPH)
#        self.Bind(wx.EVT_TOOL, self.onCheckLog  , id=self.TB_LOG)
#        self.Bind(wx.EVT_TOOL, self.onCheckConf , id=self.TB_CONF)
        self.Bind(wx.EVT_TOOL, self.onLoad , id=TB_OPEN)
        self.Bind(wx.EVT_TOOL, self.onReLoad , id=TB_RELOAD)
        self.Bind(wx.EVT_TOOL, self.onConfigure , id=TB_CONFIGURE)
        self.Bind(wx.EVT_TOOL, self.onInit , id=TB_INIT)
        self.Bind(wx.EVT_TOOL, self.onDelete , id=TB_DELETE)
        self.Bind(wx.EVT_TOOL, self.onStart , id=TB_START)
        self.Bind(wx.EVT_TOOL, self.onSingle , id=TB_SINGLE)

#    def makeFrames(self):
#        self.logFrame=LogFrame(cat, self, "Log window")
#        self.cfgFrame=ConfFrame(cat, self, "Configuration window")
#        self.gphFrame=GraphFrame(cat, self, "Graphical window")
        
    def onIdle(self, event):
        '''Responds to idle time in the system'''
        # when the timer says it's time, we do the actual downloading in the main thread (wx doesn't work well in secondary threads)
        print "onIdle"
        
    def onCloseConfirm(self, event):
        '''Closes the application'''
        dlg = wx.MessageDialog(self, "Exit the program?", "Exit", wx.YES_NO | wx.ICON_QUESTION)
        if dlg.ShowModal() == wx.ID_YES:
            dlg.Destroy()  # frame
        self.Destroy()

    def onClose(self, event):
        '''Closes the application'''
        self.Destroy()

    def onExit(self, event):
        '''Exit the app'''
        self.Close(True)
#        exit(2)

    def onHelp(self, event):
        '''Help'''
        print "help"
        
    def onAbout(self, event):
        '''About'''
        print "about"

    def onAutoCheck(self, event):
        cat.options().setRunNumberMgr(self.getControl("autoCheck").GetValue())
        print cat.options().runNumberMgr()
        
    def onStopOnError(self, event):
        cat.options().setStopOnError(self.getControl("stoponerror").GetValue())

    def onFileCheck(self, event):
        cat.options().setDataStorage(self.getControl("fileCheck").GetValue())
        print cat.options().dataStorage()
        
    def onLogCheck(self, event):
        cat.options().setLogStorage(self.getControl("logCheck").GetValue())
        print cat.options().logStorage()
        
    def eventCtrl(self,event):
        cat.options().setNEvtMax(self.getControl("eventCtrl").GetValue()) 

    def runCtrl(self,event):
        cat.options().setRunNumber(self.getControl("runCtrl").GetValue()) 

    def printFreq(self,event):
        cat.options().setPrintFreq(self.getControl("printFreq").GetValue()) 

    def plotFreq(self,event):
        cat.options().setPlotFreq(self.getControl("plotFreq").GetValue()) 

    def onEnter(self,event):
        cmd=self.getControl("cmdline").GetValue()
        self.getControl("cmdline").SetValue("") 
        exec(cmd)
 
    # Graphical Window management    
    # def onCheckGraph(self, event):
    #     state=not self.gphState
    #     self.gphState=state
    #     self.gphFrame.Show(state)
    #     self.toolBar.ToggleTool(self.TB_GRAPH, state)
    #     menuItem = self.menuBar.FindItemById(self.MB_GRAPH)
    #     menuItem.Check(state)

    # Log Window management    
    # def onCheckLog(self, event):
    #     state=not self.logState
    #     self.logState=state
    #     self.logFrame.Show(state)
    #     self.toolBar.ToggleTool(self.TB_LOG, state)
    #     menuItem = self.menuBar.FindItemById(self.MB_LOG)
    #     menuItem.Check(state)
        
    # Configuration Window management    
    # def onCheckConf(self, event):
    #     state=not self.cfgState
    #     self.cfgState=state
    #     self.cfgFrame.Show(state)
    #     self.toolBar.ToggleTool(self.TB_CONF, state)
    #     menuItem = self.menuBar.FindItemById(self.MB_CONF)
    #     menuItem.Check(state)

    def onLoad(self, event):
        path=[]
        dlg = wx.FileDialog(
            self, message="Choose a file",
            defaultDir=os.getcwd(), 
            defaultFile="",
            wildcard="Python source (*.py)|*.py|" "All files (*.*)|*.*",
            style=wx.OPEN | wx.CHANGE_DIR
            )

        # Show the dialog and retrieve the user response. If it is the OK response, 
        # process the data.
        if dlg.ShowModal() == wx.ID_OK:
            # This returns a Python list of files that were selected.
            path = dlg.GetPaths()
        # Destroy the dialog. Don't do this until you are done with it!
        # BAD things can happen otherwise!
        dlg.Destroy()
        if len(path)==1:
            filename=str(path[0])
            execfile(filename)
            cat.options().setDefFile(filename)
            cat.computer().tree()
            self.update()
            
    # def onEdit(self, event):
    #     objtype=self.tree.GetItem()
    #     if (objtype[1]=='Element'):
    #         self.cfgFrame.onEdit(cat.computer().child(objtype[0]),objtype[0],'element')
    #         self.cfgFrame.Show(True)
    #         self.cfgFrame.show=True            
    #     if (objtype[1]=='Processus'):
    #         list=[]
    #         listPtr=cat.procDb().list()
    #         for proc in range(len(listPtr)):
    #             if (objtype[0]==listPtr[proc].name()):
    #                 processus=listPtr[proc]
    #         self.cfgFrame.onEdit(processus,objtype[0],'proc')
    #         self.cfgFrame.Show(True)
    #         self.cfgFrame.show=True            

    def onEdit(self, event):
        objtype=self.tree.GetItem()
#        print "objtype is : ",objtype
        objpanel=-1
        for i in range(len(self.objs)):
            if objtype[0]==self.paths[i]:
                self.cfgpanels[objpanel].update()
                self.cfgpanels[objpanel].Show(True)
                return
            
        self.paths.append(objtype[0])
        if (objtype[1]=='Element'):
            self.objs.append(cat.computer().child(objtype[0]))
            self.cfgpanels.append(CfgFrame(cat, self, self.objs[-1], objtype[0], "element"))

        if (objtype[1]=='Processus'):
            list = cat.procDb().list()
            for p in range(len(list)):
                if list[p].name()==objtype[0]:
                    self.objs.append(list[p])
                    self.cfgpanels.append(CfgFrame(cat, self, self.objs[-1], objtype[0], "proc"))
                    break
                
    def deleteHardware(self, event):
        objtype=self.tree.GetItem()
        cat.warning("Removing object "+objtype[0]+" of type "+objtype[1])
        element=cat.computer().child(objtype[0])
        if (element!=0):
            cat.computer().delChild(element)
        self.update()
                        
    def onExpand(self, event):
        self.tree.ExpandAll()

    def onCollapse(self, event):
        self.tree.CollapseAll()
        
    def onReLoad(self, event):
        reload()
        cat.computer().tree()
        self.update()

    def onConfigure(self, event):
        print "Not implemented yet"
        
    def onInit(self, event):
        init()

    def onDelete(self, event):
        cat.computer().clear()        
        
    def onStart(self, event):
        cat.options().setStorageDir(str(self.getControl("fileCtrl").GetValue()))
        cat.options().setStoragePath(str(self.getControl("pathCtrl").GetValue()))
        item=self.elementCombo.GetSelection()
        element=cat.computer().child(self.listElement[item])
        list=cat.procDb().list(element)
        processus=list[self.procCombo.GetSelection()]
        nevt=self.getControl("eventCtrl").GetValue()

        dlg = wx.ProgressDialog(processus.title(),
                                processus.name(),
                                maximum = abs(nevt),
                                parent=self,
                                style = wx.PD_CAN_ABORT
                                | wx.PD_APP_MODAL
                                | wx.PD_ELAPSED_TIME
                                | wx.PD_ESTIMATED_TIME
                                | wx.PD_REMAINING_TIME
                                )
        plts   = None
        module = None
        processus.setElement(element)
        wrap = wrapper(cat, processus, "proc")

        online  = cat.options().plotFreq()
        
        if (wrap.ok):
            module = wrap.GetActive()
            if module and online!=0 :
                plts = module.createPlots(cat, processus, cat.options().runNumber())        

        keepGoing = True

        timing = -1
        if (nevt<0):
            timing = time.time()
        evt    = abs(nevt)

        ievt=0 
        status=Code.SUCCESS
        dlg.Update(ievt, " Initializing"+processus.name())
        cat.prepare(processus.name(),element,nevt)
        while (keepGoing):
            ievt+=1
            status=cat.loop()
            if online>0 and plt:
                if module and ievt%online==0:
                    module.updatePlots(plts, processus)
            if timing>=0:
                elapsed = time.time() - timing
                (keepGoing, skip)=dlg.Update(elapsed,"Running "+processus.name())
                if elapsed > evt: keepGoing = False
            else:
                (keepGoing, skip)=dlg.Update(ievt,"Running "+processus.name())
                if ievt >= evt: keepGoing = False
        dlg.Update(evt,"Finalizing "+processus.name())
        cat.terminate()

        if module and online==0:
            plts = module.createPlots(cat, processus, cat.options().runNumber())        
            if plts :
                module.updatePlots(plts, processus)
        
        dlg.Destroy()
        
#        self.plot(processus,False)
#        self.getControl("runCtrl").SetValue(cat.options().runNumber())
                
        
    def onSingle(self, event):
        cat.options().setStorageDir(str(self.getControl("fileCtrl").GetValue()))
        cat.options().setStoragePath(str(self.getControl("pathCtrl").GetValue()))
        item=self.elementCombo.GetSelection()
        element=cat.computer().child(self.listElement[item])
        list=cat.procDb().list(element)
        processus=list[self.procCombo.GetSelection()]
        cat.prepare(processus.name(),element,1)
        cat.loop()
        cat.terminate()
        self.plot(processus,False)
        self.getControl("runCtrl").SetValue(cat.options().runNumber())


    def plot(self, proc, force):
        self.gphFrame.onPlot(proc)
        if (force):
            self.gphFrame.Show(True)
            self.gphFrame.show=True            

        
    #---------------------------------------------
    def BuildElementList(self):
        def sublevel(list, element):
            if (element.hasChildren()):
                newlist=[]
                children=element.children()
                for child in range(len(children)):
                    newlist.append(children[child].name())
                    if (children[child].hasChildren()):
                        sublevel(newlist,children[child])
                list.append(newlist)
        list=[]
        list.append(cat.computer().name())
        sublevel(list,cat.computer())
        return list

    #---------------------------------------------
    def BuildProcessusList(self):
        list=[]
        listPtr=cat.procDb().list()
        for proc in range(len(listPtr)):
            list.append(listPtr[proc].name())
        return list
        
    def update(self):
        # Update options
        self.getControl("cdffileCtrl").SetValue(cat.options().defFile());
        self.getControl("printFreq").SetValue(cat.options().printFreq())
        self.getControl("plotFreq").SetValue(cat.options().plotFreq())
        self.getControl("eventCtrl").SetValue(cat.options().nEvtMax())
        self.getControl("runCtrl").SetValue(cat.options().runNumber())
        self.getControl("errorCtrl").SetValue(str(cat.options().nErrors()))
        self.getControl("fileCtrl").SetValue(cat.options().storageDir())
        self.getControl("pathCtrl").SetValue(cat.options().storagePath())
        self.getControl("stoponerror").SetValue(cat.options().stopOnError())
        self.getControl("autoCheck").SetValue(cat.options().runNumberMgr())
        self.getControl("fileCheck").SetValue(cat.options().dataStorage())
        self.getControl("logCheck").SetValue(cat.options().logStorage())
        level=cat.options().logOutputLevel()
        combo=self.getControl("outputLevel")
        if level==MsgLevel.VERBOSE:
            combo.SetSelection(0)
        if level==MsgLevel.DEBUG:
            combo.SetSelection(1)
        if level==MsgLevel.INFO:
            combo.SetSelection(2)
        if level==MsgLevel.WARNING:
            combo.SetSelection(3)
        if level==MsgLevel.ERROR:
            combo.SetSelection(4)
        if level==MsgLevel.FATAL:
            combo.SetSelection(5)
        # Tree control
#        self.RecreateTree()        
#        self.tree.SelectItem(self.root)
        self.elementCombo.Clear()
        self.listElement=self.ElementList()
        index   = 0
        current = 0
        for i in self.listElement:
            if (i==cat.current().path("")):
                current=index
            index=index+1
            self.elementCombo.Append(i)
        self.elementCombo.SetSelection(current)
        self.procComboUpdate(cat.current());
        self.tree.RecreateTree(self.BuildElementList(), self.BuildProcessusList())

    def ElementList(self):
        def sublevel(list, element):
            if (element.hasChildren()):
                children=element.children()
                for child in range(len(children)):
                    if (len(cat.procDb().list(children[child]))>0):
                       list.append(children[child].path(""))
                    if (children[child].hasChildren()):
                        sublevel(list,children[child])

        list=[]
        list.append(cat.computer().path(""))
        sublevel(list,cat.computer())
        return list
            
    def updateCombo(self, event):
        item=event.GetSelection()
        if item==0:
            element=cat.computer()
        else:
            element=cat.computer().child(self.listElement[item])
        self.procComboUpdate(element)
        
    def updateOutputLevel(self, event):
        level=self.getControl("outputLevel").GetValue()
        if level=="Verbose":
            cat.options().setLogOutputLevel(MsgLevel.VERBOSE)
        if level=="Debug":
            cat.options().setLogOutputLevel(MsgLevel.DEBUG)            
        if level=="Info":
            cat.options().setLogOutputLevel(MsgLevel.INFO)
        if level=="Warning":
            cat.options().setLogOutputLevel(MsgLevel.WARNING)            
        if level=="Error":
            cat.options().setLogOutputLevel(MsgLevel.ERROR)            
        if level=="Fatal Error":
            cat.options().setLogOutputLevel(MsgLevel.FATAL)
        print cat.options().logOutputLevel()

    def procComboUpdate(self, element):
        self.procCombo.Clear()
        self.procCombo.Remove(0,self.procCombo.GetLastPosition()+1)
        list=cat.procDb().list(element)
        for i in range(len(list)):
            self.procCombo.Append(list[i].name())
        self.procCombo.SetSelection(0)    
 
#----------------------------------------------------------------------------