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