1 // Copyright (C) 2006-2012 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.
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;
113 class SubjectReference;
114 class HMI_EXPORT Subject: public YACS::ENGINE::Observer
117 friend class CommandReparentNode;
118 Subject(Subject *parent=0);
120 virtual void attach(GuiObserver *obs);
121 virtual void detach(GuiObserver *obs);
122 virtual void select(bool isSelected);
123 virtual void update(GuiEvent event, int type, Subject* son);
124 virtual std::string getName();
125 virtual bool setName(std::string name);
126 virtual bool setProperties(std::map<std::string, std::string> properties);
127 virtual std::map<std::string, std::string> getProperties();
128 virtual std::vector<std::string> knownProperties();
129 virtual Subject* getParent();
130 virtual void setParent(Subject* son);
131 virtual bool destroy(Subject *son);
132 virtual void loadChildren();
133 virtual void loadLinks();
134 virtual void addSubjectReference(Subject *ref);
135 virtual void clean(Command *command=0);
136 void localclean(Command *command=0);
137 void registerUndoDestroy();
138 void askRegisterUndoDestroy() {_askRegisterUndo=true; };
139 bool isDestructible() { return _destructible; };
140 static void erase(Subject* sub, Command *command=0, bool post=false);
141 virtual TypeOfElem getType(){return UNKNOWN;}
143 std::set<GuiObserver *> _setObs;
146 bool _askRegisterUndo;
149 class HMI_EXPORT GuiObserver
153 virtual ~GuiObserver();
154 virtual void select(bool isSelected);
155 virtual void update(GuiEvent event, int type, Subject* son);
156 virtual void incrementSubjects(Subject *subject);
157 virtual void decrementSubjects(Subject *subject);
159 bool isDestructible() { return _destructible; };
160 static std::string eventName(GuiEvent event);
161 static void setEventMap();
163 std::set<Subject*> _subjectSet;
165 static std::map<int, std::string> _eventNameMap;
168 class HMI_EXPORT SubjectObserver:public GuiObserver
171 SubjectObserver(Subject* ref);
172 virtual ~SubjectObserver();
173 virtual void select(bool isSelected);
174 virtual void update(GuiEvent event, int type, Subject* son);
179 class SubjectReference: public Subject
182 SubjectReference(Subject* ref, Subject *parent);
183 virtual ~SubjectReference();
184 virtual std::string getName();
185 virtual Subject* getReference() const;
186 virtual void reparent(Subject *parent);
187 virtual void clean(Command *command=0);
188 void localclean(Command *command=0);
189 virtual TypeOfElem getType(){return REFERENCE;}
192 SubjectObserver* _sobs;
196 class SubjectControlLink;
197 class HMI_EXPORT SubjectDataPort: public Subject
200 SubjectDataPort(YACS::ENGINE::DataPort* port, Subject *parent);
201 virtual ~SubjectDataPort();
202 virtual std::string getName();
203 virtual bool setName(std::string name);
204 virtual YACS::ENGINE::DataPort* getPort();
205 static bool tryCreateLink(SubjectDataPort *subOutport, SubjectDataPort *subInport,bool control=true);
206 virtual void clean(Command *command=0);
207 void localclean(Command *command=0);
208 void addSubjectLink(SubjectLink* subject) { _listSubjectLink.push_back(subject); };
209 void removeSubjectLink(SubjectLink* subject) { _listSubjectLink.remove(subject); };
210 std::list<SubjectLink*> getListOfSubjectLink() { return _listSubjectLink; };
211 virtual bool setValue(std::string value);
212 void setExecValue(std::string value);
213 std::string getExecValue();
214 void registerUndoDestroy();
216 YACS::ENGINE::DataPort *_dataPort;
217 std::list<SubjectLink*> _listSubjectLink;
218 std::string _execValue;
221 class SubjectInputPort: public SubjectDataPort
224 SubjectInputPort(YACS::ENGINE::InputPort *port, Subject *parent);
225 virtual ~SubjectInputPort();
226 virtual void clean(Command *command=0);
227 void localclean(Command *command=0);
228 virtual bool setValue(std::string value);
229 virtual TypeOfElem getType(){return INPUTPORT;}
231 YACS::ENGINE::InputPort *_inputPort;
234 class SubjectOutputPort: public SubjectDataPort
237 SubjectOutputPort(YACS::ENGINE::OutputPort *port, Subject *parent);
238 virtual ~SubjectOutputPort();
239 virtual void clean(Command *command=0);
240 void localclean(Command *command=0);
241 virtual bool setValue(std::string value);
242 virtual TypeOfElem getType(){return OUTPUTPORT;}
244 YACS::ENGINE::OutputPort *_outputPort;
247 class SubjectInputDataStreamPort: public SubjectDataPort
250 SubjectInputDataStreamPort(YACS::ENGINE::InputDataStreamPort *port, Subject *parent);
251 virtual ~SubjectInputDataStreamPort();
252 virtual bool setProperties(std::map<std::string, std::string> properties);
253 virtual std::map<std::string, std::string> getProperties();
254 virtual std::vector<std::string> knownProperties();
255 virtual void clean(Command *command=0);
256 void localclean(Command *command=0);
257 virtual TypeOfElem getType(){return INPUTDATASTREAMPORT;}
258 void registerUndoDestroy();
260 YACS::ENGINE::InputDataStreamPort *_inputDataStreamPort;
263 class SubjectOutputDataStreamPort: public SubjectDataPort
266 SubjectOutputDataStreamPort(YACS::ENGINE::OutputDataStreamPort *port, Subject *parent);
267 virtual ~SubjectOutputDataStreamPort();
268 virtual bool setProperties(std::map<std::string, std::string> properties);
269 virtual std::map<std::string, std::string> getProperties();
270 virtual void clean(Command *command=0);
271 void localclean(Command *command=0);
272 virtual TypeOfElem getType(){return OUTPUTDATASTREAMPORT;}
273 void registerUndoDestroy();
275 YACS::ENGINE::OutputDataStreamPort *_outputDataStreamPort;
279 class HMI_EXPORT SubjectNode: public Subject
282 friend class CommandAddInputPortFromCatalog;
283 friend class CommandAddOutputPortFromCatalog;
284 friend class CommandAddIDSPortFromCatalog;
285 friend class CommandAddODSPortFromCatalog;
286 SubjectNode(YACS::ENGINE::Node *node, Subject *parent);
287 virtual ~SubjectNode();
288 virtual bool setProperties(std::map<std::string, std::string> properties);
289 virtual std::map<std::string, std::string> getProperties();
290 virtual bool reparent(Subject* parent);
291 virtual bool copy(Subject* parent);
292 virtual std::string getName();
293 virtual bool setName(std::string name);
294 virtual YACS::ENGINE::Node* getNode();
295 virtual void clean(Command *command=0);
296 void registerUndoDestroy();
297 SubjectControlLink* addSubjectControlLink(SubjectControlLink *sub) { _listSubjectControlLink.push_back(sub); return sub; };
298 void removeSubjectControlLink(SubjectControlLink* sub) { _listSubjectControlLink.remove(sub); };
299 std::list<SubjectLink*> getSubjectLinks() const { return _listSubjectLink; };
300 std::list<SubjectControlLink*> getSubjectControlLinks() const { return _listSubjectControlLink; };
301 std::list<SubjectInputPort*> getSubjectInputPorts() const { return _listSubjectInputPort; };
302 std::list<SubjectOutputPort*> getSubjectOutputPorts() const { return _listSubjectOutputPort; };
303 std::list<SubjectInputDataStreamPort*> getSubjectInputDataStreamPorts() const { return _listSubjectIDSPort; };
304 std::list<SubjectOutputDataStreamPort*> getSubjectOutputDataStreamPorts() const { return _listSubjectODSPort; };
305 void localclean(Command *command=0);
306 virtual void update(GuiEvent event, int type, Subject* son);
307 virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
308 virtual void removeExternalLinks();
309 virtual void removeExternalControlLinks();
310 virtual void saveLinks();
311 virtual void restoreLinks();
312 virtual bool putInComposedNode(std::string name,std::string type, bool toSaveRestoreLinks=true);
313 virtual int isValid();
314 void setExecState(int execState);
315 static bool tryCreateLink(SubjectNode *subOutNode, SubjectNode *subInNode);
318 virtual SubjectInputPort* addSubjectInputPort(YACS::ENGINE::InputPort *port,
319 std::string name = "");
320 virtual SubjectOutputPort* addSubjectOutputPort(YACS::ENGINE::OutputPort *port,
321 std::string name = "");
322 virtual SubjectInputDataStreamPort* addSubjectIDSPort(YACS::ENGINE::InputDataStreamPort *port,
323 std::string name = "");
324 virtual SubjectOutputDataStreamPort* addSubjectODSPort(YACS::ENGINE::OutputDataStreamPort *port,
325 std::string name = "");
326 virtual void notifyObserver(YACS::ENGINE::Node* object,const std::string& event);
328 YACS::ENGINE::Node *_node;
329 std::list<SubjectInputPort*> _listSubjectInputPort;
330 std::list<SubjectOutputPort*> _listSubjectOutputPort;
331 std::list<SubjectInputDataStreamPort*> _listSubjectIDSPort;
332 std::list<SubjectOutputDataStreamPort*> _listSubjectODSPort;
333 std::list<SubjectLink*> _listSubjectLink;
334 std::list<SubjectControlLink*> _listSubjectControlLink;
336 std::list<YACS::ENGINE::OutGate *> loutgate;
337 std::set<YACS::ENGINE::InGate *> singate;
338 std::vector< std::pair<YACS::ENGINE::OutPort *, YACS::ENGINE::InPort *> > dataLinks;
339 std::vector< std::pair<YACS::ENGINE::OutPort *, YACS::ENGINE::InPort *> > dataflowLinks;
342 class SubjectComposedNode: public SubjectNode
345 SubjectComposedNode(YACS::ENGINE::ComposedNode *composedNode, Subject *parent);
346 virtual ~SubjectComposedNode();
347 virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
352 virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const { return 0; }
353 virtual void loadChildren();
354 virtual void loadLinks();
355 virtual void completeChildrenSubjectList(SubjectNode *son);
356 SubjectNode* addSubjectNode(YACS::ENGINE::Node * node,
357 std::string name = "",
358 YACS::ENGINE::Catalog *catalog = 0,
359 std::string compo = "",
360 std::string type ="");
361 SubjectLink* addSubjectLink(SubjectNode *sno,
362 SubjectDataPort *spo,
364 SubjectDataPort *spi);
365 SubjectControlLink* addSubjectControlLink(SubjectNode *sno,
367 virtual void removeLink(SubjectLink* link);
368 virtual void removeControlLink(SubjectControlLink* link);
369 virtual void removeExternalControlLinks();
370 virtual void houseKeepingAfterCutPaste(bool isCut, SubjectNode *son);
371 virtual bool hasValue();
372 virtual std::string getValue();
373 virtual void clean(Command *command=0);
374 void localclean(Command *command=0);
375 static SubjectComposedNode* getLowestCommonAncestor(SubjectNode* snode1, SubjectNode* snode2);
377 virtual SubjectNode *createNode(YACS::ENGINE::Catalog *catalog,
383 YACS::ENGINE::ComposedNode *_composedNode;
386 class SubjectBloc: public SubjectComposedNode
389 SubjectBloc(YACS::ENGINE::Bloc *bloc, Subject *parent);
390 virtual ~SubjectBloc();
391 virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
396 virtual void removeNode(SubjectNode* child);
397 virtual void completeChildrenSubjectList(SubjectNode *son);
398 virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const;
399 virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
400 virtual void houseKeepingAfterCutPaste(bool isCut, SubjectNode *son);
401 virtual void clean(Command *command=0);
402 void localclean(Command *command=0);
403 virtual TypeOfElem getType(){return BLOC;}
405 YACS::ENGINE::Bloc *_bloc;
406 std::set<SubjectNode*> _children;
409 class SubjectComponent;
410 class HMI_EXPORT SubjectContainer: public Subject
413 SubjectContainer(YACS::ENGINE::Container* container, Subject *parent);
414 virtual ~SubjectContainer();
415 virtual std::string getName();
416 virtual bool setName(std::string name);
417 virtual std::map<std::string, std::string> getProperties();
418 virtual bool setProperties(std::map<std::string, std::string> properties);
419 virtual SubjectReference* attachComponent(SubjectComponent* component);
420 virtual void detachComponent(SubjectComponent* component);
421 virtual void moveComponent(SubjectReference* reference);
422 virtual void removeSubComponentFromSet(SubjectComponent *component);
423 virtual void notifyComponentsChange(GuiEvent event, int type, Subject* son);
424 virtual void clean(Command *command=0);
425 void localclean(Command *command=0);
426 YACS::ENGINE::Container* getContainer() const;
427 bool isUsed() {return !_subComponentSet.empty(); };
428 virtual TypeOfElem getType(){return CONTAINER;}
429 void registerUndoDestroy();
431 YACS::ENGINE::Container* _container;
432 std::set<SubjectComponent*> _subComponentSet;
433 std::map<SubjectComponent*,SubjectReference*> _subReferenceMap;
436 class SubjectServiceNode;
437 class HMI_EXPORT SubjectComponent: public Subject
440 friend class SubjectNode;
441 SubjectComponent(YACS::ENGINE::ComponentInstance* component, Subject *parent);
442 virtual ~SubjectComponent();
443 virtual std::string getName();
444 virtual void setContainer();
445 virtual bool associateToContainer(SubjectContainer* subcont);
446 virtual SubjectReference* attachService(SubjectServiceNode* service);
447 virtual void detachService(SubjectServiceNode* service);
448 virtual void moveService(SubjectReference* reference);
449 virtual void removeSubServiceFromSet(SubjectServiceNode *service);
450 virtual bool setProperties(std::map<std::string, std::string> properties);
451 virtual std::map<std::string, std::string> getProperties();
452 virtual void notifyServicesChange(GuiEvent event, int type, Subject* son);
453 virtual std::pair<std::string, int> getKey();
454 virtual void clean(Command *command=0);
455 bool hasServices() { return !_subServiceSet.empty(); };
456 void localclean(Command *command=0);
457 YACS::ENGINE::ComponentInstance* getComponent() const;
458 virtual TypeOfElem getType(){return COMPONENT;}
459 SubjectReference* _subRefContainer;
462 YACS::ENGINE::ComponentInstance* _compoInst;
463 std::set<SubjectServiceNode*> _subServiceSet;
464 std::map<SubjectServiceNode*,SubjectReference*> _subReferenceMap;
467 class SubjectDataType: public Subject
470 SubjectDataType(YACS::ENGINE::TypeCode *typeCode, Subject *parent, std::string alias);
471 virtual ~SubjectDataType();
472 virtual std::string getName();
473 virtual std::string getAlias();
474 virtual YACS::ENGINE::TypeCode* getTypeCode();
475 virtual void clean(Command *command=0);
476 void localclean(Command *command=0);
477 virtual TypeOfElem getType(){return DATATYPE;}
479 YACS::ENGINE::TypeCode *_typeCode;
483 class SubjectProc: public SubjectBloc
486 SubjectProc(YACS::ENGINE::Proc *proc, Subject *parent);
487 virtual ~SubjectProc();
489 void loadComponents();
490 void loadContainers();
492 virtual SubjectComponent* addComponent(std::string compoName, std::string containerName="");
493 virtual SubjectContainer* addContainer(std::string name, std::string ref="");
494 virtual bool addDataType(YACS::ENGINE::Catalog* catalog, std::string typeName);
495 SubjectComponent* addSubjectComponent(YACS::ENGINE::ComponentInstance* compo);
496 SubjectContainer* addSubjectContainer(YACS::ENGINE::Container* cont,
497 std::string name = "");
498 SubjectDataType* addComSubjectDataType(YACS::ENGINE::TypeCode *type, std::string alias);
499 SubjectDataType* addSubjectDataType(YACS::ENGINE::TypeCode *type, std::string alias);
500 void removeSubjectDataType(std::string typeName);
501 void removeSubjectContainer(SubjectContainer* scont);
502 virtual void clean(Command *command=0);
503 void localclean(Command *command=0);
504 void addPostErase(Subject* sub) {_postEraseList.push_back(sub); };
505 void cleanPostErase();
506 virtual TypeOfElem getType(){return SALOMEPROC;}
508 YACS::ENGINE::Proc *_proc;
509 std::vector<Subject*> _postEraseList;
512 class SubjectForLoop: public SubjectComposedNode
515 SubjectForLoop(YACS::ENGINE::ForLoop *forLoop, Subject *parent);
516 virtual ~SubjectForLoop();
517 virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
522 virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
523 virtual void completeChildrenSubjectList(SubjectNode *son);
524 virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const { return _body; }
525 virtual bool setNbSteps(std::string nbSteps);
526 virtual bool hasValue();
527 virtual std::string getValue();
528 virtual void houseKeepingAfterCutPaste(bool isCut, SubjectNode *son);
529 virtual void clean(Command *command=0);
530 void localclean(Command *command=0);
531 virtual TypeOfElem getType(){return FORLOOP;}
533 YACS::ENGINE::ForLoop *_forLoop;
537 class SubjectWhileLoop: public SubjectComposedNode
540 SubjectWhileLoop(YACS::ENGINE::WhileLoop *whileLoop, Subject *parent);
541 virtual ~SubjectWhileLoop();
542 virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
547 virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
548 virtual void completeChildrenSubjectList(SubjectNode *son);
549 virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const { return _body; }
550 virtual bool setCondition(std::string condition);
551 virtual bool hasValue();
552 virtual std::string getValue();
553 virtual void houseKeepingAfterCutPaste(bool isCut, SubjectNode *son);
554 virtual void clean(Command *command=0);
555 void localclean(Command *command=0);
556 virtual TypeOfElem getType(){return WHILELOOP;}
558 YACS::ENGINE::WhileLoop *_whileLoop;
562 class HMI_EXPORT SubjectSwitch: public SubjectComposedNode
565 SubjectSwitch(YACS::ENGINE::Switch *aSwitch, Subject *parent);
566 virtual ~SubjectSwitch();
567 virtual SubjectNode* addNode(YACS::ENGINE::Catalog *catalog,
573 bool replace = false);
574 virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
575 virtual void removeNode(SubjectNode* son);
576 std::map<int, SubjectNode*> getBodyMap();
577 virtual void completeChildrenSubjectList(SubjectNode *son);
578 virtual SubjectNode* getChild(YACS::ENGINE::Node* node=0) const;
579 virtual bool setSelect(std::string select);
580 virtual bool setCase(std::string caseId, SubjectNode* snode);
581 virtual bool hasValue();
582 virtual std::string getValue();
583 virtual void houseKeepingAfterCutPaste(bool isCut, SubjectNode *son);
584 virtual void clean(Command *command=0);
585 void localclean(Command *command=0);
586 virtual TypeOfElem getType(){return SWITCH;}
588 YACS::ENGINE::Switch *_switch;
589 std::map<int, SubjectNode*> _bodyMap;
592 class SubjectDynParaLoop: public SubjectComposedNode
595 SubjectDynParaLoop(YACS::ENGINE::DynParaLoop * dynParaLoop, Subject * parent);
596 virtual ~SubjectDynParaLoop();
597 virtual SubjectNode * addNode(YACS::ENGINE::Catalog * catalog,
602 virtual void recursiveUpdate(GuiEvent event, int type, Subject * son);
603 virtual void completeChildrenSubjectList(SubjectNode * son);
604 virtual void removeNode(SubjectNode * child);
605 virtual SubjectNode * getChild(YACS::ENGINE::Node * node = NULL) const;
606 virtual bool setNbBranches(std::string nbBranches);
607 virtual bool hasValue();
608 virtual std::string getValue();
609 virtual void houseKeepingAfterCutPaste(bool isCut, SubjectNode * son);
610 virtual void clean(Command * command = NULL);
611 void localclean(Command * command = NULL);
613 YACS::ENGINE::DynParaLoop * _dynParaLoop;
614 SubjectNode * _subjectExecNode;
615 SubjectNode * _subjectInitNode;
616 SubjectNode * _subjectFinalizeNode;
619 class SubjectForEachLoop: public SubjectDynParaLoop
622 SubjectForEachLoop(YACS::ENGINE::ForEachLoop *forEachLoop, Subject *parent);
623 virtual ~SubjectForEachLoop();
624 virtual void completeChildrenSubjectList(SubjectNode *son);
625 virtual void removeNode(SubjectNode * child);
626 virtual void clean(Command *command=0);
627 void localclean(Command *command=0);
628 virtual TypeOfElem getType(){return FOREACHLOOP;}
630 YACS::ENGINE::ForEachLoop *_forEachLoop;
631 SubjectNode* _splitter;
634 class SubjectOptimizerLoop: public SubjectDynParaLoop
637 SubjectOptimizerLoop(YACS::ENGINE::OptimizerLoop *optimizerLoop, Subject *parent);
638 virtual ~SubjectOptimizerLoop();
639 virtual void clean(Command *command=0);
640 void localclean(Command *command=0);
641 virtual TypeOfElem getType(){return OPTIMIZERLOOP;}
642 virtual bool setAlgorithm(const std::string& alglib,const std::string& symbol);
644 YACS::ENGINE::OptimizerLoop *_optimizerLoop;
647 class SubjectElementaryNode: public SubjectNode
650 SubjectElementaryNode(YACS::ENGINE::ElementaryNode *elementaryNode, Subject *parent);
651 virtual ~SubjectElementaryNode();
652 virtual void recursiveUpdate(GuiEvent event, int type, Subject* son);
653 virtual SubjectDataPort* addInputPort(YACS::ENGINE::Catalog *catalog, std::string type, std::string name);
654 virtual SubjectDataPort* addOutputPort(YACS::ENGINE::Catalog *catalog, std::string type, std::string name);
655 virtual SubjectDataPort* addIDSPort(YACS::ENGINE::Catalog *catalog, std::string type, std::string name);
656 virtual SubjectDataPort* addODSPort(YACS::ENGINE::Catalog *catalog, std::string type, std::string name);
657 virtual bool OrderDataPorts(SubjectDataPort* portToMove, int isUp);
658 virtual void removePort(SubjectDataPort* port);
659 virtual void loadChildren();
660 virtual void clean(Command *command=0);
661 void localclean(Command *command=0);
662 virtual void saveLinks();
663 virtual void restoreLinks();
665 YACS::ENGINE::ElementaryNode *_elementaryNode;
668 class SubjectInlineNode: public SubjectElementaryNode
671 SubjectInlineNode(YACS::ENGINE::InlineNode *inlineNode, Subject *parent);
672 virtual ~SubjectInlineNode();
673 virtual bool setScript(std::string script);
674 virtual std::string getScript();
675 virtual void clean(Command *command=0);
676 void localclean(Command *command=0);
677 virtual bool setContainer(SubjectContainer* scont);
678 virtual bool setExecutionMode(const std::string& mode);
680 YACS::ENGINE::InlineNode *_inlineNode;
683 class SubjectPythonNode: public SubjectInlineNode
686 SubjectPythonNode(YACS::ENGINE::PythonNode *pythonNode, Subject *parent);
687 virtual ~SubjectPythonNode();
688 virtual void clean(Command *command=0);
689 void localclean(Command *command=0);
690 virtual TypeOfElem getType(){return PYTHONNODE;}
692 YACS::ENGINE::PythonNode *_pythonNode;
695 class SubjectPyFuncNode: public SubjectInlineNode
698 SubjectPyFuncNode(YACS::ENGINE::PyFuncNode *pyFuncNode, Subject *parent);
699 virtual ~SubjectPyFuncNode();
700 virtual bool setFunctionName(std::string funcName);
701 virtual void clean(Command *command=0);
702 void localclean(Command *command=0);
703 virtual TypeOfElem getType(){return PYFUNCNODE;}
705 YACS::ENGINE::PyFuncNode *_pyFuncNode;
708 class SubjectServiceNode: public SubjectElementaryNode
710 friend class CommandAssociateServiceToComponent;
711 friend class CommandAddComponentFromCatalog;
713 SubjectServiceNode(YACS::ENGINE::ServiceNode *serviceNode, Subject *parent);
714 virtual ~SubjectServiceNode();
715 virtual void setComponentFromCatalog(YACS::ENGINE::Catalog *catalog,
717 std::string service);
718 virtual void setComponent();
719 virtual bool associateToComponent(SubjectComponent *subcomp);
720 virtual void removeSubRefComponent() { _subRefComponent = 0; };
721 virtual void removeSubjectReference(){ _subjectReference = 0; };
722 virtual void addSubjectReference(Subject *ref);
723 virtual SubjectReference* getSubjectReference();
724 virtual void clean(Command *command=0);
725 void localclean(Command *command=0);
727 YACS::ENGINE::ServiceNode *_serviceNode;
728 SubjectReference* _subjectReference;
729 SubjectReference* _subRefComponent;
732 class SubjectCORBANode: public SubjectServiceNode
735 SubjectCORBANode(YACS::ENGINE::CORBANode *corbaNode, Subject *parent);
736 virtual ~SubjectCORBANode();
737 virtual void clean(Command *command=0);
738 void localclean(Command *command=0);
739 virtual TypeOfElem getType(){return CORBANODE;}
741 YACS::ENGINE::CORBANode *_corbaNode;
744 class SubjectCppNode: public SubjectServiceNode
747 SubjectCppNode(YACS::ENGINE::CppNode *cppNode, Subject *parent);
748 virtual ~SubjectCppNode();
749 virtual void clean(Command *command=0);
750 void localclean(Command *command=0);
751 virtual TypeOfElem getType(){return CPPNODE;}
753 YACS::ENGINE::CppNode *_cppNode;
756 class SubjectSalomeNode: public SubjectServiceNode
759 SubjectSalomeNode(YACS::ENGINE::SalomeNode *salomeNode, Subject *parent);
760 virtual ~SubjectSalomeNode();
761 virtual void clean(Command *command=0);
762 void localclean(Command *command=0);
763 virtual TypeOfElem getType(){return SALOMENODE;}
765 YACS::ENGINE::SalomeNode *_salomeNode;
768 class SubjectSalomePythonNode: public SubjectServiceNode
771 SubjectSalomePythonNode(YACS::ENGINE::SalomePythonNode *salomePythonNode,
773 virtual ~SubjectSalomePythonNode();
774 virtual void clean(Command *command=0);
775 void localclean(Command *command=0);
776 virtual TypeOfElem getType(){return SALOMEPYTHONNODE;}
778 YACS::ENGINE::SalomePythonNode *_salomePythonNode;
781 class SubjectXmlNode: public SubjectServiceNode
784 SubjectXmlNode(YACS::ENGINE::XmlNode *xmlNode, Subject *parent);
785 virtual ~SubjectXmlNode();
786 virtual void clean(Command *command=0);
787 void localclean(Command *command=0);
788 virtual TypeOfElem getType(){return XMLNODE;}
790 YACS::ENGINE::XmlNode *_xmlNode;
793 class SubjectSplitterNode: public SubjectElementaryNode
796 SubjectSplitterNode(YACS::ENGINE::SplitterNode *splitterNode, Subject *parent);
797 virtual ~SubjectSplitterNode();
798 virtual std::string getName();
799 virtual void clean(Command *command=0);
800 void localclean(Command *command=0);
801 virtual TypeOfElem getType(){return SPLITTERNODE;}
803 YACS::ENGINE::SplitterNode *_splitterNode;
806 class SubjectDataNode: public SubjectElementaryNode
809 SubjectDataNode(YACS::ENGINE::DataNode *dataNode, Subject *parent);
810 virtual ~SubjectDataNode();
811 virtual void clean(Command *command=0);
812 void localclean(Command *command=0);
814 YACS::ENGINE::DataNode *_dataNode;
817 class SubjectPresetNode: public SubjectDataNode
820 SubjectPresetNode(YACS::ENGINE::PresetNode *presetNode, Subject *parent);
821 virtual ~SubjectPresetNode();
822 virtual void clean(Command *command=0);
823 void localclean(Command *command=0);
824 virtual TypeOfElem getType(){return PRESETNODE;}
826 YACS::ENGINE::PresetNode *_presetNode;
829 class SubjectOutNode: public SubjectDataNode
832 SubjectOutNode(YACS::ENGINE::OutNode *outNode, Subject *parent);
833 virtual ~SubjectOutNode();
834 virtual void clean(Command *command=0);
835 void localclean(Command *command=0);
836 virtual TypeOfElem getType(){return OUTNODE;}
838 YACS::ENGINE::OutNode *_outNode;
841 class SubjectStudyInNode: public SubjectDataNode
844 SubjectStudyInNode(YACS::ENGINE::StudyInNode *studyInNode, Subject *parent);
845 virtual ~SubjectStudyInNode();
846 virtual void clean(Command *command=0);
847 void localclean(Command *command=0);
848 virtual TypeOfElem getType(){return STUDYINNODE;}
850 YACS::ENGINE::StudyInNode *_studyInNode;
853 class SubjectStudyOutNode: public SubjectDataNode
856 SubjectStudyOutNode(YACS::ENGINE::StudyOutNode *studyOutNode, Subject *parent);
857 virtual ~SubjectStudyOutNode();
858 virtual void clean(Command *command=0);
859 void localclean(Command *command=0);
860 virtual TypeOfElem getType(){return STUDYOUTNODE;}
862 YACS::ENGINE::StudyOutNode *_studyOutNode;
865 class SubjectLink: public Subject
868 SubjectLink(SubjectNode* subOutNode,
869 SubjectDataPort* outPort,
870 SubjectNode* subInNode,
871 SubjectDataPort* inPort,
873 virtual ~SubjectLink();
874 virtual std::string getName();
875 virtual void clean(Command *command=0);
876 void localclean(Command *command=0);
877 SubjectNode* getSubjectOutNode() { return _subOutNode; };
878 SubjectNode* getSubjectInNode() { return _subInNode; };
879 SubjectDataPort* getSubjectOutPort() { return _outPort; };
880 SubjectDataPort* getSubjectInPort() { return _inPort; };
881 virtual bool setProperties(std::map<std::string, std::string> properties);
882 virtual std::map<std::string, std::string> getProperties();
883 virtual std::vector<std::string> knownProperties();
884 virtual TypeOfElem getType(){return DATALINK;}
885 void registerUndoDestroy();
887 SubjectNode* _subOutNode;
888 SubjectDataPort* _outPort;
889 SubjectNode* _subInNode;
890 SubjectDataPort* _inPort;
892 YACS::ENGINE::ComposedNode *_cla;
893 YACS::ENGINE::OutPort *_outp;
894 YACS::ENGINE::InPort *_inp;
897 class SubjectControlLink: public Subject
900 SubjectControlLink(SubjectNode* subOutNode,
901 SubjectNode* subInNode,
903 virtual ~SubjectControlLink();
904 virtual std::string getName();
905 virtual void clean(Command *command=0);
906 void localclean(Command *command=0);
907 SubjectNode* getSubjectOutNode() { return _subOutNode; };
908 SubjectNode* getSubjectInNode() { return _subInNode; };
909 virtual TypeOfElem getType(){return CONTROLLINK;}
910 void registerUndoDestroy();
912 SubjectNode* _subOutNode;
913 SubjectNode* _subInNode;
915 YACS::ENGINE::ComposedNode *_cla;