src/GraphEditor/DataFlowEditor_InNode.hxx

   1 #ifndef _DATAFLOWEDITOR_INNODE_HXX
   2 #define _DATAFLOWEDITOR_INNODE_HXX
   3
   4 #include "DataFlowBase_FactoryNode.hxx"
   5 #include "DataFlowBase_GOTONode.hxx"
   6 #include "DataFlowBase_LoopNode.hxx"
   7 #include "DataFlowBase_EndOfLoopNode.hxx"
   8 #include "DataFlowBase_SwitchNode.hxx"
   9 #include "DataFlowBase_EndOfSwitchNode.hxx"
  10
  11 namespace GraphEditor {
  12
  13   class InNode : public GraphBase::Base {
  14
  15     private:
  16
  17       GraphBase::ComputingNode       * _ComputingNode ;
  18       GraphBase::FactoryNode         * _FactoryNode ;
  19       GraphBase::InLineNode          * _InLineNode ;
  20       GraphBase::GOTONode            * _GOTONode ;
  21       GraphBase::LoopNode            * _LoopNode ;
  22       GraphBase::EndOfLoopNode       * _EndOfLoopNode ;
  23       GraphBase::SwitchNode          * _SwitchNode ;
  24       GraphBase::EndOfSwitchNode     * _EndOfSwitchNode ;
  25
  26     public:
  27
  28       InNode() ;
  29       InNode( CORBA::ORB_ptr ORB,
  30               SALOME_NamingService* ptrNamingService ,
  31               GraphBase::ListOfFuncName aFuncName ,
  32               GraphBase::ListOfPythonFunctions aPythonFunction ,
  33               const SALOME_ModuleCatalog::Service& NodeService ,
  34               const char *NodeComponentName ,
  35               const char* NodeInterfaceName ,
  36               const char *NodeName ,
  37               const SUPERV::KindOfNode akind ,
  38               const SUPERV::SDate NodeFirstCreation ,
  39               const SUPERV::SDate NodeLastModification ,
  40               const char * NodeEditorRelease ,
  41               const char * NodeAuthor ,
  42               const char * NodeComputer ,
  43               const char * NodeComment ,
  44               const bool   GeneratedName ,
  45               const int NodeX ,
  46               const int NodeY ,
  47               int * Graph_prof_debug = NULL ,
  48               ostream * Graph_fdebug = NULL ) ;
  49       virtual ~InNode() ;
  50
  51       char * Name() const { return _ComputingNode->Name() ; } ;
  52       const char *const * NamePtr() const {
  53                           return _ComputingNode->NamePtr() ; } ;
  54
  55       SUPERV::KindOfNode Kind() const {
  56                          return _ComputingNode->Kind() ; } ;
  57       const bool IsComputingNode() const {
  58                  return _ComputingNode->IsComputingNode() ; } ;
  59       const bool IsFactoryNode() const {
  60                  return _ComputingNode->IsFactoryNode() ; } ;
  61       const bool IsInLineNode() const {
  62                  return _ComputingNode->IsInLineNode() ; } ;
  63       const bool IsOneOfInLineNodes() const {
  64                  return _ComputingNode->IsOneOfInLineNodes() ; } ;
  65       const bool IsOneOfGOTONodes() const {
  66                  return _ComputingNode->IsOneOfGOTONodes() ; } ;
  67       const bool IsDataFlowNode() const {
  68                  return _ComputingNode->IsDataFlowNode() ; } ;
  69       const bool IsGOTONode() const {
  70                  return _ComputingNode->IsGOTONode() ; } ;
  71       const bool IsLoopNode() const {
  72                  return _ComputingNode->IsLoopNode() ; } ;
  73       const bool IsEndLoopNode() const {
  74                  return _ComputingNode->IsEndLoopNode() ; } ;
  75       const bool IsSwitchNode() const {
  76                  return _ComputingNode->IsSwitchNode() ; } ;
  77       const bool IsEndSwitchNode() const {
  78                  return _ComputingNode->IsEndSwitchNode() ; } ;
  79       const bool IsHeadNode() const {
  80                  return _ComputingNode->IsHeadNode() ; } ;
  81       GraphBase::ComputingNode * ComputingNode() {
  82                                  return _ComputingNode ; } ;
  83       GraphBase::FactoryNode * FactoryNode() {
  84                                return _FactoryNode ; } ;
  85       GraphBase::GOTONode * GOTONode() {
  86                             if ( _GOTONode )
  87                               return _GOTONode ;
  88                             if ( _LoopNode )
  89                               return _LoopNode ;
  90                             if ( _EndOfLoopNode )
  91                               return _EndOfLoopNode ;
  92                             if ( _SwitchNode )
  93                               return _SwitchNode ;
  94                             if ( _EndOfSwitchNode )
  95                               return _EndOfSwitchNode ;
  96                             return NULL ;
  97                             } ;
  98       GraphBase::GOTONode * GOTONode() const {
  99                             if ( _GOTONode )
 100                               return _GOTONode ;
 101                             if ( _LoopNode )
 102                               return _LoopNode ;
 103                             if ( _EndOfLoopNode )
 104                               return _EndOfLoopNode ;
 105                             if ( _SwitchNode )
 106                               return _SwitchNode ;
 107                             if ( _EndOfSwitchNode )
 108                               return _EndOfSwitchNode ;
 109                             return NULL ;
 110                             } ;
 111       GraphBase::InLineNode * InLineNode() {
 112                               GraphBase::InLineNode * aNode = GOTONode() ;
 113                               if ( aNode == NULL )
 114                                 return _InLineNode ;
 115                               return aNode ;
 116                               } ;
 117       GraphBase::InLineNode * InLineNode() const {
 118                               GraphBase::InLineNode * aNode = GOTONode() ;
 119                               if ( aNode == NULL )
 120                                 return _InLineNode ;
 121                               return aNode ;
 122                               } ;
 123       GraphBase::LoopNode * LoopNode() {
 124                             return _LoopNode ; } ;
 125       GraphBase::EndOfLoopNode * EndOfLoopNode() {
 126                                  return _EndOfLoopNode ; } ;
 127       GraphBase::SwitchNode * SwitchNode() {
 128                               return _SwitchNode ; } ;
 129       GraphBase::EndOfSwitchNode * EndOfSwitchNode() {
 130                                    return _EndOfSwitchNode ; } ;
 131
 132       SUPERV::CNode_var ObjRef() const { return _ComputingNode->ObjRef() ; } ;
 133       void SetObjRef(SUPERV::CNode_var aNode) {
 134                      _ComputingNode->SetObjRef( aNode ) ; } ;
 135
 136       const SALOME_ModuleCatalog::Service * GetService() const {
 137             return _ComputingNode->GetService() ; } ;
 138
 139       SUPERV::SDate FirstCreation() const {
 140                     return _ComputingNode->FirstCreation() ; } ;
 141       SUPERV::SDate LastModification() const {
 142                     return _ComputingNode->LastModification() ; } ;
 143       char* Author() const {
 144             return my_strdup( _ComputingNode->Author() ) ; }
 145       char* EditorRelease() const {
 146             return my_strdup( _ComputingNode->EditorRelease() ) ; } ;
 147       char * Comment() const {
 148              return my_strdup( _ComputingNode->Comment() ) ; } ;
 149       bool Author( const char * anAuthor ) {
 150            return _ComputingNode->Author( anAuthor ) ; } ;
 151       bool EditorRelease( const char* anEditorRelease ) {
 152            return _ComputingNode->EditorRelease( anEditorRelease ) ; } ;
 153       bool Comment( const char *c ) {
 154            return _ComputingNode->Comment( c ) ; };
 155
 156       GraphBase::SNode * GetInfo() {
 157                          return _ComputingNode->GetInfo() ; } ;
 158
 159       GraphBase::InPort * AddInPort( const char * InputParameterName ,
 160                                      const char * InputParameterType ) {
 161                           return _ComputingNode->AddInPort( InputParameterName ,
 162                                                             InputParameterType ) ; } ;
 163       GraphBase::OutPort * AddOutPort( const char * OutputParameterName ,
 164                                        const char * OutputParameterType ) {
 165                            return _ComputingNode->AddOutPort( OutputParameterName ,
 166                                                               OutputParameterType ) ; } ;
 167
 168       void DelInPort( const char * InputParameterName ) {
 169            _ComputingNode->DelInPort( InputParameterName ) ; } ;
 170       void DelOutPort( const char * OutputParameterName ) {
 171            _ComputingNode->DelOutPort( OutputParameterName ) ; } ;
 172
 173       bool IsLinked(const char * ToServiceParameterName ) {
 174            return _ComputingNode->IsLinked( ToServiceParameterName ) ; } ;
 175       bool HasInput(const char * ToServiceParameterName ) {
 176            return _ComputingNode->HasInput( ToServiceParameterName ) ; } ;
 177
 178 //      void InOutPort( GraphBase::InPort * InputPort ,
 179 //                      GraphBase::OutPort * OutputPort ) {
 180 //           return _ComputingNode->InOutPort( InputPort , OutputPort ) ; } ;
 181
 182       const int GetNodeInPortsSize() const {
 183                 return _ComputingNode->GetNodeInPortsSize() ; } ;
 184       const GraphBase::InPort *GetNodeInPort(int i) const {
 185                               return _ComputingNode->GetNodeInPort( i ) ; } ;
 186       GraphBase::InPort *GetChangeNodeInPort(int i) const {
 187                         return _ComputingNode->GetChangeNodeInPort( i ) ; } ;
 188       const int GetNodeOutPortsSize() const {
 189                 return _ComputingNode->GetNodeOutPortsSize() ; } ;
 190       const GraphBase::OutPort *GetNodeOutPort(int i) const {
 191                                return _ComputingNode->GetNodeOutPort( i ) ; } ;
 192       GraphBase::OutPort *GetChangeNodeOutPort(int i) const {
 193                          return _ComputingNode->GetChangeNodeOutPort( i ) ; } ;
 194
 195       const GraphBase::InPort *GetInPort( const char *name ) {
 196             return _ComputingNode->GetInPort( name ) ; } ;
 197       const GraphBase::OutPort *GetOutPort( const char *name ) {
 198             return _ComputingNode->GetOutPort( name ) ; } ;
 199       GraphBase::InPort *GetChangeInPort( const char *name ) {
 200                         return _ComputingNode->GetChangeInPort( name ) ; } ;
 201       GraphBase::OutPort *GetChangeOutPort( const char *name ) {
 202                          return _ComputingNode->GetChangeOutPort( name ) ; } ;
 203
 204       void SetPythonFunction( const char * aFuncName ,
 205                               const SUPERV::ListOfStrings & aPythonFunction ) {
 206            InLineNode()->SetPythonFunction( aFuncName , aPythonFunction ) ; }
 207       const SUPERV::ListOfStrings * PythonFunction() const {
 208             return InLineNode()->PythonFunction() ; } ;
 209       char * PyFuncName() const {
 210              return InLineNode()->PyFuncName() ; } ;
 211
 212       void SetPyMorePythonFunction( const char * aMoreName ,
 213                                     const SUPERV::ListOfStrings & aMorePythonFunction ) {
 214            _LoopNode->SetMorePythonFunction( aMoreName , aMorePythonFunction ) ; }
 215       SUPERV::ListOfStrings * PyMorePythonFunction() const {
 216                     return _LoopNode->MorePythonFunction() ; } ;
 217       char * PyMoreName() {
 218              return _LoopNode->PyMoreName() ; };
 219
 220       void SetPyNextPythonFunction( const char * aNextName ,
 221                                const SUPERV::ListOfStrings & aNextPythonFunction ) {
 222            _LoopNode->SetNextPythonFunction( aNextName , aNextPythonFunction ) ; }
 223       SUPERV::ListOfStrings * PyNextPythonFunction() const {
 224                     return _LoopNode->NextPythonFunction() ; } ;
 225       char * PyNextName() {
 226              return _LoopNode->PyNextName() ; } ;
 227
 228       void CoupledNode( GraphBase::InLineNode * aCoupledNode ) {
 229            _GOTONode->CoupledNode( aCoupledNode ) ; } ;
 230       GraphBase::InLineNode * CoupledNode() {
 231                               return _GOTONode->CoupledNode() ; } ;
 232
 233       int SubGraph() {
 234           return _ComputingNode->SubGraph() ; } ;
 235
 236       char * ComponentName() const {
 237              return _FactoryNode->ComponentName() ; } ;
 238       char * InterfaceName() const {
 239              return _FactoryNode->InterfaceName() ; } ;
 240       char * Computer() const {
 241              return _FactoryNode->Computer() ; } ;
 242
 243       bool ComponentName( const char * aComponentName ) {
 244            return _FactoryNode->ComponentName( aComponentName ) ; } ;
 245       bool InterfaceName( const char * anInterfaceName ) {
 246            return _FactoryNode->InterfaceName( anInterfaceName ) ; } ;
 247       bool Computer( const char *c ) {
 248            return _FactoryNode->Computer( c ) ; } ;
 249
 250       void Coordinates( const int X , const int Y ) {
 251            _ComputingNode->Coordinates( X , Y ) ; } ;
 252       int XCoordinate () {
 253           return _ComputingNode->XCoordinate () ; } ;
 254       int YCoordinate () {
 255           return _ComputingNode->YCoordinate () ; } ;
 256   };
 257
 258
 259 };
 260
 261 #endif