-// Copyright (C) 2006-2008 CEA/DEN, EDF R&D
+// Copyright (C) 2006-2012 CEA/DEN, EDF R&D
//
-// This library is free software; you can redistribute it and/or
-// modify it under the terms of the GNU Lesser General Public
-// License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
//
-// This library is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
//
-// You should have received a copy of the GNU Lesser General Public
-// License along with this library; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
-// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+
#ifndef _GUIOBSERVERS_HXX_
#define _GUIOBSERVERS_HXX_
#include <set>
#include <string>
#include <map>
+#include <vector>
#include <list>
+#include "HMIExport.hxx"
#include "Dispatcher.hxx"
#include "commandsProc.hxx"
class Bloc;
class Proc;
class ForLoop;
+ class DynParaLoop;
class ForEachLoop;
class WhileLoop;
class Switch;
class ComponentInstance;
class Container;
class TypeCode;
+ class OutGate;
+ class InGate;
}
namespace HMI
PASTE,
ORDER,
EDIT,
- UPDATE,
- UPDATEPROGRESS,
+ UPDATE,
+ UPDATEPROGRESS,
SYNCHRO,
- UP,
- DOWN,
+ UP,
+ DOWN,
RENAME,
NEWROOT,
ENDLOAD,
SETVALUE,
SETCASE,
SETSELECT,
- GEOMETRY
+ GEOMETRY,
+ EMPHASIZE,
+ SWITCHSHAPE
} GuiEvent;
class ProcInvoc;
class GuiObserver;
class SubjectReference;
- class Subject: public YACS::ENGINE::Observer
+ class HMI_EXPORT Subject: public YACS::ENGINE::Observer
{
public:
+ friend class CommandReparentNode;
Subject(Subject *parent=0);
virtual ~Subject();
virtual void attach(GuiObserver *obs);
virtual void update(GuiEvent event, int type, Subject* son);
virtual std::string getName();
virtual bool setName(std::string name);
+ virtual bool setProperties(std::map<std::string, std::string> properties);
+ virtual std::map<std::string, std::string> getProperties();
+ virtual std::vector<std::string> knownProperties();
virtual Subject* getParent();
+ virtual void setParent(Subject* son);
virtual bool destroy(Subject *son);
virtual void loadChildren();
virtual void loadLinks();
virtual void addSubjectReference(Subject *ref);
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
+ void registerUndoDestroy();
+ void askRegisterUndoDestroy() {_askRegisterUndo=true; };
bool isDestructible() { return _destructible; };
- static void erase(Subject* sub);
+ static void erase(Subject* sub, Command *command=0, bool post=false);
virtual TypeOfElem getType(){return UNKNOWN;}
protected:
std::set<GuiObserver *> _setObs;
Subject *_parent;
bool _destructible;
+ bool _askRegisterUndo;
};
- class GuiObserver
+ class HMI_EXPORT GuiObserver
{
public:
GuiObserver();
static std::map<int, std::string> _eventNameMap;
};
+ class HMI_EXPORT SubjectObserver:public GuiObserver
+ {
+ public:
+ SubjectObserver(Subject* ref);
+ virtual ~SubjectObserver();
+ virtual void select(bool isSelected);
+ virtual void update(GuiEvent event, int type, Subject* son);
+ protected:
+ Subject* _reference;
+ };
+
class SubjectReference: public Subject
{
public:
virtual std::string getName();
virtual Subject* getReference() const;
virtual void reparent(Subject *parent);
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return REFERENCE;}
protected:
Subject* _reference;
+ SubjectObserver* _sobs;
};
class SubjectLink;
class SubjectControlLink;
- class SubjectDataPort: public Subject
+ class HMI_EXPORT SubjectDataPort: public Subject
{
public:
SubjectDataPort(YACS::ENGINE::DataPort* port, Subject *parent);
virtual bool setName(std::string name);
virtual YACS::ENGINE::DataPort* getPort();
static bool tryCreateLink(SubjectDataPort *subOutport, SubjectDataPort *subInport,bool control=true);
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
void addSubjectLink(SubjectLink* subject) { _listSubjectLink.push_back(subject); };
void removeSubjectLink(SubjectLink* subject) { _listSubjectLink.remove(subject); };
std::list<SubjectLink*> getListOfSubjectLink() { return _listSubjectLink; };
virtual bool setValue(std::string value);
void setExecValue(std::string value);
std::string getExecValue();
+ void registerUndoDestroy();
protected:
YACS::ENGINE::DataPort *_dataPort;
std::list<SubjectLink*> _listSubjectLink;
public:
SubjectInputPort(YACS::ENGINE::InputPort *port, Subject *parent);
virtual ~SubjectInputPort();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual bool setValue(std::string value);
virtual TypeOfElem getType(){return INPUTPORT;}
protected:
public:
SubjectOutputPort(YACS::ENGINE::OutputPort *port, Subject *parent);
virtual ~SubjectOutputPort();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual bool setValue(std::string value);
virtual TypeOfElem getType(){return OUTPUTPORT;}
protected:
virtual ~SubjectInputDataStreamPort();
virtual bool setProperties(std::map<std::string, std::string> properties);
virtual std::map<std::string, std::string> getProperties();
- virtual void clean();
- void localClean();
+ virtual std::vector<std::string> knownProperties();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return INPUTDATASTREAMPORT;}
+ void registerUndoDestroy();
protected:
YACS::ENGINE::InputDataStreamPort *_inputDataStreamPort;
};
virtual ~SubjectOutputDataStreamPort();
virtual bool setProperties(std::map<std::string, std::string> properties);
virtual std::map<std::string, std::string> getProperties();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return OUTPUTDATASTREAMPORT;}
+ void registerUndoDestroy();
protected:
YACS::ENGINE::OutputDataStreamPort *_outputDataStreamPort;
};
- class SubjectNode: public Subject
+ class HMI_EXPORT SubjectNode: public Subject
{
public:
+ friend class CommandAddInputPortFromCatalog;
+ friend class CommandAddOutputPortFromCatalog;
+ friend class CommandAddIDSPortFromCatalog;
+ friend class CommandAddODSPortFromCatalog;
SubjectNode(YACS::ENGINE::Node *node, Subject *parent);
virtual ~SubjectNode();
+ virtual bool setProperties(std::map<std::string, std::string> properties);
+ virtual std::map<std::string, std::string> getProperties();
virtual bool reparent(Subject* parent);
virtual bool copy(Subject* parent);
virtual std::string getName();
virtual bool setName(std::string name);
virtual YACS::ENGINE::Node* getNode();
- virtual void clean();
- SubjectControlLink* addSubjectControlLink(SubjectControlLink *sub) { _listSubjectControlLink.push_back(sub); };
+ virtual void clean(Command *command=0);
+ void registerUndoDestroy();
+ SubjectControlLink* addSubjectControlLink(SubjectControlLink *sub) { _listSubjectControlLink.push_back(sub); return sub; };
void removeSubjectControlLink(SubjectControlLink* sub) { _listSubjectControlLink.remove(sub); };
std::list<SubjectLink*> getSubjectLinks() const { return _listSubjectLink; };
std::list<SubjectControlLink*> getSubjectControlLinks() const { return _listSubjectControlLink; };
std::list<SubjectOutputPort*> getSubjectOutputPorts() const { return _listSubjectOutputPort; };
std::list<SubjectInputDataStreamPort*> getSubjectInputDataStreamPorts() const { return _listSubjectIDSPort; };
std::list<SubjectOutputDataStreamPort*> getSubjectOutputDataStreamPorts() const { return _listSubjectODSPort; };
- void localClean();
+ void localclean(Command *command=0);
virtual void update(GuiEvent event, int type, Subject* son);
virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
virtual void removeExternalLinks();
virtual void removeExternalControlLinks();
+ virtual void saveLinks();
+ virtual void restoreLinks();
+ virtual bool putInComposedNode(std::string name,std::string type);
+ virtual int isValid();
void setExecState(int execState);
static bool tryCreateLink(SubjectNode *subOutNode, SubjectNode *subInNode);
std::list<SubjectLink*> _listSubjectLink;
std::list<SubjectControlLink*> _listSubjectControlLink;
int _execState;
+ std::list<YACS::ENGINE::OutGate *> loutgate;
+ std::set<YACS::ENGINE::InGate *> singate;
+ std::vector< std::pair<YACS::ENGINE::OutPort *, YACS::ENGINE::InPort *> > dataLinks;
+ std::vector< std::pair<YACS::ENGINE::OutPort *, YACS::ENGINE::InPort *> > dataflowLinks;
};
class SubjectComposedNode: public SubjectNode
SubjectComposedNode(YACS::ENGINE::ComposedNode *composedNode, Subject *parent);
virtual ~SubjectComposedNode();
virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
- std::string compo,
- std::string type,
- std::string name);
+ std::string compo,
+ std::string type,
+ std::string name,
+ bool newCompoInst);
virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const { return 0; }
virtual void loadChildren();
virtual void loadLinks();
virtual void removeLink(SubjectLink* link);
virtual void removeControlLink(SubjectControlLink* link);
virtual void removeExternalControlLinks();
+ virtual void houseKeepingAfterCutPaste(bool isCut, SubjectNode *son);
virtual bool hasValue();
virtual std::string getValue();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
static SubjectComposedNode* getLowestCommonAncestor(SubjectNode* snode1, SubjectNode* snode2);
protected:
virtual SubjectNode *createNode(YACS::ENGINE::Catalog *catalog,
std::string compo,
std::string type,
std::string name,
+ bool newCompoInst,
int swCase=0);
YACS::ENGINE::ComposedNode *_composedNode;
};
SubjectBloc(YACS::ENGINE::Bloc *bloc, Subject *parent);
virtual ~SubjectBloc();
virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
- std::string compo,
- std::string type,
- std::string name);
+ std::string compo,
+ std::string type,
+ std::string name,
+ bool newCompoInst);
virtual void removeNode(SubjectNode* child);
virtual void completeChildrenSubjectList(SubjectNode *son);
virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const;
virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
- virtual void clean();
- void localClean();
+ virtual void houseKeepingAfterCutPaste(bool isCut, SubjectNode *son);
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return BLOC;}
protected:
YACS::ENGINE::Bloc *_bloc;
};
class SubjectComponent;
- class SubjectContainer: public Subject
+ class HMI_EXPORT SubjectContainer: public Subject
{
public:
SubjectContainer(YACS::ENGINE::Container* container, Subject *parent);
virtual std::map<std::string, std::string> getProperties();
virtual bool setProperties(std::map<std::string, std::string> properties);
virtual SubjectReference* attachComponent(SubjectComponent* component);
- virtual void detachComponent(SubjectReference* reference);
+ virtual void detachComponent(SubjectComponent* component);
virtual void moveComponent(SubjectReference* reference);
virtual void removeSubComponentFromSet(SubjectComponent *component);
virtual void notifyComponentsChange(GuiEvent event, int type, Subject* son);
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
YACS::ENGINE::Container* getContainer() const;
+ bool isUsed() {return !_subComponentSet.empty(); };
virtual TypeOfElem getType(){return CONTAINER;}
+ void registerUndoDestroy();
protected:
YACS::ENGINE::Container* _container;
std::set<SubjectComponent*> _subComponentSet;
+ std::map<SubjectComponent*,SubjectReference*> _subReferenceMap;
};
class SubjectServiceNode;
- class SubjectComponent: public Subject
+ class HMI_EXPORT SubjectComponent: public Subject
{
public:
+ friend class SubjectNode;
SubjectComponent(YACS::ENGINE::ComponentInstance* component, Subject *parent);
virtual ~SubjectComponent();
virtual std::string getName();
virtual void setContainer();
virtual bool associateToContainer(SubjectContainer* subcont);
virtual SubjectReference* attachService(SubjectServiceNode* service);
- virtual void detachService(SubjectReference* reference);
+ virtual void detachService(SubjectServiceNode* service);
virtual void moveService(SubjectReference* reference);
virtual void removeSubServiceFromSet(SubjectServiceNode *service);
+ virtual bool setProperties(std::map<std::string, std::string> properties);
+ virtual std::map<std::string, std::string> getProperties();
virtual void notifyServicesChange(GuiEvent event, int type, Subject* son);
virtual std::pair<std::string, int> getKey();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ bool hasServices() { return !_subServiceSet.empty(); };
+ void localclean(Command *command=0);
YACS::ENGINE::ComponentInstance* getComponent() const;
virtual TypeOfElem getType(){return COMPONENT;}
+ SubjectReference* _subRefContainer;
protected:
int _id;
YACS::ENGINE::ComponentInstance* _compoInst;
- SubjectReference* _subRefContainer;
std::set<SubjectServiceNode*> _subServiceSet;
+ std::map<SubjectServiceNode*,SubjectReference*> _subReferenceMap;
};
class SubjectDataType: public Subject
virtual std::string getName();
virtual std::string getAlias();
virtual YACS::ENGINE::TypeCode* getTypeCode();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return DATATYPE;}
protected:
YACS::ENGINE::TypeCode *_typeCode;
void loadProc();
void loadComponents();
void loadContainers();
- virtual SubjectComponent* addComponent(std::string name);
+ void loadTypes();
+ virtual SubjectComponent* addComponent(std::string compoName, std::string containerName="");
virtual SubjectContainer* addContainer(std::string name, std::string ref="");
- virtual SubjectDataType* addDataType(YACS::ENGINE::Catalog* catalog, std::string typeName);
+ virtual bool addDataType(YACS::ENGINE::Catalog* catalog, std::string typeName);
SubjectComponent* addSubjectComponent(YACS::ENGINE::ComponentInstance* compo);
SubjectContainer* addSubjectContainer(YACS::ENGINE::Container* cont,
std::string name = "");
+ SubjectDataType* addComSubjectDataType(YACS::ENGINE::TypeCode *type, std::string alias);
SubjectDataType* addSubjectDataType(YACS::ENGINE::TypeCode *type, std::string alias);
- void removeSubjectDataType(YACS::ENGINE::TypeCode *type);
- virtual void clean();
- void localClean();
+ void removeSubjectDataType(std::string typeName);
+ void removeSubjectContainer(SubjectContainer* scont);
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
+ void addPostErase(Subject* sub) {_postEraseList.push_back(sub); };
+ void cleanPostErase();
virtual TypeOfElem getType(){return SALOMEPROC;}
protected:
YACS::ENGINE::Proc *_proc;
+ std::vector<Subject*> _postEraseList;
};
class SubjectForLoop: public SubjectComposedNode
SubjectForLoop(YACS::ENGINE::ForLoop *forLoop, Subject *parent);
virtual ~SubjectForLoop();
virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
- std::string compo,
- std::string type,
- std::string name);
+ std::string compo,
+ std::string type,
+ std::string name,
+ bool newCompoInst);
virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
virtual void completeChildrenSubjectList(SubjectNode *son);
virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const { return _body; }
virtual bool setNbSteps(std::string nbSteps);
virtual bool hasValue();
virtual std::string getValue();
- virtual void clean();
- void localClean();
+ virtual void houseKeepingAfterCutPaste(bool isCut, SubjectNode *son);
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return FORLOOP;}
protected:
YACS::ENGINE::ForLoop *_forLoop;
SubjectWhileLoop(YACS::ENGINE::WhileLoop *whileLoop, Subject *parent);
virtual ~SubjectWhileLoop();
virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
- std::string compo,
- std::string type,
- std::string name);
+ std::string compo,
+ std::string type,
+ std::string name,
+ bool newCompoInst);
virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
virtual void completeChildrenSubjectList(SubjectNode *son);
virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const { return _body; }
virtual bool setCondition(std::string condition);
virtual bool hasValue();
virtual std::string getValue();
- virtual void clean();
- void localClean();
+ virtual void houseKeepingAfterCutPaste(bool isCut, SubjectNode *son);
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return WHILELOOP;}
protected:
YACS::ENGINE::WhileLoop *_whileLoop;
SubjectNode* _body;
};
- class SubjectSwitch: public SubjectComposedNode
+ class HMI_EXPORT SubjectSwitch: public SubjectComposedNode
{
public:
SubjectSwitch(YACS::ENGINE::Switch *aSwitch, Subject *parent);
virtual ~SubjectSwitch();
virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
- std::string compo,
- std::string type,
- std::string name,
- int swCase,
- bool replace = false);
+ std::string compo,
+ std::string type,
+ std::string name,
+ bool newCompoInst,
+ int swCase,
+ bool replace = false);
virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
virtual void removeNode(SubjectNode* son);
std::map<int, SubjectNode*> getBodyMap();
virtual bool setCase(std::string caseId, SubjectNode* snode);
virtual bool hasValue();
virtual std::string getValue();
- virtual void clean();
- void localClean();
+ virtual void houseKeepingAfterCutPaste(bool isCut, SubjectNode *son);
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return SWITCH;}
protected:
YACS::ENGINE::Switch *_switch;
std::map<int, SubjectNode*> _bodyMap;
};
- class SubjectForEachLoop: public SubjectComposedNode
+ class SubjectDynParaLoop: public SubjectComposedNode
{
public:
- SubjectForEachLoop(YACS::ENGINE::ForEachLoop *forEachLoop, Subject *parent);
- virtual ~SubjectForEachLoop();
- virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
- std::string compo,
- std::string type,
- std::string name);
- virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
- virtual void completeChildrenSubjectList(SubjectNode *son);
- virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const { return _body; }
+ SubjectDynParaLoop(YACS::ENGINE::DynParaLoop * dynParaLoop, Subject * parent);
+ virtual ~SubjectDynParaLoop();
+ virtual SubjectNode * addNode(YACS::ENGINE::Catalog * catalog,
+ std::string compo,
+ std::string type,
+ std::string name,
+ bool newCompoInst);
+ virtual void recursiveUpdate(GuiEvent event, int type, Subject * son);
+ virtual void completeChildrenSubjectList(SubjectNode * son);
+ virtual void removeNode(SubjectNode * child);
+ virtual SubjectNode * getChild(YACS::ENGINE::Node * node = NULL) const;
virtual bool setNbBranches(std::string nbBranches);
virtual bool hasValue();
virtual std::string getValue();
- virtual void clean();
- void localClean();
+ virtual void houseKeepingAfterCutPaste(bool isCut, SubjectNode * son);
+ virtual void clean(Command * command = NULL);
+ void localclean(Command * command = NULL);
+ protected:
+ YACS::ENGINE::DynParaLoop * _dynParaLoop;
+ SubjectNode * _subjectExecNode;
+ SubjectNode * _subjectInitNode;
+ SubjectNode * _subjectFinalizeNode;
+ };
+
+ class SubjectForEachLoop: public SubjectDynParaLoop
+ {
+ public:
+ SubjectForEachLoop(YACS::ENGINE::ForEachLoop *forEachLoop, Subject *parent);
+ virtual ~SubjectForEachLoop();
+ virtual void completeChildrenSubjectList(SubjectNode *son);
+ virtual void removeNode(SubjectNode * child);
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return FOREACHLOOP;}
protected:
YACS::ENGINE::ForEachLoop *_forEachLoop;
- SubjectNode* _body;
SubjectNode* _splitter;
};
- class SubjectOptimizerLoop: public SubjectComposedNode
+ class SubjectOptimizerLoop: public SubjectDynParaLoop
{
public:
SubjectOptimizerLoop(YACS::ENGINE::OptimizerLoop *optimizerLoop, Subject *parent);
virtual ~SubjectOptimizerLoop();
- virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
- std::string compo,
- std::string type,
- std::string name);
- virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
- virtual void completeChildrenSubjectList(SubjectNode *son);
- virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const { return _body; }
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return OPTIMIZERLOOP;}
+ virtual bool setAlgorithm(const std::string& alglib,const std::string& symbol);
protected:
YACS::ENGINE::OptimizerLoop *_optimizerLoop;
- SubjectNode* _body;
};
class SubjectElementaryNode: public SubjectNode
virtual bool OrderDataPorts(SubjectDataPort* portToMove, int isUp);
virtual void removePort(SubjectDataPort* port);
virtual void loadChildren();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
+ virtual void saveLinks();
+ virtual void restoreLinks();
protected:
YACS::ENGINE::ElementaryNode *_elementaryNode;
};
virtual ~SubjectInlineNode();
virtual bool setScript(std::string script);
virtual std::string getScript();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
+ virtual bool setContainer(SubjectContainer* scont);
+ virtual bool setExecutionMode(const std::string& mode);
protected:
YACS::ENGINE::InlineNode *_inlineNode;
};
public:
SubjectPythonNode(YACS::ENGINE::PythonNode *pythonNode, Subject *parent);
virtual ~SubjectPythonNode();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return PYTHONNODE;}
protected:
YACS::ENGINE::PythonNode *_pythonNode;
SubjectPyFuncNode(YACS::ENGINE::PyFuncNode *pyFuncNode, Subject *parent);
virtual ~SubjectPyFuncNode();
virtual bool setFunctionName(std::string funcName);
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return PYFUNCNODE;}
protected:
YACS::ENGINE::PyFuncNode *_pyFuncNode;
class SubjectServiceNode: public SubjectElementaryNode
{
+ friend class CommandAssociateServiceToComponent;
+ friend class CommandAddComponentFromCatalog;
public:
SubjectServiceNode(YACS::ENGINE::ServiceNode *serviceNode, Subject *parent);
virtual ~SubjectServiceNode();
std::string service);
virtual void setComponent();
virtual bool associateToComponent(SubjectComponent *subcomp);
- virtual void removeSubjectReference(Subject *ref);
+ virtual void removeSubRefComponent() { _subRefComponent = 0; };
+ virtual void removeSubjectReference(){ _subjectReference = 0; };
virtual void addSubjectReference(Subject *ref);
virtual SubjectReference* getSubjectReference();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
protected:
YACS::ENGINE::ServiceNode *_serviceNode;
SubjectReference* _subjectReference;
public:
SubjectCORBANode(YACS::ENGINE::CORBANode *corbaNode, Subject *parent);
virtual ~SubjectCORBANode();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
+ virtual TypeOfElem getType(){return CORBANODE;}
protected:
YACS::ENGINE::CORBANode *_corbaNode;
};
public:
SubjectCppNode(YACS::ENGINE::CppNode *cppNode, Subject *parent);
virtual ~SubjectCppNode();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
+ virtual TypeOfElem getType(){return CPPNODE;}
protected:
YACS::ENGINE::CppNode *_cppNode;
};
public:
SubjectSalomeNode(YACS::ENGINE::SalomeNode *salomeNode, Subject *parent);
virtual ~SubjectSalomeNode();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return SALOMENODE;}
protected:
YACS::ENGINE::SalomeNode *_salomeNode;
SubjectSalomePythonNode(YACS::ENGINE::SalomePythonNode *salomePythonNode,
Subject *parent);
virtual ~SubjectSalomePythonNode();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return SALOMEPYTHONNODE;}
protected:
YACS::ENGINE::SalomePythonNode *_salomePythonNode;
public:
SubjectXmlNode(YACS::ENGINE::XmlNode *xmlNode, Subject *parent);
virtual ~SubjectXmlNode();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return XMLNODE;}
protected:
YACS::ENGINE::XmlNode *_xmlNode;
SubjectSplitterNode(YACS::ENGINE::SplitterNode *splitterNode, Subject *parent);
virtual ~SubjectSplitterNode();
virtual std::string getName();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return SPLITTERNODE;}
protected:
YACS::ENGINE::SplitterNode *_splitterNode;
public:
SubjectDataNode(YACS::ENGINE::DataNode *dataNode, Subject *parent);
virtual ~SubjectDataNode();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
protected:
YACS::ENGINE::DataNode *_dataNode;
};
public:
SubjectPresetNode(YACS::ENGINE::PresetNode *presetNode, Subject *parent);
virtual ~SubjectPresetNode();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return PRESETNODE;}
protected:
YACS::ENGINE::PresetNode *_presetNode;
public:
SubjectOutNode(YACS::ENGINE::OutNode *outNode, Subject *parent);
virtual ~SubjectOutNode();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return OUTNODE;}
protected:
YACS::ENGINE::OutNode *_outNode;
public:
SubjectStudyInNode(YACS::ENGINE::StudyInNode *studyInNode, Subject *parent);
virtual ~SubjectStudyInNode();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return STUDYINNODE;}
protected:
YACS::ENGINE::StudyInNode *_studyInNode;
public:
SubjectStudyOutNode(YACS::ENGINE::StudyOutNode *studyOutNode, Subject *parent);
virtual ~SubjectStudyOutNode();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
virtual TypeOfElem getType(){return STUDYOUTNODE;}
protected:
YACS::ENGINE::StudyOutNode *_studyOutNode;
Subject *parent);
virtual ~SubjectLink();
virtual std::string getName();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
SubjectNode* getSubjectOutNode() { return _subOutNode; };
SubjectNode* getSubjectInNode() { return _subInNode; };
SubjectDataPort* getSubjectOutPort() { return _outPort; };
SubjectDataPort* getSubjectInPort() { return _inPort; };
+ virtual bool setProperties(std::map<std::string, std::string> properties);
+ virtual std::map<std::string, std::string> getProperties();
+ virtual std::vector<std::string> knownProperties();
virtual TypeOfElem getType(){return DATALINK;}
+ void registerUndoDestroy();
protected:
SubjectNode* _subOutNode;
SubjectDataPort* _outPort;
Subject *parent);
virtual ~SubjectControlLink();
virtual std::string getName();
- virtual void clean();
- void localClean();
+ virtual void clean(Command *command=0);
+ void localclean(Command *command=0);
SubjectNode* getSubjectOutNode() { return _subOutNode; };
SubjectNode* getSubjectInNode() { return _subInNode; };
virtual TypeOfElem getType(){return CONTROLLINK;}
+ void registerUndoDestroy();
protected:
SubjectNode* _subOutNode;
SubjectNode* _subInNode;
