src/hmi/guiObservers.hxx

   1 //  Copyright (C) 2006-2008  CEA/DEN, EDF R&D
   2 //
   3 //  This library is free software; you can redistribute it and/or
   4 //  modify it under the terms of the GNU Lesser General Public
   5 //  License as published by the Free Software Foundation; either
   6 //  version 2.1 of the License.
   7 //
   8 //  This library is distributed in the hope that it will be useful,
   9 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 //  Lesser General Public License for more details.
  12 //
  13 //  You should have received a copy of the GNU Lesser General Public
  14 //  License along with this library; if not, write to the Free Software
  15 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19 #ifndef _GUIOBSERVERS_HXX_
  20 #define _GUIOBSERVERS_HXX_
  21
  22 #include <set>
  23 #include <string>
  24 #include <map>
  25 #include <list>
  26 #include "Dispatcher.hxx"
  27 #include "commandsProc.hxx"
  28
  29 namespace YACS
  30 {
  31   namespace ENGINE
  32   {
  33     class Node;
  34     class ComposedNode;
  35     class Bloc;
  36     class Proc;
  37     class ForLoop;
  38     class ForEachLoop;
  39     class WhileLoop;
  40     class Switch;
  41     class OptimizerLoop;
  42     class ElementaryNode;
  43     class InlineNode;
  44     class ServiceNode;
  45     class PythonNode;
  46     class PyFuncNode;
  47     class CORBANode;
  48     class CppNode;
  49     class SalomeNode;
  50     class SalomePythonNode;
  51     class XmlNode;
  52     class SplitterNode;
  53     class DataNode;
  54     class PresetNode;
  55     class OutNode;
  56     class StudyInNode;
  57     class StudyOutNode;
  58     class DataPort;
  59     class InputPort;
  60     class OutputPort;
  61     class InPort;
  62     class OutPort;
  63     class InputDataStreamPort;
  64     class OutputDataStreamPort;
  65     class Catalog;
  66     class ComponentInstance;
  67     class Container;
  68     class TypeCode;
  69   }
  70
  71   namespace HMI
  72   {
  73
  74     typedef enum
  75       {
  76         ADD,
  77         REMOVE,
  78         CUT,
  79         PASTE,
  80         ORDER,
  81         EDIT,
  82         UPDATE,
  83         UPDATEPROGRESS,
  84         SYNCHRO,
  85         UP,
  86         DOWN,
  87         RENAME,
  88         NEWROOT,
  89         ENDLOAD,
  90         ADDLINK,
  91         ADDCONTROLLINK,
  92         ADDREF,
  93         ADDCHILDREF,
  94         REMOVECHILDREF,
  95         ASSOCIATE,
  96         SETVALUE,
  97         SETCASE,
  98         SETSELECT,
  99         GEOMETRY
 100       } GuiEvent;
 101
 102     class ProcInvoc;
 103     class GuiObserver;
 104
 105     class SubjectReference;
 106     class Subject: public YACS::ENGINE::Observer
 107     {
 108     public:
 109       Subject(Subject *parent=0);
 110       virtual ~Subject();
 111       virtual void attach(GuiObserver *obs);
 112       virtual void detach(GuiObserver *obs);
 113       virtual void select(bool isSelected);
 114       virtual void update(GuiEvent event, int type, Subject* son);
 115       virtual std::string getName();
 116       virtual bool setName(std::string name);
 117       virtual Subject* getParent();
 118       virtual bool destroy(Subject *son);
 119       virtual void loadChildren();
 120       virtual void loadLinks();
 121       virtual void addSubjectReference(Subject *ref);
 122       virtual void clean();
 123       void localClean();
 124       bool isDestructible() { return _destructible; };
 125       static void erase(Subject* sub);
 126       virtual TypeOfElem getType(){return UNKNOWN;}
 127     protected:
 128       std::set<GuiObserver *> _setObs;
 129       Subject *_parent;
 130       bool _destructible;
 131     };
 132
 133     class GuiObserver
 134     {
 135     public:
 136       GuiObserver();
 137       virtual ~GuiObserver();
 138       virtual void select(bool isSelected);
 139       virtual void update(GuiEvent event, int type, Subject* son);
 140       virtual void incrementSubjects(Subject *subject);
 141       virtual void decrementSubjects(Subject *subject);
 142       int getNbSubjects();
 143       bool isDestructible() { return _destructible; };
 144       static std::string eventName(GuiEvent event);
 145       static void setEventMap();
 146     protected:
 147       std::set<Subject*> _subjectSet;
 148       bool _destructible;
 149       static std::map<int, std::string> _eventNameMap;
 150     };
 151
 152     class SubjectReference: public Subject
 153     {
 154     public:
 155       SubjectReference(Subject* ref, Subject *parent);
 156       virtual ~SubjectReference();
 157       virtual std::string getName();
 158       virtual Subject* getReference() const;
 159       virtual void reparent(Subject *parent);
 160       virtual void clean();
 161       void localClean();
 162       virtual TypeOfElem getType(){return REFERENCE;}
 163     protected:
 164       Subject* _reference;
 165     };
 166
 167     class SubjectLink;
 168     class SubjectControlLink;
 169     class SubjectDataPort: public Subject
 170     {
 171     public:
 172       SubjectDataPort(YACS::ENGINE::DataPort* port, Subject *parent);
 173       virtual ~SubjectDataPort();
 174       virtual std::string getName();
 175       virtual bool setName(std::string name);
 176       virtual YACS::ENGINE::DataPort* getPort();
 177       static bool tryCreateLink(SubjectDataPort *subOutport, SubjectDataPort *subInport,bool control=true);
 178       virtual void clean();
 179       void localClean();
 180       void addSubjectLink(SubjectLink* subject) { _listSubjectLink.push_back(subject); };
 181       void removeSubjectLink(SubjectLink* subject) { _listSubjectLink.remove(subject); };
 182       std::list<SubjectLink*> getListOfSubjectLink() { return _listSubjectLink; };
 183       virtual bool setValue(std::string value);
 184       void setExecValue(std::string value);
 185       std::string getExecValue();
 186     protected:
 187       YACS::ENGINE::DataPort *_dataPort;
 188       std::list<SubjectLink*> _listSubjectLink;
 189       std::string _execValue;
 190     };
 191
 192     class SubjectInputPort: public SubjectDataPort
 193     {
 194     public:
 195       SubjectInputPort(YACS::ENGINE::InputPort *port, Subject *parent);
 196       virtual ~SubjectInputPort();
 197       virtual void clean();
 198       void localClean();
 199       virtual bool setValue(std::string value);
 200       virtual TypeOfElem getType(){return INPUTPORT;}
 201     protected:
 202       YACS::ENGINE::InputPort *_inputPort;
 203     };
 204
 205     class SubjectOutputPort: public SubjectDataPort
 206     {
 207     public:
 208       SubjectOutputPort(YACS::ENGINE::OutputPort *port, Subject *parent);
 209       virtual ~SubjectOutputPort();
 210       virtual void clean();
 211       void localClean();
 212       virtual bool setValue(std::string value);
 213       virtual TypeOfElem getType(){return OUTPUTPORT;}
 214     protected:
 215       YACS::ENGINE::OutputPort *_outputPort;
 216     };
 217
 218     class SubjectInputDataStreamPort: public SubjectDataPort
 219     {
 220     public:
 221       SubjectInputDataStreamPort(YACS::ENGINE::InputDataStreamPort *port, Subject *parent);
 222       virtual ~SubjectInputDataStreamPort();
 223       virtual bool setProperties(std::map<std::string, std::string> properties);
 224       virtual std::map<std::string, std::string> getProperties();
 225       virtual void clean();
 226       void localClean();
 227       virtual TypeOfElem getType(){return INPUTDATASTREAMPORT;}
 228     protected:
 229       YACS::ENGINE::InputDataStreamPort *_inputDataStreamPort;
 230     };
 231
 232     class SubjectOutputDataStreamPort: public SubjectDataPort
 233     {
 234     public:
 235       SubjectOutputDataStreamPort(YACS::ENGINE::OutputDataStreamPort *port, Subject *parent);
 236       virtual ~SubjectOutputDataStreamPort();
 237       virtual bool setProperties(std::map<std::string, std::string> properties);
 238       virtual std::map<std::string, std::string> getProperties();
 239       virtual void clean();
 240       void localClean();
 241       virtual TypeOfElem getType(){return OUTPUTDATASTREAMPORT;}
 242     protected:
 243       YACS::ENGINE::OutputDataStreamPort *_outputDataStreamPort;
 244     };
 245
 246
 247     class SubjectNode: public Subject
 248     {
 249     public:
 250       SubjectNode(YACS::ENGINE::Node *node, Subject *parent);
 251       virtual ~SubjectNode();
 252       virtual bool reparent(Subject* parent);
 253       virtual bool copy(Subject* parent);
 254       virtual std::string getName();
 255       virtual bool setName(std::string name);
 256       virtual YACS::ENGINE::Node* getNode();
 257       virtual void clean();
 258       SubjectControlLink* addSubjectControlLink(SubjectControlLink *sub) { _listSubjectControlLink.push_back(sub); };
 259       void removeSubjectControlLink(SubjectControlLink* sub) { _listSubjectControlLink.remove(sub); };
 260       std::list<SubjectLink*> getSubjectLinks() const { return _listSubjectLink; };
 261       std::list<SubjectControlLink*> getSubjectControlLinks() const { return _listSubjectControlLink; };
 262       std::list<SubjectInputPort*> getSubjectInputPorts() const { return _listSubjectInputPort; };
 263       std::list<SubjectOutputPort*> getSubjectOutputPorts() const { return _listSubjectOutputPort; };
 264       std::list<SubjectInputDataStreamPort*> getSubjectInputDataStreamPorts() const { return _listSubjectIDSPort; };
 265       std::list<SubjectOutputDataStreamPort*> getSubjectOutputDataStreamPorts() const { return _listSubjectODSPort; };
 266       void localClean();
 267       virtual void update(GuiEvent event, int type, Subject* son);
 268       virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
 269       virtual void removeExternalLinks();
 270       virtual void removeExternalControlLinks();
 271       void setExecState(int execState);
 272       static bool tryCreateLink(SubjectNode *subOutNode, SubjectNode *subInNode);
 273
 274     protected:
 275       virtual SubjectInputPort* addSubjectInputPort(YACS::ENGINE::InputPort *port,
 276                                                     std::string name = "");
 277       virtual SubjectOutputPort* addSubjectOutputPort(YACS::ENGINE::OutputPort *port,
 278                                                       std::string name = "");
 279       virtual SubjectInputDataStreamPort* addSubjectIDSPort(YACS::ENGINE::InputDataStreamPort *port,
 280                                                             std::string name = "");
 281       virtual SubjectOutputDataStreamPort* addSubjectODSPort(YACS::ENGINE::OutputDataStreamPort *port,
 282                                                              std::string name = "");
 283       virtual void notifyObserver(YACS::ENGINE::Node* object,const std::string& event);
 284
 285       YACS::ENGINE::Node *_node;
 286       std::list<SubjectInputPort*> _listSubjectInputPort;
 287       std::list<SubjectOutputPort*> _listSubjectOutputPort;
 288       std::list<SubjectInputDataStreamPort*> _listSubjectIDSPort;
 289       std::list<SubjectOutputDataStreamPort*> _listSubjectODSPort;
 290       std::list<SubjectLink*> _listSubjectLink;
 291       std::list<SubjectControlLink*> _listSubjectControlLink;
 292       int _execState;
 293     };
 294
 295     class SubjectComposedNode: public SubjectNode
 296     {
 297     public:
 298       SubjectComposedNode(YACS::ENGINE::ComposedNode *composedNode, Subject *parent);
 299       virtual ~SubjectComposedNode();
 300       virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
 301                                    std::string compo,
 302                                    std::string type,
 303                                    std::string name);
 304       virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const  { return 0; }
 305       virtual void loadChildren();
 306       virtual void loadLinks();
 307       virtual void completeChildrenSubjectList(SubjectNode *son);
 308       SubjectNode* addSubjectNode(YACS::ENGINE::Node * node,
 309                                   std::string name = "",
 310                                   YACS::ENGINE::Catalog *catalog = 0,
 311                                   std::string compo = "",
 312                                   std::string type ="");
 313       SubjectLink* addSubjectLink(SubjectNode *sno,
 314                                   SubjectDataPort *spo,
 315                                   SubjectNode *sni,
 316                                   SubjectDataPort *spi);
 317       SubjectControlLink* addSubjectControlLink(SubjectNode *sno,
 318                                                 SubjectNode *sni);
 319       virtual void removeLink(SubjectLink* link);
 320       virtual void removeControlLink(SubjectControlLink* link);
 321       virtual void removeExternalControlLinks();
 322       virtual bool hasValue();
 323       virtual std::string getValue();
 324       virtual void clean();
 325       void localClean();
 326       static SubjectComposedNode* getLowestCommonAncestor(SubjectNode* snode1, SubjectNode* snode2);
 327     protected:
 328       virtual SubjectNode *createNode(YACS::ENGINE::Catalog *catalog,
 329                                       std::string compo,
 330                                       std::string type,
 331                                       std::string name,
 332                                       int swCase=0);
 333       YACS::ENGINE::ComposedNode *_composedNode;
 334     };
 335
 336     class SubjectBloc: public SubjectComposedNode
 337     {
 338     public:
 339       SubjectBloc(YACS::ENGINE::Bloc *bloc, Subject *parent);
 340       virtual ~SubjectBloc();
 341       virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
 342                                    std::string compo,
 343                                    std::string type,
 344                                    std::string name);
 345       virtual void removeNode(SubjectNode* child);
 346       virtual void completeChildrenSubjectList(SubjectNode *son);
 347       virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const;
 348       virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
 349       virtual void clean();
 350       void localClean();
 351       virtual TypeOfElem getType(){return BLOC;}
 352     protected:
 353       YACS::ENGINE::Bloc *_bloc;
 354       std::set<SubjectNode*> _children;
 355     };
 356
 357     class SubjectComponent;
 358     class SubjectContainer: public Subject
 359     {
 360     public:
 361       SubjectContainer(YACS::ENGINE::Container* container, Subject *parent);
 362       virtual ~SubjectContainer();
 363       virtual std::string getName();
 364       virtual bool setName(std::string name);
 365       virtual std::map<std::string, std::string> getProperties();
 366       virtual bool setProperties(std::map<std::string, std::string> properties);
 367       virtual SubjectReference* attachComponent(SubjectComponent* component);
 368       virtual void detachComponent(SubjectReference* reference);
 369       virtual void moveComponent(SubjectReference* reference);
 370       virtual void removeSubComponentFromSet(SubjectComponent *component);
 371       virtual void notifyComponentsChange(GuiEvent event, int type, Subject* son);
 372       virtual void clean();
 373       void localClean();
 374       YACS::ENGINE::Container* getContainer() const;
 375       virtual TypeOfElem getType(){return CONTAINER;}
 376     protected:
 377       YACS::ENGINE::Container* _container;
 378       std::set<SubjectComponent*> _subComponentSet;
 379     };
 380
 381     class SubjectServiceNode;
 382     class SubjectComponent: public Subject
 383     {
 384     public:
 385       SubjectComponent(YACS::ENGINE::ComponentInstance* component, Subject *parent);
 386       virtual ~SubjectComponent();
 387       virtual std::string getName();
 388       virtual void setContainer();
 389       virtual bool associateToContainer(SubjectContainer* subcont);
 390       virtual SubjectReference* attachService(SubjectServiceNode* service);
 391       virtual void detachService(SubjectReference* reference);
 392       virtual void moveService(SubjectReference* reference);
 393       virtual void removeSubServiceFromSet(SubjectServiceNode *service);
 394       virtual void notifyServicesChange(GuiEvent event, int type, Subject* son);
 395       virtual std::pair<std::string, int> getKey();
 396       virtual void clean();
 397       void localClean();
 398       YACS::ENGINE::ComponentInstance* getComponent() const;
 399       virtual TypeOfElem getType(){return COMPONENT;}
 400     protected:
 401       int _id;
 402       YACS::ENGINE::ComponentInstance* _compoInst;
 403       SubjectReference* _subRefContainer;
 404       std::set<SubjectServiceNode*> _subServiceSet;
 405     };
 406
 407     class SubjectDataType: public Subject
 408     {
 409     public:
 410       SubjectDataType(YACS::ENGINE::TypeCode *typeCode, Subject *parent, std::string alias);
 411       virtual ~SubjectDataType();
 412       virtual std::string getName();
 413       virtual std::string getAlias();
 414       virtual YACS::ENGINE::TypeCode* getTypeCode();
 415       virtual void clean();
 416       void localClean();
 417       virtual TypeOfElem getType(){return DATATYPE;}
 418     protected:
 419       YACS::ENGINE::TypeCode *_typeCode;
 420       std::string _alias;
 421     };
 422
 423     class SubjectProc: public SubjectBloc
 424     {
 425     public:
 426       SubjectProc(YACS::ENGINE::Proc *proc, Subject *parent);
 427       virtual ~SubjectProc();
 428       void loadProc();
 429       void loadComponents();
 430       void loadContainers();
 431       virtual SubjectComponent* addComponent(std::string name);
 432       virtual SubjectContainer* addContainer(std::string name, std::string ref="");
 433       virtual SubjectDataType* addDataType(YACS::ENGINE::Catalog* catalog, std::string typeName);
 434       SubjectComponent* addSubjectComponent(YACS::ENGINE::ComponentInstance* compo);
 435       SubjectContainer* addSubjectContainer(YACS::ENGINE::Container* cont,
 436                                             std::string name = "");
 437       SubjectDataType* addSubjectDataType(YACS::ENGINE::TypeCode *type, std::string alias);
 438       void removeSubjectDataType(YACS::ENGINE::TypeCode *type);
 439       virtual void clean();
 440       void localClean();
 441       virtual TypeOfElem getType(){return SALOMEPROC;}
 442     protected:
 443       YACS::ENGINE::Proc *_proc;
 444     };
 445
 446     class SubjectForLoop: public SubjectComposedNode
 447     {
 448     public:
 449       SubjectForLoop(YACS::ENGINE::ForLoop *forLoop, Subject *parent);
 450       virtual ~SubjectForLoop();
 451       virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
 452                                    std::string compo,
 453                                    std::string type,
 454                                    std::string name);
 455       virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
 456       virtual void completeChildrenSubjectList(SubjectNode *son);
 457       virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const { return _body; }
 458       virtual bool setNbSteps(std::string nbSteps);
 459       virtual bool hasValue();
 460       virtual std::string getValue();
 461       virtual void clean();
 462       void localClean();
 463       virtual TypeOfElem getType(){return FORLOOP;}
 464     protected:
 465       YACS::ENGINE::ForLoop *_forLoop;
 466       SubjectNode* _body;
 467     };
 468
 469     class SubjectWhileLoop: public SubjectComposedNode
 470     {
 471     public:
 472       SubjectWhileLoop(YACS::ENGINE::WhileLoop *whileLoop, Subject *parent);
 473       virtual ~SubjectWhileLoop();
 474       virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
 475                                    std::string compo,
 476                                    std::string type,
 477                                    std::string name);
 478       virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
 479       virtual void completeChildrenSubjectList(SubjectNode *son);
 480       virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const { return _body; }
 481       virtual bool setCondition(std::string condition);
 482       virtual bool hasValue();
 483       virtual std::string getValue();
 484       virtual void clean();
 485       void localClean();
 486       virtual TypeOfElem getType(){return WHILELOOP;}
 487     protected:
 488       YACS::ENGINE::WhileLoop *_whileLoop;
 489       SubjectNode* _body;
 490     };
 491
 492     class SubjectSwitch: public SubjectComposedNode
 493     {
 494     public:
 495       SubjectSwitch(YACS::ENGINE::Switch *aSwitch, Subject *parent);
 496       virtual ~SubjectSwitch();
 497       virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
 498                                    std::string compo,
 499                                    std::string type,
 500                                    std::string name,
 501                                    int swCase,
 502                                    bool replace = false);
 503       virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
 504       virtual void removeNode(SubjectNode* son);
 505       std::map<int, SubjectNode*> getBodyMap();
 506       virtual void completeChildrenSubjectList(SubjectNode *son);
 507       virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const;
 508       virtual bool setSelect(std::string select);
 509       virtual bool setCase(std::string caseId, SubjectNode* snode);
 510       virtual bool hasValue();
 511       virtual std::string getValue();
 512       virtual void clean();
 513       void localClean();
 514       virtual TypeOfElem getType(){return SWITCH;}
 515     protected:
 516       YACS::ENGINE::Switch *_switch;
 517       std::map<int, SubjectNode*> _bodyMap;
 518     };
 519
 520     class SubjectForEachLoop: public SubjectComposedNode
 521     {
 522     public:
 523       SubjectForEachLoop(YACS::ENGINE::ForEachLoop *forEachLoop, Subject *parent);
 524       virtual ~SubjectForEachLoop();
 525       virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
 526                                    std::string compo,
 527                                    std::string type,
 528                                    std::string name);
 529       virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
 530       virtual void completeChildrenSubjectList(SubjectNode *son);
 531       virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const { return _body; }
 532       virtual bool setNbBranches(std::string nbBranches);
 533       virtual bool hasValue();
 534       virtual std::string getValue();
 535       virtual void clean();
 536       void localClean();
 537       virtual TypeOfElem getType(){return FOREACHLOOP;}
 538     protected:
 539       YACS::ENGINE::ForEachLoop *_forEachLoop;
 540       SubjectNode* _body;
 541       SubjectNode* _splitter;
 542     };
 543
 544     class SubjectOptimizerLoop: public SubjectComposedNode
 545     {
 546     public:
 547       SubjectOptimizerLoop(YACS::ENGINE::OptimizerLoop *optimizerLoop, Subject *parent);
 548       virtual ~SubjectOptimizerLoop();
 549       virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
 550                                    std::string compo,
 551                                    std::string type,
 552                                    std::string name);
 553       virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
 554       virtual void completeChildrenSubjectList(SubjectNode *son);
 555       virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const { return _body; }
 556       virtual void clean();
 557       void localClean();
 558       virtual TypeOfElem getType(){return OPTIMIZERLOOP;}
 559     protected:
 560       YACS::ENGINE::OptimizerLoop *_optimizerLoop;
 561       SubjectNode* _body;
 562     };
 563
 564     class SubjectElementaryNode: public SubjectNode
 565     {
 566     public:
 567       SubjectElementaryNode(YACS::ENGINE::ElementaryNode *elementaryNode, Subject *parent);
 568       virtual ~SubjectElementaryNode();
 569       virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
 570       virtual SubjectDataPort* addInputPort(YACS::ENGINE::Catalog *catalog, std::string type, std::string name);
 571       virtual SubjectDataPort* addOutputPort(YACS::ENGINE::Catalog *catalog, std::string type, std::string name);
 572       virtual SubjectDataPort* addIDSPort(YACS::ENGINE::Catalog *catalog, std::string type, std::string name);
 573       virtual SubjectDataPort* addODSPort(YACS::ENGINE::Catalog *catalog, std::string type, std::string name);
 574       virtual bool OrderDataPorts(SubjectDataPort* portToMove, int isUp);
 575       virtual void removePort(SubjectDataPort* port);
 576       virtual void loadChildren();
 577       virtual void clean();
 578       void localClean();
 579     protected:
 580       YACS::ENGINE::ElementaryNode *_elementaryNode;
 581     };
 582
 583     class SubjectInlineNode: public SubjectElementaryNode
 584     {
 585     public:
 586       SubjectInlineNode(YACS::ENGINE::InlineNode *inlineNode, Subject *parent);
 587       virtual ~SubjectInlineNode();
 588       virtual bool setScript(std::string script);
 589       virtual std::string getScript();
 590       virtual void clean();
 591       void localClean();
 592     protected:
 593       YACS::ENGINE::InlineNode *_inlineNode;
 594     };
 595
 596     class SubjectPythonNode: public SubjectInlineNode
 597     {
 598     public:
 599       SubjectPythonNode(YACS::ENGINE::PythonNode *pythonNode, Subject *parent);
 600       virtual ~SubjectPythonNode();
 601       virtual void clean();
 602       void localClean();
 603       virtual TypeOfElem getType(){return PYTHONNODE;}
 604     protected:
 605       YACS::ENGINE::PythonNode *_pythonNode;
 606     };
 607
 608     class SubjectPyFuncNode: public SubjectInlineNode
 609     {
 610     public:
 611       SubjectPyFuncNode(YACS::ENGINE::PyFuncNode *pyFuncNode, Subject *parent);
 612       virtual ~SubjectPyFuncNode();
 613       virtual bool setFunctionName(std::string funcName);
 614       virtual void clean();
 615       void localClean();
 616       virtual TypeOfElem getType(){return PYFUNCNODE;}
 617     protected:
 618       YACS::ENGINE::PyFuncNode *_pyFuncNode;
 619     };
 620
 621     class SubjectServiceNode: public SubjectElementaryNode
 622     {
 623     public:
 624       SubjectServiceNode(YACS::ENGINE::ServiceNode *serviceNode, Subject *parent);
 625       virtual ~SubjectServiceNode();
 626       virtual void setComponentFromCatalog(YACS::ENGINE::Catalog *catalog,
 627                                            std::string compo,
 628                                            std::string service);
 629       virtual void setComponent();
 630       virtual bool associateToComponent(SubjectComponent *subcomp);
 631       virtual void removeSubjectReference(Subject *ref);
 632       virtual void addSubjectReference(Subject *ref);
 633       virtual SubjectReference* getSubjectReference();
 634       virtual void clean();
 635       void localClean();
 636     protected:
 637       YACS::ENGINE::ServiceNode *_serviceNode;
 638       SubjectReference* _subjectReference;
 639       SubjectReference* _subRefComponent;
 640    };
 641
 642     class SubjectCORBANode: public SubjectServiceNode
 643     {
 644     public:
 645       SubjectCORBANode(YACS::ENGINE::CORBANode *corbaNode, Subject *parent);
 646       virtual ~SubjectCORBANode();
 647       virtual void clean();
 648       void localClean();
 649     protected:
 650       YACS::ENGINE::CORBANode *_corbaNode;
 651     };
 652
 653     class SubjectCppNode: public SubjectServiceNode
 654     {
 655     public:
 656       SubjectCppNode(YACS::ENGINE::CppNode *cppNode, Subject *parent);
 657       virtual ~SubjectCppNode();
 658       virtual void clean();
 659       void localClean();
 660     protected:
 661       YACS::ENGINE::CppNode *_cppNode;
 662     };
 663
 664     class SubjectSalomeNode: public SubjectServiceNode
 665     {
 666     public:
 667       SubjectSalomeNode(YACS::ENGINE::SalomeNode *salomeNode, Subject *parent);
 668       virtual ~SubjectSalomeNode();
 669       virtual void clean();
 670       void localClean();
 671       virtual TypeOfElem getType(){return SALOMENODE;}
 672     protected:
 673       YACS::ENGINE::SalomeNode *_salomeNode;
 674     };
 675
 676     class SubjectSalomePythonNode: public SubjectServiceNode
 677     {
 678     public:
 679       SubjectSalomePythonNode(YACS::ENGINE::SalomePythonNode *salomePythonNode,
 680                               Subject *parent);
 681       virtual ~SubjectSalomePythonNode();
 682       virtual void clean();
 683       void localClean();
 684       virtual TypeOfElem getType(){return SALOMEPYTHONNODE;}
 685     protected:
 686       YACS::ENGINE::SalomePythonNode *_salomePythonNode;
 687     };
 688
 689     class SubjectXmlNode: public SubjectServiceNode
 690     {
 691     public:
 692       SubjectXmlNode(YACS::ENGINE::XmlNode *xmlNode, Subject *parent);
 693       virtual ~SubjectXmlNode();
 694       virtual void clean();
 695       void localClean();
 696       virtual TypeOfElem getType(){return XMLNODE;}
 697     protected:
 698       YACS::ENGINE::XmlNode *_xmlNode;
 699     };
 700
 701     class SubjectSplitterNode: public SubjectElementaryNode
 702     {
 703     public:
 704       SubjectSplitterNode(YACS::ENGINE::SplitterNode *splitterNode, Subject *parent);
 705       virtual ~SubjectSplitterNode();
 706       virtual std::string getName();
 707       virtual void clean();
 708       void localClean();
 709       virtual TypeOfElem getType(){return SPLITTERNODE;}
 710     protected:
 711       YACS::ENGINE::SplitterNode *_splitterNode;
 712     };
 713
 714     class SubjectDataNode: public SubjectElementaryNode
 715     {
 716     public:
 717       SubjectDataNode(YACS::ENGINE::DataNode *dataNode, Subject *parent);
 718       virtual ~SubjectDataNode();
 719       virtual void clean();
 720       void localClean();
 721     protected:
 722       YACS::ENGINE::DataNode *_dataNode;
 723     };
 724
 725     class SubjectPresetNode: public SubjectDataNode
 726     {
 727     public:
 728       SubjectPresetNode(YACS::ENGINE::PresetNode *presetNode, Subject *parent);
 729       virtual ~SubjectPresetNode();
 730       virtual void clean();
 731       void localClean();
 732       virtual TypeOfElem getType(){return PRESETNODE;}
 733     protected:
 734       YACS::ENGINE::PresetNode *_presetNode;
 735     };
 736
 737     class SubjectOutNode: public SubjectDataNode
 738     {
 739     public:
 740       SubjectOutNode(YACS::ENGINE::OutNode *outNode, Subject *parent);
 741       virtual ~SubjectOutNode();
 742       virtual void clean();
 743       void localClean();
 744       virtual TypeOfElem getType(){return OUTNODE;}
 745     protected:
 746       YACS::ENGINE::OutNode *_outNode;
 747     };
 748
 749     class SubjectStudyInNode: public SubjectDataNode
 750     {
 751     public:
 752       SubjectStudyInNode(YACS::ENGINE::StudyInNode *studyInNode, Subject *parent);
 753       virtual ~SubjectStudyInNode();
 754       virtual void clean();
 755       void localClean();
 756       virtual TypeOfElem getType(){return STUDYINNODE;}
 757     protected:
 758       YACS::ENGINE::StudyInNode *_studyInNode;
 759     };
 760
 761     class SubjectStudyOutNode: public SubjectDataNode
 762     {
 763     public:
 764       SubjectStudyOutNode(YACS::ENGINE::StudyOutNode *studyOutNode, Subject *parent);
 765       virtual ~SubjectStudyOutNode();
 766       virtual void clean();
 767       void localClean();
 768       virtual TypeOfElem getType(){return STUDYOUTNODE;}
 769     protected:
 770       YACS::ENGINE::StudyOutNode *_studyOutNode;
 771     };
 772
 773     class SubjectLink: public Subject
 774     {
 775     public:
 776       SubjectLink(SubjectNode* subOutNode,
 777                   SubjectDataPort* outPort,
 778                   SubjectNode* subInNode,
 779                   SubjectDataPort* inPort,
 780                   Subject *parent);
 781       virtual ~SubjectLink();
 782       virtual std::string getName();
 783       virtual void clean();
 784       void localClean();
 785       SubjectNode* getSubjectOutNode() { return _subOutNode; };
 786       SubjectNode* getSubjectInNode() { return _subInNode; };
 787       SubjectDataPort* getSubjectOutPort() { return _outPort; };
 788       SubjectDataPort* getSubjectInPort() { return _inPort; };
 789       virtual TypeOfElem getType(){return DATALINK;}
 790     protected:
 791       SubjectNode* _subOutNode;
 792       SubjectDataPort* _outPort;
 793       SubjectNode* _subInNode;
 794       SubjectDataPort* _inPort;
 795       std::string _name;
 796       YACS::ENGINE::ComposedNode *_cla;
 797       YACS::ENGINE::OutPort *_outp;
 798       YACS::ENGINE::InPort *_inp;
 799     };
 800
 801     class SubjectControlLink: public Subject
 802     {
 803     public:
 804       SubjectControlLink(SubjectNode* subOutNode,
 805                          SubjectNode* subInNode,
 806                          Subject *parent);
 807       virtual ~SubjectControlLink();
 808       virtual std::string getName();
 809       virtual void clean();
 810       void localClean();
 811       SubjectNode* getSubjectOutNode() { return _subOutNode; };
 812       SubjectNode* getSubjectInNode() { return _subInNode; };
 813       virtual TypeOfElem getType(){return CONTROLLINK;}
 814     protected:
 815       SubjectNode* _subOutNode;
 816       SubjectNode* _subInNode;
 817       std::string _name;
 818       YACS::ENGINE::ComposedNode *_cla;
 819     };
 820
 821   }
 822 }
 823 #endif