1 // Copyright (C) 2006-2014 CEA/DEN, EDF R&D
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"
54 class SalomePythonNode;
67 class InputDataStreamPort;
68 class OutputDataStreamPort;
70 class ComponentInstance;
114 class SubjectReference;
115 class HMI_EXPORT Subject: public YACS::ENGINE::Observer
118 friend class CommandReparentNode;
119 Subject(Subject *parent=0);
121 virtual void attach(GuiObserver *obs);
122 virtual void detach(GuiObserver *obs);
123 virtual void select(bool isSelected);
124 virtual void update(GuiEvent event, int type, Subject* son);
125 virtual std::string getName();
126 virtual bool setName(std::string name);
127 virtual bool setProperties(std::map<std::string, std::string> properties);
128 virtual std::map<std::string, std::string> getProperties();
129 virtual std::vector<std::string> knownProperties();
130 virtual Subject* getParent();
131 virtual void setParent(Subject* son);
132 virtual bool destroy(Subject *son);
133 virtual void loadChildren();
134 virtual void loadLinks();
135 virtual void addSubjectReference(Subject *ref);
136 virtual void clean(Command *command=0);
137 void localclean(Command *command=0);
138 void registerUndoDestroy();
139 void askRegisterUndoDestroy() {_askRegisterUndo=true; };
140 bool isDestructible() { return _destructible; };
141 static void erase(Subject* sub, Command *command=0, bool post=false);
142 virtual TypeOfElem getType(){return UNKNOWN;}
143 virtual void setProgress( std::string newProgress );
144 virtual std::string getProgress() { return _progress; };
146 std::set<GuiObserver *> _setObs;
149 bool _askRegisterUndo;
150 std::string _progress;
153 class HMI_EXPORT GuiObserver
157 virtual ~GuiObserver();
158 virtual void select(bool isSelected);
159 virtual void update(GuiEvent event, int type, Subject* son);
160 virtual void incrementSubjects(Subject *subject);
161 virtual void decrementSubjects(Subject *subject);
163 bool isDestructible() { return _destructible; };
164 static std::string eventName(GuiEvent event);
165 static void setEventMap();
167 std::set<Subject*> _subjectSet;
169 static std::map<int, std::string> _eventNameMap;
172 class HMI_EXPORT SubjectObserver:public GuiObserver
175 SubjectObserver(Subject* ref);
176 virtual ~SubjectObserver();
177 virtual void select(bool isSelected);
178 virtual void update(GuiEvent event, int type, Subject* son);
183 class SubjectReference: public Subject
186 SubjectReference(Subject* ref, Subject *parent);
187 virtual ~SubjectReference();
188 virtual std::string getName();
189 virtual Subject* getReference() const;
190 virtual void reparent(Subject *parent);
191 virtual void clean(Command *command=0);
192 void localclean(Command *command=0);
193 virtual TypeOfElem getType(){return REFERENCE;}
196 SubjectObserver* _sobs;
200 class SubjectControlLink;
201 class HMI_EXPORT SubjectDataPort: public Subject
204 SubjectDataPort(YACS::ENGINE::DataPort* port, Subject *parent);
205 virtual ~SubjectDataPort();
206 virtual std::string getName();
207 virtual bool setName(std::string name);
208 virtual YACS::ENGINE::DataPort* getPort();
209 static bool tryCreateLink(SubjectDataPort *subOutport, SubjectDataPort *subInport,bool control=true);
210 virtual void clean(Command *command=0);
211 void localclean(Command *command=0);
212 void addSubjectLink(SubjectLink* subject) { _listSubjectLink.push_back(subject); };
213 void removeSubjectLink(SubjectLink* subject) { _listSubjectLink.remove(subject); };
214 std::list<SubjectLink*> getListOfSubjectLink() { return _listSubjectLink; };
215 virtual bool setValue(std::string value);
216 void setExecValue(std::string value);
217 std::string getExecValue();
218 void registerUndoDestroy();
220 YACS::ENGINE::DataPort *_dataPort;
221 std::list<SubjectLink*> _listSubjectLink;
222 std::string _execValue;
225 class SubjectInputPort: public SubjectDataPort
228 SubjectInputPort(YACS::ENGINE::InputPort *port, Subject *parent);
229 virtual ~SubjectInputPort();
230 virtual void clean(Command *command=0);
231 void localclean(Command *command=0);
232 virtual bool setValue(std::string value);
233 virtual TypeOfElem getType(){return INPUTPORT;}
235 YACS::ENGINE::InputPort *_inputPort;
238 class SubjectOutputPort: public SubjectDataPort
241 SubjectOutputPort(YACS::ENGINE::OutputPort *port, Subject *parent);
242 virtual ~SubjectOutputPort();
243 virtual void clean(Command *command=0);
244 void localclean(Command *command=0);
245 virtual bool setValue(std::string value);
246 virtual TypeOfElem getType(){return OUTPUTPORT;}
248 YACS::ENGINE::OutputPort *_outputPort;
251 class SubjectInputDataStreamPort: public SubjectDataPort
254 SubjectInputDataStreamPort(YACS::ENGINE::InputDataStreamPort *port, Subject *parent);
255 virtual ~SubjectInputDataStreamPort();
256 virtual bool setProperties(std::map<std::string, std::string> properties);
257 virtual std::map<std::string, std::string> getProperties();
258 virtual std::vector<std::string> knownProperties();
259 virtual void clean(Command *command=0);
260 void localclean(Command *command=0);
261 virtual TypeOfElem getType(){return INPUTDATASTREAMPORT;}
262 void registerUndoDestroy();
264 YACS::ENGINE::InputDataStreamPort *_inputDataStreamPort;
267 class SubjectOutputDataStreamPort: public SubjectDataPort
270 SubjectOutputDataStreamPort(YACS::ENGINE::OutputDataStreamPort *port, Subject *parent);
271 virtual ~SubjectOutputDataStreamPort();
272 virtual bool setProperties(std::map<std::string, std::string> properties);
273 virtual std::map<std::string, std::string> getProperties();
274 virtual void clean(Command *command=0);
275 void localclean(Command *command=0);
276 virtual TypeOfElem getType(){return OUTPUTDATASTREAMPORT;}
277 void registerUndoDestroy();
279 YACS::ENGINE::OutputDataStreamPort *_outputDataStreamPort;
283 class HMI_EXPORT SubjectNode: public Subject
286 friend class CommandAddInputPortFromCatalog;
287 friend class CommandAddOutputPortFromCatalog;
288 friend class CommandAddIDSPortFromCatalog;
289 friend class CommandAddODSPortFromCatalog;
290 SubjectNode(YACS::ENGINE::Node *node, Subject *parent);
291 virtual ~SubjectNode();
292 virtual bool setProperties(std::map<std::string, std::string> properties);
293 virtual std::map<std::string, std::string> getProperties();
294 virtual bool reparent(Subject* parent);
295 virtual bool copy(Subject* parent);
296 virtual std::string getName();
297 virtual bool setName(std::string name);
298 virtual YACS::ENGINE::Node* getNode();
299 virtual void clean(Command *command=0);
300 void registerUndoDestroy();
301 SubjectControlLink* addSubjectControlLink(SubjectControlLink *sub) { _listSubjectControlLink.push_back(sub); return sub; };
302 void removeSubjectControlLink(SubjectControlLink* sub) { _listSubjectControlLink.remove(sub); };
303 std::list<SubjectLink*> getSubjectLinks() const { return _listSubjectLink; };
304 std::list<SubjectControlLink*> getSubjectControlLinks() const { return _listSubjectControlLink; };
305 std::list<SubjectInputPort*> getSubjectInputPorts() const { return _listSubjectInputPort; };
306 std::list<SubjectOutputPort*> getSubjectOutputPorts() const { return _listSubjectOutputPort; };
307 std::list<SubjectInputDataStreamPort*> getSubjectInputDataStreamPorts() const { return _listSubjectIDSPort; };
308 std::list<SubjectOutputDataStreamPort*> getSubjectOutputDataStreamPorts() const { return _listSubjectODSPort; };
309 void localclean(Command *command=0);
310 virtual void update(GuiEvent event, int type, Subject* son);
311 virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
312 virtual void removeExternalLinks();
313 virtual void removeExternalControlLinks();
314 virtual void saveLinks();
315 virtual void restoreLinks();
316 virtual bool putInComposedNode(std::string name,std::string type, bool toSaveRestoreLinks=true);
317 virtual int isValid();
318 void setExecState(int execState);
319 static bool tryCreateLink(SubjectNode *subOutNode, SubjectNode *subInNode);
322 virtual SubjectInputPort* addSubjectInputPort(YACS::ENGINE::InputPort *port,
323 std::string name = "");
324 virtual SubjectOutputPort* addSubjectOutputPort(YACS::ENGINE::OutputPort *port,
325 std::string name = "");
326 virtual SubjectInputDataStreamPort* addSubjectIDSPort(YACS::ENGINE::InputDataStreamPort *port,
327 std::string name = "");
328 virtual SubjectOutputDataStreamPort* addSubjectODSPort(YACS::ENGINE::OutputDataStreamPort *port,
329 std::string name = "");
330 virtual void notifyObserver(YACS::ENGINE::Node* object,const std::string& event);
332 YACS::ENGINE::Node *_node;
333 std::list<SubjectInputPort*> _listSubjectInputPort;
334 std::list<SubjectOutputPort*> _listSubjectOutputPort;
335 std::list<SubjectInputDataStreamPort*> _listSubjectIDSPort;
336 std::list<SubjectOutputDataStreamPort*> _listSubjectODSPort;
337 std::list<SubjectLink*> _listSubjectLink;
338 std::list<SubjectControlLink*> _listSubjectControlLink;
340 std::list<YACS::ENGINE::OutGate *> loutgate;
341 std::set<YACS::ENGINE::InGate *> singate;
342 std::vector< std::pair<YACS::ENGINE::OutPort *, YACS::ENGINE::InPort *> > dataLinks;
343 std::vector< std::pair<YACS::ENGINE::OutPort *, YACS::ENGINE::InPort *> > dataflowLinks;
346 class SubjectComposedNode: public SubjectNode
349 SubjectComposedNode(YACS::ENGINE::ComposedNode *composedNode, Subject *parent);
350 virtual ~SubjectComposedNode();
351 virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
356 virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const { return 0; }
357 virtual void loadChildren();
358 virtual void loadLinks();
359 virtual void completeChildrenSubjectList(SubjectNode *son);
360 SubjectNode* addSubjectNode(YACS::ENGINE::Node * node,
361 std::string name = "",
362 YACS::ENGINE::Catalog *catalog = 0,
363 std::string compo = "",
364 std::string type ="");
365 SubjectLink* addSubjectLink(SubjectNode *sno,
366 SubjectDataPort *spo,
368 SubjectDataPort *spi);
369 SubjectControlLink* addSubjectControlLink(SubjectNode *sno,
371 virtual void removeLink(SubjectLink* link);
372 virtual void removeControlLink(SubjectControlLink* link);
373 virtual void removeExternalControlLinks();
374 virtual void houseKeepingAfterCutPaste(bool isCut, SubjectNode *son);
375 virtual bool hasValue();
376 virtual std::string getValue();
377 virtual void clean(Command *command=0);
378 void localclean(Command *command=0);
379 static SubjectComposedNode* getLowestCommonAncestor(SubjectNode* snode1, SubjectNode* snode2);
381 virtual SubjectNode *createNode(YACS::ENGINE::Catalog *catalog,
387 YACS::ENGINE::ComposedNode *_composedNode;
390 class SubjectBloc: public SubjectComposedNode
393 SubjectBloc(YACS::ENGINE::Bloc *bloc, Subject *parent);
394 virtual ~SubjectBloc();
395 virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
400 virtual void removeNode(SubjectNode* child);
401 virtual void completeChildrenSubjectList(SubjectNode *son);
402 virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const;
403 virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
404 virtual void houseKeepingAfterCutPaste(bool isCut, SubjectNode *son);
405 virtual void clean(Command *command=0);
406 void localclean(Command *command=0);
407 virtual TypeOfElem getType(){return BLOC;}
409 YACS::ENGINE::Bloc *_bloc;
410 std::set<SubjectNode*> _children;
413 class SubjectComponent;
414 class HMI_EXPORT SubjectContainer: public Subject
417 SubjectContainer(YACS::ENGINE::Container* container, Subject *parent);
418 virtual ~SubjectContainer();
419 virtual std::string getName();
420 virtual bool setName(std::string name);
421 virtual std::map<std::string, std::string> getProperties();
422 virtual bool setProperties(std::map<std::string, std::string> properties);
423 virtual SubjectReference* attachComponent(SubjectComponent* component);
424 virtual void detachComponent(SubjectComponent* component);
425 virtual void moveComponent(SubjectReference* reference);
426 virtual void removeSubComponentFromSet(SubjectComponent *component);
427 virtual void notifyComponentsChange(GuiEvent event, int type, Subject* son);
428 virtual void clean(Command *command=0);
429 void localclean(Command *command=0);
430 YACS::ENGINE::Container* getContainer() const;
431 bool isUsed() {return !_subComponentSet.empty(); };
432 virtual TypeOfElem getType(){return CONTAINER;}
433 void registerUndoDestroy();
435 YACS::ENGINE::Container* _container;
436 std::set<SubjectComponent*> _subComponentSet;
437 std::map<SubjectComponent*,SubjectReference*> _subReferenceMap;
440 class SubjectServiceNode;
441 class HMI_EXPORT SubjectComponent: public Subject
444 friend class SubjectNode;
445 SubjectComponent(YACS::ENGINE::ComponentInstance* component, Subject *parent);
446 virtual ~SubjectComponent();
447 virtual std::string getName();
448 virtual void setContainer();
449 virtual bool associateToContainer(SubjectContainer* subcont);
450 virtual SubjectReference* attachService(SubjectServiceNode* service);
451 virtual void detachService(SubjectServiceNode* service);
452 virtual void moveService(SubjectReference* reference);
453 virtual void removeSubServiceFromSet(SubjectServiceNode *service);
454 virtual bool setProperties(std::map<std::string, std::string> properties);
455 virtual std::map<std::string, std::string> getProperties();
456 virtual void notifyServicesChange(GuiEvent event, int type, Subject* son);
457 virtual std::pair<std::string, int> getKey();
458 virtual void clean(Command *command=0);
459 bool hasServices() { return !_subServiceSet.empty(); };
460 void localclean(Command *command=0);
461 YACS::ENGINE::ComponentInstance* getComponent() const;
462 virtual TypeOfElem getType(){return COMPONENT;}
463 SubjectReference* _subRefContainer;
466 YACS::ENGINE::ComponentInstance* _compoInst;
467 std::set<SubjectServiceNode*> _subServiceSet;
468 std::map<SubjectServiceNode*,SubjectReference*> _subReferenceMap;
471 class SubjectDataType: public Subject
474 SubjectDataType(YACS::ENGINE::TypeCode *typeCode, Subject *parent, std::string alias);
475 virtual ~SubjectDataType();
476 virtual std::string getName();
477 virtual std::string getAlias();
478 virtual YACS::ENGINE::TypeCode* getTypeCode();
479 virtual void clean(Command *command=0);
480 void localclean(Command *command=0);
481 virtual TypeOfElem getType(){return DATATYPE;}
483 YACS::ENGINE::TypeCode *_typeCode;
487 class SubjectProc: public SubjectBloc
490 SubjectProc(YACS::ENGINE::Proc *proc, Subject *parent);
491 virtual ~SubjectProc();
493 void loadComponents();
494 void loadContainers();
496 virtual SubjectComponent* addComponent(std::string compoName, std::string containerName="");
497 virtual SubjectContainer* addContainer(std::string name, std::string ref="");
498 virtual bool addDataType(YACS::ENGINE::Catalog* catalog, std::string typeName);
499 SubjectComponent* addSubjectComponent(YACS::ENGINE::ComponentInstance* compo);
500 SubjectContainer* addSubjectContainer(YACS::ENGINE::Container* cont,
501 std::string name = "");
502 SubjectDataType* addComSubjectDataType(YACS::ENGINE::TypeCode *type, std::string alias);
503 SubjectDataType* addSubjectDataType(YACS::ENGINE::TypeCode *type, std::string alias);
504 void removeSubjectDataType(std::string typeName);
505 void removeSubjectContainer(SubjectContainer* scont);
506 virtual void clean(Command *command=0);
507 void localclean(Command *command=0);
508 void addPostErase(Subject* sub) {_postEraseList.push_back(sub); };
509 void cleanPostErase();
510 virtual TypeOfElem getType(){return SALOMEPROC;}
512 YACS::ENGINE::Proc *_proc;
513 std::vector<Subject*> _postEraseList;
516 class SubjectForLoop: public SubjectComposedNode
519 SubjectForLoop(YACS::ENGINE::ForLoop *forLoop, Subject *parent);
520 virtual ~SubjectForLoop();
521 virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
526 virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
527 virtual void completeChildrenSubjectList(SubjectNode *son);
528 virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const { return _body; }
529 virtual bool setNbSteps(std::string nbSteps);
530 virtual bool hasValue();
531 virtual std::string getValue();
532 virtual void houseKeepingAfterCutPaste(bool isCut, SubjectNode *son);
533 virtual void clean(Command *command=0);
534 void localclean(Command *command=0);
535 virtual TypeOfElem getType(){return FORLOOP;}
537 YACS::ENGINE::ForLoop *_forLoop;
541 class SubjectWhileLoop: public SubjectComposedNode
544 SubjectWhileLoop(YACS::ENGINE::WhileLoop *whileLoop, Subject *parent);
545 virtual ~SubjectWhileLoop();
546 virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
551 virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
552 virtual void completeChildrenSubjectList(SubjectNode *son);
553 virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const { return _body; }
554 virtual bool setCondition(std::string condition);
555 virtual bool hasValue();
556 virtual std::string getValue();
557 virtual void houseKeepingAfterCutPaste(bool isCut, SubjectNode *son);
558 virtual void clean(Command *command=0);
559 void localclean(Command *command=0);
560 virtual TypeOfElem getType(){return WHILELOOP;}
562 YACS::ENGINE::WhileLoop *_whileLoop;
566 class HMI_EXPORT SubjectSwitch: public SubjectComposedNode
569 SubjectSwitch(YACS::ENGINE::Switch *aSwitch, Subject *parent);
570 virtual ~SubjectSwitch();
571 virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
577 bool replace = false);
578 virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
579 virtual void removeNode(SubjectNode* son);
580 std::map<int, SubjectNode*> getBodyMap();
581 virtual void completeChildrenSubjectList(SubjectNode *son);
582 virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const;
583 virtual bool setSelect(std::string select);
584 virtual bool setCase(std::string caseId, SubjectNode* snode);
585 virtual bool hasValue();
586 virtual std::string getValue();
587 virtual void houseKeepingAfterCutPaste(bool isCut, SubjectNode *son);
588 virtual void clean(Command *command=0);
589 void localclean(Command *command=0);
590 virtual TypeOfElem getType(){return SWITCH;}
592 YACS::ENGINE::Switch *_switch;
593 std::map<int, SubjectNode*> _bodyMap;
596 class SubjectDynParaLoop: public SubjectComposedNode
599 SubjectDynParaLoop(YACS::ENGINE::DynParaLoop * dynParaLoop, Subject * parent);
600 virtual ~SubjectDynParaLoop();
601 virtual SubjectNode * addNode(YACS::ENGINE::Catalog * catalog,
606 virtual void recursiveUpdate(GuiEvent event, int type, Subject * son);
607 virtual void completeChildrenSubjectList(SubjectNode * son);
608 virtual void removeNode(SubjectNode * child);
609 virtual SubjectNode * getChild(YACS::ENGINE::Node * node = NULL) const;
610 virtual bool setNbBranches(std::string nbBranches);
611 virtual bool hasValue();
612 virtual std::string getValue();
613 virtual void houseKeepingAfterCutPaste(bool isCut, SubjectNode * son);
614 virtual void clean(Command * command = NULL);
615 void localclean(Command * command = NULL);
617 YACS::ENGINE::DynParaLoop * _dynParaLoop;
618 SubjectNode * _subjectExecNode;
619 SubjectNode * _subjectInitNode;
620 SubjectNode * _subjectFinalizeNode;
623 class SubjectForEachLoop: public SubjectDynParaLoop
626 SubjectForEachLoop(YACS::ENGINE::ForEachLoop *forEachLoop, Subject *parent);
627 virtual ~SubjectForEachLoop();
628 virtual void completeChildrenSubjectList(SubjectNode *son);
629 virtual void removeNode(SubjectNode * child);
630 virtual void clean(Command *command=0);
631 void localclean(Command *command=0);
632 virtual TypeOfElem getType(){return FOREACHLOOP;}
634 YACS::ENGINE::ForEachLoop *_forEachLoop;
635 SubjectNode* _splitter;
638 class SubjectOptimizerLoop: public SubjectDynParaLoop
641 SubjectOptimizerLoop(YACS::ENGINE::OptimizerLoop *optimizerLoop, Subject *parent);
642 virtual ~SubjectOptimizerLoop();
643 virtual void clean(Command *command=0);
644 void localclean(Command *command=0);
645 virtual TypeOfElem getType(){return OPTIMIZERLOOP;}
646 virtual bool setAlgorithm(const std::string& alglib,const std::string& symbol);
648 YACS::ENGINE::OptimizerLoop *_optimizerLoop;
651 class SubjectElementaryNode: public SubjectNode
654 SubjectElementaryNode(YACS::ENGINE::ElementaryNode *elementaryNode, Subject *parent);
655 virtual ~SubjectElementaryNode();
656 virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
657 virtual SubjectDataPort* addInputPort(YACS::ENGINE::Catalog *catalog, std::string type, std::string name);
658 virtual SubjectDataPort* addOutputPort(YACS::ENGINE::Catalog *catalog, std::string type, std::string name);
659 virtual SubjectDataPort* addIDSPort(YACS::ENGINE::Catalog *catalog, std::string type, std::string name);
660 virtual SubjectDataPort* addODSPort(YACS::ENGINE::Catalog *catalog, std::string type, std::string name);
661 virtual bool OrderDataPorts(SubjectDataPort* portToMove, int isUp);
662 virtual void removePort(SubjectDataPort* port);
663 virtual void loadChildren();
664 virtual void clean(Command *command=0);
665 void localclean(Command *command=0);
666 virtual void saveLinks();
667 virtual void restoreLinks();
669 YACS::ENGINE::ElementaryNode *_elementaryNode;
672 class SubjectInlineNode: public SubjectElementaryNode
675 SubjectInlineNode(YACS::ENGINE::InlineNode *inlineNode, Subject *parent);
676 virtual ~SubjectInlineNode();
677 virtual bool setScript(std::string script);
678 virtual std::string getScript();
679 virtual void clean(Command *command=0);
680 void localclean(Command *command=0);
681 virtual bool setContainer(SubjectContainer* scont);
682 virtual bool setExecutionMode(const std::string& mode);
684 YACS::ENGINE::InlineNode *_inlineNode;
687 class SubjectPythonNode: public SubjectInlineNode
690 SubjectPythonNode(YACS::ENGINE::PythonNode *pythonNode, Subject *parent);
691 virtual ~SubjectPythonNode();
692 virtual void clean(Command *command=0);
693 void localclean(Command *command=0);
694 virtual TypeOfElem getType(){return PYTHONNODE;}
696 YACS::ENGINE::PythonNode *_pythonNode;
699 class SubjectPyFuncNode: public SubjectInlineNode
702 SubjectPyFuncNode(YACS::ENGINE::PyFuncNode *pyFuncNode, Subject *parent);
703 virtual ~SubjectPyFuncNode();
704 virtual bool setFunctionName(std::string funcName);
705 virtual void clean(Command *command=0);
706 void localclean(Command *command=0);
707 virtual TypeOfElem getType(){return PYFUNCNODE;}
709 YACS::ENGINE::PyFuncNode *_pyFuncNode;
712 class SubjectServiceNode: public SubjectElementaryNode
714 friend class CommandAssociateServiceToComponent;
715 friend class CommandAddComponentFromCatalog;
717 SubjectServiceNode(YACS::ENGINE::ServiceNode *serviceNode, Subject *parent);
718 virtual ~SubjectServiceNode();
719 virtual void setComponentFromCatalog(YACS::ENGINE::Catalog *catalog,
721 std::string service);
722 virtual void setComponent();
723 virtual bool associateToComponent(SubjectComponent *subcomp);
724 virtual void removeSubRefComponent() { _subRefComponent = 0; };
725 virtual void removeSubjectReference(){ _subjectReference = 0; };
726 virtual void addSubjectReference(Subject *ref);
727 virtual SubjectReference* getSubjectReference();
728 virtual void clean(Command *command=0);
729 void localclean(Command *command=0);
731 YACS::ENGINE::ServiceNode *_serviceNode;
732 SubjectReference* _subjectReference;
733 SubjectReference* _subRefComponent;
736 class SubjectCORBANode: public SubjectServiceNode
739 SubjectCORBANode(YACS::ENGINE::CORBANode *corbaNode, Subject *parent);
740 virtual ~SubjectCORBANode();
741 virtual void clean(Command *command=0);
742 void localclean(Command *command=0);
743 virtual TypeOfElem getType(){return CORBANODE;}
745 YACS::ENGINE::CORBANode *_corbaNode;
748 class SubjectCppNode: public SubjectServiceNode
751 SubjectCppNode(YACS::ENGINE::CppNode *cppNode, Subject *parent);
752 virtual ~SubjectCppNode();
753 virtual void clean(Command *command=0);
754 void localclean(Command *command=0);
755 virtual TypeOfElem getType(){return CPPNODE;}
757 YACS::ENGINE::CppNode *_cppNode;
760 class SubjectSalomeNode: public SubjectServiceNode
763 SubjectSalomeNode(YACS::ENGINE::SalomeNode *salomeNode, Subject *parent);
764 virtual ~SubjectSalomeNode();
765 virtual void clean(Command *command=0);
766 void localclean(Command *command=0);
767 virtual TypeOfElem getType(){return SALOMENODE;}
769 YACS::ENGINE::SalomeNode *_salomeNode;
772 class SubjectSalomePythonNode: public SubjectServiceNode
775 SubjectSalomePythonNode(YACS::ENGINE::SalomePythonNode *salomePythonNode,
777 virtual ~SubjectSalomePythonNode();
778 virtual void clean(Command *command=0);
779 void localclean(Command *command=0);
780 virtual TypeOfElem getType(){return SALOMEPYTHONNODE;}
782 YACS::ENGINE::SalomePythonNode *_salomePythonNode;
785 class SubjectXmlNode: public SubjectServiceNode
788 SubjectXmlNode(YACS::ENGINE::XmlNode *xmlNode, Subject *parent);
789 virtual ~SubjectXmlNode();
790 virtual void clean(Command *command=0);
791 void localclean(Command *command=0);
792 virtual TypeOfElem getType(){return XMLNODE;}
794 YACS::ENGINE::XmlNode *_xmlNode;
797 class SubjectSplitterNode: public SubjectElementaryNode
800 SubjectSplitterNode(YACS::ENGINE::SplitterNode *splitterNode, Subject *parent);
801 virtual ~SubjectSplitterNode();
802 virtual std::string getName();
803 virtual void clean(Command *command=0);
804 void localclean(Command *command=0);
805 virtual TypeOfElem getType(){return SPLITTERNODE;}
807 YACS::ENGINE::SplitterNode *_splitterNode;
810 class SubjectDataNode: public SubjectElementaryNode
813 SubjectDataNode(YACS::ENGINE::DataNode *dataNode, Subject *parent);
814 virtual ~SubjectDataNode();
815 virtual void clean(Command *command=0);
816 void localclean(Command *command=0);
818 YACS::ENGINE::DataNode *_dataNode;
821 class SubjectPresetNode: public SubjectDataNode
824 SubjectPresetNode(YACS::ENGINE::PresetNode *presetNode, Subject *parent);
825 virtual ~SubjectPresetNode();
826 virtual void clean(Command *command=0);
827 void localclean(Command *command=0);
828 virtual TypeOfElem getType(){return PRESETNODE;}
830 YACS::ENGINE::PresetNode *_presetNode;
833 class SubjectOutNode: public SubjectDataNode
836 SubjectOutNode(YACS::ENGINE::OutNode *outNode, Subject *parent);
837 virtual ~SubjectOutNode();
838 virtual void clean(Command *command=0);
839 void localclean(Command *command=0);
840 virtual TypeOfElem getType(){return OUTNODE;}
842 YACS::ENGINE::OutNode *_outNode;
845 class SubjectStudyInNode: public SubjectDataNode
848 SubjectStudyInNode(YACS::ENGINE::StudyInNode *studyInNode, Subject *parent);
849 virtual ~SubjectStudyInNode();
850 virtual void clean(Command *command=0);
851 void localclean(Command *command=0);
852 virtual TypeOfElem getType(){return STUDYINNODE;}
854 YACS::ENGINE::StudyInNode *_studyInNode;
857 class SubjectStudyOutNode: public SubjectDataNode
860 SubjectStudyOutNode(YACS::ENGINE::StudyOutNode *studyOutNode, Subject *parent);
861 virtual ~SubjectStudyOutNode();
862 virtual void clean(Command *command=0);
863 void localclean(Command *command=0);
864 virtual TypeOfElem getType(){return STUDYOUTNODE;}
866 YACS::ENGINE::StudyOutNode *_studyOutNode;
869 class SubjectLink: public Subject
872 SubjectLink(SubjectNode* subOutNode,
873 SubjectDataPort* outPort,
874 SubjectNode* subInNode,
875 SubjectDataPort* inPort,
877 virtual ~SubjectLink();
878 virtual std::string getName();
879 virtual void clean(Command *command=0);
880 void localclean(Command *command=0);
881 SubjectNode* getSubjectOutNode() { return _subOutNode; };
882 SubjectNode* getSubjectInNode() { return _subInNode; };
883 SubjectDataPort* getSubjectOutPort() { return _outPort; };
884 SubjectDataPort* getSubjectInPort() { return _inPort; };
885 virtual bool setProperties(std::map<std::string, std::string> properties);
886 virtual std::map<std::string, std::string> getProperties();
887 virtual std::vector<std::string> knownProperties();
888 virtual TypeOfElem getType(){return DATALINK;}
889 void registerUndoDestroy();
891 SubjectNode* _subOutNode;
892 SubjectDataPort* _outPort;
893 SubjectNode* _subInNode;
894 SubjectDataPort* _inPort;
896 YACS::ENGINE::ComposedNode *_cla;
897 YACS::ENGINE::OutPort *_outp;
898 YACS::ENGINE::InPort *_inp;
901 class SubjectControlLink: public Subject
904 SubjectControlLink(SubjectNode* subOutNode,
905 SubjectNode* subInNode,
907 virtual ~SubjectControlLink();
908 virtual std::string getName();
909 virtual void clean(Command *command=0);
910 void localclean(Command *command=0);
911 SubjectNode* getSubjectOutNode() { return _subOutNode; };
912 SubjectNode* getSubjectInNode() { return _subInNode; };
913 virtual TypeOfElem getType(){return CONTROLLINK;}
914 void registerUndoDestroy();
916 SubjectNode* _subOutNode;
917 SubjectNode* _subInNode;
919 YACS::ENGINE::ComposedNode *_cla;