src/hmi/guiObservers.hxx

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