src/Supervision/batchmode_SuperV.py

   1 #! /usr/bin/env python
   2 #
   3 #  SUPERV Supervision : contains the implementation of interfaces of SuperVision described in SUPERV.idl
   4 #
   5 #  Copyright (C) 2003  CEA/DEN, EDF R&D
   6 #
   7 #
   8 #
   9 #  File   : batchmode_SuperV.py
  10 #  Module : SUPERV
  11
  12 try :
  13     from batchmode_salome import orb
  14     from batchmode_salome import lcc
  15     from batchmode_salome import naming_service
  16     from batchmode_salome import CORBA
  17     from batchmode_salome import myStudy
  18 except :
  19     import curses
  20     from LifeCycleCORBA import *
  21     from SALOME_NamingServicePy import *
  22     import SUPERV
  23     import SUPERV_idl
  24     from batchmode_salome import *
  25 #    try :
  26 #        from libSuperVision_Swig import SuperV_Swig
  27 #        print 'SuperV_Swig imported'
  28 #    except :
  29 #        SuperV_Swig = None
  30     orb = CORBA.ORB_init([''], CORBA.ORB_ID)
  31     lcc = LifeCycleCORBA(orb)
  32     naming_service = SALOME_NamingServicePy_i(orb)
  33
  34 import re
  35 from types import *
  36 import SALOMEDS
  37 import SALOMEDS_Attributes_idl
  38 #try :
  39 #    SuperVision = SuperV_Swig( len(sys.argv) , sys.argv )
  40 #    SuperVision.Swig = 1
  41 #    print 'SuperV_Swig created'
  42 #except :
  43 #    SuperVision = lcc.FindOrLoadComponent("SuperVisionContainer","SUPERV")
  44 #    SuperVision.Swig = 0
  45 #    print 'Supervision Component loaded'
  46
  47 SuperVision = lcc.FindOrLoadComponent("SuperVisionContainer","SUPERV")
  48 SuperVision.Swig = 0
  49
  50 modulecatalog = naming_service.Resolve("/Kernel/ModulCatalog")
  51
  52 myBuilder = myStudy.NewBuilder()
  53 father = myStudy.FindComponent("SUPERV")
  54 if father is None:
  55         father = myBuilder.NewComponent("SUPERV")
  56         A1 = myBuilder.FindOrCreateAttribute(father, "AttributeName");
  57         FName = A1._narrow(SALOMEDS.AttributeName)
  58         #FName.SetValue("Supervision")
  59         Comp = modulecatalog.GetComponent( "SUPERV" )
  60         FName.SetValue(Comp._get_componentusername())
  61         A2 = myBuilder.FindOrCreateAttribute(father, "AttributePixMap");
  62         aPixmap = A2._narrow(SALOMEDS.AttributePixMap);
  63         aPixmap.SetPixMap( "ICON_OBJBROWSER_Supervision" );
  64         myBuilder.DefineComponentInstance(father,SuperVision)
  65
  66
  67 def PortInputFloat(obj, x):
  68     return obj.Input( SuperVision.AnyValue( CORBA.Any(CORBA.TC_double, x)))
  69
  70 def PortInputLong(obj, x):
  71     return obj.Input( SuperVision.AnyValue( CORBA.Any(CORBA.TC_long, x)))
  72
  73 def PortInputObject(obj, x):
  74     try:
  75         return obj.Input( SuperVision.AnyValue( CORBA.Any(CORBA.TC_Object, x)))
  76     except:
  77         return obj.Input( SuperVision.AnyValue( x ) )
  78
  79 def PortInputString(obj, x):
  80     return obj.Input( SuperVision.AnyValue( CORBA.Any(CORBA.TC_string, x)))
  81
  82 def InputFloat(obj, nodein_port, x):
  83     return obj.Input(nodein_port, SuperVision.AnyValue( CORBA.Any(CORBA.TC_double, x)))
  84
  85 def InputLong(obj, nodein_port, x):
  86     return obj.Input(nodein_port, SuperVision.AnyValue( CORBA.Any(CORBA.TC_long, x)))
  87
  88 def InputObject(obj, nodein_port, x):
  89     try:
  90         return obj.Input(nodein_port, SuperVision.AnyValue( CORBA.Any(CORBA.TC_Object, x)))
  91     except:
  92         return obj.Input(nodein_port, SuperVision.AnyValue( x ) )
  93
  94 def InputString(obj, nodein_port, x):
  95         return obj.Input(nodein_port, SuperVision.AnyValue( CORBA.Any(CORBA.TC_string, x)))
  96
  97
  98 def addStudy(ior):
  99     dataflow = SuperVision.getGraph(ior)
 100     name=dataflow.Name()
 101     itr = myStudy.NewChildIterator(father)
 102     while itr.More():
 103         item=itr.Value()
 104         res,A=item.FindAttribute("AttributeName")
 105         if res:
 106             aName = A._narrow(SALOMEDS.AttributeName)
 107             if aName.Value() == name :
 108                 res, A = myBuilder.FindOrCreateAttribute(item, "AttributeIOR")
 109                 anIOR  = A._narrow(SALOMEDS.AttributeIOR);
 110                 anIOR.SetValue(dataflow.getIOR())
 111                 return
 112         itr.Next()
 113     obj = myBuilder.NewObject(father)
 114     A=myBuilder.FindOrCreateAttribute(obj, "AttributeName")
 115     aName=A._narrow(SALOMEDS.AttributeName)
 116     aName.SetValue(name)
 117     A=myBuilder.FindOrCreateAttribute(obj, "AttributeIOR")
 118     anIOR  = A._narrow(SALOMEDS.AttributeIOR)
 119     anIOR.SetValue(dataflow.getIOR())
 120
 121 typestring = re.compile(r"_[^_]+_([^_]+)_.*")
 122
 123 def getRealArgs(self,args):
 124     types = []
 125     realargs = []
 126
 127     try:
 128         t = self.this
 129         types.append(typestring.match(self).group(1))
 130         realargs.append(t)
 131     except:
 132         types.append(type(self))
 133         realargs.append(self)
 134     for a in args:
 135         try:
 136             t = a.this
 137             types.append(typestring.match(a).group(1))
 138             realargs.append(t)
 139         except:
 140             types.append(type(a))
 141             realargs.append(a)
 142
 143     return tuple(types), tuple(realargs)
 144
 145 bs_AddInput_valuedict = {
 146      (InstanceType, FloatType) : PortInputFloat,
 147      (InstanceType, IntType) : PortInputLong,
 148      (InstanceType, StringType) : PortInputString,
 149      (InstanceType, InstanceType) : PortInputObject,
 150      (InstanceType, StringType, FloatType) : InputFloat,
 151      (InstanceType, StringType, IntType) : InputLong,
 152      (InstanceType, StringType, StringType) : InputString,
 153      (InstanceType, StringType, InstanceType) : InputObject,
 154      (InstanceType, StringType, ListType) : InputObject,
 155 }
 156
 157
 158 def Args( aService , aNodeName , verbose ):
 159     lenin = len( aService.ServiceinParameter )
 160     infos = aNodeName + 'info = "'
 161     infos = infos + 'NodeName    : ' + aNodeName + '\\n'
 162     infos = infos + 'ServiceName : ' + aService.ServiceName + '\\n'
 163     infos = infos + 'PortNames   : \\n'
 164     defnames = aNodeName + " = " + "'" + aNodeName + "' ; "
 165     i = 0
 166     while i < lenin :
 167         argname = aNodeName + aService.ServiceinParameter[ i ].Parametername
 168         valname = aNodeName + "\\\\"
 169         valname = valname + aService.ServiceinParameter[ i ].Parametername
 170         defnames = defnames + argname + " = " + "'" + valname + "' ; "
 171         infos = infos + str(i) + '. ' + argname + ' : Input'
 172         infos = infos + str(i) + ' '
 173         infos = infos + aService.ServiceinParameter[ i ].Parametername + ' '
 174         infos = infos + aService.ServiceinParameter[ i ].Parametertype + '\\n'
 175         i = i + 1
 176     lenout = len( aService.ServiceoutParameter )
 177     i = 0
 178     while i < lenout :
 179         argname = aNodeName +  aService.ServiceoutParameter[ i ].Parametername
 180         valname = aNodeName + "\\\\"
 181         valname = valname + aService.ServiceoutParameter[ i ].Parametername
 182         defnames = defnames + argname + " = " + "'" + valname + "' ; "
 183         infos = infos + str(lenin+i) + '. ' + argname + ' : Output'
 184         infos = infos + str(i) + ' '
 185         infos = infos + aService.ServiceoutParameter[ i ].Parametername + ' '
 186         infos = infos + aService.ServiceoutParameter[ i ].Parametertype + '\\n'
 187         i = i + 1
 188     infos = infos + '"'
 189     defnames = defnames + infos
 190     if verbose :
 191         defnames = defnames + " ; print " + aNodeName + "info"
 192     return defnames
 193
 194 def Service_Swig( aCatalogService ) :
 195     aService = SuperVision.Service()
 196     aService.ServiceName = aCatalogService.ServiceName
 197     i = 0
 198     while i < len( aCatalogService.ServiceinParameter ) :
 199         p = SuperVision.ServicesParameter( aCatalogService.ServiceinParameter[i].Parametertype , aCatalogService.ServiceinParameter[i].Parametername )
 200         SuperVision.AddInParameter( aService , p )
 201         i = i + 1
 202     i = 0
 203     while i < len( aCatalogService.ServiceoutParameter ) :
 204         p = SuperVision.ServicesParameter( aCatalogService.ServiceoutParameter[i].Parametertype , aCatalogService.ServiceoutParameter[i].Parametername )
 205         SuperVision.AddOutParameter( aService , p )
 206         i = i + 1
 207     return aService
 208
 209 ##########################################################
 210 class CNode:
 211 ##########################################################
 212     def __init__( self , aNode , Verbose ):
 213         self.N = aNode
 214         self.N.Verbose = Verbose
 215     def Name( self ):
 216         return self.N.Name()
 217     def Service( self ):
 218         return self.N.Service()
 219     def Kind( self ):
 220         return self.N.Kind()
 221     def CreationDate( self ):
 222         return self.N.CreationDate()
 223     def LastUpdateDate( self ):
 224         return self.N.LastUpdateDate()
 225     def Version( self ):
 226         return self.N.Version()
 227     def Author( self ):
 228         return self.N.Author()
 229     def Comment( self ):
 230         return self.N.Comment()
 231
 232     def SetName( self , aNewName ):
 233         return self.N.SetName( aNewName )
 234     def SetAuthor( self , anAuthor ):
 235         return self.N.SetAuthor( anAuthor )
 236     def SetComment( self , aComment ):
 237         return self.N.SetComment( aComment )
 238
 239     def Print( self ):
 240         print "Name          ",self.N.Name()
 241         if self.N.IsFactory() :
 242             print "ComponentName ",self.N.GetComponentName()
 243             print "InterfaceName ",self.N.GetInterfaceName()
 244         aService = self.N.Service()
 245         print "Service Name  ",aService.ServiceName
 246         lenin = len( aService.ServiceinParameter )
 247         print "   ",lenin," input argument(s) :"
 248         i = 0
 249         while i < lenin :
 250             print "      ",i,". ",aService.ServiceinParameter[ i ].Parametername," ",aService.ServiceinParameter[ i ].Parametertype
 251             i = i + 1
 252         lenout = len( aService.ServiceoutParameter )
 253         print "   ",lenout," output argument(s) :"
 254         i = 0
 255         while i < lenout :
 256             print "      ",i,". ",aService.ServiceoutParameter[ i ].Parametername," ",aService.ServiceoutParameter[ i ].Parametertype
 257             i = i + 1
 258         aKind = self.N.Kind()
 259         print "KindOfNode",aKind
 260         aFirstCreation = self.N.CreationDate()
 261         print "Creation Date ",aFirstCreation.Day,"-",aFirstCreation.Month,"-",aFirstCreation.Year," ",aFirstCreation.Hour,":",aFirstCreation.Minute,":",aFirstCreation.Second
 262         aLastModification = self.N.LastUpdateDate()
 263         print "Update Date   ",aLastModification.Day,"-",aLastModification.Month,"-",aLastModification.Year," ",aLastModification.Hour,":",aLastModification.Minute,":",aLastModification.Second
 264         print "Version       ",self.N.Version()
 265         print "Author        ",self.N.Author()
 266         if self.N.IsFactory() :
 267             print "Container     ",self.N.GetContainer()
 268         print "Comment       ",self.N.Comment()
 269         print "Coords        ",self.N.X()," ",self.N.Y()
 270     def Port( self , aPortName ):
 271         aPort = self.N.Port( aPortName )
 272         if aPort != None :
 273             myPort = Port( aPort , self.N.Verbose )
 274             return myPort
 275         if self.N.Verbose :
 276             print "Error while creating the Port : ",aPortName
 277         return None
 278     def Input( self , *args ):
 279         types, realargs = getRealArgs(self.N,args)
 280         fn = bs_AddInput_valuedict[types]
 281         anInput = apply( fn, realargs)
 282         if anInput != None :
 283             myInput = Port( anInput , self.N.Verbose )
 284             return myInput
 285         ErrMsg = "Failed to create the Input"
 286         if self.N.Verbose :
 287             print ErrMsg
 288         return anInput
 289 #    def BusPort( self , InOutParameterName , InOutParameterType ):
 290 #        sts,inp,outp = self.N.BusPort( InOutParameterName ,
 291 #                                       InOutParameterType )
 292 #        inp = Port( inp , self.N.Verbose )
 293 #        outp = Port( outp , self.N.Verbose )
 294 #        return sts,inp,outp
 295 #    def BusPorts( self , InputParameterName , InputParameterType ,
 296 #                  OutputParameterName , OutputParameterType ):
 297 #        sts,inp,outp = self.N.BusPorts( InputParameterName ,
 298 #                                        InputParameterType ,
 299 #                                        OutputParameterName ,
 300 #                                        OutputParameterType )
 301 #        inp = Port( inp , self.N.Verbose )
 302 #        outp = Port( outp , self.N.Verbose )
 303 #        return sts,inp,outp
 304     def Ports( self ):
 305         ports = self.N.Ports()
 306         i = 0
 307         while i < len( ports ) :
 308             ports[ i ] = Port( ports[i] , self.N.Verbose )
 309             i = i + 1
 310         return ports
 311     def ListPorts( self , *args ):
 312         if len( args ) == 0 :
 313             aName = self.N.Name()
 314         else :
 315             aName = args[ 0 ]
 316         ports = self.N.Ports()
 317         listofports = ""
 318         if len( ports ) :
 319             portsname = ports[ 0 ].Name()
 320             bs = portsname.find('\\')
 321             if bs != -1 :
 322                 portsname1,portsname2 = portsname.split('\\')
 323                 portsname = portsname1 + portsname2
 324             if ports[ 0 ].IsInput():
 325                 listofports = aName + 'In' + portsname
 326             else :
 327                 listofports = aName + 'Out' + portsname
 328             i = 1
 329             while i < len( ports ) :
 330                 portsname = ports[ i ].Name()
 331                 bs = portsname.find('\\')
 332                 if bs != -1 :
 333                     portsname1,portsname2 = portsname.split('\\')
 334                     portsname = portsname1 + portsname2
 335                 if ports[ i ].IsInput():
 336                     listofports = listofports + ',' + aName + 'In' + portsname
 337                 else :
 338                     listofports = listofports + ',' + aName + 'Out' + portsname
 339                 i = i + 1
 340         print listofports
 341         if len( ports ) == 1 :
 342             listofports = "[" + listofports + "] = " + aName + ".Ports()"
 343         else :
 344             listofports = listofports + " = " + aName + ".Ports()"
 345         return listofports
 346     def PrintPorts( self ):
 347         ports = self.N.Ports()
 348         i = 0
 349         while i < len( ports ) :
 350             Direction = "Out"
 351             if ports[ i ].IsInput() :
 352                 Direction = "In"
 353             print Direction,self.N.Name(),'(',ports[ i ].Name(),ports[ i ].Kind(),ports[ i ].Type(),') = ',ports[ i ].ToString()
 354             i = i + 1
 355     def Links( self ) :
 356         links = self.N.Links()
 357         i = 0
 358         while i < len( links ) :
 359             links[ i ] = Link( links[i] , self.N.Verbose )
 360             i = i + 1
 361         return links
 362     def PrintLinks( self ):
 363         links = self.Links()
 364         i = 0
 365         while i < len( links ) :
 366             links[i].Print()
 367             i = i + 1
 368     def IsGraph( self ):
 369         return self.N.IsGraph()
 370     def IsComputing( self ):
 371         return self.N.IsComputing()
 372     def IsFactory( self ):
 373         return self.N.IsFactory()
 374     def IsInLine( self ):
 375         return self.N.IsInLine()
 376     def IsGOTO( self ):
 377         return self.N.IsGOTO()
 378     def IsLoop( self ):
 379         return self.N.IsLoop()
 380     def IsEndLoop( self ):
 381         return self.N.IsEndLoop()
 382     def IsSwitch( self ):
 383         return self.N.IsSwitch()
 384     def IsEndSwitch( self ):
 385         return self.N.IsEndSwitch()
 386     def SubGraph( self ):
 387         return self.N.SubGraph()
 388     def Thread( self ):
 389         return self.N.Thread()
 390     def IsWaiting( self ):
 391         return self.N.IsWaiting()
 392     def IsRunning( self ):
 393         return self.N.IsRunning()
 394     def IsDone( self ):
 395         return self.N.IsDone()
 396     def IsSuspended( self ):
 397         return self.N.IsSuspended()
 398     def State( self ):
 399         return self.N.State()
 400     def Control( self ):
 401         return self.N.Control()
 402     def ControlClear( self ):
 403         return self.N.ControlClear()
 404     def AutoState( self ):
 405         return self.N.AutoState()
 406     def ReadyW( self ):
 407         return self.N.ReadyW()
 408     def RunningW( self ):
 409         return self.N.RunningW()
 410     def DoneW( self ):
 411         return self.N.DoneW()
 412     def SuspendedW( self ):
 413         return self.N.SuspendedW()
 414     def ReRun( self ):
 415         return self.N.ReRun()
 416     def ReStart( self ):
 417         return self.N.ReStart()
 418     def ReRunAt( self , aNodeName ):
 419         return self.N.ReRunAt( aNodeName )
 420     def ReStartAt( self , aNodeName ):
 421         return self.N.ReStartAt( aNodeName )
 422     def Ping( self ):
 423         return self.N.ping()
 424     def Kill( self ):
 425         return self.N.Kill()
 426     def KillDone( self ):
 427         return self.N.KillDone()
 428     def Suspend( self ):
 429         return self.N.Suspend()
 430     def SuspendDone( self ):
 431         return self.N.SuspendDone()
 432     def Resume( self ):
 433         return self.N.Resume()
 434     def Stop( self ):
 435         return self.N.Stop()
 436     def Coords( self , X , Y ):
 437         return self.N.Coords( X , Y )
 438     def X( self ):
 439         return self.N.X()
 440     def Y( self ):
 441         return self.N.Y()
 442     def destroy( self ):
 443         self.N.destroy()
 444     def CpuUsed( self ):
 445         return self.N.CpuUsed()
 446
 447 ##########################################################
 448 class FNode(CNode):
 449 ##########################################################
 450     def __init__( self , aNode , Verbose ):
 451         self.N = aNode
 452         self.N.Verbose = Verbose
 453     def GetComponentName( self ):
 454         return self.N.GetComponentName()
 455     def GetInterfaceName( self ):
 456         return self.N._get_interfaceName()
 457     def GetContainer( self ):
 458         return self.N.GetContainer()
 459     def SetComponentName( self , aComponentName ):
 460         return self.N.SetComponentName( aComponentName )
 461     def SetInterfaceName( self , anInterfaceName ):
 462         return self.N.SetInterfaceName( anInterfaceName )
 463     def SetContainer( self , aComputer ):
 464         return self.N.SetContainer( aComputer )
 465
 466 ##########################################################
 467 class INode(CNode):
 468 ##########################################################
 469     def __init__( self , aNode , Verbose ):
 470         self.N = aNode
 471         self.N.Verbose = Verbose
 472     def Edit( self , FuncName , PyFunc ) :
 473         import os
 474         import random
 475         suf = str(random.randrange(1,10000))
 476         file = '/tmp/' + FuncName + '_' + suf + '.py'
 477         try :
 478             #d = dir ()
 479             #print "dir()",d
 480             fd = os.open( file , os.O_CREAT | os.O_WRONLY | os.O_TRUNC )
 481             #d = dir (fd)
 482             #print "dir(fd)",d
 483             i = 0
 484             while ( i < len( PyFunc ) ) :
 485                 print i,'/',len( PyFunc ),PyFunc[ i ]
 486                 os.write( fd , PyFunc[ i ] + '\n' )
 487                 i = i + 1
 488             os.close( fd )
 489             edit = '${EDITOR} ' + file
 490             os.system( edit )
 491             fd = os.open( file , os.O_RDONLY )
 492             line = os.read( fd , 132 )
 493             res = ''
 494             while len( line ) :
 495                 res = res + line
 496                 line = os.read( fd , 132 )
 497             os.close( fd )
 498             PyFunc = res.splitlines()
 499             i = 0
 500             while i < len( PyFunc ) :
 501                 print PyFunc[i]
 502                 i = i + 1
 503         except :
 504             print "Open of",file,"failed."
 505         return PyFunc
 506     def SetPyFunction( self , FuncName , aPyFunction ):
 507         return self.N.SetPyFunction( FuncName , aPyFunction )
 508     def PyFunction( self ):
 509         return self.N.PyFunction()
 510     def PyFuncName( self ):
 511         return self.N.PyFuncName()
 512     def EPyFunc( self ):
 513         PyFunc = self.N.PyFunction()
 514         PyFunc = self.Edit( self.N.PyFuncName() , PyFunc )
 515         self.N.SetPyFunction( self.N.PyFuncName() , PyFunc )
 516     def InPort( self , aParameterName , aParameterType ):
 517         aPort = self.N.InPort( aParameterName ,
 518                              aParameterType )
 519         if aPort != None :
 520             myPort = Port( aPort , self.N.Verbose )
 521             return myPort
 522         if self.N.Verbose :
 523             print "Error while creating the Port : ",aParameterName
 524         return None
 525     def OutPort( self , aParameterName , aParameterType ):
 526         aPort = self.N.OutPort( aParameterName ,
 527                                 aParameterType )
 528         if aPort != None :
 529             myPort = Port( aPort , self.N.Verbose )
 530             return myPort
 531         if self.N.Verbose :
 532             print "Error while creating the Port : ",aParameterName
 533         return None
 534
 535 ##########################################################
 536 class GNode(INode):
 537 ##########################################################
 538     def __init__( self , aNode , Verbose ):
 539         self.N = aNode
 540         self.N.Verbose = Verbose
 541     def SetCoupled( self , anInLineNode ):
 542         if self.N.IsGOTO() :
 543             node = self.N.SetCoupled( anInLineNode )
 544         else :
 545             node = None
 546         return node
 547     def Coupled( self ):
 548         node = self.N.Coupled()
 549         if node != None :
 550             if node.IsInLine() :
 551                 node = INode( node , self.N.Verbose )
 552             elif node.IsLoop() :
 553                 node = LNode( node , self.N.Verbose )
 554             elif node.IsEndLoop() :
 555                 node = ELNode( node , self.N.Verbose )
 556             elif node.IsSwitch() :
 557                 node = SNode( node , self.N.Verbose )
 558             elif node.IsEndSwitch() :
 559                 node = ESNode( node , self.N.Verbose )
 560         return node
 561
 562 ##########################################################
 563 class LNode(GNode):
 564 ##########################################################
 565     def __init__( self , aNode , Verbose ):
 566         self.N = aNode
 567         self.N.Verbose = Verbose
 568     def SetPyInit( self , InitName , aPyFunction ):
 569         return self.N.SetPyInit( InitName , aPyFunction )
 570     def PyInit( self ):
 571         return self.N.PyInit()
 572     def PyInitName( self ) :
 573         return self.N.PyInitName()
 574     def EPyInit( self ):
 575         PyFunc = self.N.PyFunction()
 576         PyFunc = self.Edit( self.N.PyFuncName() , PyFunc )
 577         self.N.SetPyFunction( self.N.PyFuncName() , PyFunc )
 578     def SetPyMore( self , MoreName , aPyFunction ):
 579         return self.N.SetPyMore( MoreName , aPyFunction )
 580     def PyMore( self ):
 581         return self.N.PyMore()
 582     def PyMoreName( self ) :
 583         return self.N.PyMoreName()
 584     def EPyMore( self ):
 585         PyMore = self.N.PyMore()
 586         PyMore = self.Edit( self.N.PyMoreName() , PyMore )
 587         self.N.SetPyMore( self.N.PyMoreName() , PyMore )
 588     def SetPyNext( self , NextName , aPyFunction ):
 589         return self.N.SetPyNext( NextName , aPyFunction )
 590     def PyNext( self ):
 591         return self.N.PyNext()
 592     def PyNextName( self ) :
 593         return self.N.PyNextName()
 594     def EPyNext( self ):
 595         PyNext = self.N.PyNext()
 596         PyNext = self.Edit( self.N.PyNextName() , PyNext )
 597         self.N.SetPyNext( self.N.PyNextName() , PyNext )
 598
 599 ##########################################################
 600 class ELNode(GNode):
 601 ##########################################################
 602     def __init__( self , aNode , Verbose ):
 603         self.N = aNode
 604         self.N.Verbose = Verbose
 605
 606 ##########################################################
 607 class SNode(GNode):
 608 ##########################################################
 609     def __init__( self , aNode , Verbose ):
 610         self.N = aNode
 611         self.N.Verbose = Verbose
 612
 613 ##########################################################
 614 class ESNode(GNode):
 615 ##########################################################
 616     def __init__( self , aNode , Verbose ):
 617         self.N = aNode
 618         self.N.Verbose = Verbose
 619
 620 ##########################################################
 621 #class ServicesParameter_Swig :
 622 ##########################################################
 623 #    def __init__( self , aServicesParameter ):
 624 #        self.Parametertype = aServicesParameter.Parametertype
 625 #        self.Parametername = aServicesParameter.Parametername
 626
 627 ##########################################################
 628 class Graph(INode):
 629 ##########################################################
 630     def __init__( self , aName ):
 631         try:
 632             graph = SuperVision.Graph( aName )
 633         except:
 634             try:
 635                 graph = aName.G.Copy()
 636             except:
 637                 graph = None
 638         if graph != None :
 639             self.G = graph
 640             self.G.Verbose = 1
 641             self.N = graph
 642             self.N.Verbose = 1
 643         else :
 644             print "Graph creation failed"
 645     def CNode( self , *args ):
 646         if len( args ) == 1 :
 647             aService = args[ 0 ]
 648         else :
 649             aComponent = args[ 0 ]
 650             anInterface = args[ 1 ]
 651             aService = args[ 2 ]
 652             NodeComponent = modulecatalog.GetComponent( aComponent )
 653             aService = NodeComponent.GetService( anInterface , aService )
 654         aNode = self.G.CNode( aService )
 655         if aNode != None :
 656             myNode = CNode( aNode , self.G.Verbose )
 657             return myNode
 658         ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 659         if self.G.Verbose :
 660             print ErrMsg
 661         return aNode
 662     def Node( self , aComponent , anInterface , aService ):
 663         if SuperVision.Swig :
 664             aService = Service_Swig( aService )
 665         return self.FNode( aComponent , anInterface , aService )
 666     def FNode( self , aComponent , anInterface , aService ):
 667         NodeComponent = modulecatalog.GetComponent( aComponent )
 668         aService = NodeComponent.GetService( anInterface , aService )
 669         if SuperVision.Swig :
 670             aService = Service_Swig( aService )
 671         aNode = self.G.FNode( aComponent , anInterface , aService )
 672         if aNode != None :
 673             myNode = FNode( aNode , self.G.Verbose )
 674             return myNode
 675         ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 676         if self.G.Verbose :
 677             print ErrMsg
 678         return aNode
 679     def INode( self , FuncName , aPythonFunction ):
 680         aNode = self.G.INode( FuncName , aPythonFunction )
 681         if aNode != None :
 682             myNode = INode( aNode , self.G.Verbose )
 683             return myNode
 684         ErrMsg = "Failed to create a Node"
 685         if self.G.Verbose :
 686             print ErrMsg
 687             return aNode
 688     def GNode( self , FuncName , aPythonFunction , anINode ):
 689         aNode = self.G.GNode( FuncName , aPythonFunction , anINode )
 690         if aNode != None :
 691             myNode = GNode( aNode , self.G.Verbose )
 692             return myNode
 693         ErrMsg = "Failed to create a Node"
 694         if self.G.Verbose :
 695             print ErrMsg
 696             return aNode
 697     def LNode( self , InitName , InitFunction , MoreName , MoreFunction , NextName , NextFunction ):
 698         aNode,anEndOfLoop = self.G.LNode( InitName , InitFunction , MoreName , MoreFunction , NextName , NextFunction )
 699         if aNode != None :
 700             myNode = LNode( aNode , self.G.Verbose )
 701             myEndOfLoop = INode( anEndOfLoop , self.G.Verbose )
 702             return myNode,myEndOfLoop
 703         ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 704         if self.G.Verbose :
 705             print ErrMsg
 706         return aNode
 707     def SNode( self , FuncName , aPythonFunction ):
 708         aNode,anEndOfSwitch = self.G.SNode( FuncName , aPythonFunction )
 709         if aNode != None :
 710             myNode = SNode( aNode , self.G.Verbose )
 711             myEndOfSwitch = INode( anEndOfSwitch , self.G.Verbose )
 712             return myNode,myEndOfSwitch
 713         ErrMsg = "Failed to create a Node"
 714         if self.G.Verbose :
 715             print ErrMsg
 716         return aNode
 717 #    def LoopNode( self , aComponent , anInterface , aService , aNodeName ):
 718 #        NodeComponent = modulecatalog.GetComponent( aComponent )
 719 #        aService = NodeComponent.GetService( anInterface , aService )
 720 #        aNode,anEndNode = self.G.LoopNode( aComponent , anInterface , aService , aNodeName )
 721 #        myNode = aNode
 722 #        myEndNode = anEndNode
 723 #        if aNode != None :
 724 #            myNode = Node( aNode , self.G.Verbose )
 725 #        if anEndNode != None :
 726 #            myEndNode = Node( anEndNode , self.G.Verbose )
 727 #        if ( aNode != None ) & ( anEndNode != None ) :
 728 #            return myNode,myEndNode
 729 #        ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 730 #        if self.G.Verbose :
 731 #            print ErrMsg
 732 #        return aNode,anEndNode
 733 #    def SwitchNode( self , aComponent , anInterface , aService , aNodeName ):
 734 #        NodeComponent = modulecatalog.GetComponent( aComponent )
 735 #        aService = NodeComponent.GetService( anInterface , aService )
 736 #        aNode,anEndNode = self.G.SwitchNode( aComponent , anInterface , aService , aNodeName )
 737 #        myNode = aNode
 738 #        myEndNode = anEndNode
 739 #        if aNode != None :
 740 #            myNode = Node( aNode , self.G.Verbose )
 741 #        if anEndNode != None :
 742 #            myEndNode = Node( anEndNode , self.G.Verbose )
 743 #        if ( aNode != None ) & ( anEndNode != None ) :
 744 #            return myNode,myEndNode
 745 #        ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 746 #        if self.G.Verbose :
 747 #            print ErrMsg
 748 #        return aNode,anEndNode
 749 #    def LNode( self , aNodeName ):
 750 #        aNode = self.G.LNode( aNodeName )
 751 #        if aNode != None :
 752 #            myNode = Node( aNode , self.G.Verbose )
 753 #            return myNode
 754 #        ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 755 #        if self.G.Verbose :
 756 #            print ErrMsg
 757 #        return aNode
 758 #    def LService( self , aComponent , anInterface , aService ):
 759 #        NodeComponent = modulecatalog.GetComponent( aComponent )
 760 #        aService = NodeComponent.GetService( anInterface , aService )
 761 #        aNode = self.G.LService( aComponent , anInterface , aService )
 762 #        if aNode != None :
 763 #            myNode = Node( aNode , self.G.Verbose )
 764 #            return myNode
 765 #        ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 766 #        if self.G.Verbose :
 767 #            print ErrMsg
 768 #        return aNode
 769 #    def CNode( self , aNodeName ):
 770 #        aNode = self.G.CNode( aNodeName )
 771 #        if aNode != None :
 772 #            myNode = Node( aNode , self.G.Verbose )
 773 #            return myNode
 774 #        ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 775 #        if self.G.Verbose :
 776 #            print ErrMsg
 777 #        return aNode
 778 #    def CService( self , aComponent , anInterface , aService ):
 779 #        NodeComponent = modulecatalog.GetComponent( aComponent )
 780 #        aService = NodeComponent.GetService( anInterface , aService )
 781 #        aNode = self.G.CService( aComponent , anInterface , aService )
 782 #        if aNode != None :
 783 #            myNode = Node( aNode , self.G.Verbose )
 784 #            return myNode
 785 #        ErrMsg = "Failed to create a Node with Service " + aService.ServiceName
 786 #        if self.G.Verbose :
 787 #            print ErrMsg
 788 #        return aNode
 789     def PrintService( self , aComponent , anInterface , aService ):
 790         NodeComponent = modulecatalog.GetComponent( aComponent )
 791         aService = NodeComponent.GetService( anInterface , aService )
 792         print "ServiceName ",aService.ServiceName," :"
 793         lenin = len( aService.ServiceinParameter )
 794         print "   ",lenin," input argument(s) :"
 795         i = 0
 796         while i < lenin :
 797             print "      ",i,". ",aService.ServiceinParameter[ i ].Parametername," ",aService.ServiceinParameter[ i ].Parametertype
 798             i = i + 1
 799         lenout = len( aService.ServiceoutParameter )
 800         print "   ",lenout," output argument(s) :"
 801         i = 0
 802         while i < lenout :
 803             print "      ",i,". ",aService.ServiceoutParameter[ i ].Parametername," ",aService.ServiceoutParameter[ i ].Parametertype
 804             i = i + 1
 805     def Link( self , aFromNodePort , aToNodePort ):
 806         aLink = self.G.Link( aFromNodePort.P , aToNodePort.P )
 807         if aLink != None :
 808             myLink = Link( aLink , self.G.Verbose )
 809             return myLink
 810         ErrMsg = "Failed to create a Link from " + aFromNodePort.Node().Name() + "(" + aFromNodePort.Name() + ") to " + aToNodePort.Node().Name() + "(" + aToNodePort.Name() + ")"
 811         if self.G.Verbose :
 812             print ErrMsg
 813         return aLink
 814     def Import( self , anXmlFileName ):
 815         return self.G.Import( anXmlFileName )
 816     def Export( self , anXmlFileName ):
 817         return self.G.Export( anXmlFileName )
 818     def IsReadOnly( self ) :
 819         return self.G.IsReadOnly()
 820     def ComponentRef( self , aFactoryServer , aComponent ) :
 821         return self.G.ComponentRef( aFactoryServer , aComponent )
 822     def IsValid( self ):
 823         return self.G.IsValid()
 824     def IsExecutable( self ):
 825         return self.G.IsExecutable()
 826     def IsEditing( self ):
 827         return self.G.IsEditing()
 828     def IsExecuting( self ):
 829         return self.G.IsExecuting()
 830     def LevelMax( self ):
 831         return self.G.LevelMax()
 832     def ThreadsMax( self ):
 833         return self.G.ThreadsMax()
 834     def GraphsNumber( self ):
 835         return self.G.GraphsNumber()
 836     def LevelNodes( self , aLevel ):
 837         nodes = self.G.LevelNodes( aLevel )
 838         return self.nodesTuple( nodes )
 839     def Run( self , *args ):
 840         self.S = -1
 841         aService = self.Service()
 842         nargs = len( args )
 843         i = 0
 844         while nargs > 0 :
 845             print aService.ServiceinParameter[ i ].Parametername," = ",args[i]
 846             self.Input( aService.ServiceinParameter[ i ].Parametername , args[i] )
 847             i = i + 1
 848             nargs = nargs - 1
 849         return self.G.Run()
 850     def Start( self , *args ):
 851         self.S = -1
 852         aService = self.Service()
 853         nargs = len( args )
 854         i = 0
 855         while nargs > 0 :
 856             print aService.ServiceinParameter[ i ].Parametername," = ",args[i]
 857             self.Input( aService.ServiceinParameter[ i ].Parametername , args[i] )
 858             i = i + 1
 859             nargs = nargs - 1
 860         return self.G.Start()
 861     def Event( self ):
 862         sts,aNode,anEvent,aState = self.G.Event()
 863         self.S = sts
 864         return sts,aNode,anEvent,aState
 865     def EventNoW( self ):
 866         sts,aNode,anEvent,aState = self.G.EventNoW()
 867         self.S = sts
 868         return sts,aNode,anEvent,aState
 869     def EventW( self ):
 870         sts,aNode,anEvent,aState = self.G.EventW()
 871         self.S = sts
 872         return sts,aNode,anEvent,aState
 873     def NextW( self ):
 874         if self.S != 0 :
 875             sts,aNode,anEvent,aState = self.G.EventW()
 876             self.S = sts
 877             print sts,aNode.Thread(),aNode.SubGraph(),aNode.Name(),anEvent,aState
 878         return sts
 879     def Threads( self ):
 880         return self.G.Threads()
 881     def SuspendedThreads( self ):
 882         return self.G.SuspendedThreads()
 883     def LastLevelDone( self ):
 884         return self.G.LastLevelDone()
 885     def Verbose( self , verbose ):
 886         preverbose = self.G.Verbose
 887         self.G.Verbose = verbose
 888         return preverbose
 889     def Nodes( self ):
 890         nodes = self.G.Nodes()
 891         return self.nodesTuple( nodes )
 892     def nodesTuple( self , nodes ) :
 893         n = len( nodes.CNodes )
 894         i = 0
 895         j = 0
 896         pynodes = []
 897         while i < n :
 898             pynodes.append( CNode( nodes.CNodes[i] , self.G.Verbose ) )
 899             i = i + 1
 900             j = j + 1
 901         n = len( nodes.FNodes )
 902         i = 0
 903         while i < n :
 904             pynodes.append( FNode( nodes.FNodes[i] , self.G.Verbose ) )
 905             i = i + 1
 906             j = j + 1
 907         n = len( nodes.INodes )
 908         i = 0
 909         while i < n :
 910             pynodes.append( INode( nodes.INodes[i] , self.G.Verbose ) )
 911             i = i + 1
 912             j = j + 1
 913         n = len( nodes.GNodes )
 914         i = 0
 915         while i < n :
 916             pynodes.append( GNode( nodes.GNodes[i] , self.G.Verbose ) )
 917             i = i + 1
 918             j = j + 1
 919         n = len( nodes.LNodes )
 920         i = 0
 921         while i < n :
 922             pynodes.append( LNode( nodes.LNodes[i] , self.G.Verbose ) )
 923             i = i + 1
 924             j = j + 1
 925         n = len( nodes.ELNodes )
 926         i = 0
 927         while i < n :
 928             pynodes.append( GNode( nodes.ELNodes[i] , self.G.Verbose ) )
 929             i = i + 1
 930             j = j + 1
 931         n = len( nodes.SNodes )
 932         i = 0
 933         while i < n :
 934             pynodes.append( SNode( nodes.SNodes[i] , self.G.Verbose ) )
 935             i = i + 1
 936             j = j + 1
 937         n = len( nodes.ESNodes )
 938         i = 0
 939         while i < n :
 940             pynodes.append( GNode( nodes.ESNodes[i] , self.G.Verbose ) )
 941             i = i + 1
 942             j = j + 1
 943         return pynodes
 944     def ListNodes( self , *args ):
 945         nodes = self.Nodes()
 946         listofnodes = ""
 947         if len( nodes ) :
 948             listofnodes = nodes[ 0 ].Name()
 949             i = 1
 950             while i < len( nodes ) :
 951                 listofnodes = listofnodes + ',' + nodes[ i ].Name()
 952                 i = i + 1
 953         print listofnodes
 954         if len( args ) == 0 :
 955             aName = self.N.Name()
 956         else :
 957             aName = args[ 0 ]
 958         if len( nodes ) == 1 :
 959             listofnodes = "[" + listofnodes + "] = " + aName + ".Nodes()"
 960         else :
 961             listofnodes = listofnodes + " = " + aName + ".Nodes()"
 962         return listofnodes
 963     def PrintNodes( self ):
 964         nodes = self.Nodes()
 965         n = len( nodes )
 966         i = 0
 967         while i < n :
 968             print ' '
 969             nodes[i].Print()
 970             i = i + 1
 971     def PrintThreads( self ):
 972         nodes = self.Nodes()
 973         i = 0
 974         while i < len( nodes ) :
 975             print nodes[i].Name(),nodes[i].Thread(),nodes[i].State(),nodes[i].Control(),nodes[i].AutoState()
 976             i = i + 1
 977     def GLinks( self ):
 978         links = self.G.GLinks()
 979         i = 0
 980         while i < len( links ) :
 981             links[ i ] = Link( links[i] , self.G.Verbose )
 982             i = i + 1
 983         return links
 984     def ListLinks( self , *args ):
 985         links = self.G.GLinks()
 986         if len( links ) :
 987             listoflinks = links[ 0 ].InPort().Node().Name()
 988             listoflinks = listoflinks + links[ 0 ].InPort().Name()
 989             i = 1
 990             while i < len( links ) :
 991                 listoflinks = listoflinks + ',' + links[ i ].InPort().Node().Name()
 992                 listoflinks = listoflinks + links[ i ].InPort().Name()
 993                 i = i + 1
 994         print listoflinks
 995         if len( args ) == 0 :
 996             aName = self.N.Name()
 997         else :
 998             aName = args[ 0 ]
 999         if len( links ) == 1 :
