1 // Copyright (C) 2006-2024 CEA, EDF
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.
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.
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
17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 #ifndef _GUIOBSERVERS_HXX_
21 #define _GUIOBSERVERS_HXX_
28 #include "HMIExport.hxx"
29 #include "Dispatcher.hxx"
30 #include "commandsProc.hxx"
55 class SalomePythonNode;
68 class InputDataStreamPort;
69 class OutputDataStreamPort;
71 class ComponentInstance;
73 class HomogeneousPoolContainer;
116 class SubjectReference;
117 class HMI_EXPORT Subject: public YACS::ENGINE::Observer
120 friend class CommandReparentNode;
121 Subject(Subject *parent=0);
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; };
148 std::set<GuiObserver *> _setObs;
151 bool _askRegisterUndo;
152 std::string _progress;
155 class HMI_EXPORT 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);
165 bool isDestructible() { return _destructible; };
166 static std::string eventName(GuiEvent event);
167 static void setEventMap();
169 std::set<Subject*> _subjectSet;
171 static std::map<int, std::string> _eventNameMap;
174 class HMI_EXPORT SubjectObserver:public GuiObserver
177 SubjectObserver(Subject* ref);
178 virtual ~SubjectObserver();
179 virtual void select(bool isSelected);
180 virtual void update(GuiEvent event, int type, Subject* son);
185 class SubjectReference: public Subject
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;}
198 SubjectObserver* _sobs;
202 class SubjectControlLink;
203 class HMI_EXPORT SubjectDataPort: public Subject
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();
222 YACS::ENGINE::DataPort *_dataPort;
223 std::list<SubjectLink*> _listSubjectLink;
224 std::string _execValue;
227 class SubjectInputPort: public SubjectDataPort
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;}
237 YACS::ENGINE::InputPort *_inputPort;
240 class SubjectOutputPort: public SubjectDataPort
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;}
250 YACS::ENGINE::OutputPort *_outputPort;
253 class SubjectInputDataStreamPort: public SubjectDataPort
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();
266 YACS::ENGINE::InputDataStreamPort *_inputDataStreamPort;
269 class SubjectOutputDataStreamPort: public SubjectDataPort
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();
281 YACS::ENGINE::OutputDataStreamPort *_outputDataStreamPort;
285 class HMI_EXPORT SubjectNode: public Subject
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);
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);
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;
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;
348 class SubjectComposedNode: public SubjectNode
351 SubjectComposedNode(YACS::ENGINE::ComposedNode *composedNode, Subject *parent);
352 virtual ~SubjectComposedNode();
353 virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
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,
370 SubjectDataPort *spi);
371 SubjectControlLink* addSubjectControlLink(SubjectNode *sno,
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);
383 virtual SubjectNode *createNode(YACS::ENGINE::Catalog *catalog,
389 YACS::ENGINE::ComposedNode *_composedNode;
392 class SubjectBloc: public SubjectComposedNode
395 SubjectBloc(YACS::ENGINE::Bloc *bloc, Subject *parent);
396 virtual ~SubjectBloc();
397 virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
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;}
411 YACS::ENGINE::Bloc *_bloc;
412 std::set<SubjectNode*> _children;
415 class SubjectComponent;
416 class HMI_EXPORT SubjectContainerBase : public Subject
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; }
438 YACS::ENGINE::Container* _container;
439 std::set<SubjectComponent*> _subComponentSet;
440 std::map<SubjectComponent*,SubjectReference*> _subReferenceMap;
443 class HMI_EXPORT SubjectContainer: public SubjectContainerBase
446 SubjectContainer(YACS::ENGINE::Container *container, Subject *parent);
447 void registerUndoDestroy();
448 std::string getLabelForHuman() const { return std::string("Salome Container"); }
451 class HMI_EXPORT SubjectHPContainer : public SubjectContainerBase
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"); }
460 class SubjectServiceNode;
461 class HMI_EXPORT SubjectComponent : public Subject
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;
486 YACS::ENGINE::ComponentInstance* _compoInst;
487 std::set<SubjectServiceNode*> _subServiceSet;
488 std::map<SubjectServiceNode*,SubjectReference*> _subReferenceMap;
491 class SubjectDataType: public Subject
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;}
503 YACS::ENGINE::TypeCode *_typeCode;
507 class SubjectProc: public SubjectBloc
510 SubjectProc(YACS::ENGINE::Proc *proc, Subject *parent);
511 virtual ~SubjectProc();
513 void loadComponents();
514 void loadContainers();
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;}
532 YACS::ENGINE::Proc *_proc;
533 std::vector<Subject*> _postEraseList;
536 class SubjectForLoop: public SubjectComposedNode
539 SubjectForLoop(YACS::ENGINE::ForLoop *forLoop, Subject *parent);
540 virtual ~SubjectForLoop();
541 virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
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;}
557 YACS::ENGINE::ForLoop *_forLoop;
561 class SubjectWhileLoop: public SubjectComposedNode
564 SubjectWhileLoop(YACS::ENGINE::WhileLoop *whileLoop, Subject *parent);
565 virtual ~SubjectWhileLoop();
566 virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
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;}
582 YACS::ENGINE::WhileLoop *_whileLoop;
586 class HMI_EXPORT SubjectSwitch: public SubjectComposedNode
589 SubjectSwitch(YACS::ENGINE::Switch *aSwitch, Subject *parent);
590 virtual ~SubjectSwitch();
591 virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
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;}
612 YACS::ENGINE::Switch *_switch;
613 std::map<int, SubjectNode*> _bodyMap;
616 class SubjectDynParaLoop: public SubjectComposedNode
619 SubjectDynParaLoop(YACS::ENGINE::DynParaLoop * dynParaLoop, Subject * parent);
620 virtual ~SubjectDynParaLoop();
621 virtual SubjectNode * addNode(YACS::ENGINE::Catalog * catalog,
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);
637 YACS::ENGINE::DynParaLoop * _dynParaLoop;
638 SubjectNode * _subjectExecNode;
639 SubjectNode * _subjectInitNode;
640 SubjectNode * _subjectFinalizeNode;
643 class SubjectForEachLoop: public SubjectDynParaLoop
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;}
654 YACS::ENGINE::ForEachLoopGen *_forEachLoop;
655 SubjectNode* _splitter;
658 class SubjectOptimizerLoop: public SubjectDynParaLoop
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);
668 YACS::ENGINE::OptimizerLoop *_optimizerLoop;
671 class SubjectElementaryNode: public SubjectNode
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();
689 YACS::ENGINE::ElementaryNode *_elementaryNode;
692 class SubjectInlineNode: public SubjectElementaryNode
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);
704 YACS::ENGINE::InlineNode *_inlineNode;
707 class SubjectPythonNode: public SubjectInlineNode
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;}
716 YACS::ENGINE::PythonNode *_pythonNode;
719 class SubjectPyFuncNode: public SubjectInlineNode
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;}
729 YACS::ENGINE::PyFuncNode *_pyFuncNode;
732 class SubjectServiceNode: public SubjectElementaryNode
734 friend class CommandAssociateServiceToComponent;
735 friend class CommandAddComponentFromCatalog;
737 SubjectServiceNode(YACS::ENGINE::ServiceNode *serviceNode, Subject *parent);
738 virtual ~SubjectServiceNode();
739 virtual void setComponentFromCatalog(YACS::ENGINE::Catalog *catalog,
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);
751 YACS::ENGINE::ServiceNode *_serviceNode;
752 SubjectReference* _subjectReference;
753 SubjectReference* _subRefComponent;
756 class SubjectCORBANode: public SubjectServiceNode
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;}
765 YACS::ENGINE::CORBANode *_corbaNode;
768 class SubjectCppNode: public SubjectServiceNode
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;}
777 YACS::ENGINE::CppNode *_cppNode;
780 class SubjectSalomeNode: public SubjectServiceNode
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;}
789 YACS::ENGINE::SalomeNode *_salomeNode;
792 class SubjectSalomePythonNode: public SubjectServiceNode
795 SubjectSalomePythonNode(YACS::ENGINE::SalomePythonNode *salomePythonNode,
797 virtual ~SubjectSalomePythonNode();
798 virtual void clean(Command *command=0);
799 void localclean(Command *command=0);
800 virtual TypeOfElem getType(){return SALOMEPYTHONNODE;}
802 YACS::ENGINE::SalomePythonNode *_salomePythonNode;
805 class SubjectXmlNode: public SubjectServiceNode
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;}
814 YACS::ENGINE::XmlNode *_xmlNode;
817 class SubjectSplitterNode: public SubjectElementaryNode
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;}
827 YACS::ENGINE::SplitterNode *_splitterNode;
830 class SubjectDataNode: public SubjectElementaryNode
833 SubjectDataNode(YACS::ENGINE::DataNode *dataNode, Subject *parent);
834 virtual ~SubjectDataNode();
835 virtual void clean(Command *command=0);
836 void localclean(Command *command=0);
838 YACS::ENGINE::DataNode *_dataNode;
841 class SubjectPresetNode: public SubjectDataNode
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;}
850 YACS::ENGINE::PresetNode *_presetNode;
853 class SubjectOutNode: public SubjectDataNode
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;}
862 YACS::ENGINE::OutNode *_outNode;
865 class SubjectStudyInNode: public SubjectDataNode
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;}
874 YACS::ENGINE::StudyInNode *_studyInNode;
877 class SubjectStudyOutNode: public SubjectDataNode
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;}
886 YACS::ENGINE::StudyOutNode *_studyOutNode;
889 class SubjectLink: public Subject
892 SubjectLink(SubjectNode* subOutNode,
893 SubjectDataPort* outPort,
894 SubjectNode* subInNode,
895 SubjectDataPort* inPort,
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();
911 SubjectNode* _subOutNode;
912 SubjectDataPort* _outPort;
913 SubjectNode* _subInNode;
914 SubjectDataPort* _inPort;
916 YACS::ENGINE::ComposedNode *_cla;
917 YACS::ENGINE::OutPort *_outp;
918 YACS::ENGINE::InPort *_inp;
921 class SubjectControlLink: public Subject
924 SubjectControlLink(SubjectNode* subOutNode,
925 SubjectNode* subInNode,
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();
936 SubjectNode* _subOutNode;
937 SubjectNode* _subInNode;
939 YACS::ENGINE::ComposedNode *_cla;