src/hmi/guiObservers.hxx

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