src/GraphEditor/DataFlowEditor_OutNode.cxx

   1 using namespace std;
   2
   3 #include "DataFlowEditor_OutNode.hxx"
   4 #include "DataFlowBase_EndOfLoopNode.hxx"
   5 #include "DataFlowBase_EndOfSwitchNode.hxx"
   6
   7 // Implementation de la classe GraphEditor::Graph
   8
   9 GraphEditor::OutNode::OutNode() :
  10              Graph() {
  11   cdebug_in << "GraphEditor::OutNode::OutNode()" << endl;
  12
  13   _Imported = false ;
  14   _Valid = false ;
  15   _Executable = false ;
  16
  17   cdebug_out << "GraphEditor::OutNode::OutNode()" << endl;
  18 }
  19
  20 GraphEditor::OutNode::OutNode( CORBA::ORB_ptr ORB ,
  21                                SALOME_NamingService* ptrNamingService ,
  22                                const char *DataFlowName ,
  23                                const char * DebugFileName ) :
  24              Graph( ORB , ptrNamingService , DataFlowName , DebugFileName ) {
  25   cdebug_in << "GraphEditor::OutNode::OutNode(" ;
  26   if ( DataFlowName ) {
  27     cdebug << DataFlowName ;
  28   }
  29   cdebug << ")" << endl;
  30
  31   _Orb = CORBA::ORB::_duplicate( ORB ) ;
  32   _Imported = false ;
  33   _Valid = false ;
  34   _Executable = false ;
  35
  36   cdebug_out << "GraphEditor::OutNode::OutNode" << endl;
  37 }
  38
  39 GraphEditor::OutNode::OutNode(
  40                      CORBA::ORB_ptr ORB ,
  41                      SALOME_NamingService* ptrNamingService ,
  42                      const SALOME_ModuleCatalog::Service& DataFlowService ,
  43                      const char *DataFlowComponentName ,
  44                      const char *DataFlowInterfaceName ,
  45                      const char *DataFlowName ,
  46                      const SUPERV::KindOfNode DataFlowkind ,
  47                      const SUPERV::SDate DataFlowFirstCreation ,
  48                      const SUPERV::SDate DataFlowLastModification ,
  49                      const char * DataFlowEditorRelease ,
  50                      const char * DataFlowAuthor ,
  51                      const char * DataFlowComputer ,
  52                      const char * DataFlowComment ,
  53                      const char * DebugFileName ) :
  54              Graph( ORB , ptrNamingService , DataFlowService , DataFlowComponentName ,
  55                     DataFlowInterfaceName , DataFlowName , DataFlowkind ,
  56                     DataFlowFirstCreation , DataFlowLastModification  ,
  57                     DataFlowEditorRelease , DataFlowAuthor ,
  58                     DataFlowComputer , DataFlowComment , DebugFileName ) {
  59
  60   _Orb = CORBA::ORB::_duplicate( ORB ) ;
  61   _Imported = false ;
  62   _Valid = false ;
  63   _Executable = false ;
  64
  65 } ;
  66
  67 GraphEditor::OutNode::~OutNode() {
  68 //  delete _DataFlowNode ;
  69 //  delete _DataFlowDatas ;
  70 //  delete _GT ;
  71 }
  72
  73 bool GraphEditor::OutNode::LoadDataFlow(
  74                          const GraphBase::SGraph *aDataFlow ) {
  75   bool RetVal = false ;
  76   cdebug_in << "GraphEditor::OutNode::LoadDataFlow() " << aDataFlow->Info.theName.c_str()
  77             << endl;
  78 //  if ( GraphBase::Service::ServiceName() == NULL ||
  79 //       !strlen( GraphBase::Service::ServiceName() ) || !aConstructor ) {
  80   if ( !_Imported ) {
  81     RetVal = LoadInfo( aDataFlow->Info ) ;
  82     _Imported = true ;
  83   }
  84   else
  85     RetVal = true ;
  86
  87     map< string , int > aMapOfNodes ;
  88     if ( RetVal )
  89       RetVal = LoadNodes( aMapOfNodes , aDataFlow->Nodes ) ;
  90     if ( RetVal )
  91       RetVal = LoadLinks( aMapOfNodes , aDataFlow->Links ) ;
  92     if ( RetVal ) {
  93       Valid() ;
  94       RetVal = LoadDatas( aMapOfNodes , aDataFlow->Datas ) ;
  95     }
  96 //  }
  97 //  else {
  98 //    cdebug << "GraphEditor::OutNode::LoadDataFlow Error. ServiceName : "
  99 //            << (void *) GraphBase::Service::ServiceName() << " '"
 100 //           << GraphBase::Service::ServiceName() << "'" << endl ;
 101 //  }
 102   cdebug_out << "GraphEditor::OutNode::LoadDataFlow" << endl;
 103   return RetVal ;
 104 }
 105
 106 bool GraphEditor::OutNode::LoadXml( const char* myFileName ) {
 107   bool RetVal = false ;
 108   GraphBase::SGraph aDataFlow ;
 109   cdebug_in << "GraphEditor::OutNode::LoadXml() " << endl;
 110   if ( myFileName == NULL ) {
 111     _Imported = true ;
 112     RetVal = true ;
 113   }
 114   else if ( GraphBase::Graph::LoadXml( _Orb , myFileName , aDataFlow ) ) {
 115     RetVal = LoadDataFlow( &aDataFlow ) ;
 116 //    if ( RetVal )
 117 //      RetVal = Name( aDataFlow.Info.theName.c_str() ) ;
 118   }
 119   cdebug_out << "GraphEditor::OutNode::LoadXml" << endl;
 120   return RetVal ;
 121 }
 122
 123 bool GraphEditor::OutNode::LoadInfo(const GraphBase::SNode &aDataFlowInfo ) {
 124   cdebug_in << "GraphEditor::OutNode::LoadInfo " << aDataFlowInfo.theName.c_str()
 125             << endl ;
 126 //  MESSAGE( "GraphEditor::OutNode::LoadDataFlow" );
 127 //  ComponentName( aDataFlowInfo.theComponentName.c_str() ) ;
 128 //  InterfaceName( aDataFlowInfo.theInterfaceName.c_str() ) ;
 129   Name( aDataFlowInfo.theName.c_str() ) ;
 130   Kind( aDataFlowInfo.theKind ) ;
 131   Service( aDataFlowInfo.theService ) ;
 132   FirstCreation( aDataFlowInfo.theFirstCreation ) ;
 133   LastModification( aDataFlowInfo.theLastModification ) ;
 134   EditorRelease( aDataFlowInfo.theEditorRelease.c_str() ) ;
 135   Author( aDataFlowInfo.theAuthor.c_str()  ) ;
 136 //  Computer( aDataFlowInfo.theContainer.c_str() ) ;
 137   Comment( aDataFlowInfo.theComment.c_str() ) ;
 138 // Not in OutNode/DataFlow but in InNode/DataFlow_in_an_other_DataFlow
 139 //  Coordinates( aDataFlowInfo.theX , aDataFlowInfo.theY ) ;
 140   cdebug_out << "GraphEditor::OutNode::LoadInfo" << endl ;
 141   return true ;
 142 }
 143
 144 bool GraphEditor::OutNode::LoadNodes(map< string , int > & aMapOfNodes ,
 145                                      const GraphBase::ListOfNodes &aListOfNodes ) {
 146   GraphEditor::InNode * anInNode ;
 147   cdebug_in << "GraphEditor::OutNode::LoadNodes" << endl ;
 148   int i ;
 149   for ( i = 0 ; i < aListOfNodes.size() ; i++ ) {
 150     GraphBase::SNode aNode = aListOfNodes[ i ] ;
 151 //    if ( aConstructor ) {
 152 //      anInNode = AddNode( aNode.theService , aNode.theComponentName.c_str() ,
 153 //                        aNode.theInterfaceName.c_str() ,
 154 //                        aNode.theName.c_str() ,
 155 //                        aNode.theKind ,
 156 //                        aNode.theFirstCreation , aNode.theLastModification ,
 157 //                        aNode.theEditorRelease.c_str() ,
 158 //                        aNode.theAuthor.c_str() , aNode.theContainer.c_str() ,
 159 //                        aNode.theComment.c_str() ,
 160 //                        aNode.theCoords.theX , aNode.theCoords.theY ) ;
 161 //    }
 162 //    else {
 163       const char * aNodeName = aNode.theName.c_str() ;
 164       if ( aNode.theListOfFuncName.size() == 0 ) {
 165         aNode.theListOfFuncName.resize( 1 ) ;
 166         aNode.theListOfFuncName[ 0 ] = "" ;
 167         aNode.theListOfPythonFunctions.resize( 1 ) ;
 168         aNode.theListOfPythonFunctions[ 0 ] = new SUPERV::ListOfStrings() ;
 169       }
 170       if ( GetGraphNode( aNode.theName.c_str() ) )
 171         aNodeName = NULL ;
 172       anInNode = AddNode( aNode.theService ,
 173                           aNode.theListOfFuncName ,
 174                           aNode.theListOfPythonFunctions ,
 175                           aNode.theComponentName.c_str() ,
 176                           aNode.theInterfaceName.c_str() , aNodeName ,
 177                           aNode.theKind ,
 178                           aNode.theFirstCreation , aNode.theLastModification ,
 179                           aNode.theEditorRelease.c_str() ,
 180                           aNode.theAuthor.c_str() , aNode.theContainer.c_str() ,
 181                           aNode.theComment.c_str() ,
 182                           aNode.theCoords.theX , aNode.theCoords.theY ) ;
 183       string * aNodetheName = new string( aNode.theName ) ;
 184       aMapOfNodes[ *aNodetheName ] = GetGraphNodeIndex( anInNode->Name() ) ;
 185       if ( anInNode->IsOneOfInLineNodes() ) {
 186         anInNode->GraphEditor::InNode::InLineNode()->DefPortsOfNode(
 187                                 _Orb , aNode.theService , anInNode->NamePtr() ,
 188                                 anInNode->Kind() , false ,
 189                                 anInNode->IsLoopNode() || anInNode->IsEndLoopNode() ,
 190                                 true , true , Graph_prof_debug() , Graph_fdebug() ) ;
 191         GraphBase::InLineNode * aINode = anInNode->InLineNode() ;
 192         GraphBase::LoopNode * aLNode = NULL ;
 193         if ( aINode->IsLoopNode() ) {
 194           aLNode = anInNode->LoopNode() ;
 195           aLNode->SetPythonFunction( aNode.theListOfFuncName[ 0 ].c_str() ,
 196                                      *aNode.theListOfPythonFunctions[ 0 ] ) ;
 197           aLNode->SetMorePythonFunction( aNode.theListOfFuncName[ 1 ].c_str() ,
 198                                          *aNode.theListOfPythonFunctions[ 1 ] ) ;
 199           aLNode->SetNextPythonFunction( aNode.theListOfFuncName[ 2 ].c_str() ,
 200                                          *aNode.theListOfPythonFunctions[ 2 ] ) ;
 201         }
 202         else if ( aINode->IsInLineNode() || aINode->IsGOTONode() ||
 203                   aINode->IsSwitchNode() || aINode->IsEndSwitchNode() ) {
 204           aINode->SetPythonFunction( aNode.theListOfFuncName[ 0 ].c_str() ,
 205                                      *aNode.theListOfPythonFunctions[ 0 ] ) ;
 206         }
 207       }
 208 #if 0
 209       if ( aNode.theListOfParameters.size() ) {
 210         int j ;
 211         for ( j = 0 ; j < aNode.theListOfParameters.size() ; j++ ) {
 212           if ( IsInLineNode() ) {
 213             GraphBase::InPort * InputPort = anInNode->AddInPort(
 214                  aNode.theListOfParameters[ j ].theInParameter.Parametername ,
 215                  aNode.theListOfParameters[ j ].theInParameter.Parametertype ) ;
 216             GraphBase::OutPort * OutputPort = anInNode->AddOutPort(
 217                  aNode.theListOfParameters[ j ].theOutParameter.Parametername ,
 218                  aNode.theListOfParameters[ j ].theOutParameter.Parametertype ) ;
 219             anInNode->InOutPort( InputPort , OutputPort ) ;
 220           }
 221         }
 222       }
 223 #endif
 224 //      cout << "LoadNodes " << aNodetheName << " "
 225 //           << GetGraphNodeIndex( anInNode->Name() ) << endl ;
 226       delete aNodetheName ;
 227 //    }
 228     if ( !anInNode )
 229       return false ;
 230   }
 231   for ( i = 0 ; i < aListOfNodes.size() ; i++ ) {
 232     GraphBase::SNode aNode = aListOfNodes[ i ] ;
 233     cdebug << "GraphEditor::OutNode::LoadNodes " << aNode.theName.c_str() << " Coupled to "
 234            << aNode.theCoupledNode.c_str() << endl ;
 235     anInNode = (GraphEditor::InNode * ) GetChangeGraphNode( aNode.theName.c_str() )->GetInNode() ;
 236     if ( anInNode->IsOneOfGOTONodes() && strlen( aNode.theCoupledNode.c_str() ) ) {
 237       GraphBase::GOTONode * aCoupledNode ;
 238       aCoupledNode = (GraphBase::GOTONode * ) GetGraphNode( aNode.theName.c_str() ) ;
 239       aCoupledNode->CoupledNode( (GraphBase::GOTONode * ) GetChangeGraphNode( aNode.theCoupledNode.c_str() ) ) ;
 240     }
 241   }
 242   cdebug_out << "GraphEditor::OutNode::LoadNodes" << endl ;
 243   return true ;
 244 }
 245
 246 bool GraphEditor::OutNode::LoadLinks(map< string , int > & aMapOfNodes ,
 247                                      const GraphBase::ListOfLinks &aListOfLinks ) {
 248   bool RetVal = true ;
 249   cdebug_in << "GraphEditor::OutNode::LoadLinks" << endl ;
 250 //  MESSAGE( "GraphEditor::OutNode::LoadLinks" );
 251   int i , j ;
 252   for ( i = 0 ; i < aListOfLinks.size() ; i++ ) {
 253     GraphBase::SLink aLink = aListOfLinks[ i ] ;
 254     string * aLinkFromNodeName = new string( aLink.FromNodeName.c_str() ) ;
 255     string * aLinkToNodeName = new string( aLink.ToNodeName.c_str() ) ;
 256     RetVal = AddLink( GetGraphNode( aMapOfNodes[ aLinkFromNodeName->c_str() ] )->Name() ,
 257                       aLink.FromServiceParameterName.c_str() ,
 258                       GetGraphNode( aMapOfNodes[ aLinkToNodeName->c_str() ] )->Name() ,
 259                       aLink.ToServiceParameterName.c_str() ,
 260                       *((GraphBase::ComputingNode *) GetGraphNode( aMapOfNodes[ aLinkFromNodeName->c_str() ] ))->GetOutPort( aLink.FromServiceParameterName.c_str() )->Value() ) ;
 261 //                      aLink.aLinkValue ) ;
 262     if ( !RetVal )
 263       break ;
 264     else {
 265       for ( j = 0 ; j < aLink.aListOfCoords.size() ; j++ ) {
 266         RetVal = AddLinkCoord( GetGraphNode( aMapOfNodes[ aLinkFromNodeName->c_str() ] )->Name() ,
 267                                aLink.FromServiceParameterName.c_str() ,
 268                                GetGraphNode( aMapOfNodes[ aLink.ToNodeName.c_str() ] )->Name() ,
 269                                aLink.ToServiceParameterName.c_str() ,
 270                                j + 1 ,
 271                                aLink.aListOfCoords[j].theX ,
 272                                aLink.aListOfCoords[j].theY ) ;
 273         if ( !RetVal )
 274           break ;
 275       }
 276     }
 277     delete aLinkFromNodeName ;
 278     delete aLinkToNodeName ;
 279   }
 280   cdebug_out << "GraphEditor::OutNode::LoadLinks" << endl ;
 281   return RetVal ;
 282 }
 283
 284 bool GraphEditor::OutNode::LoadDatas(map< string , int > & aMapOfNodes ,
 285                                      const GraphBase::ListOfLinks &aListOfDatas ) {
 286   bool RetVal = true ;
 287   cdebug_in << "GraphEditor::OutNode::LoadDatas" << endl ;
 288 //  MESSAGE( "GraphEditor::OutNode::LoadDatas" );
 289   int i ;
 290   for ( i = 0 ; i < aListOfDatas.size() ; i++ ) {
 291     GraphBase::SLink aLink = aListOfDatas[ i ] ;
 292     if ( !strcmp( aLink.FromNodeName.c_str() , Name() ) ) {
 293       cdebug << "GraphEditor::OutNode::LoadDatas Warning "
 294              << aLink.FromNodeName.c_str()
 295              << " and " << aLink.ToNodeName.c_str() << " differents from " << Name()
 296              << endl ;
 297     }
 298     string * aLinkFromNodeName = new string( aLink.FromNodeName.c_str() ) ;
 299     string * aLinkToNodeName = new string( aLink.ToNodeName.c_str() ) ;
 300 //      cout << "LoadDatas " << aLink.FromNodeName.c_str() << " "
 301 //           << aMapOfNodes[ aLinkFromNodeName->c_str() ] << endl ;
 302 //      cout << "          " << aLink.ToNodeName.c_str() << " "
 303 //           << aMapOfNodes[ aLinkToNodeName->c_str() ] << endl ;
 304     RetVal = GraphBase::Graph::AddInputData( GetGraphNode( aMapOfNodes[ aLinkToNodeName->c_str() ] )->Name() ,
 305                                              aLink.ToServiceParameterName.c_str() ,
 306                                              aLink.aLinkValue ) ;
 307     delete aLinkFromNodeName ;
 308     delete aLinkToNodeName ;
 309     if ( !RetVal )
 310       break ;
 311   }
 312   cdebug_out << "GraphEditor::OutNode::LoadDatas" << endl ;
 313   return RetVal ;
 314 }
 315
 316 bool GraphEditor::OutNode::SaveXml(const char* filename) {
 317   bool test;
 318   cdebug_in << "GraphEditor::OutNode::SaveXml(" << filename << ")" << endl;
 319   ofstream f(filename);
 320   IsValid() ;
 321 //  test = SaveXML( f );
 322   QDomDocument Graph ;
 323   test = SaveXML( Graph );
 324   if ( test ) {
 325     QString xml = Graph.toString() ;
 326 //    cout << "GraphEditor::OutNode::SaveXML " << xml << endl ;
 327     f << xml << endl ;
 328   }
 329   cdebug_out << "GraphEditor::OutNode::SaveXml" << endl;
 330   return test;
 331 }
 332
 333
 334 bool GraphEditor::OutNode::SavePy( const char* filename ) {
 335   bool test;
 336   cdebug_in << "GraphEditor::OutNode::SavePy(" << filename << ")" << endl;
 337   ofstream f( filename ) ;
 338   IsValid() ;
 339   test = SavePY( f );
 340   cdebug_out << "GraphEditor::OutNode::SavePy" << endl;
 341   return test;
 342 }
 343
 344 GraphBase::SGraph * GraphEditor::OutNode::GetDataFlow() {
 345   GraphBase::SGraph * aDataFlow = new GraphBase::SGraph;
 346   aDataFlow->Info = *GetInfo() ;
 347   aDataFlow->Nodes = *GetNodes() ;
 348   aDataFlow->Links = *GetLinks() ;
 349   aDataFlow->Datas = *GetDatas() ;
 350   return aDataFlow ;
 351 }
 352
 353 void GraphEditor::OutNode::DateModification() {
 354   time_t T = time(NULL);
 355   struct tm * Tm = localtime(&T);
 356   SUPERV::SDate aLastModificationDate ;
 357
 358   aLastModificationDate.Second = Tm->tm_sec;
 359   aLastModificationDate.Minute = Tm->tm_min;
 360   aLastModificationDate.Hour   = Tm->tm_hour;
 361   aLastModificationDate.Day    = Tm->tm_mday;
 362   aLastModificationDate.Month  = Tm->tm_mon + 1;
 363   aLastModificationDate.Year   = Tm->tm_year + 1900;
 364   LastModification( aLastModificationDate ) ;
 365 }
 366
 367 void GraphEditor::OutNode::Coordinates( const char* NodeName ,
 368                                         const int X ,
 369                                         const int Y ) {
 370   ((GraphEditor::InNode * ) GetChangeGraphNode( NodeName ))->Coordinates( X , Y ) ;
 371 }
 372
 373 const int GraphEditor::OutNode::XCoordinate( const char* NodeName ) {
 374   return ((GraphEditor::InNode * ) GetChangeGraphNode( NodeName ))->XCoordinate() ;
 375 }
 376
 377 const int GraphEditor::OutNode::YCoordinate( const char* NodeName ) {
 378   return ((GraphEditor::InNode * ) GetChangeGraphNode( NodeName ))->YCoordinate() ;
 379 }
 380
 381 GraphEditor::InNode *GraphEditor::OutNode::AddNode(
 382                       const SALOME_ModuleCatalog::Service& NodeService ,
 383                       GraphBase::ListOfFuncName aFuncName ,
 384                       GraphBase::ListOfPythonFunctions aPythonFunction ,
 385                       const char *NodeComponentName ,
 386                       const char* NodeInterfaceName ,
 387                       const char *theNodeName ,
 388                       const SUPERV::KindOfNode NodeKindOfNode ,
 389                       const SUPERV::SDate NodeFirstCreation ,
 390                       const SUPERV::SDate NodeLastModification  ,
 391                       const char * NodeEditorRelease ,
 392                       const char * NodeAuthor ,
 393                       const char * NodeComputer ,
 394                       const char * NodeComment ,
 395                       const int NodeX ,
 396                       const int NodeY ) {
 397   cdebug_in << "GraphEditor::OutNode::AddNode(" << NodeComponentName << " , "
 398             << theNodeName << ")" << endl;
 399   char * RetVal = NULLSTRING ;
 400   GraphEditor::InNode *Nd = NULL ;
 401   char * aNodeName = NULL ;
 402   bool   GeneratedName = false ;
 403   if ( NodeKindOfNode == SUPERV::InLineNode ||
 404        NodeKindOfNode == SUPERV::LoopNode ||
 405        NodeKindOfNode == SUPERV::EndLoopNode ||
 406        NodeKindOfNode == SUPERV::SwitchNode ||
 407        NodeKindOfNode == SUPERV::EndSwitchNode ||
 408        NodeKindOfNode == SUPERV::GOTONode ) {
 409     if ( theNodeName == NULL || strlen( theNodeName ) == 0 ) {
 410       if ( NodeKindOfNode == SUPERV::InLineNode ) {
 411         ((SALOME_ModuleCatalog::Service& ) NodeService).ServiceName = my_strdup( "InLine" ) ;
 412       }
 413       else if ( NodeKindOfNode == SUPERV::LoopNode ) {
 414         ((SALOME_ModuleCatalog::Service& ) NodeService).ServiceName = my_strdup( "Loop" ) ;
 415       }
 416       else if ( NodeKindOfNode == SUPERV::EndLoopNode ) {
 417         ((SALOME_ModuleCatalog::Service& ) NodeService).ServiceName = my_strdup( "EndLoop" ) ;
 418       }
 419       else if ( NodeKindOfNode == SUPERV::SwitchNode ) {
 420         ((SALOME_ModuleCatalog::Service& ) NodeService).ServiceName = my_strdup( "Switch" ) ;
 421       }
 422       else if ( NodeKindOfNode == SUPERV::EndSwitchNode ) {
 423         ((SALOME_ModuleCatalog::Service& ) NodeService).ServiceName = my_strdup( "EndSwitch" ) ;
 424       }
 425       else if ( NodeKindOfNode == SUPERV::GOTONode ) {
 426         ((SALOME_ModuleCatalog::Service& ) NodeService).ServiceName = my_strdup( "GOTO" ) ;
 427       }
 428     }
 429     else {
 430       ((SALOME_ModuleCatalog::Service& ) NodeService).ServiceName = CORBA::string_dup( theNodeName ) ;
 431     }
 432     theNodeName = NULL ;
 433   }
 434   if ( theNodeName == NULL ) {
 435     aNodeName = new char[ strlen( NodeService.ServiceName )+1 ] ;
 436     strcpy( aNodeName , NodeService.ServiceName ) ;
 437     if ( GetGraphNode( NodeService.ServiceName ) ) {
 438       GeneratedName = true ;
 439       while ( GetGraphNode( aNodeName ) ) {
 440         if ( aNodeName )
 441           delete [] aNodeName ;
 442         int num = GetServiceNameNumber( NodeService.ServiceName ) ;
 443         ostrstream s ;
 444         s << num << ends ;
 445         const char * n_instance = s.str() ;
 446         int lname = strlen( NodeService.ServiceName ) + 1 +
 447                     strlen( n_instance ) + 1 ;
 448         aNodeName = new char[lname] ;
 449         strcpy( aNodeName , NodeService.ServiceName ) ;
 450         strcat( aNodeName , "_" ) ;
 451         strcat( aNodeName , n_instance ) ;
 452       }
 453     }
 454   }
 455   else {
 456     if ( GetGraphNode( theNodeName ) == NULL ) {
 457       aNodeName = new char[ strlen( theNodeName )+1 ] ;
 458       strcpy( aNodeName , theNodeName ) ;
 459     }
 460   }
 461   if ( aNodeName != NULL ) {
 462     Nd = new GraphEditor::InNode( _Orb , NamingService() ,
 463                                   aFuncName , aPythonFunction , NodeService ,
 464                                   NodeComponentName , NodeInterfaceName ,
 465                                   aNodeName , NodeKindOfNode ,
 466                                   NodeFirstCreation , NodeLastModification ,
 467                                   NodeEditorRelease , NodeAuthor ,
 468                                   NodeComputer , NodeComment , GeneratedName ,
 469                                   NodeX , NodeY ,
 470                                   Graph_prof_debug() , Graph_fdebug() ) ;
 471 //    MESSAGE( "GraphEditor::OutNode::AddNode " << hex << (void *) Nd << dec );
 472 //    if ( GraphBase::Graph::AddNode( Nd ) ) {
 473     if ( GraphBase::Graph::AddNode( Nd->ComputingNode() ) ) {
 474       DateModification() ;
 475       RetVal = Nd->Name() ;
 476     }
 477     else {
 478       cdebug << "NodeName already exists." << endl ;
 479     }
 480   }
 481   else {
 482     cdebug << "NodeName is NULL or already exists." << endl ;
 483   }
 484 //  delete [] aNodeName ;
 485   cdebug_out << "GraphEditor::OutNode::AddNode" << endl;
 486   _Valid = false ;
 487   return Nd ;
 488 }
 489
 490 bool GraphEditor::OutNode::AddLinkCoord( const char* FromNodeName ,
 491                                          const char* FromServiceParameterName ,
 492                                          const char* ToNodeName ,
 493                                          const char* ToServiceParameterName ,
 494                                          const int nXY ,
 495                                          const int* X ,
 496                                          const int* Y ) {
 497   GraphBase::InPort * aLink = GraphBase::Graph::GetChangeInPort( ToNodeName ,
 498                                                ToServiceParameterName ) ;
 499   if ( aLink ) {
 500     if ( aLink->IsSwitch() ) {
 501       return GraphBase::Graph::GetChangeOutPort( FromNodeName , FromServiceParameterName )->AddCoord( nXY , X , Y ) ;
 502     }
 503     else {
 504       return aLink->AddCoord( nXY , X , Y ) ;
 505     }
 506   }
 507   return false ;
 508 }
 509
 510 bool GraphEditor::OutNode::AddLinkCoord( const char* FromNodeName ,
 511                                          const char* FromServiceParameterName ,
 512                                          const char* ToNodeName ,
 513                                          const char* ToServiceParameterName ,
 514                                          const int index ,
 515                                          const int X ,
 516                                          const int Y ) {
 517   GraphBase::InPort * aLink = GraphBase::Graph::GetChangeInPort( ToNodeName ,
 518                                                ToServiceParameterName ) ;
 519   if ( aLink ) {
 520     if ( aLink->IsSwitch() ) {
 521       return GraphBase::Graph::GetChangeOutPort( FromNodeName , FromServiceParameterName )->AddCoord( index , X , Y ) ;
 522     }
 523     else {
 524       return aLink->AddCoord( index , X , Y ) ;
 525     }
 526   }
 527   return false ;
 528 }
 529
 530 bool GraphEditor::OutNode::ChangeLinkCoord(
 531                                          const char* FromNodeName ,
 532                                          const char* FromServiceParameterName ,
 533                                          const char* ToNodeName ,
 534                                          const char* ToServiceParameterName ,
 535                                          const int index ,
 536                                          const int X ,
 537                                          const int Y ) {
 538   GraphBase::InPort * aLink = GraphBase::Graph::GetChangeInPort( ToNodeName ,
 539                                                ToServiceParameterName ) ;
 540   if ( aLink ) {
 541     if ( aLink->IsSwitch() ) {
 542       return GraphBase::Graph::GetChangeOutPort( FromNodeName , FromServiceParameterName )->ChangeCoord( index , X , Y ) ;
 543     }
 544     else {
 545       return aLink->ChangeCoord( index , X , Y ) ;
 546     }
 547   }
 548   return false ;
 549 }
 550
 551 bool GraphEditor::OutNode::RemoveLinkCoord(
 552                                          const char* FromNodeName ,
 553                                          const char* FromServiceParameterName ,
 554                                          const char* ToNodeName ,
 555                                          const char* ToServiceParameterName ,
 556                                          const int index ) {
 557   GraphBase::InPort * aLink = GraphBase::Graph::GetChangeInPort( ToNodeName ,
 558                                                ToServiceParameterName ) ;
 559   if ( aLink ) {
 560     if ( aLink->IsSwitch() ) {
 561       return GraphBase::Graph::GetChangeOutPort( FromNodeName , FromServiceParameterName )->RemoveCoord( index ) ;
 562     }
 563     else {
 564       return aLink->RemoveCoord( index ) ;
 565     }
 566   }
 567   return false ;
 568 }
 569
 570 int GraphEditor::OutNode::GetLinkCoordSize(
 571                                          const char* FromNodeName ,
 572                                          const char* FromServiceParameterName ,
 573                                          const char* ToNodeName ,
 574                                          const char* ToServiceParameterName ) {
 575   const GraphBase::InPort * aLink = GraphBase::Graph::GetInPort( ToNodeName , ToServiceParameterName ) ;
 576   if ( aLink ) {
 577     if ( aLink->IsSwitch() ) {
 578       return GraphBase::Graph::GetChangeOutPort( FromNodeName , FromServiceParameterName )->GetCoord() ;
 579     }
 580     else {
 581       return aLink->GetCoord() ;
 582     }
 583   }
 584   return 0 ;
 585 }
 586
 587 bool GraphEditor::OutNode::GetLinkCoord( const char* FromNodeName ,
 588                                          const char* FromServiceParameterName ,
 589                                          const char* ToNodeName ,
 590                                          const char* ToServiceParameterName ,
 591                                          int *X , int *Y ) {
 592   const GraphBase::InPort * aLink = GraphBase::Graph::GetInPort( ToNodeName , ToServiceParameterName ) ;
 593   if ( aLink ) {
 594     if ( aLink->IsSwitch() ) {
 595       return GraphBase::Graph::GetChangeOutPort( FromNodeName , FromServiceParameterName )->GetCoord( X , Y ) ;
 596     }
 597     else {
 598       return aLink->GetCoord( X , Y ) ;
 599     }
 600   }
 601   return false ;
 602 }
 603
 604 bool GraphEditor::OutNode::GetLinkCoord(
 605                                   const char* FromNodeName ,
 606                                   const char* FromServiceParameterName ,
 607                                   const char* ToNodeName ,
 608                                   const char* ToServiceParameterName ,
 609                                   const int index , long &X , long &Y ) {
 610   GraphBase::InPort * aLink = GraphBase::Graph::GetChangeInPort( ToNodeName ,
 611                                                ToServiceParameterName ) ;
 612   if ( aLink ) {
 613     if ( aLink->IsSwitch() ) {
 614       return GraphBase::Graph::GetChangeOutPort( FromNodeName , FromServiceParameterName )->GetCoord( index , X , Y ) ;
 615     }
 616     else {
 617       return aLink->GetCoord( index , X , Y ) ;
 618     }
 619   }
 620   return false ;
 621 }
 622
 623 bool GraphEditor::OutNode::AddInputData( const char* ToNodeName1 ,
 624                                          const char* ToParameterName1 ,
 625                                          const char* ToNodeName2 ,
 626                                          const char* ToParameterName2 ) {
 627   cdebug_in << "GraphEditor::OutNode::AddInputData" << endl;
 628   bool RetVal = GraphBase::Graph::AddInputData( ToNodeName1 ,
 629                                                 ToParameterName1 ,
 630                                                 ToNodeName2 ,
 631                                                 ToParameterName2 ) ;
 632   cdebug_out << "GraphEditor::OutNode::AddInputData" << endl;
 633   _Valid = false ;
 634   return RetVal ;
 635 }
 636
 637 bool GraphEditor::OutNode::Valid() {
 638   if ( _Valid )
 639     return true ;
 640
 641   cdebug_in << "GraphEditor::OutNode::Valid" << endl;
 642   _Executable = false ;
 643
 644   CreateService() ;
 645
 646   if ( !Sort() ) {
 647     cdebug << "This DataFlow is not valid." << endl ;
 648     return false ;
 649   }
 650
 651 //  CreateService() ;
 652
 653   InLineServices() ;
 654
 655   ComputingNodes() ;
 656
 657   _Valid = true ;
 658
 659   cdebug_out << "GraphEditor::OutNode::Valid" << endl;
 660   return _Valid ;
 661 }
 662
 663 bool GraphEditor::OutNode::Executable() {
 664
 665   cdebug_in << "GraphEditor::OutNode::Executable" << endl;
 666   if ( !IsValid() )
 667     Valid() ;
 668   if ( !IsValid() )
 669     return false ;
 670 //  if ( !_GT )
 671 //  GraphExecutor::GraphControl _GT = new GraphExecutor::GraphControl( this );
 672
 673   if ( DataServerNodes() )
 674     _Executable = true ;
 675   else {
 676     cdebug << "This DataFlow is not executable." << endl ;
 677     _Executable = false ;
 678   }
 679
 680   cdebug_out << "GraphEditor::OutNode::Executable" << endl;
 681   return _Executable ;
 682 }
 683
 684 const CORBA::Any *GraphEditor::OutNode::GetInData(
 685                               const char * ToNodeName ,
 686                               const char * ToParameterName ) {
 687   cdebug_in << "GraphEditor::OutNode::GetInData" << endl ;
 688   const CORBA::Any * retdata = PortInData( ToNodeName , ToParameterName ) ;
 689   cdebug_out << "GraphEditor::OutNode::GetInData " << ToNodeName
 690              << " " << ToParameterName << endl ;
 691   return retdata ;
 692 }
 693
 694 const CORBA::Any *GraphEditor::OutNode::GetOutData(
 695                               const char * FromNodeName ,
 696                               const char * FromParameterName ) {
 697   cdebug_in << "GraphEditor::OutNode::GetOutData" << endl ;
 698   const CORBA::Any * retdata = PortOutData( FromNodeName , FromParameterName ) ;
 699   cdebug_out << "GraphEditor::OutNode::GetOutData " << FromNodeName
 700              << " " << FromParameterName << endl ;
 701   return retdata ;
 702 }
 703
 704 //bool GraphEditor::OutNode::LinkSaveXML( ostream &f , char *Tabs ,
 705 bool GraphEditor::OutNode::LinkSaveXML( QDomDocument & Graph , QDomElement & link ,
 706                                         GraphBase::SLink aLink ,
 707                                         bool wdata ) const {
 708   QDomElement fromnodename = Graph.createElement( "fromnode-name" ) ;
 709   QDomText aField ;
 710   if ( strlen( aLink.FromNodeName.c_str() ) ) {
 711 //    f << Tabs << "<fromnode-name>" << aLink.FromNodeName.c_str()
 712 //      << "</fromnode-name>" << endl ;
 713     aField = Graph.createTextNode( aLink.FromNodeName.c_str() ) ;
 714   }
 715   else {
 716 //    f << Tabs << "<fromnode-name>?</fromnode-name>" << endl ;
 717     aField = Graph.createTextNode( "?" ) ;
 718   }
 719   link.appendChild( fromnodename ) ;
 720   fromnodename.appendChild( aField ) ;
 721
 722 //  f << Tabs << "<fromserviceparameter-name>"
 723 //    << aLink.FromServiceParameterName.c_str() << "</fromserviceparameter-name>"
 724 //    << endl ;
 725   QDomElement fromserviceparametername = Graph.createElement( "fromserviceparameter-name" ) ;
 726   aField = Graph.createTextNode( aLink.FromServiceParameterName.c_str() ) ;
 727   link.appendChild( fromserviceparametername ) ;
 728   fromserviceparametername.appendChild( aField ) ;
 729
 730   QDomElement tonodename = Graph.createElement( "tonode-name" ) ;
 731   if ( strlen( aLink.ToNodeName.c_str() ) ) {
 732 //    f << Tabs << "<tonode-name>" << aLink.ToNodeName.c_str()
 733 //      << "</tonode-name>" << endl ;
 734     aField = Graph.createTextNode( aLink.ToNodeName.c_str() ) ;
 735   }
 736   else {
 737 //    f << Tabs << "<tonode-name>?</tonode-name>" << endl ;
 738     aField = Graph.createTextNode( "?" ) ;
 739   }
 740   link.appendChild( tonodename ) ;
 741   tonodename.appendChild( aField ) ;
 742
 743 //  f << Tabs << "<toserviceparameter-name>"
 744 //    << aLink.ToServiceParameterName.c_str() << "</toserviceparameter-name>"
 745 //    << endl ;
 746   QDomElement toserviceparametername = Graph.createElement( "toserviceparameter-name" ) ;
 747   aField = Graph.createTextNode( aLink.ToServiceParameterName.c_str() ) ;
 748   link.appendChild( toserviceparametername ) ;
 749   toserviceparametername.appendChild( aField ) ;
 750
 751   if ( wdata ) {
 752 //    f << Tabs << "<data-value>" << endl ;
 753     QDomElement datavalue = Graph.createElement( "data-value" ) ;
 754     link.appendChild( datavalue ) ;
 755 //    f << Tabs << "    <value-type>" << aLink.aLinkValue.type()->kind()
 756 //      << "</value-type>" << endl ;
 757     QDomElement valuetype = Graph.createElement( "value-type" ) ;
 758     QString aKind ;
 759     aKind = aKind.setNum( aLink.aLinkValue.type()->kind() ) ;
 760     aField = Graph.createTextNode( aKind ) ;
 761     datavalue.appendChild( valuetype ) ;
 762     valuetype.appendChild( aField ) ;
 763     switch (aLink.aLinkValue.type()->kind()) {
 764       case CORBA::tk_string: {
 765         char* retstr ;
 766         aLink.aLinkValue >>= retstr;
 767 //        f << Tabs << "        <value>" << retstr << "</value>" << endl ;
 768         QDomElement value = Graph.createElement( "value" ) ;
 769         aField = Graph.createTextNode( retstr ) ;
 770         datavalue.appendChild( value ) ;
 771         value.appendChild( aField ) ;
 772 //        MESSAGE( "ToString( string ) " << retstr );
 773         break ;
 774       }
 775       case CORBA::tk_double: {
 776         double d;
 777         aLink.aLinkValue >>= d;
 778 //        f << Tabs << "        <value>" << d << "</value>" << endl ;
 779         QDomElement value = Graph.createElement( "value" ) ;
 780         QString aKind ;
 781         aKind = aKind.setNum( d ) ;
 782         aField = Graph.createTextNode( aKind ) ;
 783         datavalue.appendChild( value ) ;
 784         value.appendChild( aField ) ;
 785 //        MESSAGE( "ToString( double ) " << d );
 786         break ;
 787       }
 788       case CORBA::tk_long: {
 789         long l;
 790         aLink.aLinkValue >>= l;
 791 //        f << Tabs << "        <value>" << l << "</value>" << endl ;
 792         QDomElement value = Graph.createElement( "value" ) ;
 793         QString aKind ;
 794         aKind = aKind.setNum( l ) ;
 795         aField = Graph.createTextNode( aKind ) ;
 796         datavalue.appendChild( value ) ;
 797         value.appendChild( aField ) ;
 798 //        MESSAGE( "ToString( long ) " << l );
 799         break ;
 800       }
 801       case CORBA::tk_objref: {
 802         char* retstr ;
 803         CORBA::Object_ptr obj ;
 804         aLink.aLinkValue >>= obj ;
 805         retstr = _Orb->object_to_string(obj );
 806 //        f << Tabs << "        <value>" << retstr << "</value>" << endl ;
 807         QDomElement value = Graph.createElement( "value" ) ;
 808         aField = Graph.createTextNode( retstr ) ;
 809         datavalue.appendChild( value ) ;
 810         value.appendChild( aField ) ;
 811 //        MESSAGE( "ToString( object ) " << retstr );
 812         break ;
 813       }
 814       default: {
 815 //        f << Tabs << "        <value>?</value>" << endl ;
 816         QDomElement value = Graph.createElement( "value" ) ;
 817         aField = Graph.createTextNode( "?" ) ;
 818         datavalue.appendChild( value ) ;
 819         value.appendChild( aField ) ;
 820 //        MESSAGE( "Unknown CORBA::Any Type" );
 821         break ;
 822       }
 823     }
 824 //    f << Tabs << "</data-value>" << endl ;
 825   }
 826 //  f << Tabs << "<coord-list>" << endl ;
 827   QDomElement coordlist = Graph.createElement( "coord-list" ) ;
 828   link.appendChild( coordlist ) ;
 829
 830   int i ;
 831   for ( i = 0 ; i < aLink.aListOfCoords.size() ; i++ ) {
 832 //    f << Tabs << "    <coord>" << endl ;
 833     QDomElement coord = Graph.createElement( "coord" ) ;
 834     coordlist.appendChild( coord ) ;
 835 //    f << Tabs << "            <x>" << aLink.aListOfCoords[ i ].theX << "</x>" << endl ;
 836     QDomElement x = Graph.createElement( "x" ) ;
 837     QString ax ;
 838     ax = ax.setNum( aLink.aListOfCoords[ i ].theX ) ;
 839     aField = Graph.createTextNode( ax ) ;
 840     coord.appendChild( x ) ;
 841     x.appendChild( aField ) ;
 842 //    f << Tabs << "            <y>" << aLink.aListOfCoords[ i ].theY << "</y>" << endl ;
 843     QDomElement y = Graph.createElement( "y" ) ;
 844     QString ay ;
 845     ay = ay.setNum( aLink.aListOfCoords[ i ].theY ) ;
 846     aField = Graph.createTextNode( ay ) ;
 847     coord.appendChild( y ) ;
 848     y.appendChild( aField ) ;
 849 //    f << Tabs << "    </coord>" << endl ;
 850   }
 851 //  f << Tabs << "</coord-list>" << endl ;
 852   return true ;
 853 }
 854
 855 bool GraphEditor::OutNode::LinkSavePY( ostream &f , const char * aGraphName ,
 856                                        GraphBase::SLink aLink ,
 857                                        bool intervar , bool wdata ) const {
 858   if ( !wdata ) {
 859     if ( intervar ) {
 860       f << aLink.FromNodeName.c_str() << aLink.FromServiceParameterName.c_str()
 861         << " = "
 862         << aLink.FromNodeName.c_str() << ".Port( '"
 863         << aLink.FromServiceParameterName.c_str()
 864         << "' )" << endl ;
 865     }
 866     f << aLink.ToNodeName.c_str() << aLink.ToServiceParameterName.c_str()
 867       << " = " << aGraphName << ".Link( " << aLink.FromNodeName.c_str()
 868       << aLink.FromServiceParameterName.c_str() << " , "
 869       << aLink.ToNodeName.c_str() << ".Port( '"
 870       << aLink.ToServiceParameterName.c_str() << "' ) )" << endl ;
 871   }
 872   else {
 873     f << aLink.ToNodeName.c_str() << aLink.ToServiceParameterName.c_str()
 874       << " = " << aLink.ToNodeName.c_str() << ".Input( '"
 875       << aLink.ToServiceParameterName.c_str() << "' , " ;
 876     switch (aLink.aLinkValue.type()->kind()) {
 877       case CORBA::tk_string: {
 878         char* retstr ;
 879         aLink.aLinkValue >>= retstr;
 880         f << "'" << retstr << "'" ;
 881         break ;
 882       }
 883       case CORBA::tk_double: {
 884         double d;
 885         aLink.aLinkValue >>= d;
 886         f << d ;
 887         break ;
 888       }
 889       case CORBA::tk_long: {
 890         long l;
 891         aLink.aLinkValue >>= l;
 892         f << l ;
 893         break ;
 894       }
 895       case CORBA::tk_objref: {
 896         char* retstr ;
 897         CORBA::Object_ptr obj ;
 898         aLink.aLinkValue >>= obj ;
 899         retstr = _Orb->object_to_string(obj );
 900         f << "'" << retstr << "'" ;
 901         break ;
 902       }
 903       default: {
 904         f << "?" ;
 905 //        MESSAGE( "Unknown CORBA::Any Type" );
 906         break ;
 907       }
 908     }
 909     f << ")" << endl ;
 910   }
 911   int i ;
 912   for ( i = 0 ; i < aLink.aListOfCoords.size() ; i++ ) {
 913     f << aLink.ToNodeName.c_str()
 914       << aLink.ToServiceParameterName.c_str() << ".AddCoord( " << i+1 << " , "
 915       << aLink.aListOfCoords[ i ].theX << " , "
 916       << aLink.aListOfCoords[ i ].theY << " )" << endl ;
 917   }
 918   return true ;
 919 }
 920
 921 //bool GraphEditor::OutNode::SaveXML(ostream & f ) {
 922 bool GraphEditor::OutNode::SaveXML(QDomDocument & Graph ) {
 923   int i ;
 924 //  f << "<?xml version='1.0' encoding='us-ascii' ?>" << endl << endl ;
 925 //  f << "<!-- XML Dataflow -->" << endl << endl ;
 926 //  f << "<!-- Dataflow information -->" << endl ;
 927   QString Dataflow("Dataflow") ;
 928   Graph = QDomDocument(Dataflow) ;
 929 //  f << "<dataflow>" << endl ;
 930   QDomElement dataflow = Graph.createElement( "dataflow" ) ;
 931   Graph.appendChild( dataflow ) ;
 932 //  f << "      <info-list>" << endl ;
 933   QDomElement info = Graph.createElement( "info-list" ) ;
 934   dataflow.appendChild( info ) ;
 935
 936 //  f << "              <node>" << endl ;
 937
 938 //  GraphBase::DataNode::SaveXML( f , "                 " , 0 , 0 ) ;
 939   GraphBase::DataNode::SaveXML( Graph , info , 0 , 0 ) ;
 940
 941 //  f << "              </node>" << endl ;
 942
 943 //  f << "      </info-list>" << endl << endl ;
 944
 945 //  f << "      <node-list>" << endl ;
 946   QDomElement nodelist = Graph.createElement( "node-list" ) ;
 947   dataflow.appendChild( nodelist ) ;
 948   for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
 949 //      f << "          <node>" << endl ;
 950       if ( GraphNodes( i )->IsComputingNode() ) {
 951 //        ((GraphBase::ComputingNode *)GraphNodes( i ))->SaveXML( f ,
 952 //                    "                 " ,
 953         ((GraphBase::ComputingNode *)GraphNodes( i ))->SaveXML( Graph , nodelist ,
 954                     GraphNodes( i )->XCoordinate() ,
 955                     GraphNodes( i )->YCoordinate() ) ;
 956       }
 957       else if ( GraphNodes( i )->IsFactoryNode() ) {
 958 //        ((GraphBase::FactoryNode * ) GraphNodes( i ))->SaveXML( f ,
 959 //                    "                 " ,
 960         ((GraphBase::FactoryNode * ) GraphNodes( i ))->SaveXML( Graph , nodelist ,
 961                     GraphNodes( i )->XCoordinate() ,
 962                     GraphNodes( i )->YCoordinate() ) ;
 963       }
 964       else if ( GraphNodes( i )->IsInLineNode() ) {
 965 //        ((GraphBase::InLineNode * ) GraphNodes( i ))->SaveXML( f ,
 966 //                    "                 " ,
 967         ((GraphBase::InLineNode * ) GraphNodes( i ))->SaveXML( Graph , nodelist ,
 968                     GraphNodes( i )->XCoordinate() ,
 969                     GraphNodes( i )->YCoordinate() ) ;
 970       }
 971       else if ( GraphNodes( i )->IsGOTONode() ) {
 972 //        ((GraphBase::GOTONode * ) GraphNodes( i ))->SaveXML( f ,
 973 //                    "                 " ,
 974         ((GraphBase::GOTONode * ) GraphNodes( i ))->SaveXML( Graph , nodelist ,
 975                     GraphNodes( i )->XCoordinate() ,
 976                     GraphNodes( i )->YCoordinate() ) ;
 977       }
 978       else if ( GraphNodes( i )->IsLoopNode() ) {
 979 //        ((GraphBase::LoopNode * ) GraphNodes( i ))->SaveXML( f ,
 980 //                    "                 " ,
 981         ((GraphBase::LoopNode * ) GraphNodes( i ))->SaveXML( Graph , nodelist ,
 982                     GraphNodes( i )->XCoordinate() ,
 983                     GraphNodes( i )->YCoordinate() ) ;
 984       }
 985       else if ( GraphNodes( i )->IsEndLoopNode() ) {
 986 //        ((GraphBase::EndOfLoopNode * ) GraphNodes( i ))->SaveXML( f ,
 987 //                    "                 " ,
 988         ((GraphBase::EndOfLoopNode * ) GraphNodes( i ))->SaveXML( Graph , nodelist ,
 989                     GraphNodes( i )->XCoordinate() ,
 990                     GraphNodes( i )->YCoordinate() ) ;
 991       }
 992       else if ( GraphNodes( i )->IsSwitchNode() ) {
 993 //        ((GraphBase::SwitchNode * ) GraphNodes( i ))->SaveXML( f ,
 994 //                    "                 " ,
 995         ((GraphBase::SwitchNode * ) GraphNodes( i ))->SaveXML( Graph , nodelist ,
 996                     GraphNodes( i )->XCoordinate() ,
 997                     GraphNodes( i )->YCoordinate() ) ;
 998       }
 999       else if ( GraphNodes( i )->IsEndSwitchNode() ) {
1000 //        ((GraphBase::EndOfSwitchNode * ) GraphNodes( i ))->SaveXML( f ,
1001 //                    "                 " ,
1002         ((GraphBase::EndOfSwitchNode * ) GraphNodes( i ))->SaveXML( Graph , nodelist ,
1003                     GraphNodes( i )->XCoordinate() ,
1004                     GraphNodes( i )->YCoordinate() ) ;
1005       }
1006 //      f << "          </node>" << endl ;
1007 //    }
1008   }
1009 //  f << "      </node-list>" << endl << endl ;
1010
1011 //  f << "      <link-list>" << endl ;
1012   QDomElement linklist = Graph.createElement( "link-list" ) ;
1013   dataflow.appendChild( linklist ) ;
1014   const GraphBase::ListOfLinks * Links = GetLinks() ;
1015   for ( i = 0 ; i < Links->size() ; i++ ) {
1016 //    f << "            <link>" << endl ;
1017     QDomElement link = Graph.createElement( "link" ) ;
1018     linklist.appendChild( link ) ;
1019 //    LinkSaveXML( f , "                        " , (*Links)[ i ] , false ) ;
1020     LinkSaveXML( Graph , link , (*Links)[ i ] , false ) ;
1021 //    f << "            </link>" << endl ;
1022   }
1023 //  f << "      </link-list>" << endl << endl ;
1024
1025 //  f << "      <data-list>" << endl ;
1026   QDomElement datalist = Graph.createElement( "data-list" ) ;
1027   dataflow.appendChild( datalist ) ;
1028   const GraphBase::ListOfLinks * Datas = GetDatas() ;
1029   for ( i = 0 ; i < Datas->size() ; i++ ) {
1030 //    f << "            <data>" << endl ;
1031     QDomElement data = Graph.createElement( "data" ) ;
1032     datalist.appendChild( data ) ;
1033 //    LinkSaveXML( f , "                        " , (*Datas)[ i ] , true ) ;
1034     LinkSaveXML( Graph , data , (*Datas)[ i ] , true ) ;
1035 //    f << "            </data>" << endl ;
1036   }
1037 //#if 0
1038 //  const GraphEditor::OutNode * aDataNode = (GraphEditor::OutNode *) this ;
1039 //  if ( aDataNode ) {
1040 //    int i ;
1041 //    for ( i = 0 ; i < aDataNode->GetNodeOutPortsSize() ; i++ ) {
1042 //      const GraphBase::InPort *aLink = aDataNode->GetNodeOutPort(i)->GetLink() ;
1043 //      if ( aLink ) {
1044 //        f << "                <data>" << endl ;
1045 //        aLink->SaveXML( f , "                 " ) ;
1046 //        f << "                </data>" << endl ;
1047 //      }
1048 //    }
1049 //    for ( i = 0 ; i < aDataNode->GetNodeInPortsSize() ; i++ ) {
1050 //      const GraphBase::InPort *aLink = aDataNode->GetNodeInPort(i)->GetLink() ;
1051 //      if ( aLink ) {
1052 //        f << "                <data>" << endl ;
1053 //        aLink->SaveXML( f , "                 " ) ;
1054 //        f << "                </data>" << endl ;
1055 //      }
1056 //    }
1057 //  }
1058 //#endif
1059
1060 #if 0
1061   f << "        </data-list>" << endl << endl ;
1062   f << "</dataflow>" << endl ;
1063 #endif
1064
1065   return true ;
1066 }
1067
1068 bool GraphEditor::OutNode::SavePY( ostream & f ) {
1069   int i ;
1070   f << endl << "# Generated python file of Graph " << Name() << endl << endl ;
1071
1072   f << "from SuperV import *" << endl ;
1073
1074   f << "# Graph creation " << endl ;
1075   GraphBase::DataNode::SavePY( f , Name() , 0 , 0 ) ;
1076
1077   f << endl << "# Creation of Factory Nodes" << endl ;
1078   for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
1079     if ( GraphNodes( i )->IsFactoryNode() ) {
1080       ((GraphBase::FactoryNode * ) GraphNodes( i ))->SavePY( f , Name() ,
1081                 GraphNodes( i )->XCoordinate() ,
1082                 GraphNodes( i )->YCoordinate() ) ;
1083     }
1084   }
1085
1086   bool first = true ;
1087   for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
1088     if ( GraphNodes( i )->IsComputingNode() ) {
1089       if ( first ) {
1090         f << endl << "# Creation of Computing Nodes" << endl ;
1091         first = false ;
1092       }
1093       ((GraphBase::ComputingNode * ) GraphNodes( i ))->SavePY( f , Name() ,
1094                 GraphNodes( i )->XCoordinate() ,
1095                 GraphNodes( i )->YCoordinate() ) ;
1096     }
1097   }
1098
1099   first = true ;
1100   for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
1101     if ( GraphNodes( i )->IsInLineNode() ) {
1102       if ( first ) {
1103         f << endl << "# Creation of InLine Nodes" << endl ;
1104         first = false ;
1105       }
1106       ((GraphBase::InLineNode * ) GraphNodes( i ))->SavePY( f , Name() ,
1107                 GraphNodes( i )->XCoordinate() ,
1108                 GraphNodes( i )->YCoordinate() ) ;
1109     }
1110   }
1111
1112   first = true ;
1113   for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
1114     if ( GraphNodes( i )->IsLoopNode() ) {
1115       if ( first ) {
1116         f << endl << "# Creation of Loop Nodes" << endl ;
1117         first = false ;
1118       }
1119       ((GraphBase::LoopNode * ) GraphNodes( i ))->SavePY( f , Name() ,
1120                 GraphNodes( i )->XCoordinate() ,
1121                 GraphNodes( i )->YCoordinate() ) ;
1122     }
1123   }
1124
1125   first = true ;
1126   for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
1127     if ( GraphNodes( i )->IsSwitchNode() ) {
1128       if ( first ) {
1129         f << endl << "# Creation of Switch Nodes" << endl ;
1130         first = false ;
1131       }
1132       ((GraphBase::SwitchNode * ) GraphNodes( i ))->SavePY( f , Name() ,
1133                 GraphNodes( i )->XCoordinate() ,
1134                 GraphNodes( i )->YCoordinate() ) ;
1135     }
1136   }
1137
1138   first = true ;
1139   for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
1140     if ( GraphNodes( i )->IsGOTONode() ) {
1141       if ( first ) {
1142         f << endl << "# Creation of GOTO Nodes" << endl ;
1143         first = false ;
1144       }
1145       ((GraphBase::GOTONode * ) GraphNodes( i ))->SavePY( f , Name() ,
1146                 GraphNodes( i )->XCoordinate() ,
1147                 GraphNodes( i )->YCoordinate() ) ;
1148     }
1149   }
1150
1151   const GraphBase::ListOfLinks * Links = GetLinks() ;
1152   bool intervar ;
1153   map< string , int > aMapOfOutPorts ;
1154   first = true ;
1155   for ( i = 0 ; i < Links->size() ; i++ ) {
1156     if ( GetGraphNode( (*Links)[ i ].FromNodeName.c_str() )->IsComputingNode() &&
1157          GetGraphNode( (*Links)[ i ].ToNodeName.c_str() )->IsComputingNode() ) {
1158       if ( first ) {
1159         f << endl
1160           << "# Creation of intermediate Output variables and of Computing Links"
1161           << endl ;
1162         first = false ;
1163       }
1164       char * NodePort = new char [ strlen( (*Links)[ i ].FromNodeName.c_str() ) +
1165                                    strlen( (*Links)[ i ].FromServiceParameterName.c_str() ) + 1 ] ;
1166       strcpy( NodePort , (*Links)[ i ].FromNodeName.c_str() ) ;
1167       strcat( NodePort , (*Links)[ i ].FromServiceParameterName.c_str() ) ;
1168       if ( aMapOfOutPorts[ NodePort ] == 0 ) {
1169         aMapOfOutPorts[ NodePort ] = i + 1 ;
1170         intervar = true ;
1171       }
1172       else {
1173         intervar = false ;
1174       }
1175       LinkSavePY( f , Name() , (*Links)[ i ] , intervar , false ) ;
1176       delete [] NodePort ;
1177     }
1178   }
1179
1180 #if 0
1181   first = true ;
1182   for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
1183     if ( GraphNodes( i )->IsInLineNode() ||
1184          GraphNodes( i )->IsGOTONode() ) {
1185       int j ;
1186       for ( j = 0 ; j < GraphNodes( i )->GetNodeInPortsSize() ; j++ ) {
1187         if ( GraphNodes( i )->GetNodeInPort( j )->IsBus() ) {
1188           if ( first ) {
1189             f << endl
1190               << "# Creation of Output variables and of Bus Ports"
1191               << endl ;
1192             first = false ;
1193           }
1194           f << GraphNodes( i )->Name() << ".InOutPort( '"
1195             << GraphNodes( i )->GetNodeInPort( j )->PortName() << "' , '"
1196             << GraphNodes( i )->GetNodeInPort( j )->PortType() << "' , '"
1197             << GraphNodes( i )->GetNodeOutPort( GraphNodes( i )->GetNodeInPort( j )->PortIndex() )->PortName()
1198             << "' , '"
1199             << GraphNodes( i )->GetNodeOutPort( GraphNodes( i )->GetNodeInPort( j )->PortIndex() )->PortType()
1200             << "' )" << endl ;
1201         }
1202       }
1203     }
1204   }
1205 #endif
1206
1207   first = true ;
1208   for ( i = 0 ; i < Links->size() ; i++ ) {
1209     if ( !( GetGraphNode( (*Links)[ i ].FromNodeName.c_str() )->IsComputingNode() &&
1210            GetGraphNode( (*Links)[ i ].ToNodeName.c_str() )->IsComputingNode() ) &&
1211          !( GetGraphNode( (*Links)[ i ].FromNodeName.c_str() )->IsGOTONode() &&
1212            GetGraphNode( (*Links)[ i ].ToNodeName.c_str() )->IsInLineNode() ) ) {
1213       if ( first ) {
1214         f << endl
1215           << "# Creation of intermediate Output variables and of Control Links"
1216           << endl ;
1217         first = false ;
1218       }
1219       char * NodePort = new char [ strlen( (*Links)[ i ].FromNodeName.c_str() ) +
1220                                    strlen( (*Links)[ i ].FromServiceParameterName.c_str() ) + 1 ] ;
1221       strcpy( NodePort , (*Links)[ i ].FromNodeName.c_str() ) ;
1222       strcat( NodePort , (*Links)[ i ].FromServiceParameterName.c_str() ) ;
1223       if ( aMapOfOutPorts[ NodePort ] == 0 ) {
1224         aMapOfOutPorts[ NodePort ] = i + 1 ;
1225         intervar = true ;
1226       }
1227       else {
1228         intervar = false ;
1229       }
1230       LinkSavePY( f , Name() , (*Links)[ i ] , intervar , false ) ;
1231       delete [] NodePort ;
1232     }
1233   }
1234
1235   first = true ;
1236   for ( i = 0 ; i < Links->size() ; i++ ) {
1237     if ( GetGraphNode( (*Links)[ i ].FromNodeName.c_str() )->IsGOTONode() &&
1238          GetGraphNode( (*Links)[ i ].ToNodeName.c_str() )->IsInLineNode() ) {
1239       if ( first ) {
1240         f << endl
1241           << "# Creation of intermediate Output variables and of Loop Links"
1242           << endl ;
1243         first = false ;
1244       }
1245       char * NodePort = new char [ strlen( (*Links)[ i ].FromNodeName.c_str() ) +
1246                                    strlen( (*Links)[ i ].FromServiceParameterName.c_str() ) + 1 ] ;
1247       strcpy( NodePort , (*Links)[ i ].FromNodeName.c_str() ) ;
1248       strcat( NodePort , (*Links)[ i ].FromServiceParameterName.c_str() ) ;
1249       if ( aMapOfOutPorts[ NodePort ] == 0 ) {
1250         aMapOfOutPorts[ NodePort ] = i + 1 ;
1251         intervar = true ;
1252       }
1253       else {
1254         intervar = false ;
1255       }
1256       LinkSavePY( f , Name() , (*Links)[ i ] , intervar , false ) ;
1257       delete [] NodePort ;
1258     }
1259   }
1260
1261   const GraphBase::ListOfLinks * Datas = GetDatas() ;
1262   first = true ;
1263   for ( i = 0 ; i < Datas->size() ; i++ ) {
1264     if ( first ) {
1265       f << endl << "# Creation of Input datas" << endl ;
1266       first = false ;
1267     }
1268     LinkSavePY( f , Name() , (*Datas)[ i ] , false , true ) ;
1269   }
1270
1271   first = true ;
1272   const SALOME_ModuleCatalog::ListOfServicesParameter ListOfInParam = ServiceInParameter() ;
1273   for ( i = 0 ; i < ListOfInParam.length() ; i++ ) {
1274     string _aParam = CORBA::string_dup(ListOfInParam[ i ].Parametername) ;
1275     const char * aParam = _aParam.c_str() ;
1276     char * aNodeName ;
1277     char * aPortName ;
1278     int j , k ;
1279     for ( j = 0 ; j < strlen( aParam ) ; j++ ) {
1280       if ( aParam[ j ] == '\\' ) {
1281         aNodeName = new char[ j+1 ] ;
1282         strncpy( aNodeName , aParam , j ) ;
1283         aNodeName[ j ] = '\0' ;
1284         aPortName = new char[ strlen( aParam ) - j ] ;
1285         strncpy( aPortName , &aParam[ j+1 ] , strlen( aParam ) - j ) ;
1286         break ;
1287       }
1288     }
1289     if ( !GetChangeGraphNode( aNodeName )->GetInPort( aPortName )->IsDataConnected() ) {
1290       if ( first ) {
1291         f << endl << "# Missing Input datas" << endl ;
1292         first = false ;
1293       }
1294       f << aNodeName << aPortName << " = " << aNodeName << ".Port( '"
1295         << aPortName << "' )" << endl ;
1296     }
1297     delete [] aNodeName ;
1298     delete [] aPortName ;
1299   }
1300
1301   f << endl << "# Creation of Output variables" << endl ;
1302   const SALOME_ModuleCatalog::ListOfServicesParameter ListOfOutParam = ServiceOutParameter() ;
1303   for ( i = 0 ; i < ListOfOutParam.length() ; i++ ) {
1304     string _aParam = CORBA::string_dup(ListOfOutParam[ i ].Parametername) ;
1305     const char * aParam = _aParam.c_str() ;
1306     char * aNodeName ;
1307     char * aPortName ;
1308     int j , k ;
1309     for ( j = 0 ; j < strlen( aParam ) ; j++ ) {
1310       if ( aParam[ j ] == '\\' ) {
1311         aNodeName = new char[ j+1 ] ;
1312         strncpy( aNodeName , aParam , j ) ;
1313         aNodeName[ j ] = '\0' ;
1314         aPortName = new char[ strlen( aParam ) - j ] ;
1315         strncpy( aPortName , &aParam[ j+1 ] , strlen( aParam ) - j ) ;
1316         break ;
1317       }
1318     }
1319     f << aNodeName << aPortName << " = " << aNodeName << ".Port( '"
1320       << aPortName << "' )" << endl ;
1321     delete [] aNodeName ;
1322     delete [] aPortName ;
1323   }
1324   return true ;
1325 }
1326
1327
1328
1329 ostrstream & operator<< (ostrstream & f,const GraphEditor::OutNode & G) {
1330   f << (GraphBase::ComputingNode ) G ;
1331   f << endl ;
1332
1333   f << "  Nodes : " << G.GraphNodesSize() << " node"
1334     << (G.GraphNodesSize() > 1 ? "s" : "") << endl;
1335
1336   int i ;
1337   for ( i = 0 ; i < G.GraphNodesSize() ; i++ ) {
1338     f
1339 //      << hex << (void *) G.GraphNodes( i ) << dec << " "
1340       << *G.GraphNodes( i ) << endl;
1341   }
1342
1343   f << "  Links : " << endl ;
1344   for ( i = 0 ; i < G.GraphNodesSize() ; i++ ) {
1345     G.GraphNodes( i )->ListLinks( f ) ;
1346   }
1347
1348   f << "  Datas : " << endl ;
1349   G.ListDatas( f ) ;
1350
1351   f << "DataFlow " << G.Name() << " is " ;
1352   if ( G.IsNotValid() )
1353     f << "not " ;
1354   f << "valid and is " ;
1355   if ( G.IsNotExecutable() )
1356     f << "not " ;
1357   f << "executable." << endl ;
1358
1359   f << endl ;
1360
1361   return f;
1362 }
1363
1364 ostream & operator<< (ostream &fOut,const SUPERV::SDate &D)
1365 {
1366 //  cdebug_in << "operator<< GraphEditor::Date" << endl;
1367
1368   fOut  << D.Day << "/"
1369         << D.Month << "/"
1370         << D.Year << " - "
1371         << D.Hour << ":"
1372         << D.Minute <<  ":"
1373         << D.Second;
1374
1375 //  cdebug_out << "operator<< GraphEditor::Date" << endl;
1376   return fOut;
1377 }
1378
1379
1380
1381
1382
1383
1384
1385