src/hmi/guiObservers.hxx

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