src/hmi/guiObservers.hxx

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