]> SALOME platform Git repositories - modules/smesh.git/blob - src/OBJECT/SMESH_ActorDef.h
Salome HOME
09b2232f0bd660194c09227b804e8c0ab9b58371
[modules/smesh.git] / src / OBJECT / SMESH_ActorDef.h
1 //  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
6 //  This library is free software; you can redistribute it and/or
7 //  modify it under the terms of the GNU Lesser General Public
8 //  License as published by the Free Software Foundation; either
9 //  version 2.1 of the License.
10 //
11 //  This library is distributed in the hope that it will be useful,
12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14 //  Lesser General Public License for more details.
15 //
16 //  You should have received a copy of the GNU Lesser General Public
17 //  License along with this library; if not, write to the Free Software
18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19 //
20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22
23 //  SMESH OBJECT : interactive object for SMESH visualization
24 //  File   : SMESH_ActorDef.h
25 //  Author : Nicolas REJNERI
26 //  Module : SMESH
27 //
28 #ifndef SMESH_ACTORDEF_H
29 #define SMESH_ACTORDEF_H
30
31 #include "SMESH_Actor.h"
32 #include "SMESH_Object.h"
33
34 #include <vtkSmartPointer.h>
35
36 template <class T>
37 class TVTKSmartPtr: public vtkSmartPointer<T>
38 {
39 public:
40   TVTKSmartPtr() {}
41   TVTKSmartPtr(T* r, bool theIsOwner = false): vtkSmartPointer<T>(r) { 
42     if(r && theIsOwner) 
43       r->Delete();
44   }
45   TVTKSmartPtr& operator()(T* r, bool theIsOwner = false){ 
46     vtkSmartPointer<T>::operator=(r); 
47     if(r && theIsOwner) 
48       r->Delete();
49     return *this;
50   }
51   TVTKSmartPtr& operator=(T* r){ vtkSmartPointer<T>::operator=(r); return *this;}
52   T* Get() const { return this->GetPointer();}
53 };
54
55
56 class vtkProperty;
57 class vtkShrinkFilter;
58 class vtkPolyDataMapper;
59 class vtkUnstructuredGrid;
60 class vtkMergeFilter;
61 class vtkPolyData;
62 class vtkMapper;
63 class vtkActor2D;
64 class vtkMaskPoints;
65 class vtkLabeledDataMapper;
66 class vtkSelectVisiblePoints;
67 class vtkLookupTable;
68 class vtkPlane;
69 class vtkImplicitBoolean;
70 class vtkTimeStamp;
71
72 class VTKViewer_CellCenters;
73
74 class SMESH_DeviceActor;
75 class SMESH_ScalarBarActor;
76
77
78 class SMESH_ActorDef : public SMESH_Actor
79 {
80   friend class SMESH_VisualObj;
81   friend class SMESH_Actor;
82
83  public:
84   vtkTypeMacro(SMESH_ActorDef,SMESH_Actor);
85   
86   virtual void ReleaseGraphicsResources(vtkWindow *renWin);
87   virtual int RenderOpaqueGeometry(vtkViewport *viewport);
88   virtual int RenderTranslucentGeometry(vtkViewport *viewport);
89   virtual void Render(vtkRenderer *ren);
90
91   virtual void AddToRender(vtkRenderer* theRenderer); 
92   virtual void RemoveFromRender(vtkRenderer* theRenderer);
93
94   virtual bool hasHighlight() { return true; }  
95   virtual void highlight(bool theHighlight);  
96   virtual void SetPreSelected(bool thePreselect = false);
97
98   virtual bool IsInfinitive();  
99
100   virtual void SetOpacity(vtkFloatingPointType theValue);
101   virtual vtkFloatingPointType GetOpacity();
102
103   virtual void SetSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
104   virtual void GetSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
105
106   virtual void SetBackSufaceColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
107   virtual void GetBackSufaceColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
108
109   virtual void SetEdgeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
110   virtual void GetEdgeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
111
112   virtual void SetNodeColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
113   virtual void GetNodeColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
114
115   virtual void Set0DColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
116   virtual void Get0DColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
117
118   virtual void SetHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
119   virtual void GetHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
120
121   virtual void SetPreHighlightColor(vtkFloatingPointType r,vtkFloatingPointType g,vtkFloatingPointType b);
122   virtual void GetPreHighlightColor(vtkFloatingPointType& r,vtkFloatingPointType& g,vtkFloatingPointType& b);
123  
124   virtual vtkFloatingPointType GetLineWidth();
125   virtual void SetLineWidth(vtkFloatingPointType theVal);
126
127   virtual void Set0DSize(vtkFloatingPointType size);
128   virtual vtkFloatingPointType Get0DSize();
129
130   virtual int GetNodeObjId(int theVtkID);
131   virtual vtkFloatingPointType* GetNodeCoord(int theObjID);
132
133   virtual int GetElemObjId(int theVtkID);
134   virtual vtkCell* GetElemCell(int theObjID);
135
136   virtual int GetObjDimension( const int theObjId );
137
138   virtual void SetVisibility(int theMode);
139   void SetVisibility(int theMode, bool theIsUpdateRepersentation);
140
141   virtual void SetRepresentation(int theMode);
142   
143   virtual unsigned int GetEntityMode() const { return myEntityMode;}
144   virtual void SetEntityMode(unsigned int theMode);
145
146   virtual void SetPointRepresentation(bool theIsPointsVisible);
147   virtual bool GetPointRepresentation();
148
149   virtual vtkFloatingPointType* GetBounds();
150   virtual void SetTransform(VTKViewer_Transform* theTransform); 
151
152   virtual vtkUnstructuredGrid* GetUnstructuredGrid();
153   virtual vtkDataSet* GetInput();
154   virtual vtkMapper* GetMapper();
155
156   virtual vtkFloatingPointType GetShrinkFactor();
157   virtual void SetShrinkFactor(vtkFloatingPointType theValue);
158
159   virtual bool IsShrunkable() { return myIsShrinkable;}
160   virtual bool IsShrunk() { return myIsShrunk;}
161   virtual void SetShrink(); 
162   virtual void UnShrink(); 
163
164   virtual void SetPointsLabeled(bool theIsPointsLabeled);
165   virtual bool GetPointsLabeled(){ return myIsPointsLabeled;}
166
167   virtual void SetCellsLabeled(bool theIsCellsLabeled);
168   virtual bool GetCellsLabeled(){ return myIsCellsLabeled;}
169
170   virtual void SetFacesOriented(bool theIsFacesOriented);
171   virtual bool GetFacesOriented();
172
173   virtual void SetFacesOrientationColor(vtkFloatingPointType theColor[3]);
174   virtual void GetFacesOrientationColor(vtkFloatingPointType theColor[3]);
175
176   virtual void SetFacesOrientationScale(vtkFloatingPointType theScale);
177   virtual vtkFloatingPointType GetFacesOrientationScale();
178
179   virtual void SetFacesOrientation3DVectors(bool theState);
180   virtual bool GetFacesOrientation3DVectors();
181
182   virtual void SetControlMode(eControl theMode);
183   virtual eControl GetControlMode(){ return myControlMode;}
184   virtual SMESH::Controls::FunctorPtr GetFunctor() { return myFunctor; }
185
186   virtual SMESH_ScalarBarActor* GetScalarBarActor(){ return myScalarBarActor;}
187
188   virtual void RemoveAllClippingPlanes();
189   virtual vtkIdType GetNumberOfClippingPlanes();
190   virtual vtkPlane* GetClippingPlane(vtkIdType theID);
191   virtual vtkIdType AddClippingPlane(vtkPlane* thePlane); 
192
193   virtual TVisualObjPtr GetObject() { return myVisualObj;}
194
195   virtual void SetControlsPrecision( const long p ) { myControlsPrecision = p; }
196   virtual long GetControlsPrecision() const { return myControlsPrecision; }
197
198   virtual void UpdateScalarBar();
199
200
201   virtual void SetQuadratic2DRepresentation(EQuadratic2DRepresentation);
202   virtual EQuadratic2DRepresentation GetQuadratic2DRepresentation();
203   
204   virtual void SetMarkerStd( VTK::MarkerType, VTK::MarkerScale );
205   virtual void SetMarkerTexture( int, VTK::MarkerTexture );
206
207  protected:
208   void SetControlMode(eControl theMode, bool theCheckEntityMode);
209   void SetImplicitFunctionUsed(bool theIsImplicitFunctionUsed);
210   bool IsImplicitFunctionUsed() const;
211
212   TVisualObjPtr myVisualObj;
213   vtkTimeStamp* myTimeStamp;
214
215   SMESH_ScalarBarActor* myScalarBarActor;
216   vtkLookupTable* myLookupTable;
217
218   vtkProperty* mySurfaceProp;
219   vtkProperty* myBackSurfaceProp;
220   vtkProperty* myEdgeProp;
221   vtkProperty* myNodeProp;
222
223   SMESH_DeviceActor* myBaseActor;
224   SMESH_DeviceActor* myNodeActor;
225   SMESH_DeviceActor* myPickableActor;
226
227   vtkProperty* myHighlightProp;
228   vtkProperty* myPreselectProp;
229   SMESH_DeviceActor* myHighlitableActor;
230
231   eControl myControlMode;
232   SMESH::Controls::FunctorPtr myFunctor;
233   vtkProperty* my2DExtProp;
234   SMESH_DeviceActor* my2DActor;
235   SMESH_DeviceActor* my2DExtActor;
236   SMESH_DeviceActor* my3DActor;
237   SMESH_DeviceActor* myControlActor;
238
239   vtkProperty* myNodeExtProp;
240   SMESH_DeviceActor* myNodeExtActor;
241
242   vtkProperty* my1DProp;
243   SMESH_DeviceActor* my1DActor;
244   vtkProperty* my1DExtProp;
245   SMESH_DeviceActor* my1DExtActor;
246
247   vtkProperty* my0DProp;
248   SMESH_DeviceActor* my0DActor;
249   vtkProperty* my0DExtProp;
250   SMESH_DeviceActor* my0DExtActor;
251
252   unsigned int myEntityMode;
253   unsigned int myEntityState;
254   bool myIsPointsVisible;
255
256   bool myIsShrinkable;
257   bool myIsShrunk;
258   
259   bool myIsPointsLabeled;
260   vtkUnstructuredGrid* myPointsNumDataSet;
261   vtkActor2D *myPointLabels;
262   vtkMaskPoints* myPtsMaskPoints;
263   vtkLabeledDataMapper* myPtsLabeledDataMapper;
264   vtkSelectVisiblePoints* myPtsSelectVisiblePoints;
265
266   bool myIsCellsLabeled;
267   vtkUnstructuredGrid* myCellsNumDataSet;
268   vtkActor2D *myCellsLabels;
269   vtkMaskPoints* myClsMaskPoints;
270   VTKViewer_CellCenters* myCellCenters;
271   vtkLabeledDataMapper* myClsLabeledDataMapper;
272   vtkSelectVisiblePoints* myClsSelectVisiblePoints;
273
274   vtkImplicitBoolean* myImplicitBoolean;
275   typedef TVTKSmartPtr<vtkPlane> TPlanePtr;
276   typedef std::vector<TPlanePtr> TCippingPlaneCont;
277   TCippingPlaneCont myCippingPlaneCont;
278   long myControlsPrecision;
279
280   bool myIsFacesOriented;
281
282   VTK::MarkerTexture myMarkerTexture;
283
284   SMESH_ActorDef();
285   ~SMESH_ActorDef();
286
287   bool Init(TVisualObjPtr theVisualObj, 
288             const char* theEntry, 
289             const char* theName,
290             int theIsClear);
291
292   void SetIsShrunkable(bool theShrunkable);
293   void UpdateHighlight();
294   void Update();
295
296  private:
297   // hide the two parameter Render() method from the user and the compiler.
298   virtual void Render(vtkRenderer *, vtkMapper *) {};
299   virtual void ShallowCopy(vtkProp *prop);
300   virtual void SetMapper(vtkMapper *);
301   static SMESH_ActorDef* New();
302
303   // Not implemented.
304   SMESH_ActorDef(const SMESH_ActorDef&);  
305   void operator=(const SMESH_ActorDef&);
306 };
307
308
309 #endif //SMESH_ACTORDEF_H