1000             listoflinks = "[" + listoflinks + "] = " + aName + ".GLinks()"
1001         else :
1002             listoflinks = listoflinks + " = " + aName + ".GLinks()"
1003         return listoflinks
1004     def PrintLinks( self ):
1005         links = self.G.GLinks()
1006         i = 0
1007         while i < len( links ) :
1008             Link( links[ i ] , self.G.Verbose ).Print()
1009             i = i + 1
1010     def Graphs( self ):
1011         graphs = self.G.Graphs()
1012         outgraphs = graphs
1013         i = 0
1014         while i < len( graphs ) :
1015             outgraphs[ i ] = Graph( graphs[i].Name() , self.G.Verbose )
1016             outgraphs[ i ].Merge( graphs[i] )
1017             i = i + 1
1018         return outgraphs
1019     def Copy( self ):
1020         aCopy = self.G.Copy()
1021         if aCopy != None:
1022             myCopy = Graph( aCopy )
1023             return myCopy
1024         ErrMsg = "Failed to get a Copy of " + self.G.Name()
1025         if self.G.Verbose :
1026             print ErrMsg
1027         return aCopy
1028     def Merge( self , aGraph ):
1029         return self.G.Merge( aGraph.G )
1030     def Destroy( self ):
1031         self.N.destroy()
1032
1033 ##########################################################
1034 class GraphE(Graph):
1035 ##########################################################
1036     def __init__( self , aName ):
1037         graph = SuperVision.GraphE( aName )
1038         self.G = graph
1039         self.G.Verbose = 1
1040         self.N = graph
1041         self.N.Verbose = 1
1042
1043 ##########################################################
1044 class Value:
1045 ##########################################################
1046     def __init__( self , aValue , Verbose ):
1047         self.V = aValue
1048         self.V.Verbose = Verbose
1049     def ToString( self ):
1050         return self.V.ToString()
1051     def ToAny( self ):
1052         return self.V.ToAny()
1053     def Destroy( self ):
1054         self.N.destroy()
1055
1056 ##########################################################
1057 class Port:
1058 ##########################################################
1059     def __init__( self , aPort , Verbose ):
1060         self.P = aPort
1061         self.P.Verbose = Verbose
1062     def Input( self , *args ):
1063         types, realargs = getRealArgs(self.P,args)
1064         fn = bs_AddInput_valuedict[types]
1065         anInput = apply( fn, realargs)
1066         return anInput
1067     def Node( self ):
1068         aNode = self.P.Node()
1069         if aNode != None :
1070             if aNode.IsComputing() :
1071                 myNode = CNode( aNode , self.P.Verbose )
1072             elif aNode.IsFactory() :
1073                 myNode = FNode( aNode , self.P.Verbose )
1074             elif aNode.IsInLine() :
1075                 myNode = INode( aNode , self.P.Verbose )
1076             elif aNode.IsGOTO() :
1077                 myNode = GNode( aNode , self.P.Verbose )
1078             elif aNode.IsLoop() :
1079                 myNode = LNode( aNode , self.P.Verbose )
1080             elif aNode.IsEndLoop() :
1081                 myNode = ELNode( aNode , self.P.Verbose )
1082             elif aNode.IsSwitch() :
1083                 myNode = SNode( aNode , self.P.Verbose )
1084             elif aNode.IsEndSwitch() :
1085                 myNode = ESNode( aNode , self.P.Verbose )
1086             else :
1087                 myNode = None
1088             return myNode
1089         return aNode
1090     def Name( self ):
1091         return self.P.Name()
1092     def Type( self ):
1093         return self.P.Type()
1094     def Link( self ):
1095         aLink = self.P.Link()
1096         if aLink != None :
1097             myLink = Link( aLink , self.P.Verbose )
1098             return myLink
1099         ErrMsg = "Failed to get a Link to " + self.P.Node().Name() + "(" + self.P.Name() + ")"
1100         if self.P.Verbose :
1101             print ErrMsg
1102         return aLink
1103     def Links( self ):
1104         links = self.P.Links()
1105         i = 0
1106         while i < len( links ) :
1107             links[ i ] = Link( links[i] , self.P.Verbose )
1108             i = i + 1
1109         return links
1110     def PrintLinks( self ):
1111         links = self.P.Links()
1112         i = 0
1113         while i < len( links ) :
1114             Link( links[ i ] , self.P.Verbose ).Print()
1115             i = i + 1
1116     def IsInput( self ):
1117         return self.P.IsInput()
1118     def IsLinked( self ):
1119         return self.P.IsLinked()
1120     def HasInput( self ):
1121         return self.P.HasInput()
1122     def Kind( self ) :
1123         return self.P.Kind()
1124     def IsParam( self ):
1125         return self.P.IsParam()
1126     def IsGate( self ):
1127         return self.P.IsGate()
1128     def IsLoop( self ):
1129         return self.P.IsLoop()
1130     def IsInLine( self ):
1131         return self.P.IsInLine()
1132     def IsSwitch( self ):
1133         return self.P.IsSwitch()
1134     def IsEndSwitch( self ):
1135         return self.P.IsEndSwitch()
1136 #    def IsBus( self ):
1137 #        return self.P.IsBus()
1138     def Done( self ):
1139         return self.P.Done()
1140     def State( self ):
1141         return self.P.State()
1142     def ToString( self ):
1143         return self.P.ToString()
1144     def ToAny( self ):
1145         return self.P.ToAny()
1146     def Print( self ):
1147         if self.P.IsInput() :
1148             if self.P.IsLinked() :
1149                 print "In",self.P.Node().Name(),'(',self.P.Name(),self.P.Kind(),self.P.Type(),') = ',self.P.ToString(),' from ',self.Link().OutPort().Print()
1150             else :
1151                 print "In",self.P.Node().Name(),'(',self.P.Name(),self.P.Kind(),self.P.Type(),') = ',self.P.ToString()
1152         else :
1153             print "Out",self.P.Node().Name(),'(',self.P.Name(),self.P.Kind(),self.P.Type(),') = ',self.P.ToString()
1154     def Destroy( self ):
1155         self.P.destroy()
1156
1157 ##########################################################
1158 class Link:
1159 ##########################################################
1160     def __init__( self , aLink , Verbose ):
1161         self.L = aLink
1162         self.L.Verbose = Verbose
1163     def OutPort( self ):
1164         aPort = self.L.OutPort()
1165         if aPort != None :
1166             myPort = Port( aPort , self.L.Verbose )
1167             return myPort
1168         if self.L.Verbose :
1169             print "Error while getting the Port : "
1170         return None
1171     def InPort( self ):
1172         aPort = self.L.InPort()
1173         if aPort != None :
1174             myPort = Port( aPort , self.L.Verbose )
1175             return myPort
1176         if self.L.Verbose :
1177             print "Error while getting the Port : "
1178         return None
1179     def Print( self ):
1180         anOutPort = self.L.OutPort()
1181         anInPort = self.L.InPort()
1182         print anOutPort.Node().Name(),'(',anOutPort.Name(),' ',anOutPort.Kind(),') =',anOutPort.ToString(),' --> ',anInPort.Node().Name(),'(',anInPort.Name(),')',' ',anInPort.Kind()
1183     def CoordsSize( self ):
1184         return self.L.CoordsSize()
1185     def AddCoord( self , index , X , Y ):
1186         return self.L.AddCoord( index , X , Y )
1187     def ChangeCoord( self , index , X , Y ):
1188         return self.L.ChangeCoord( index , X , Y )
1189     def RemoveCoord( self , index ):
1190         return self.L.RemoveCoord( index )
1191     def Coords( self , index ):
1192         return self.L.Coords( index )
1193     def destroy( self ):
1194         self.L.destroy()
1195
1196