src/GraphEditor/DataFlowEditor_OutNode.cxx

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