Computer Assited Medical Intervention Tool Kit  version 3.2
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
Component.h
Go to the documentation of this file.
1 /*****************************************************************************
2  * $CAMITK_LICENCE_BEGIN$
3  *
4  * CamiTK - Computer Assisted Medical Intervention ToolKit
5  * (c) 2001-2013 UJF-Grenoble 1, CNRS, TIMC-IMAG UMR 5525 (GMCAO)
6  *
7  * Visit http://camitk.imag.fr for more information
8  *
9  * This file is part of CamiTK.
10  *
11  * CamiTK is free software: you can redistribute it and/or modify
12  * it under the terms of the GNU Lesser General Public License version 3
13  * only, as published by the Free Software Foundation.
14  *
15  * CamiTK is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18  * GNU Lesser General Public License version 3 for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public License
21  * version 3 along with CamiTK. If not, see <http://www.gnu.org/licenses/>.
22  *
23  * $CAMITK_LICENCE_END$
24  ****************************************************************************/
25 
26 #ifndef CAMITK_COMPONENT_H
27 #define CAMITK_COMPONENT_H
28 
29 // -- Core stuff
30 #include "InterfaceNode.h"
31 #include "InterfaceGeometry.h"
32 #include "InterfaceBitMap.h"
33 #include "InterfaceProperty.h"
34 #include "AbortException.h"
35 
36 // -- QT stuff
37 #include <QPixmap>
38 #include <QMenu>
39 
40 // -- vtk stuff
41 #include <vtkWindowLevelLookupTable.h>
42 #include <vtkImageData.h>
43 #include <vtkPointSet.h>
44 #include <vtkSmartPointer.h>
45 #include <vtkAlgorithmOutput.h>
46 #include <vtkActor.h>
47 #include <vtkActor2D.h>
48 #include <vtkImageActor.h>
49 
50 // -- vtk stuff Classes
51 class vtkTexture;
52 class vtkPointSet;
53 class vtkUnstructuredGridAlgorithm;
54 class vtkDataSetToUnstructuredGridFilter;
55 class vtkWindowLevelLookupTable;
56 
57 // -----------------------------------------------------------------------
58 //
59 // Delegation macros
60 // (And your dream comes true)
61 //
62 // -----------------------------------------------------------------------
63 
68 #define invoke0(HANDLER,METHOD) \
69 if (HANDLER) \
70  HANDLER->METHOD();
71 
72 #define invoke1(HANDLER,METHOD,PARAM) \
73 if (HANDLER) \
74  HANDLER->METHOD(PARAM);
75 
76 #define invoke2(HANDLER,METHOD,PARAM1,PARAM2) \
77 if (HANDLER) \
78  HANDLER->METHOD(PARAM1,PARAM2);
79 
80 #define invoke3(HANDLER,METHOD,PARAM1,PARAM2,PARAM3) \
81 if (HANDLER) \
82  HANDLER->METHOD(PARAM1,PARAM2,PARAM3);
83 
84 #define invoke4(HANDLER,METHOD,PARAM1,PARAM2,PARAM3,PARAM4) \
85 if (HANDLER) \
86  HANDLER->METHOD(PARAM1,PARAM2,PARAM3,PARAM4);
87 
92 #define invokeGet0(HANDLER,METHOD) \
93 if (HANDLER) \
94  return HANDLER->METHOD();
95 
96 #define invokeGet1(HANDLER,METHOD,PARAM) \
97 if (HANDLER) \
98  return HANDLER->METHOD(PARAM);
99 
100 #define invokeGet2(HANDLER,METHOD,PARAM1,PARAM2) \
101 if (HANDLER) \
102  return HANDLER->METHOD(PARAM1,PARAM2);
103 
104 #define invokeGet3(HANDLER,METHOD,PARAM1,PARAM2,PARAM3) \
105 if (HANDLER) \
106  return HANDLER->METHOD(PARAM1,PARAM2,PARAM3);
107 
108 #define invokeGet4(HANDLER,METHOD,PARAM1,PARAM2,PARAM3,PARAM4) \
109 if (HANDLER) \
110  return HANDLER->METHOD(PARAM1,PARAM2,PARAM3,PARAM4);
111 
115 #define invokeChildren0(METHOD) \
116 foreach (Component *child, childrenComponent) { \
117  child->METHOD(); \
118  }
119 
120 #define invokeChildren1(METHOD,PARAM) \
121 foreach (Component *child, childrenComponent) { \
122  child->METHOD(PARAM); \
123  }
124 
125 #define invokeChildren2(METHOD,PARAM1,PARAM2) \
126 foreach (Component *child, childrenComponent) { \
127  child->METHOD(PARAM1,PARAM2); \
128  }
129 
130 #define invokeChildren3(METHOD,PARAM1,PARAM2,PARAM3) \
131 foreach (Component *child, childrenComponent) { \
132  child->METHOD(PARAM1,PARAM2,PARAM3); \
133  }
134 
135 #define invokeChildren4(METHOD,PARAM1,PARAM2,PARAM3,PARAM4) \
136 foreach (Component *child, childrenComponent) { \
137  child->METHOD(PARAM1,PARAM2,PARAM3,PARAM4); \
138  }
139 
145 #define delegate0(HANDLER,METHOD) \
146 virtual void METHOD() { \
147  invoke0(HANDLER,METHOD) \
148  }
149 
150 #define delegate1(HANDLER,METHOD,PARAM_TYPE) \
151 virtual void METHOD(PARAM_TYPE param) { \
152  invoke1(HANDLER,METHOD,param) \
153  }
154 
155 #define delegate2(HANDLER,METHOD,PARAM_TYPE1,PARAM_TYPE2) \
156 virtual void METHOD(PARAM_TYPE1 param1, PARAM_TYPE2 param2) { \
157  invoke2(HANDLER,METHOD,param1,param2) \
158  }
159 
160 #define delegate3(HANDLER,METHOD,PARAM_TYPE1,PARAM_TYPE2,PARAM_TYPE3) \
161 virtual void METHOD(PARAM_TYPE1 param1, PARAM_TYPE2 param2, PARAM_TYPE3 param3) { \
162  invoke3(HANDLER,METHOD,param1,param2,param3) \
163  }
164 
165 #define delegate4(HANDLER,METHOD,PARAM_TYPE1,PARAM_TYPE2,PARAM_TYPE3, PARAM_TYPE4) \
166 virtual void METHOD(PARAM_TYPE1 param1, PARAM_TYPE2 param2, PARAM_TYPE3 param3, PARAM_TYPE4 param4) { \
167  invoke4(HANDLER,METHOD,param1,param2,param3,param4) \
168  }
169 
176 #define delegateGet0(HANDLER,METHOD,TYPE) \
177 virtual TYPE METHOD() { \
178  invokeGet0(HANDLER,METHOD) \
179  else \
180  return 0; \
181  }
182 
183 #define delegateGet1(HANDLER,METHOD,TYPE,PARAM_TYPE) \
184 virtual TYPE METHOD(PARAM_TYPE param) { \
185  invokeGet1(HANDLER,METHOD,param) \
186  else \
187  return 0; \
188  }
189 
190 #define delegateGet2(HANDLER,METHOD,TYPE,PARAM1_TYPE,PARAM2_TYPE) \
191 virtual TYPE METHOD(PARAM1_TYPE param1, PARAM2_TYPE param2) { \
192  invokeGet2(HANDLER,METHOD,param1,param2) \
193  else \
194  return 0; \
195  }
196 
199 #define delegateConstGet0(HANDLER,METHOD,TYPE) \
200 virtual TYPE METHOD() const { \
201  invokeGet0(HANDLER,METHOD) \
202  else \
203  return 0; \
204  }
205 
206 #define delegateConstGet1(HANDLER,METHOD,TYPE,PARAM_TYPE) \
207 virtual TYPE METHOD(PARAM_TYPE param) const { \
208  invokeGet1(HANDLER,METHOD,param) \
209  else \
210  return 0; \
211  }
212 
217 #define delegateAndInvokeChildren1(HANDLER,METHOD,PARAM_TYPE) \
218 virtual void METHOD(PARAM_TYPE param) { \
219  invoke1(HANDLER,METHOD,param) \
220  invokeChildren1(METHOD,param) \
221  }
222 
223 #define delegateAndInvokeChildren2(HANDLER,METHOD,PARAM_TYPE1,PARAM_TYPE2) \
224 virtual void METHOD(PARAM_TYPE1 param1, PARAM_TYPE2 param2) { \
225  invoke2(HANDLER,METHOD,param1,param2) \
226  invokeChildren2(METHOD,param1,param2) \
227  }
228 
229 #define delegateAndInvokeChildren1Array(HANDLER,METHOD,PARAM_TYPE1,PARAM_TYPE2,DIM) \
230 virtual void METHOD(PARAM_TYPE1 param1, PARAM_TYPE2 param2[DIM]) { \
231  invoke2(HANDLER,METHOD,param1,param2) \
232  invokeChildren2(METHOD,param1,param2) \
233  }
234 
235 #define delegateAndInvokeChildren3(HANDLER,METHOD,PARAM_TYPE1,PARAM_TYPE2,PARAM_TYPE3) \
236 virtual void METHOD(PARAM_TYPE1 param1, PARAM_TYPE2 param2, PARAM_TYPE3 param3) { \
237  invoke3(HANDLER,METHOD,param1,param2,param3) \
238  invokeChildren3(METHOD,param1,param2,param3) \
239  }
240 
241 #define delegateAndInvokeChildren4(HANDLER,METHOD,PARAM_TYPE1,PARAM_TYPE2,PARAM_TYPE3,PARAM_TYPE4) \
242 virtual void METHOD(PARAM_TYPE1 param1, PARAM_TYPE2 param2, PARAM_TYPE3 param3,PARAM_TYPE4 param4) { \
243  invoke4(HANDLER,METHOD,param1,param2,param3,param4) \
244  invokeChildren4(METHOD,param1,param2,param3,param4) \
245  }
246 
247 
248 namespace camitk {
249 // -- Core stuff classes
250 class Geometry;
251 class Slice;
252 class Viewer;
253 
254 
288  Q_OBJECT
289 
290 public:
299  NO_REPRESENTATION
300  };
301 
305 
313  Component(const QString & file, const QString & name, Representation rep = NO_REPRESENTATION);
314 
322  Component(Component *parentComponent, const QString & name, Representation rep = NO_REPRESENTATION) throw(AbortException);
323 
325  virtual ~Component();
326 
330  Representation getRepresentation() const;
331 
333  bool isTopLevel() const;
334 
336  virtual Component * getParentComponent();
337 
339  virtual Component * getTopLevelComponent();
340 
342  virtual void setModified(bool modified = true);
343 
345  virtual bool getModified() const;
346 
348  virtual void setVisibility(Viewer *, bool);
349 
351  virtual bool getVisibility(Viewer *) const;
352 
354  virtual void refresh() const;
355 
362  virtual void refreshInterfaceNode();
363 
365  virtual bool isSelected() const;
366 
371  virtual void setSelected(const bool b, const bool recursive = true);
372 
374  const QString getFileName() const;
375 
377  void setFileName(const QString &);
378 
380  bool event(QEvent* e);
381 
386  QMenu * getActionAndPopupMenu();
388 
393  QStringList getHierarchy();
396 
398  bool isInstanceOf(QString className);
399 
404  virtual QWidget * getPropertyWidget(QWidget* parent = 0) {
405  return NULL;
406  }
407 
416  virtual QObject * getPropertyObject() {
417  return this;
418  }
419 
426  void updateProperty(QString name, QVariant value);
427 
435  virtual bool setDynamicProperty(const char *name, const QVariant &value, const char *description = "", bool isReadOnly=false);
437 
442  //-- the methods below are commented because the default comment in InterfaceNode lacks some information...
444  virtual void addChild(InterfaceNode *);
445  virtual void attachChild(InterfaceNode *);
449  virtual void removeChild(InterfaceNode *);
450 
452  virtual void setParent(InterfaceNode *);
453 
454  //--not commented because Doxygen automatically use the inherited documentation (set INHERIT_DOCS flag to YES in the Doxyfile)
455  virtual void deleteChildren();
456  virtual QString getName() const;
457  virtual void setName(const QString&);
458  virtual const ComponentList & getChildren();
459  virtual bool doubleClicked();
460  virtual InterfaceNode * getParent();
461  virtual QPixmap getIcon();
462 
466  virtual bool inItalic() const;
467 
469  virtual QMenu * getPopupMenu(QWidget* parent = 0) {
470  return NULL;
471  }
473 
478  const QString getLabel() const;
481 
483  void setLabel(QString newName);
484 
485  delegateGet0(myGeometry, getPointSet, vtkSmartPointer<vtkPointSet> )
486 
487  delegate1(myGeometry, setPointSet, vtkSmartPointer<vtkPointSet> )
488 
489  delegate1(myGeometry, setPointData, vtkSmartPointer<vtkDataArray> )
490 
491  delegateConstGet0(myGeometry, getDataPort, vtkSmartPointer<vtkAlgorithmOutput> )
492 
493  delegate1(myGeometry, setDataConnection, vtkSmartPointer<vtkAlgorithmOutput> )
494 
495  delegateGet1(myGeometry, getActor, vtkSmartPointer<vtkActor>, const RenderingModes)
496 
497  // TODO : uses an object myRepresentation (which is a Geometry or a Slice)
498  // to use a single delegate macro
499  virtual vtkSmartPointer<vtkProp> getProp(const QString &param)
500  {
501  if (myGeometry)
502  return myGeometry->getProp(param);
503  else if(mySlice)
504  return mySlice->getProp(param);
505  return NULL;
506  }
507 
508  virtual unsigned int getNumberOfProp() const {
509  if (myGeometry)
510  return myGeometry->getNumberOfProp();
511  else if (mySlice)
512  return mySlice->getNumberOfProp();
513  return 0;
514  }
515 
516  virtual vtkSmartPointer<vtkProp> getProp(unsigned int index) {
517  if (myGeometry)
518  return myGeometry->getProp(index);
519  else if (mySlice)
520  return mySlice->getProp(index);
521  return 0;
522  }
523 
524  virtual bool addProp(const QString &name, vtkSmartPointer<vtkProp> prop) {
525  if (myGeometry)
526  return myGeometry->addProp(name, prop);
527  else if (mySlice)
528  return mySlice->addProp(name, prop);
529  return false;
530  }
531 
532 
533  virtual bool removeProp(const QString & name) {
534  if (myGeometry)
535  return myGeometry->removeProp(name);
536  else if (mySlice)
537  return mySlice->removeProp(name);
538  return false;
539  }
540  // END TODO
541 
542 
546  virtual void pointPicked(vtkIdType, bool) {};
547 
551  virtual void cellPicked(vtkIdType, bool) {};
552 
553  // --
554 
556  virtual void getBounds(double bounds[6]);
557 
561  virtual double getBoundingRadius();
562 
563  delegate4(myGeometry, setPointPosition, const unsigned int, const double, const double, const double);
564 
565  delegateAndInvokeChildren1(myGeometry, setRenderingModes, const RenderingModes);
566 
568  virtual const InterfaceGeometry::RenderingModes getRenderingModes() const;
569 
570  delegateAndInvokeChildren1(myGeometry, setEnhancedModes, const EnhancedModes)
571 
572  delegateConstGet0(myGeometry, getEnhancedModes, const EnhancedModes)
573 
574  delegateAndInvokeChildren1Array(myGeometry, setActorColor, const RenderingModes, double, 4)
575 
576  delegateAndInvokeChildren4(myGeometry, setActorColor, const RenderingModes, const double, const double, const double)
577 
579  virtual void getActorColor(const RenderingModes, double [4]);
580 
581  delegateAndInvokeChildren3(myGeometry, setColor, const double, const double, const double)
582 
583  delegateAndInvokeChildren4(myGeometry, setColor, const double, const double, const double, const double)
584 
585  delegateAndInvokeChildren2(myGeometry, setActorOpacity, const RenderingModes, const double)
586 
587  delegateConstGet1(myGeometry, getActorOpacity, double, const RenderingModes)
588 
589  delegateAndInvokeChildren1(myGeometry, setOpacity, const double)
590 
591  delegate1(myGeometry, setTexture, vtkSmartPointer<vtkTexture>)
592 
593  virtual void setGlyphType(const GlyphTypes type, const double size = 0.0);
594 
595  delegate1(myGeometry, setLinesAsTubes, bool);
596 
598 
603  delegateConstGet0(mySlice, getImageData, vtkSmartPointer<vtkImageData>)
605 
606  delegate1(mySlice, setOriginalVolume, vtkSmartPointer<vtkImageData>)
607 
608  delegateConstGet0(mySlice, get2DImageActor, vtkSmartPointer<vtkImageActor>)
609 
610  delegateConstGet0(mySlice, get3DImageActor, vtkSmartPointer<vtkImageActor>)
611 
612  delegateConstGet0(mySlice, getPickPlaneActor, vtkSmartPointer<vtkActor>)
613 
614  delegateGet0(mySlice, getPixelActor, vtkSmartPointer<vtkActor>)
615 
616  delegate3(mySlice, pixelPicked, double, double, double)
617 
618  delegate0(mySlice, updatePickPlane)
619 
620  delegate1(mySlice, setSlice, int);
621 
622  delegate3(mySlice, setSlice, double, double, double);
623 
624  delegate1(mySlice, setRotationX, double)
625 
626  delegate1(mySlice, setRotationY, double)
627 
628  delegate1(mySlice, setRotationZ, double)
629 
630  delegateConstGet0(mySlice, getNumberOfColors, int)
631 
632  delegate3(mySlice, setPixelRealPosition, double, double, double);
633 
635  virtual double getRotationX() const;
636 
638  virtual double getRotationY() const;
639 
641  virtual double getRotationZ() const;
642 
644  virtual int getNumberOfSlices() const;
645 
647  virtual int getSlice() const;
649 
650 
651 protected:
653  InterfaceGeometry * myGeometry;
654 
656  InterfaceBitMap * mySlice;
657 
659  InterfaceNode * myParentNode;
660 
662  ComponentList childrenComponent;
663 
665  bool isSelectedFlag;
666 
668  bool modifiedFlag;
669 
671  QString myFileName;
672 
673 
674 private:
677 
680  void init();
681 
683  Representation myService;
684 
686  QString myName;
687 
692  virtual void initRepresentation() = 0;
693 
695  QMap<Viewer *, bool> myViewers;
696 
698  QMenu * actionsMenu;
700 
704  static QSet<Viewer*> allViewers;
708 
709 };
710 
711 
712 // -------------------- isSelected --------------------
713 inline bool Component::isSelected() const {
714  return isSelectedFlag;
715 }
716 
717 // -------------------- doubleClicked --------------------
719  // always false by default. You must overload this method in Components to change its behaviour.
720  return false;
721 }
722 
723 // -------------------- getChildren --------------------
725  return childrenComponent;
726 }
727 
728 // -------------------- getName --------------------
729 inline QString Component::getName() const {
730  return myName;
731 }
732 
733 // -------------------- getParent --------------------
735  return ((Component*) myParentNode);
736 }
737 
738 // -------------------- getPixmap ------------------
739 inline QPixmap Component::getIcon() {
740  return NULL;
741 }
742 
743 // -------------------- inItalic --------------------
744 inline bool Component::inItalic() const {
745  return false;
746 }
747 
748 // -------------------- setName --------------------
749 inline void Component::setName(const QString & n) {
750  myName = n;
751  if (myGeometry)
752  myGeometry->setLabel(n);
753 }
754 
755 // -------------------- setModified --------------------
756 inline void Component::setModified(bool modification) {
757  modifiedFlag = modification;
758 }
759 
760 // -------------------- getModified --------------------
761 inline bool Component::getModified() const {
762  return modifiedFlag;
763 }
764 
765 // -------------------- getModified --------------------
766 inline const QString Component::getLabel() const {
767  return getName();
768 }
769 // -------------------- getModified --------------------
770 inline void Component::setLabel(QString newName) {
771  setLabel(newName);
772 }
773 
774 }
775 
776 #endif
777 
#define delegateAndInvokeChildren3(HANDLER, METHOD, PARAM_TYPE1, PARAM_TYPE2, PARAM_TYPE3)
Definition: Component.h:235
This class describe what are the methods to implement in order to manage dynamic properties.
Definition: InterfaceProperty.h:38
This class describes what are the methods to implement for a BitMap.
Definition: InterfaceBitMap.h:59
#define delegateAndInvokeChildren2(HANDLER, METHOD, PARAM_TYPE1, PARAM_TYPE2)
Definition: Component.h:223
virtual void setName(const QString &)
set the name to be displayed
Definition: Component.h:749
virtual bool inItalic() const
A component name is not displayed in italic by default.
Definition: Component.h:744
#define delegate4(HANDLER, METHOD, PARAM_TYPE1, PARAM_TYPE2, PARAM_TYPE3, PARAM_TYPE4)
Definition: Component.h:165
Exception class to handle abortion in component instanciation.
Definition: AbortException.h:40
#define delegateAndInvokeChildren1Array(HANDLER, METHOD, PARAM_TYPE1, PARAM_TYPE2, DIM)
Definition: Component.h:229
#define delegate3(HANDLER, METHOD, PARAM_TYPE1, PARAM_TYPE2, PARAM_TYPE3)
Definition: Component.h:160
#define delegateConstGet1(HANDLER, METHOD, TYPE, PARAM_TYPE)
Definition: Component.h:206
Viewer is an abstract viewer.
Definition: Viewer.h:50
virtual void pointPicked(vtkIdType, bool)
an inherited class can redefine this method something specific.
Definition: Component.h:546
this Component can be displayed as a SLICE
Definition: Component.h:298
const QString getLabel() const
Definition: Component.h:766
#define delegateGet0(HANDLER, METHOD, TYPE)
delegateGet macros: Same as delegate macro but for an accessor non-const METHOD, returns a value of t...
Definition: Component.h:176
This class describe what are the methods to implement for a hierarchical tree node.
Definition: InterfaceNode.h:54
#define delegate0(HANDLER, METHOD)
delegate macros: completely delegates METHOD to HANDLER, eventually using parameters of given PARAM_T...
Definition: Component.h:145
this Component can be displayed as a GEOMETRY
Definition: Component.h:297
#define delegateAndInvokeChildren1(HANDLER, METHOD, PARAM_TYPE)
delegateAndInvokeChildren macros: Same as delegate but also calls METHOD, eventually with PARAM_TYPE...
Definition: Component.h:217
A Component represents something that could be included in the explorer view, the interactive 3D view...
Definition: Component.h:287
CAMITK_API QList< Component * > ComponentList
A list of Component.
Definition: CamiTKAPI.h:87
#define CAMITK_API
Definition: CamiTKAPI.h:49
void setLabel(QString newName)
set the string used to display the label, do the same as setName
Definition: Component.h:770
virtual bool getModified() const
set the modified flag
Definition: Component.h:761
virtual QMenu * getPopupMenu(QWidget *parent=0)
get the popup menu to display (always return NULL, overwrite this method if you want to give here you...
Definition: Component.h:469
#define delegate1(HANDLER, METHOD, PARAM_TYPE)
Definition: Component.h:150
virtual InterfaceNode * getParent()
get the parent Component
Definition: Component.h:734
virtual bool doubleClicked()
this method is called each time the InterfaceNode is double clicked by the user.
Definition: Component.h:718
virtual QString getName() const
get the name to be displayed
Definition: Component.h:729
virtual const ComponentList & getChildren()
get the list of the InterfaceNode children (sub items in the hierarchy)
Definition: Component.h:724
virtual QPixmap getIcon()
Get the pixmap that will be displayed for this node.
Definition: Component.h:739
#define delegateAndInvokeChildren4(HANDLER, METHOD, PARAM_TYPE1, PARAM_TYPE2, PARAM_TYPE3, PARAM_TYPE4)
Definition: Component.h:241
#define delegateGet1(HANDLER, METHOD, TYPE, PARAM_TYPE)
Definition: Component.h:183
virtual unsigned int getNumberOfProp() const
return the number of additional prop
Definition: Component.h:508
Representation
The different representation that can be implemented to represent this Component in the InteractiveVi...
Definition: Component.h:296
virtual QObject * getPropertyObject()
get the property object that could be understood by PropertyEditor.
Definition: Component.h:416
#define delegateConstGet0(HANDLER, METHOD, TYPE)
delegateConstGet macros: Same as delegateGet but for const METHOD
Definition: Component.h:199
This class describes what are the methods to implement for a Geometry (rendering parameters, input/output, filters, picking parameters...)
Definition: InterfaceGeometry.h:57
virtual void setModified(bool modified=true)
set the modified flag
Definition: Component.h:756
virtual vtkSmartPointer< vtkProp > getProp(unsigned int index)
return an additional prop by its index
Definition: Component.h:516
virtual bool addProp(const QString &name, vtkSmartPointer< vtkProp > prop)
insert an additional prop, defining it by its name (default visibility = false)
Definition: Component.h:524
virtual bool removeProp(const QString &name)
remove a given additional prop.
Definition: Component.h:533
virtual void cellPicked(vtkIdType, bool)
an inherited class can redefine this method something specific.
Definition: Component.h:551