Back to index

salome-smesh  6.5.0
Public Member Functions | Protected Types | Protected Member Functions | Protected Attributes | Private Member Functions | Static Private Member Functions | Friends
SMESH_ActorDef Class Reference

#include <SMESH_ActorDef.h>

Collaboration diagram for SMESH_ActorDef:
Collaboration graph
[legend]

List of all members.

Public Member Functions

 vtkTypeMacro (SMESH_ActorDef, SMESH_Actor)
virtual void Delete ()
virtual void ReleaseGraphicsResources (vtkWindow *renWin)
virtual int RenderOpaqueGeometry (vtkViewport *viewport)
virtual int RenderTranslucentGeometry (vtkViewport *viewport)
virtual void Render (vtkRenderer *ren)
virtual void AddToRender (vtkRenderer *theRenderer)
virtual void RemoveFromRender (vtkRenderer *theRenderer)
virtual bool hasHighlight ()
virtual void highlight (bool theHighlight)
virtual void SetPreSelected (bool thePreselect=false)
virtual bool IsInfinitive ()
virtual void SetOpacity (vtkFloatingPointType theValue)
virtual vtkFloatingPointType GetOpacity ()
virtual void SetSufaceColor (vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b, int delta)
virtual void GetSufaceColor (vtkFloatingPointType &r, vtkFloatingPointType &g, vtkFloatingPointType &b, int &delta)
virtual void SetEdgeColor (vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b)
virtual void GetEdgeColor (vtkFloatingPointType &r, vtkFloatingPointType &g, vtkFloatingPointType &b)
virtual void SetOutlineColor (vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b)
virtual void GetOutlineColor (vtkFloatingPointType &r, vtkFloatingPointType &g, vtkFloatingPointType &b)
virtual void SetNodeColor (vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b)
virtual void GetNodeColor (vtkFloatingPointType &r, vtkFloatingPointType &g, vtkFloatingPointType &b)
virtual void Set0DColor (vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b)
virtual void Get0DColor (vtkFloatingPointType &r, vtkFloatingPointType &g, vtkFloatingPointType &b)
virtual void SetHighlightColor (vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b)
virtual void GetHighlightColor (vtkFloatingPointType &r, vtkFloatingPointType &g, vtkFloatingPointType &b)
virtual void SetPreHighlightColor (vtkFloatingPointType r, vtkFloatingPointType g, vtkFloatingPointType b)
virtual void GetPreHighlightColor (vtkFloatingPointType &r, vtkFloatingPointType &g, vtkFloatingPointType &b)
virtual vtkFloatingPointType GetLineWidth ()
virtual void SetLineWidth (vtkFloatingPointType theVal)
virtual void Set0DSize (vtkFloatingPointType size)
virtual vtkFloatingPointType Get0DSize ()
virtual int GetNodeObjId (int theVtkID)
virtual vtkFloatingPointType * GetNodeCoord (int theObjID)
virtual int GetElemObjId (int theVtkID)
virtual vtkCell * GetElemCell (int theObjID)
virtual int GetObjDimension (const int theObjId)
virtual void SetVisibility (int theMode)
void SetVisibility (int theMode, bool theIsUpdateRepersentation)
virtual void SetRepresentation (int theMode)
virtual unsigned int GetEntityMode () const
virtual void SetEntityMode (unsigned int theMode)
virtual void SetPointRepresentation (bool theIsPointsVisible)
virtual bool GetPointRepresentation ()
virtual vtkFloatingPointType * GetBounds ()
virtual void SetTransform (VTKViewer_Transform *theTransform)
virtual vtkUnstructuredGrid * GetUnstructuredGrid ()
virtual vtkDataSet * GetInput ()
virtual vtkMapper * GetMapper ()
virtual vtkFloatingPointType GetShrinkFactor ()
virtual void SetShrinkFactor (vtkFloatingPointType theValue)
virtual bool IsShrunkable ()
virtual bool IsShrunk ()
virtual void SetShrink ()
virtual void UnShrink ()
virtual void SetPointsLabeled (bool theIsPointsLabeled)
virtual bool GetPointsLabeled ()
virtual void SetCellsLabeled (bool theIsCellsLabeled)
virtual bool GetCellsLabeled ()
virtual void SetFacesOriented (bool theIsFacesOriented)
virtual bool GetFacesOriented ()
virtual void SetFacesOrientationColor (vtkFloatingPointType theColor[3])
virtual void GetFacesOrientationColor (vtkFloatingPointType theColor[3])
virtual void SetFacesOrientationScale (vtkFloatingPointType theScale)
virtual vtkFloatingPointType GetFacesOrientationScale ()
virtual void SetFacesOrientation3DVectors (bool theState)
virtual bool GetFacesOrientation3DVectors ()
virtual void SetControlMode (eControl theMode)
virtual eControl GetControlMode ()
virtual SMESH::Controls::FunctorPtr GetFunctor ()
virtual SMESH_ScalarBarActor * GetScalarBarActor ()
virtual void RemoveAllClippingPlanes ()
virtual vtkIdType GetNumberOfClippingPlanes ()
virtual vtkPlane * GetClippingPlane (vtkIdType theID)
virtual vtkIdType AddClippingPlane (vtkPlane *thePlane)
virtual TVisualObjPtr GetObject ()
virtual void SetControlsPrecision (const long p)
virtual long GetControlsPrecision () const
virtual void UpdateScalarBar ()
virtual void UpdateDistribution ()
virtual SPlot2d_Histogram * GetPlot2Histogram ()
virtual SPlot2d_Histogram * UpdatePlot2Histogram ()
virtual void SetQuadratic2DRepresentation (EQuadratic2DRepresentation)
virtual EQuadratic2DRepresentation GetQuadratic2DRepresentation ()
virtual void SetMarkerStd (VTK::MarkerType, VTK::MarkerScale)
virtual void SetMarkerTexture (int, VTK::MarkerTexture)

Protected Types

typedef TVTKSmartPtr< vtkPlane > TPlanePtr
typedef std::vector< TPlanePtrTCippingPlaneCont

Protected Member Functions

void SetControlMode (eControl theMode, bool theCheckEntityMode)
void SetImplicitFunctionUsed (bool theIsImplicitFunctionUsed)
bool IsImplicitFunctionUsed () const
 SMESH_ActorDef ()
 ~SMESH_ActorDef ()
bool Init (TVisualObjPtr theVisualObj, const char *theEntry, const char *theName, int theIsClear)
void SetIsShrunkable (bool theShrunkable)
void UpdateHighlight ()
void Update ()

Protected Attributes

TVisualObjPtr myVisualObj
vtkTimeStamp * myTimeStamp
SMESH_ScalarBarActor * myScalarBarActor
vtkLookupTable * myLookupTable
vtkProperty * mySurfaceProp
vtkProperty * myBackSurfaceProp
vtkProperty * myEdgeProp
vtkProperty * myNodeProp
SMESH_DeviceActor * myBaseActor
SMESH_NodeLabelActor * myNodeActor
SMESH_DeviceActor * myPickableActor
vtkProperty * myHighlightProp
vtkProperty * myOutLineProp
vtkProperty * myPreselectProp
SMESH_DeviceActor * myHighlitableActor
eControl myControlMode
SMESH::Controls::FunctorPtr myFunctor
vtkProperty * my2DExtProp
SMESH_CellLabelActor * my2DActor
SMESH_DeviceActor * my2DExtActor
SMESH_CellLabelActor * my3DActor
SMESH_DeviceActor * my3DExtActor
SMESH_DeviceActor * myControlActor
vtkProperty * myNodeExtProp
SMESH_DeviceActor * myNodeExtActor
vtkProperty * my1DProp
SMESH_CellLabelActor * my1DActor
vtkProperty * my1DExtProp
SMESH_DeviceActor * my1DExtActor
vtkProperty * my0DProp
SMESH_CellLabelActor * my0DActor
vtkProperty * my0DExtProp
SMESH_DeviceActor * my0DExtActor
unsigned int myEntityMode
unsigned int myEntityState
unsigned int myEntityModeCache
bool myIsEntityModeCache
bool myIsPointsVisible
bool myIsShrinkable
bool myIsShrunk
vtkImplicitBoolean * myImplicitBoolean
TCippingPlaneCont myCippingPlaneCont
long myControlsPrecision
SPlot2d_Histogram * my2dHistogram
bool myIsFacesOriented
int myDeltaBrightness
VTK::MarkerTexture myMarkerTexture

Private Member Functions

virtual void Render (vtkRenderer *, vtkMapper *)
virtual void ShallowCopy (vtkProp *prop)
virtual void SetMapper (vtkMapper *)
 SMESH_ActorDef (const SMESH_ActorDef &)
void operator= (const SMESH_ActorDef &)

Static Private Member Functions

static SMESH_ActorDefNew ()

Friends

class SMESH_VisualObj
class SMESH_Actor

Detailed Description

Definition at line 79 of file SMESH_ActorDef.h.


Member Typedef Documentation

typedef std::vector<TPlanePtr> SMESH_ActorDef::TCippingPlaneCont [protected]

Definition at line 276 of file SMESH_ActorDef.h.

typedef TVTKSmartPtr<vtkPlane> SMESH_ActorDef::TPlanePtr [protected]

Definition at line 275 of file SMESH_ActorDef.h.


Constructor & Destructor Documentation

Definition at line 120 of file SMESH_Actor.cxx.

{
  if(MYDEBUG) MESSAGE("SMESH_ActorDef - "<<this);  
  myBaseActor = SMESH_DeviceActor::New();

  myTimeStamp = vtkTimeStamp::New();

  myIsPointsVisible = false;
  myIsEntityModeCache = false;

  myIsShrinkable = false;
  myIsShrunk = false;

  myIsFacesOriented = false;

  myControlsPrecision = -1;
  SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();

  if ( mgr && mgr->booleanValue( "SMESH", "use_precision", false ) )
    myControlsPrecision = mgr->integerValue( "SMESH", "controls_precision", -1);

  vtkFloatingPointType aElem0DSize = SMESH::GetFloat("SMESH:elem0d_size",5);
  vtkFloatingPointType aLineWidth  = SMESH::GetFloat("SMESH:element_width",1);

  vtkMatrix4x4 *aMatrix = vtkMatrix4x4::New();
  VTKViewer_ExtractUnstructuredGrid* aFilter = NULL;

  //Definition 2D and 3D devices of the actor
  //-----------------------------------------
  vtkFloatingPointType anRGB[3] = {1,1,1};
  mySurfaceProp = vtkProperty::New();
  QColor ffc, bfc;
  int delta;
  SMESH::GetColor( "SMESH", "fill_color", ffc, delta, "0,170,255|-100" ) ;
  mySurfaceProp->SetColor( ffc.red() / 255. , ffc.green() / 255. , ffc.blue() / 255. );
  myDeltaBrightness = delta;

  myBackSurfaceProp = vtkProperty::New();
  bfc = Qtx::mainColorToSecondary(ffc, delta);
  myBackSurfaceProp->SetColor( bfc.red() / 255. , bfc.green() / 255. , bfc.blue() / 255. );

  my2DActor = SMESH_CellLabelActor::New();
  my2DActor->SetStoreGemetryMapping(true);
  my2DActor->SetUserMatrix(aMatrix);
  my2DActor->PickableOff();
  my2DActor->SetProperty(mySurfaceProp);
  my2DActor->SetBackfaceProperty(myBackSurfaceProp);
  my2DActor->SetRepresentation(SMESH_DeviceActor::eSurface);
  aFilter = my2DActor->GetExtractUnstructuredGrid();
  aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
  aFilter->RegisterCellsWithType(VTK_TRIANGLE);
  aFilter->RegisterCellsWithType(VTK_POLYGON);
  aFilter->RegisterCellsWithType(VTK_QUAD);
  aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
  aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
  aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);

  my2DExtProp = vtkProperty::New();
  my2DExtProp->DeepCopy(mySurfaceProp);
  SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
  anRGB[0] = 1 - anRGB[0];
  anRGB[1] = 1 - anRGB[1];
  anRGB[2] = 1 - anRGB[2];
  my2DExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);

  my2DExtActor = SMESH_DeviceActor::New();
  my2DExtActor->SetUserMatrix(aMatrix);
  my2DExtActor->PickableOff();
  my2DExtActor->SetProperty(my2DExtProp);
  my2DExtActor->SetBackfaceProperty(my2DExtProp);
  my2DExtActor->SetRepresentation(SMESH_DeviceActor::eInsideframe);
  aFilter = my2DExtActor->GetExtractUnstructuredGrid();
  aFilter->RegisterCellsWithType(VTK_TRIANGLE);
  aFilter->RegisterCellsWithType(VTK_POLYGON);
  aFilter->RegisterCellsWithType(VTK_QUAD);
  aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
  aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
  aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);

  my3DActor = SMESH_CellLabelActor::New();
  my3DActor->SetStoreGemetryMapping(true);
  my3DActor->SetUserMatrix(aMatrix);
  my3DActor->PickableOff();
  my3DActor->SetProperty(mySurfaceProp);
  my3DActor->SetBackfaceProperty(myBackSurfaceProp);
  my3DActor->SetRepresentation(SMESH_DeviceActor::eSurface);
  my3DActor->SetCoincident3DAllowed(true);
  aFilter = my3DActor->GetExtractUnstructuredGrid();
  aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
  aFilter->RegisterCellsWithType(VTK_TETRA);
  aFilter->RegisterCellsWithType(VTK_VOXEL);
  aFilter->RegisterCellsWithType(VTK_HEXAHEDRON);
  aFilter->RegisterCellsWithType(VTK_WEDGE);
  aFilter->RegisterCellsWithType(VTK_PYRAMID);
  aFilter->RegisterCellsWithType(VTK_HEXAGONAL_PRISM);
  aFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA);
  aFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON);
  aFilter->RegisterCellsWithType(VTK_TRIQUADRATIC_HEXAHEDRON);
  aFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE);
  aFilter->RegisterCellsWithType(VTK_QUADRATIC_PYRAMID);
  aFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET);
//#ifdef VTK_HAVE_POLYHEDRON
  MESSAGE("RegisterCellsWithType(VTK_POLYHEDRON)");
  aFilter->RegisterCellsWithType(VTK_POLYHEDRON);
//#endif

  my3DExtActor = SMESH_DeviceActor::New();
  my3DExtActor->SetUserMatrix(aMatrix);
  my3DExtActor->PickableOff();
  my3DExtActor->SetProperty(my2DExtProp);
  my3DExtActor->SetBackfaceProperty(my2DExtProp);
  my3DExtActor->SetRepresentation(SMESH_DeviceActor::eSurface);
  my3DExtActor->SetCoincident3DAllowed(true);
  aFilter = my3DExtActor->GetExtractUnstructuredGrid();
  aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
  aFilter->RegisterCellsWithType(VTK_TETRA);
  aFilter->RegisterCellsWithType(VTK_VOXEL);
  aFilter->RegisterCellsWithType(VTK_HEXAHEDRON);
  aFilter->RegisterCellsWithType(VTK_WEDGE);
  aFilter->RegisterCellsWithType(VTK_PYRAMID);
  aFilter->RegisterCellsWithType(VTK_HEXAGONAL_PRISM);
  aFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA);
  aFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON);
  aFilter->RegisterCellsWithType(VTK_TRIQUADRATIC_HEXAHEDRON);
  aFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE);
  aFilter->RegisterCellsWithType(VTK_QUADRATIC_PYRAMID);
  aFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET);
  aFilter->RegisterCellsWithType(VTK_POLYHEDRON);

  //Definition 1D device of the actor
  //---------------------------------
  myEdgeProp = vtkProperty::New();
  myEdgeProp->SetAmbient(1.0);
  myEdgeProp->SetDiffuse(0.0);
  myEdgeProp->SetSpecular(0.0);
  SMESH::GetColor( "SMESH", "wireframe_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
  myEdgeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
  myEdgeProp->SetLineWidth(aLineWidth);

  my1DActor = SMESH_CellLabelActor::New();
  my1DActor->SetStoreGemetryMapping(true);
  my1DActor->SetUserMatrix(aMatrix);
  my1DActor->PickableOff();
  my1DActor->SetHighlited(true);
  my1DActor->SetProperty(myEdgeProp);
  my1DActor->SetRepresentation(SMESH_DeviceActor::eSurface);
  aFilter = my1DActor->GetExtractUnstructuredGrid();
  aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
  aFilter->RegisterCellsWithType(VTK_LINE);
  aFilter->RegisterCellsWithType(VTK_QUADRATIC_EDGE);

  my1DProp = vtkProperty::New();
  my1DProp->DeepCopy(myEdgeProp);
  my1DProp->SetLineWidth(aLineWidth + aLineWidthInc);
  my1DProp->SetPointSize(aElem0DSize);
  
  my1DExtProp = vtkProperty::New();
  my1DExtProp->DeepCopy(myEdgeProp);
  anRGB[0] = 1 - anRGB[0];
  anRGB[1] = 1 - anRGB[1];
  anRGB[2] = 1 - anRGB[2];
  my1DExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
  my1DExtProp->SetLineWidth(aLineWidth + aLineWidthInc);
  my1DExtProp->SetPointSize(aElem0DSize);

  my1DExtActor = SMESH_DeviceActor::New();
  my1DExtActor->SetUserMatrix(aMatrix);
  my1DExtActor->PickableOff();
  my1DExtActor->SetHighlited(true);
  my1DExtActor->SetVisibility(false);
  my1DExtActor->SetProperty(my1DExtProp);
  my1DExtActor->SetRepresentation(SMESH_DeviceActor::eInsideframe);
  aFilter = my1DExtActor->GetExtractUnstructuredGrid();
  aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
  aFilter->RegisterCellsWithType(VTK_LINE);
  aFilter->RegisterCellsWithType(VTK_QUADRATIC_EDGE);


  //Definition 0D device of the actor (0d elements)
  //-----------------------------------------------
  my0DProp = vtkProperty::New();
  SMESH::GetColor( "SMESH", "elem0d_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 255, 0 ) );
  my0DProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
  my0DProp->SetPointSize(aElem0DSize);

  my0DActor = SMESH_CellLabelActor::New();
  my0DActor->SetUserMatrix(aMatrix);
  my0DActor->SetStoreGemetryMapping(true);
  my0DActor->PickableOff();
  my0DActor->SetVisibility(false);
  my0DActor->SetProperty(my0DProp);
  my0DActor->SetRepresentation(SMESH_DeviceActor::eSurface);
  aFilter = my0DActor->GetExtractUnstructuredGrid();
  //aFilter->SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints);
  aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
  aFilter->RegisterCellsWithType(VTK_VERTEX);
  
  //my0DExtProp = vtkProperty::New();
  //my0DExtProp->DeepCopy(my0DProp);
  //anRGB[0] = 1 - anRGB[0];
  //anRGB[1] = 1 - anRGB[1];
  //anRGB[2] = 1 - anRGB[2];
  //my0DExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
  //my0DExtProp->SetPointSize(aElem0DSize);
  //
  //my0DExtActor = SMESH_DeviceActor::New();
  //my0DExtActor->SetUserMatrix(aMatrix);
  //my0DExtActor->SetStoreClippingMapping(true);
  //my0DExtActor->PickableOff();
  //my0DExtActor->SetHighlited(true);
  //my0DExtActor->SetVisibility(false);
  //my0DExtActor->SetProperty(my0DExtProp);
  //my0DExtActor->SetRepresentation(SMESH_DeviceActor::eInsideframe);
  //aFilter = my0DExtActor->GetExtractUnstructuredGrid();
  //aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);
  //aFilter->RegisterCellsWithType(VTK_VERTEX);


  //Definition 0D device of the actor (nodes)
  //-----------------------------------------
  myNodeProp = vtkProperty::New();
  SMESH::GetColor( "SMESH", "node_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 0, 0 ) );
  myNodeProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);

  myNodeActor = SMESH_NodeLabelActor::New();
  myNodeActor->SetUserMatrix(aMatrix);
  myNodeActor->SetStoreClippingMapping(true);
  myNodeActor->PickableOff();
  myNodeActor->SetVisibility(false);
  myNodeActor->SetProperty(myNodeProp);
  myNodeActor->SetRepresentation(SMESH_DeviceActor::ePoint);
  aFilter = myNodeActor->GetExtractUnstructuredGrid();
  aFilter->SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints);
  
  myNodeExtProp = vtkProperty::New();
  myNodeExtProp->DeepCopy(myNodeProp);
  anRGB[0] = 1 - anRGB[0];
  anRGB[1] = 1 - anRGB[1];
  anRGB[2] = 1 - anRGB[2];
  myNodeExtProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);

  myNodeExtActor = SMESH_DeviceActor::New();
  myNodeExtActor->SetUserMatrix(aMatrix);
  myNodeExtActor->SetStoreClippingMapping(true);
  myNodeExtActor->PickableOff();
  myNodeExtActor->SetHighlited(true);
  myNodeExtActor->SetVisibility(false);
  myNodeExtActor->SetProperty(myNodeExtProp);
  myNodeExtActor->SetRepresentation(SMESH_DeviceActor::ePoint);
  aFilter = myNodeExtActor->GetExtractUnstructuredGrid();
  aFilter->SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints);
  aFilter->RegisterCellsWithType(VTK_VERTEX);

  //Definition of Pickable and Highlitable engines
  //----------------------------------------------

  myBaseActor->SetUserMatrix(aMatrix);
  myBaseActor->SetStoreGemetryMapping(true);
  myBaseActor->GetProperty()->SetOpacity(0.0);
  myPickableActor = myBaseActor;
  
  myHighlightProp = vtkProperty::New();
  myHighlightProp->SetAmbient(1.0);
  myHighlightProp->SetDiffuse(0.0);
  myHighlightProp->SetSpecular(0.0);
  SMESH::GetColor( "SMESH", "selection_object_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 255, 255 ) );
  myHighlightProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
  myHighlightProp->SetPointSize(aElem0DSize); // ??
  myHighlightProp->SetLineWidth(aLineWidth);
  myHighlightProp->SetRepresentation(1);

  myOutLineProp = vtkProperty::New();
  myOutLineProp->SetAmbient(1.0);
  myOutLineProp->SetDiffuse(0.0);
  myOutLineProp->SetSpecular(0.0);
  SMESH::GetColor( "SMESH", "outline_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 70, 0 ) );
  myOutLineProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
  myOutLineProp->SetPointSize(aElem0DSize); // ??
  myOutLineProp->SetLineWidth(aLineWidth);
  myOutLineProp->SetRepresentation(1);

  myPreselectProp = vtkProperty::New();
  myPreselectProp->SetAmbient(1.0);
  myPreselectProp->SetDiffuse(0.0);
  myPreselectProp->SetSpecular(0.0);
  SMESH::GetColor( "SMESH", "highlight_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 255, 255 ) );
  myPreselectProp->SetColor(anRGB[0],anRGB[1],anRGB[2]);
  myPreselectProp->SetPointSize(aElem0DSize); // ??
  myPreselectProp->SetLineWidth(aLineWidth);
  myPreselectProp->SetRepresentation(1);

  myHighlitableActor = SMESH_DeviceActor::New();
  myHighlitableActor->SetUserMatrix(aMatrix);
  myHighlitableActor->PickableOff();
  myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe);
  myHighlitableActor->SetCoincident3DAllowed(true);

  aMatrix->Delete();

  myName = "";
  myIO = NULL;

  myControlMode = eNone;
  myControlActor = my2DActor;

  //Definition of myScalarBarActor
  //------------------------------
  myLookupTable = vtkLookupTable::New();
  //Fix for Bug PAL5195 - SMESH764: 
  //Controls - Aspect Ratio: incorrect colors of the best and worst values
  myLookupTable->SetHueRange(0.667,0.0);

  myScalarBarActor = SMESH_ScalarBarActor::New();
  myScalarBarActor->SetVisibility(false);
  myScalarBarActor->SetLookupTable(myLookupTable);

  //Fix for Bug 13314:
  //Incorrect "Min value" in Scalar Bar in Mesh:
  //  myScalarBarActor->SetLabelFormat("%.4g");
  // changes was commented because of regression bug IPAL 19981

  mgr = SUIT_Session::session()->resourceMgr();
  if( !mgr )
    return;

  myEntityMode = eAllEntity;
  myEntityModeCache = eAllEntity;
  
  // Clipping planes
  myImplicitBoolean = vtkImplicitBoolean::New();
  myImplicitBoolean->SetOperationTypeToIntersection();
  
  //Quadratic 2D elements representation
  //-----------------------------------------------------------------------------
  int aQuadratic2DMode = mgr->integerValue( "SMESH", "quadratic_mode", 0);
  if(aQuadratic2DMode == 0){
    myHighlitableActor->SetQuadraticArcMode(false);
    my2DActor->SetQuadraticArcMode(false);
    my1DActor->SetQuadraticArcMode(false);
  }
  else if(aQuadratic2DMode == 1){
    myHighlitableActor->SetQuadraticArcMode(true);
    my2DActor->SetQuadraticArcMode(true);
    my1DActor->SetQuadraticArcMode(true);
  }
  
  int aQuadraticAngle = mgr->integerValue( "SMESH", "max_angle", 2);
  myHighlitableActor->SetQuadraticArcAngle(aQuadraticAngle);
  my2DActor->SetQuadraticArcAngle(aQuadraticAngle);
  
  // Set colors of the name actor
  SMESH::GetColor( "SMESH", "fill_color", anRGB[0], anRGB[1], anRGB[2], QColor( 0, 170, 255 ) );
  myNameActor->SetBackgroundColor(anRGB[0], anRGB[1], anRGB[2]);
  SMESH::GetColor( "SMESH", "group_name_color", anRGB[0], anRGB[1], anRGB[2], QColor( 255, 255, 255 ) );
  myNameActor->SetForegroundColor(anRGB[0], anRGB[1], anRGB[2]);

#ifndef DISABLE_PLOT2DVIEWER
  my2dHistogram = 0;
#endif

}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 484 of file SMESH_Actor.cxx.

{
  if(MYDEBUG) MESSAGE("~SMESH_ActorDef - "<<this);

#ifndef DISABLE_PLOT2DVIEWER
  if(my2dHistogram) {
    SMESH::ProcessIn2DViewers(this,SMESH::RemoveFrom2dViewer);
    delete my2dHistogram;
  }
#endif

  myScalarBarActor->Delete();
  myLookupTable->Delete();

  mySurfaceProp->Delete();
  myBackSurfaceProp->Delete();
  myOutLineProp->Delete();

  myEdgeProp->Delete();
  myHighlightProp->Delete();
  myPreselectProp->Delete();

  myNodeProp->Delete();
  myNodeExtProp->Delete();
 
  my0DProp->Delete();
  my0DActor->Delete();

  //my0DExtProp->Delete();
  //my0DExtActor->Delete();
 
  my1DProp->Delete();
  my1DActor->Delete();

  my1DExtProp->Delete();
  my1DExtActor->Delete();

  my2DActor->Delete();
  my2DExtProp->Delete();
  my2DExtActor->Delete();
  my3DActor->Delete();
  my3DExtActor->Delete();

  myNodeActor->Delete();
  myBaseActor->Delete();

  myNodeExtActor->Delete();  
  myHighlitableActor->Delete();

  myImplicitBoolean->Delete();

  myTimeStamp->Delete();
}

Here is the call graph for this function:


Member Function Documentation

vtkIdType SMESH_ActorDef::AddClippingPlane ( vtkPlane *  thePlane) [virtual]

Definition at line 1883 of file SMESH_Actor.cxx.

{
  if(thePlane){
    myImplicitBoolean->GetFunction()->AddItem(thePlane);
    myCippingPlaneCont.push_back(thePlane);
    if(!IsImplicitFunctionUsed())
      SetImplicitFunctionUsed(true);
    myNodeActor->UpdateLabels();
  }
  return myCippingPlaneCont.size();
}

Here is the call graph for this function:

void SMESH_ActorDef::AddToRender ( vtkRenderer *  theRenderer) [virtual]

Definition at line 930 of file SMESH_Actor.cxx.

                                                        {
  theRenderer->AddActor(myBaseActor);  
  theRenderer->AddActor(myNodeExtActor);
  theRenderer->AddActor(my1DExtActor);

  my3DActor->AddToRender(theRenderer);
  my3DExtActor->AddToRender(theRenderer);
  my2DActor->AddToRender(theRenderer);
  my2DExtActor->AddToRender(theRenderer);
  myNodeActor->AddToRender(theRenderer);
  my1DActor->AddToRender(theRenderer);
  my0DActor->AddToRender(theRenderer);
  //theRenderer->AddActor(my0DExtActor);

  theRenderer->AddActor(myHighlitableActor);
  
  theRenderer->AddActor2D(myScalarBarActor);

  // the superclass' method should be called at the end
  // (in particular, for correct work of selection)
  SALOME_Actor::AddToRender(theRenderer);
}
void SMESH_ActorDef::Delete ( ) [virtual]

Definition at line 538 of file SMESH_Actor.cxx.

{
  // This is just to guarantee that the DeleteActorEvent (which was previously invoked
  // from the actor's destructor) will be thrown before removing the actor's observers,
  // that is done inside the Superclass::Delete() method but before the destructor itself
  // (see the issue 0021562: EDF SMESH: clipping and delete mesh clipped leads to crash).
  // The event is caught by SMESHGUI::ProcessEvents() static method.
  this->InvokeEvent( SMESH::DeleteActorEvent, NULL );

  Superclass::Delete();
}
void SMESH_ActorDef::Get0DColor ( vtkFloatingPointType &  r,
vtkFloatingPointType &  g,
vtkFloatingPointType &  b 
) [virtual]

Definition at line 1798 of file SMESH_Actor.cxx.

                                                                                                      { 
  ::GetColor(my0DProp,r,g,b);
}

Here is the call graph for this function:

vtkFloatingPointType SMESH_ActorDef::Get0DSize ( ) [virtual]

Definition at line 1844 of file SMESH_Actor.cxx.

                                              {
  return my0DProp->GetPointSize();
}
vtkFloatingPointType * SMESH_ActorDef::GetBounds ( ) [virtual]

Definition at line 1061 of file SMESH_Actor.cxx.

                                               {
  return myNodeActor->GetBounds();
}
bool SMESH_ActorDef::GetCellsLabeled ( ) [virtual]

Definition at line 581 of file SMESH_Actor.cxx.

                                     {
  bool result = false;
  if(my3DActor)
    result = result || my3DActor->GetCellsLabeled();

  if(my2DActor)
    result = result || my2DActor->GetCellsLabeled();

  if(my1DActor)
    result = result || my1DActor->GetCellsLabeled();

  if(my0DActor)
    result = result || my0DActor->GetCellsLabeled();

  return result;
}
vtkPlane * SMESH_ActorDef::GetClippingPlane ( vtkIdType  theID) [virtual]

Definition at line 1915 of file SMESH_Actor.cxx.

{
  if(theID >= myCippingPlaneCont.size())
    return NULL;
  return myCippingPlaneCont[theID].Get();
}
virtual eControl SMESH_ActorDef::GetControlMode ( ) [inline, virtual]

Definition at line 187 of file SMESH_ActorDef.h.

{ return myControlMode;}

Here is the caller graph for this function:

virtual long SMESH_ActorDef::GetControlsPrecision ( ) const [inline, virtual]

Definition at line 200 of file SMESH_ActorDef.h.

{ return myControlsPrecision; }
void SMESH_ActorDef::GetEdgeColor ( vtkFloatingPointType &  r,
vtkFloatingPointType &  g,
vtkFloatingPointType &  b 
) [virtual]

Definition at line 1763 of file SMESH_Actor.cxx.

                                                                                                        {
  ::GetColor(myEdgeProp,r,g,b);
}

Here is the call graph for this function:

vtkCell * SMESH_ActorDef::GetElemCell ( int  theObjID) [virtual]

Definition at line 1203 of file SMESH_Actor.cxx.

                                                {
  return myPickableActor->GetElemCell(theObjID);
}
int SMESH_ActorDef::GetElemObjId ( int  theVtkID) [virtual]

Definition at line 1199 of file SMESH_Actor.cxx.

                                            {
  return myPickableActor->GetElemObjId(theVtkID);
}
virtual unsigned int SMESH_ActorDef::GetEntityMode ( ) const [inline, virtual]

Definition at line 147 of file SMESH_ActorDef.h.

{ return myEntityMode;}

Here is the caller graph for this function:

Definition at line 642 of file SMESH_Actor.cxx.

{
  return my3DActor->GetFacesOrientation3DVectors();
}
void SMESH_ActorDef::GetFacesOrientationColor ( vtkFloatingPointType  theColor[3]) [virtual]

Definition at line 620 of file SMESH_Actor.cxx.

{
  my3DActor->GetFacesOrientationColor( theColor );
}
vtkFloatingPointType SMESH_ActorDef::GetFacesOrientationScale ( ) [virtual]

Definition at line 631 of file SMESH_Actor.cxx.

{
  return my3DActor->GetFacesOrientationScale();
}

Definition at line 609 of file SMESH_Actor.cxx.

{
  return myIsFacesOriented;
}

Definition at line 188 of file SMESH_ActorDef.h.

{ return myFunctor; }
void SMESH_ActorDef::GetHighlightColor ( vtkFloatingPointType &  r,
vtkFloatingPointType &  g,
vtkFloatingPointType &  b 
) [virtual]

Definition at line 1807 of file SMESH_Actor.cxx.

Here is the call graph for this function:

vtkDataSet * SMESH_ActorDef::GetInput ( ) [virtual]

Definition at line 1066 of file SMESH_Actor.cxx.

                                    {
  return GetUnstructuredGrid();
}

Here is the call graph for this function:

vtkFloatingPointType SMESH_ActorDef::GetLineWidth ( ) [virtual]

Definition at line 1821 of file SMESH_Actor.cxx.

                                                 {
  return myEdgeProp->GetLineWidth();
}
vtkMapper * SMESH_ActorDef::GetMapper ( ) [virtual]

Definition at line 1106 of file SMESH_Actor.cxx.

                                    {
  return myPickableActor->GetMapper();
}
void SMESH_ActorDef::GetNodeColor ( vtkFloatingPointType &  r,
vtkFloatingPointType &  g,
vtkFloatingPointType &  b 
) [virtual]

Definition at line 1786 of file SMESH_Actor.cxx.

                                                                                                        { 
  ::GetColor(myNodeProp,r,g,b);
}

Here is the call graph for this function:

vtkFloatingPointType * SMESH_ActorDef::GetNodeCoord ( int  theObjID) [virtual]

Definition at line 1194 of file SMESH_Actor.cxx.

                                                              {
  return myPickableActor->GetNodeCoord(theObjID);
}
int SMESH_ActorDef::GetNodeObjId ( int  theVtkID) [virtual]

Definition at line 1190 of file SMESH_Actor.cxx.

                                            {
  return myPickableActor->GetNodeObjId(theVtkID);
}

Definition at line 1908 of file SMESH_Actor.cxx.

{
  return myCippingPlaneCont.size();
}
int SMESH_ActorDef::GetObjDimension ( const int  theObjId) [virtual]

Definition at line 1848 of file SMESH_Actor.cxx.

{
  return myVisualObj->GetElemDimension( theObjId );
}
virtual TVisualObjPtr SMESH_ActorDef::GetObject ( ) [inline, virtual]

Definition at line 197 of file SMESH_ActorDef.h.

{ return myVisualObj;}
vtkFloatingPointType SMESH_ActorDef::GetOpacity ( ) [virtual]

Definition at line 1729 of file SMESH_Actor.cxx.

                                               {
  return mySurfaceProp->GetOpacity();
}
void SMESH_ActorDef::GetOutlineColor ( vtkFloatingPointType &  r,
vtkFloatingPointType &  g,
vtkFloatingPointType &  b 
) [virtual]

Definition at line 1772 of file SMESH_Actor.cxx.

Here is the call graph for this function:

virtual SPlot2d_Histogram* SMESH_ActorDef::GetPlot2Histogram ( ) [inline, virtual]

Definition at line 206 of file SMESH_ActorDef.h.

{ return my2dHistogram; }

Definition at line 1564 of file SMESH_Actor.cxx.

                                           { 
  return myIsPointsVisible || myNodeActor->GetPointsLabeled();
}

Here is the caller graph for this function:

Definition at line 559 of file SMESH_Actor.cxx.

                                      {
  return myNodeActor && myNodeActor->GetPointsLabeled();
}
void SMESH_ActorDef::GetPreHighlightColor ( vtkFloatingPointType &  r,
vtkFloatingPointType &  g,
vtkFloatingPointType &  b 
) [virtual]

Definition at line 1816 of file SMESH_Actor.cxx.

Here is the call graph for this function:

SMESH_Actor::EQuadratic2DRepresentation SMESH_ActorDef::GetQuadratic2DRepresentation ( ) [virtual]

Definition at line 2095 of file SMESH_Actor.cxx.

{
  if(myHighlitableActor->GetQuadraticArcMode())
    return SMESH_Actor::eArcs;
  else
    return SMESH_Actor::eLines;
}

Here is the caller graph for this function:

virtual SMESH_ScalarBarActor* SMESH_ActorDef::GetScalarBarActor ( ) [inline, virtual]

Definition at line 190 of file SMESH_ActorDef.h.

{ return myScalarBarActor;}
vtkFloatingPointType SMESH_ActorDef::GetShrinkFactor ( ) [virtual]

Definition at line 1133 of file SMESH_Actor.cxx.

                                                    {
  return myBaseActor->GetShrinkFactor();
}
void SMESH_ActorDef::GetSufaceColor ( vtkFloatingPointType &  r,
vtkFloatingPointType &  g,
vtkFloatingPointType &  b,
int &  delta 
) [virtual]

Definition at line 1747 of file SMESH_Actor.cxx.

                                                                                                                      {
  ::GetColor(mySurfaceProp,r,g,b);
  my2DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
  delta = myDeltaBrightness;
}

Here is the call graph for this function:

vtkUnstructuredGrid * SMESH_ActorDef::GetUnstructuredGrid ( ) [virtual]

Definition at line 1111 of file SMESH_Actor.cxx.

                                                        { 
  return myVisualObj->GetUnstructuredGrid();
}

Here is the caller graph for this function:

virtual bool SMESH_ActorDef::hasHighlight ( ) [inline, virtual]

Definition at line 97 of file SMESH_ActorDef.h.

{ return true; }  
void SMESH_ActorDef::highlight ( bool  theHighlight) [virtual]

Definition at line 1613 of file SMESH_Actor.cxx.

                                               {
  if ( myIsHighlighted == theHighlight )
    return;
  myIsHighlighted = theHighlight;
  UpdateHighlight();
}

Here is the call graph for this function:

bool SMESH_ActorDef::Init ( TVisualObjPtr  theVisualObj,
const char *  theEntry,
const char *  theName,
int  theIsClear 
) [protected]

Definition at line 978 of file SMESH_Actor.cxx.

{
  Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(theEntry,"SMESH",theName);
  setIO(anIO);
  setName(theName);

  myVisualObj = theVisualObj;
  myVisualObj->Update(theIsClear);

  myNodeActor->Init(myVisualObj,myImplicitBoolean);
  myBaseActor->Init(myVisualObj,myImplicitBoolean);

  myHighlitableActor->Init(myVisualObj,myImplicitBoolean);

  myNodeExtActor->Init(myVisualObj,myImplicitBoolean);
  
  my0DActor->Init(myVisualObj,myImplicitBoolean);
  //my0DExtActor->Init(myVisualObj,myImplicitBoolean);
  
  my1DActor->Init(myVisualObj,myImplicitBoolean);
  my1DExtActor->Init(myVisualObj,myImplicitBoolean);
  
  my2DActor->Init(myVisualObj,myImplicitBoolean);
  my2DExtActor->Init(myVisualObj,myImplicitBoolean);
  my3DActor->Init(myVisualObj,myImplicitBoolean);
  my3DExtActor->Init(myVisualObj,myImplicitBoolean);
  
  my0DActor->GetMapper()->SetLookupTable(myLookupTable);
  //my0DExtActor->GetMapper()->SetLookupTable(myLookupTable);
  
  my1DActor->GetMapper()->SetLookupTable(myLookupTable);
  my1DExtActor->GetMapper()->SetLookupTable(myLookupTable);

  my2DActor->GetMapper()->SetLookupTable(myLookupTable);
  my2DExtActor->GetMapper()->SetLookupTable(myLookupTable);
  my3DActor->GetMapper()->SetLookupTable(myLookupTable);
  my3DExtActor->GetMapper()->SetLookupTable(myLookupTable);
    
  vtkFloatingPointType aFactor, aUnits;
  my2DActor->GetPolygonOffsetParameters(aFactor,aUnits);
  my2DActor->SetPolygonOffsetParameters(aFactor,aUnits*0.75);
  my2DExtActor->SetPolygonOffsetParameters(aFactor,aUnits*0.5);

  SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
  if( !mgr )
    return false;

  //SetIsShrunkable(theGrid->GetNumberOfCells() > 10);
  SetIsShrunkable(true);

  SetShrinkFactor( SMESH::GetFloat( "SMESH:shrink_coeff", 75 ) / 100. );

  int aMode = mgr->integerValue( "SMESH", "display_mode" );
  SetRepresentation(-1);
  
  if(aMode == 0){
    SetRepresentation(eEdge);
  }else if(aMode == 1){
    SetRepresentation(eSurface);
  }else if(aMode == 2){
    SetRepresentation(ePoint);
  }
  
  if(aMode == 3){
    SetShrink();
  }

  if( dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
    SetIsDisplayNameActor( true );

  int aMarkerType = mgr->integerValue( "SMESH", "type_of_marker", 1 ); // dot
  int aMarkerScale = mgr->integerValue( "SMESH", "marker_scale", 9 );  // 5 pixels
  SetMarkerStd( (VTK::MarkerType)aMarkerType, (VTK::MarkerScale)aMarkerScale );

  myTimeStamp->Modified();
  Modified();
  return true;
}

Here is the call graph for this function:

bool SMESH_ActorDef::IsImplicitFunctionUsed ( ) const [protected]

Definition at line 1855 of file SMESH_Actor.cxx.

{
  return myBaseActor->IsImplicitFunctionUsed();
}

Here is the caller graph for this function:

bool SMESH_ActorDef::IsInfinitive ( ) [virtual]

Definition at line 1116 of file SMESH_Actor.cxx.

                                 {
  vtkDataSet *aDataSet = myPickableActor->GetUnstructuredGrid();
  aDataSet->Update();
  myIsInfinite = aDataSet->GetNumberOfCells() == 0 ||
    ( aDataSet->GetNumberOfCells() == 1 && 
    aDataSet->GetCell(0)->GetCellType() == VTK_VERTEX );
  return SALOME_Actor::IsInfinitive();
}
virtual bool SMESH_ActorDef::IsShrunk ( ) [inline, virtual]

Definition at line 164 of file SMESH_ActorDef.h.

{ return myIsShrunk;}
virtual bool SMESH_ActorDef::IsShrunkable ( ) [inline, virtual]

Definition at line 163 of file SMESH_ActorDef.h.

{ return myIsShrinkable;}
SMESH_ActorDef * SMESH_ActorDef::New ( ) [static, private]

Definition at line 96 of file SMESH_Actor.cxx.

                                   {
  return new SMESH_ActorDef();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SMESH_ActorDef::operator= ( const SMESH_ActorDef ) [private]
void SMESH_ActorDef::ReleaseGraphicsResources ( vtkWindow *  renWin) [virtual]

Definition at line 1704 of file SMESH_Actor.cxx.

                                                              {
  SALOME_Actor::ReleaseGraphicsResources(renWin);

  myPickableActor->ReleaseGraphicsResources(renWin);
}

Definition at line 1897 of file SMESH_Actor.cxx.

{
  myImplicitBoolean->GetFunction()->RemoveAllItems();
  myImplicitBoolean->GetFunction()->Modified(); // VTK bug
  myCippingPlaneCont.clear();
  SetImplicitFunctionUsed(false);
  myNodeActor->UpdateLabels();
}

Here is the call graph for this function:

void SMESH_ActorDef::RemoveFromRender ( vtkRenderer *  theRenderer) [virtual]

Definition at line 953 of file SMESH_Actor.cxx.

                                                             {
  SALOME_Actor::RemoveFromRender(theRenderer);

  theRenderer->RemoveActor(myBaseActor);

  theRenderer->RemoveActor(myNodeExtActor);

  theRenderer->RemoveActor(myHighlitableActor);

  //theRenderer->RemoveActor(my0DExtActor);

  theRenderer->RemoveActor(my1DExtActor);

  my2DActor->RemoveFromRender(theRenderer);
  my2DExtActor->RemoveFromRender(theRenderer);
  my3DActor->RemoveFromRender(theRenderer);
  my3DExtActor->RemoveFromRender(theRenderer);
  myNodeActor->RemoveFromRender(theRenderer);
  my0DActor->RemoveFromRender(theRenderer);
  my1DActor->RemoveFromRender(theRenderer);

  theRenderer->RemoveActor(myScalarBarActor);
}
void SMESH_ActorDef::Render ( vtkRenderer *  ren) [virtual]

Definition at line 1654 of file SMESH_Actor.cxx.

                                           {
  unsigned long aTime = myTimeStamp->GetMTime();
  unsigned long anObjTime = myVisualObj->GetUnstructuredGrid()->GetMTime();
  unsigned long aClippingTime = myImplicitBoolean->GetMTime();
  if(anObjTime > aTime || aClippingTime > aTime)
    Update();
}

Here is the call graph for this function:

Here is the caller graph for this function:

virtual void SMESH_ActorDef::Render ( vtkRenderer *  ,
vtkMapper *   
) [inline, private, virtual]

Definition at line 304 of file SMESH_ActorDef.h.

{};
int SMESH_ActorDef::RenderOpaqueGeometry ( vtkViewport *  viewport) [virtual]

Definition at line 1630 of file SMESH_Actor.cxx.

{
  if (myPickableActor->GetIsOpaque())
    {
    vtkRenderer *ren = static_cast<vtkRenderer *>(vp);
    this->Render(ren);
    return 1;
    }
  return 0;
}

Here is the call graph for this function:

int SMESH_ActorDef::RenderTranslucentGeometry ( vtkViewport *  viewport) [virtual]

Definition at line 1642 of file SMESH_Actor.cxx.

{
  if (!myPickableActor->GetIsOpaque())
    {
    vtkRenderer *ren = static_cast<vtkRenderer *>(vp);
    this->Render(ren);
    return 1;
    }
  return 0;
}

Here is the call graph for this function:

void SMESH_ActorDef::Set0DColor ( vtkFloatingPointType  r,
vtkFloatingPointType  g,
vtkFloatingPointType  b 
) [virtual]

Definition at line 1790 of file SMESH_Actor.cxx.

                                                                                                   { 
  my0DProp->SetColor(r,g,b);
  if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
    if( aGroupObj->GetElementType() == SMDSAbs_0DElement )
      myNameActor->SetBackgroundColor(r,g,b);
  Modified();
}
void SMESH_ActorDef::Set0DSize ( vtkFloatingPointType  size) [virtual]

Definition at line 1839 of file SMESH_Actor.cxx.

                                                         {
  my0DProp->SetPointSize(theVal);
  Modified();
}
void SMESH_ActorDef::SetCellsLabeled ( bool  theIsCellsLabeled) [virtual]

Definition at line 563 of file SMESH_Actor.cxx.

{
  if(my3DActor)
    my3DActor->SetCellsLabeled(theIsCellsLabeled);

  if(my2DActor)
    my2DActor->SetCellsLabeled(theIsCellsLabeled);

  if(my1DActor)
    my1DActor->SetCellsLabeled(theIsCellsLabeled);

  if(my0DActor)
    my0DActor->SetCellsLabeled(theIsCellsLabeled);
  
  myTimeStamp->Modified();
}
void SMESH_ActorDef::SetControlMode ( eControl  theMode) [virtual]

Definition at line 650 of file SMESH_Actor.cxx.

{
  SetControlMode(theMode,true);
}

Here is the caller graph for this function:

void SMESH_ActorDef::SetControlMode ( eControl  theMode,
bool  theCheckEntityMode 
) [protected]

Definition at line 658 of file SMESH_Actor.cxx.

{
  SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();  
  if( !mgr )
    return;

  myControlMode = eNone;
  theCheckEntityMode &= mgr->booleanValue( "SMESH", "display_entity", false );

  my0DActor->GetMapper()->SetScalarVisibility(false);
  my1DActor->GetMapper()->SetScalarVisibility(false);
  my2DActor->GetMapper()->SetScalarVisibility(false);
  my3DActor->GetMapper()->SetScalarVisibility(false);
  myScalarBarActor->SetVisibility(false);

  bool anIsScalarVisible = theMode > eNone;

  if(anIsScalarVisible) {
    switch(theMode) {
    case eLength:
    {
      SMESH::Controls::Length* aControl = new SMESH::Controls::Length();
      aControl->SetPrecision( myControlsPrecision );
      myFunctor.reset( aControl );
      myControlActor = my1DActor;
      break;
    }
    case eLength2D:
    {
      myFunctor.reset(new SMESH::Controls::Length2D());
      myControlActor = my2DActor;
      break;
    }
    case eFreeBorders:
      myFunctor.reset(new SMESH::Controls::FreeBorders());
      myControlActor = my1DActor;
      break;
    case eFreeEdges:
      myFunctor.reset(new SMESH::Controls::FreeEdges());
      myControlActor = my2DActor;
      break;
    case eFreeNodes:
      myFunctor.reset(new SMESH::Controls::FreeNodes());
      myControlActor = myNodeActor;
      break;
    case eFreeFaces:
      myFunctor.reset(new SMESH::Controls::FreeFaces());
      myControlActor = my2DActor;
      break;
    case eCoincidentNodes:
      {
        SMESH::Controls::CoincidentNodes* cn = new SMESH::Controls::CoincidentNodes();
        double tol = mgr->doubleValue( "SMESH", "equal_nodes_tolerance", 1e-7 );
        cn->SetTolerance( tol );
        myFunctor.reset(cn);
        myControlActor = myNodeActor;
        break;
      }
    case eCoincidentElems1D:
      myFunctor.reset(new SMESH::Controls::CoincidentElements1D());
      myControlActor = my1DActor;
      break;
    case eCoincidentElems2D:
      myFunctor.reset(new SMESH::Controls::CoincidentElements2D());
      myControlActor = my2DActor;
      break;
    case eCoincidentElems3D:
      myFunctor.reset(new SMESH::Controls::CoincidentElements3D());
      myControlActor = my3DActor;
      break;
    case eBareBorderFace:
      myFunctor.reset(new SMESH::Controls::BareBorderFace());
      myControlActor = my2DActor;
      break;
    case eOverConstrainedFace:
      myFunctor.reset(new SMESH::Controls::OverConstrainedFace());
      myControlActor = my2DActor;
      break;
    case eMultiConnection:
      myFunctor.reset(new SMESH::Controls::MultiConnection());
      myControlActor = my1DActor;
      break;
    case eMultiConnection2D:
      myFunctor.reset(new SMESH::Controls::MultiConnection2D());
      myControlActor = my2DActor;
      break;
    case eArea:
    {
      SMESH::Controls::Area* aControl = new SMESH::Controls::Area();
      aControl->SetPrecision( myControlsPrecision );
      myFunctor.reset( aControl );
      myControlActor = my2DActor;
      break;
    }
    case eTaper:
    {
      SMESH::Controls::Taper* aControl = new SMESH::Controls::Taper();
      aControl->SetPrecision( myControlsPrecision );
      myFunctor.reset( aControl );
      myControlActor = my2DActor;
      break;
    }
    case eAspectRatio:
    {
      SMESH::Controls::AspectRatio* aControl = new SMESH::Controls::AspectRatio();
      aControl->SetPrecision( myControlsPrecision );
      myFunctor.reset( aControl );
      myControlActor = my2DActor;
      break;
    }
    case eAspectRatio3D:
    {
      SMESH::Controls::AspectRatio3D* aControl = new SMESH::Controls::AspectRatio3D();
      aControl->SetPrecision( myControlsPrecision );
      myFunctor.reset( aControl );
      myControlActor = my3DActor;
      break;
    }
    case eVolume3D:
    {
      SMESH::Controls::Volume* aControl = new SMESH::Controls::Volume();
      aControl->SetPrecision( myControlsPrecision );
      myFunctor.reset( aControl );
      myControlActor = my3DActor;
      break;
    }
    case eMaxElementLength2D:
    {
      SMESH::Controls::MaxElementLength2D* aControl = new SMESH::Controls::MaxElementLength2D();
      aControl->SetPrecision( myControlsPrecision );
      myFunctor.reset( aControl );
      myControlActor = my2DActor;
      break;
    }
    case eMaxElementLength3D:
    {
      SMESH::Controls::MaxElementLength3D* aControl = new SMESH::Controls::MaxElementLength3D();
      aControl->SetPrecision( myControlsPrecision );
      myFunctor.reset( aControl );
      myControlActor = my3DActor;
      break;
    }
    case eBareBorderVolume:
    {
      myFunctor.reset(new SMESH::Controls::BareBorderVolume());
      myControlActor = my3DActor;
      break;
    }
    case eOverConstrainedVolume:
    {
      myFunctor.reset(new SMESH::Controls::OverConstrainedVolume());
      myControlActor = my3DActor;
      break;
    }
    case eMinimumAngle:
    {
      SMESH::Controls::MinimumAngle* aControl = new SMESH::Controls::MinimumAngle();
      aControl->SetPrecision( myControlsPrecision );
      myFunctor.reset( aControl );
      myControlActor = my2DActor;
      break;
    }
    case eWarping:
    {
      SMESH::Controls::Warping* aControl = new SMESH::Controls::Warping();
      aControl->SetPrecision( myControlsPrecision );
      myFunctor.reset( aControl );
      myControlActor = my2DActor;
      break;
    }
    case eSkew:
    {
      SMESH::Controls::Skew* aControl = new SMESH::Controls::Skew();
      aControl->SetPrecision( myControlsPrecision );
      myFunctor.reset( aControl );
      myControlActor = my2DActor;
      break;
    }
    default:
      return;
    }

    vtkUnstructuredGrid* aGrid = myControlActor->GetUnstructuredGrid();
    vtkIdType aNbCells = aGrid->GetNumberOfCells();
    if(aNbCells){
      myControlMode = theMode;
      switch(myControlMode){
      case eFreeNodes:
      case eCoincidentNodes:
        myNodeExtActor->SetExtControlMode(myFunctor);
        break;
      case eFreeEdges:
      case eFreeBorders:
      case eCoincidentElems1D:
        my1DExtActor->SetExtControlMode(myFunctor);
        break;
      case eFreeFaces:
      case eBareBorderFace:
      case eOverConstrainedFace:
      case eCoincidentElems2D:
        my2DExtActor->SetExtControlMode(myFunctor);
        break;
      case eBareBorderVolume:
      case eOverConstrainedVolume:
      case eCoincidentElems3D:
        my3DExtActor->SetExtControlMode(myFunctor);
        break;
      case eLength2D:
      case eMultiConnection2D:
        my1DExtActor->SetExtControlMode(myFunctor,myScalarBarActor,myLookupTable);
        UpdateDistribution();
        break;
      default:
        myControlActor->SetControlMode(myFunctor,myScalarBarActor,myLookupTable);
        UpdateDistribution();
      }
    }

    if(theCheckEntityMode) {
      if(myControlActor == my1DActor) {
        if (!myIsEntityModeCache){
          myEntityModeCache = GetEntityMode();
          myIsEntityModeCache=true;
        } 
        SetEntityMode(eEdges);
      }
      else if(myControlActor == my2DActor) {
        switch(myControlMode) {
        case eLength2D:
        case eFreeEdges:
        case eFreeFaces:
        case eMultiConnection2D:
          if (!myIsEntityModeCache){
            myEntityModeCache = GetEntityMode();
            myIsEntityModeCache=true;
          } 
          SetEntityMode(eFaces);
          break;
        default:
          if (!myIsEntityModeCache){
            myEntityModeCache = GetEntityMode();
            myIsEntityModeCache=true;
          }
          SetEntityMode(eFaces);
        }
      }else if(myControlActor == my3DActor) {
        if (!myIsEntityModeCache){
            myEntityModeCache = GetEntityMode();
            myIsEntityModeCache=true;
        } 
        SetEntityMode(eVolumes);
    }
    }

  }
  else {
    if(theCheckEntityMode){
      myEntityMode = myEntityModeCache;
      myIsEntityModeCache = false;
    }
    myFunctor.reset();
  }

  SetRepresentation(GetRepresentation());

  myTimeStamp->Modified();
  Modified();
  Update();
}

Here is the call graph for this function:

virtual void SMESH_ActorDef::SetControlsPrecision ( const long  p) [inline, virtual]

Definition at line 199 of file SMESH_ActorDef.h.

void SMESH_ActorDef::SetEdgeColor ( vtkFloatingPointType  r,
vtkFloatingPointType  g,
vtkFloatingPointType  b 
) [virtual]

Definition at line 1753 of file SMESH_Actor.cxx.

                                                                                                     {
  myEdgeProp->SetColor(r,g,b);
  my1DProp->SetColor(r,g,b);
  my1DExtProp->SetColor(1.0-r,1.0-g,1.0-b);
  if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
    if( aGroupObj->GetElementType() == SMDSAbs_Edge )
      myNameActor->SetBackgroundColor(r,g,b);
  Modified();
}
void SMESH_ActorDef::SetEntityMode ( unsigned int  theMode) [virtual]

Definition at line 1316 of file SMESH_Actor.cxx.

{
  myEntityState = eAllEntity;

  if(!myVisualObj->GetNbEntities(SMDSAbs_0DElement)) {
    myEntityState &= ~e0DElements;
    theMode &= ~e0DElements;
  }

  if(!myVisualObj->GetNbEntities(SMDSAbs_Edge)) {
    myEntityState &= ~eEdges;
    theMode &= ~eEdges;
  }

  if(!myVisualObj->GetNbEntities(SMDSAbs_Face)) {
    myEntityState &= ~eFaces;
    theMode &= ~eFaces;
  }

  if(!myVisualObj->GetNbEntities(SMDSAbs_Volume)) {
    myEntityState &= ~eVolumes;
    theMode &= ~eVolumes;
  }

  if (!theMode) {
    if(myVisualObj->GetNbEntities(SMDSAbs_0DElement))
      theMode |= e0DElements;

    if(myVisualObj->GetNbEntities(SMDSAbs_Edge))
      theMode |= eEdges;

    if(myVisualObj->GetNbEntities(SMDSAbs_Face))
      theMode |= eFaces;

    if(myVisualObj->GetNbEntities(SMDSAbs_Volume))
      theMode |= eVolumes;
  }

  myBaseActor->myGeomFilter->SetInside(myEntityMode != myEntityState);

  myEntityMode = theMode;
  VTKViewer_ExtractUnstructuredGrid* aFilter = NULL;
  aFilter = myBaseActor->GetExtractUnstructuredGrid();
  aFilter->ClearRegisteredCellsWithType();
  aFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);

  VTKViewer_ExtractUnstructuredGrid* aHightFilter = myHighlitableActor->GetExtractUnstructuredGrid();
  aHightFilter->ClearRegisteredCellsWithType();
  aHightFilter->SetModeOfChanging(VTKViewer_ExtractUnstructuredGrid::eAdding);

  if (myEntityMode & e0DElements) {
    if (MYDEBUG) MESSAGE("0D ELEMENTS");
    aFilter->RegisterCellsWithType(VTK_VERTEX);
    aHightFilter->RegisterCellsWithType(VTK_VERTEX);
  }

  if (myEntityMode & eEdges) {
    if (MYDEBUG) MESSAGE("EDGES");
    aFilter->RegisterCellsWithType(VTK_LINE);
    aFilter->RegisterCellsWithType(VTK_QUADRATIC_EDGE);

    aHightFilter->RegisterCellsWithType(VTK_LINE);
    aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_EDGE);
  }

  if (myEntityMode & eFaces) {
    if (MYDEBUG) MESSAGE("FACES");
    aFilter->RegisterCellsWithType(VTK_TRIANGLE);
    aFilter->RegisterCellsWithType(VTK_POLYGON);
    aFilter->RegisterCellsWithType(VTK_QUAD);
    aFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
    aFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
    aFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);

    aHightFilter->RegisterCellsWithType(VTK_TRIANGLE);
    aHightFilter->RegisterCellsWithType(VTK_POLYGON);
    aHightFilter->RegisterCellsWithType(VTK_QUAD);
    aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_TRIANGLE);
    aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_QUAD);
    aHightFilter->RegisterCellsWithType(VTK_BIQUADRATIC_QUAD);
  }

  if (myEntityMode & eVolumes) {
    if (MYDEBUG) MESSAGE("VOLUMES");
    aFilter->RegisterCellsWithType(VTK_TETRA);
    aFilter->RegisterCellsWithType(VTK_VOXEL);
    aFilter->RegisterCellsWithType(VTK_HEXAHEDRON);
    aFilter->RegisterCellsWithType(VTK_WEDGE);
    aFilter->RegisterCellsWithType(VTK_PYRAMID);
    aFilter->RegisterCellsWithType(VTK_HEXAGONAL_PRISM);
    aFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA);
    aFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON);
    aFilter->RegisterCellsWithType(VTK_TRIQUADRATIC_HEXAHEDRON);
    aFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE);
    aFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET);
//#ifdef VTK_HAVE_POLYHEDRON
    aFilter->RegisterCellsWithType(VTK_POLYHEDRON);
//#endif
    
    aHightFilter->RegisterCellsWithType(VTK_TETRA);
    aHightFilter->RegisterCellsWithType(VTK_VOXEL);
    aHightFilter->RegisterCellsWithType(VTK_HEXAHEDRON);
    aHightFilter->RegisterCellsWithType(VTK_WEDGE);
    aHightFilter->RegisterCellsWithType(VTK_PYRAMID);
    aHightFilter->RegisterCellsWithType(VTK_HEXAGONAL_PRISM);
    aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_TETRA);
    aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_HEXAHEDRON);
    aHightFilter->RegisterCellsWithType(VTK_TRIQUADRATIC_HEXAHEDRON);
    aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_WEDGE);
    aHightFilter->RegisterCellsWithType(VTK_QUADRATIC_PYRAMID);
    aHightFilter->RegisterCellsWithType(VTK_CONVEX_POINT_SET);
//#ifdef VTK_HAVE_POLYHEDRON
    aHightFilter->RegisterCellsWithType(VTK_POLYHEDRON);
//#endif
  }
  aFilter->Update();
  if (MYDEBUG) MESSAGE(aFilter->GetOutput()->GetNumberOfCells());
  SetVisibility(GetVisibility(),false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SMESH_ActorDef::SetFacesOrientation3DVectors ( bool  theState) [virtual]

Definition at line 636 of file SMESH_Actor.cxx.

{
  my2DActor->SetFacesOrientation3DVectors( theState );
  my3DActor->SetFacesOrientation3DVectors( theState );
}
void SMESH_ActorDef::SetFacesOrientationColor ( vtkFloatingPointType  theColor[3]) [virtual]

Definition at line 614 of file SMESH_Actor.cxx.

{
  my2DActor->SetFacesOrientationColor( theColor );
  my3DActor->SetFacesOrientationColor( theColor );
}
void SMESH_ActorDef::SetFacesOrientationScale ( vtkFloatingPointType  theScale) [virtual]

Definition at line 625 of file SMESH_Actor.cxx.

{
  my2DActor->SetFacesOrientationScale( theScale );
  my3DActor->SetFacesOrientationScale( theScale );
}
void SMESH_ActorDef::SetFacesOriented ( bool  theIsFacesOriented) [virtual]

Definition at line 599 of file SMESH_Actor.cxx.

{
  myIsFacesOriented = theIsFacesOriented;

  my2DActor->SetFacesOriented(theIsFacesOriented);
  my3DActor->SetFacesOriented(theIsFacesOriented);

  myTimeStamp->Modified();
}

Here is the caller graph for this function:

void SMESH_ActorDef::SetHighlightColor ( vtkFloatingPointType  r,
vtkFloatingPointType  g,
vtkFloatingPointType  b 
) [virtual]

Definition at line 1802 of file SMESH_Actor.cxx.

                                                                                                          { 
  myHighlightProp->SetColor(r,g,b);
  Modified();
}
void SMESH_ActorDef::SetImplicitFunctionUsed ( bool  theIsImplicitFunctionUsed) [protected]

Definition at line 1861 of file SMESH_Actor.cxx.

{
  myNodeActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
  myBaseActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);

  myHighlitableActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);

  myNodeExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);

  my0DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
  //my0DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);

  my1DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
  my1DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);

  my2DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
  my2DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
  my3DActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
  my3DExtActor->SetImplicitFunctionUsed(theIsImplicitFunctionUsed);
}

Here is the caller graph for this function:

void SMESH_ActorDef::SetIsShrunkable ( bool  theShrunkable) [protected]

Definition at line 1126 of file SMESH_Actor.cxx.

                                                      {
  if ( myIsShrinkable == theShrunkable )
    return;
  myIsShrinkable = theShrunkable;
  Modified();
}

Here is the caller graph for this function:

void SMESH_ActorDef::SetLineWidth ( vtkFloatingPointType  theVal) [virtual]

Definition at line 1826 of file SMESH_Actor.cxx.

                                                            {
  myEdgeProp->SetLineWidth(theVal);

  my1DProp->SetLineWidth(theVal + aLineWidthInc);
  my1DExtProp->SetLineWidth(theVal + aLineWidthInc);    
  my2DExtProp->SetLineWidth(theVal + aLineWidthInc);
  myOutLineProp->SetLineWidth(theVal);
  myHighlightProp->SetLineWidth(theVal);
  myPreselectProp->SetLineWidth(theVal);
  Modified();
}
void SMESH_ActorDef::SetMapper ( vtkMapper *  theMapper) [private, virtual]

Definition at line 1096 of file SMESH_Actor.cxx.

                                                  {
  vtkLODActor::SetMapper(theMapper);
}

Here is the caller graph for this function:

void SMESH_ActorDef::SetMarkerStd ( VTK::MarkerType  theMarkerType,
VTK::MarkerScale  theMarkerScale 
) [virtual]

Definition at line 2103 of file SMESH_Actor.cxx.

{
  SALOME_Actor::SetMarkerStd( theMarkerType, theMarkerScale );
  myNodeActor->SetMarkerStd( theMarkerType, theMarkerScale );
  myNodeExtActor->SetMarkerStd( theMarkerType, theMarkerScale );
}

Here is the caller graph for this function:

void SMESH_ActorDef::SetMarkerTexture ( int  theMarkerId,
VTK::MarkerTexture  theMarkerTexture 
) [virtual]

Definition at line 2110 of file SMESH_Actor.cxx.

{
  SALOME_Actor::SetMarkerTexture( theMarkerId, theMarkerTexture );
  myNodeActor->SetMarkerTexture( theMarkerId, theMarkerTexture );
  myNodeExtActor->SetMarkerTexture( theMarkerId, theMarkerTexture );
  myMarkerTexture = theMarkerTexture; // for deferred update of myHighlightActor
}
void SMESH_ActorDef::SetNodeColor ( vtkFloatingPointType  r,
vtkFloatingPointType  g,
vtkFloatingPointType  b 
) [virtual]

Definition at line 1777 of file SMESH_Actor.cxx.

                                                                                                     { 
  myNodeProp->SetColor(r,g,b);
  myNodeExtProp->SetColor(1.0-r,1.0-g,1.0-b);
  if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
    if( aGroupObj->GetElementType() == SMDSAbs_Node )
      myNameActor->SetBackgroundColor(r,g,b);
  Modified();
}
void SMESH_ActorDef::SetOpacity ( vtkFloatingPointType  theValue) [virtual]

Definition at line 1719 of file SMESH_Actor.cxx.

                                                            {
  mySurfaceProp->SetOpacity(theValue);
  myBackSurfaceProp->SetOpacity(theValue);
  myEdgeProp->SetOpacity(theValue);
  myNodeProp->SetOpacity(theValue);

  my1DProp->SetOpacity(theValue);
}
void SMESH_ActorDef::SetOutlineColor ( vtkFloatingPointType  r,
vtkFloatingPointType  g,
vtkFloatingPointType  b 
) [virtual]

Definition at line 1767 of file SMESH_Actor.cxx.

                                                                                                        {
  myOutLineProp->SetColor(r,g,b);
  Modified();
}
void SMESH_ActorDef::SetPointRepresentation ( bool  theIsPointsVisible) [virtual]

Definition at line 1557 of file SMESH_Actor.cxx.

                                                                  {
  if ( myIsPointsVisible == theIsPointsVisible )
    return;
  myIsPointsVisible = theIsPointsVisible;
  SetRepresentation(GetRepresentation());
}

Here is the call graph for this function:

void SMESH_ActorDef::SetPointsLabeled ( bool  theIsPointsLabeled) [virtual]

Definition at line 550 of file SMESH_Actor.cxx.

{    
  if(myNodeActor) {
    myNodeActor->SetPointsLabeled(theIsPointsLabeled);
    SetRepresentation(GetRepresentation());
    myTimeStamp->Modified();
  }
}

Here is the call graph for this function:

void SMESH_ActorDef::SetPreHighlightColor ( vtkFloatingPointType  r,
vtkFloatingPointType  g,
vtkFloatingPointType  b 
) [virtual]

Definition at line 1811 of file SMESH_Actor.cxx.

                                                                                                             { 
  myPreselectProp->SetColor(r,g,b);
  Modified();
}
void SMESH_ActorDef::SetPreSelected ( bool  thePreselect = false) [virtual]

Definition at line 1621 of file SMESH_Actor.cxx.

                                                    { 
  if ( myIsPreselected == thePreselect )
    return;
  myIsPreselected = thePreselect; 
  UpdateHighlight();
}

Here is the call graph for this function:

void SMESH_ActorDef::SetQuadratic2DRepresentation ( EQuadratic2DRepresentation  theMode) [virtual]

Definition at line 2074 of file SMESH_Actor.cxx.

{
  switch(theMode) {
  case SMESH_Actor::eLines :
    myHighlitableActor->SetQuadraticArcMode(false);
    my2DActor->SetQuadraticArcMode(false);
    my1DActor->SetQuadraticArcMode(false);
    break;
  case SMESH_Actor::eArcs :
    myHighlitableActor->SetQuadraticArcMode(true);
    if(GetRepresentation() != SMESH_Actor::ePoint) {
      my2DActor->SetQuadraticArcMode(true);
      my1DActor->SetQuadraticArcMode(true);
    }
    break;
  default:
    break;
  }
}
void SMESH_ActorDef::SetRepresentation ( int  theMode) [virtual]

Definition at line 1436 of file SMESH_Actor.cxx.

{ 
  int aNbEdges = myVisualObj->GetNbEntities(SMDSAbs_Edge);
  int aNbFaces = myVisualObj->GetNbEntities(SMDSAbs_Face);
  int aNbVolumes = myVisualObj->GetNbEntities(SMDSAbs_Volume);

  if (theMode < 0) {
    myRepresentation = eSurface;
    if (!aNbFaces && !aNbVolumes && aNbEdges) {
      myRepresentation = eEdge;
    } else if (!aNbFaces && !aNbVolumes && !aNbEdges) {
      myRepresentation = ePoint;
    }
  } else {
    switch (theMode) {
    case eEdge:
      if (!aNbFaces && !aNbVolumes && !aNbEdges) return;
      break;
    case eSurface:
      if (!aNbFaces && !aNbVolumes) return;
      break;
    }    
    myRepresentation = theMode;
  }

  if (!GetUnstructuredGrid()->GetNumberOfCells())
    myRepresentation = ePoint;

  if (myIsShrunk) {
    if (myRepresentation == ePoint) {
      UnShrink();
      myIsShrunk = true;
    } else {
      SetShrink();
    }      
  }

  myPickableActor = myBaseActor;
  myNodeActor->SetVisibility(false);
  myNodeExtActor->SetVisibility(false);
  vtkProperty *aProp = NULL, *aBackProp = NULL;
  SMESH_DeviceActor::EReperesent aReperesent = SMESH_DeviceActor::EReperesent(-1);
  SMESH_Actor::EQuadratic2DRepresentation aQuadraticMode = GetQuadratic2DRepresentation();
  switch (myRepresentation) {
  case ePoint:
    myPickableActor = myNodeActor;
    myNodeActor->SetVisibility(true);
    aQuadraticMode = SMESH_Actor::eLines;
    aProp = aBackProp = myNodeProp;
    aReperesent = SMESH_DeviceActor::ePoint;
    break;
  case eEdge:
    aProp = aBackProp = myEdgeProp;
    aReperesent = SMESH_DeviceActor::eInsideframe;
    break;
  case eSurface:
    aProp = mySurfaceProp;
    aBackProp = myBackSurfaceProp;
    aReperesent = SMESH_DeviceActor::eSurface;
    break;
  }

  my2DActor->SetProperty(aProp);
  my2DActor->SetBackfaceProperty(aBackProp);
  my2DActor->SetRepresentation(aReperesent);

  if(aQuadraticMode == SMESH_Actor::eLines)
    my2DActor->SetQuadraticArcMode(false);
  else if(aQuadraticMode == SMESH_Actor::eArcs)
    my2DActor->SetQuadraticArcMode(true);

  my2DExtActor->SetRepresentation(aReperesent);
  
  my3DActor->SetProperty(aProp);
  my3DActor->SetBackfaceProperty(aBackProp);
  my3DActor->SetRepresentation(aReperesent);

  //my0DExtActor->SetVisibility(false);
  my1DExtActor->SetVisibility(false);
  my2DExtActor->SetVisibility(false);
  my3DExtActor->SetVisibility(false);

  // ???
  //my0DActor->SetProperty(aProp);
  //my0DActor->SetBackfaceProperty(aBackProp);
  my0DActor->SetRepresentation(aReperesent);
  //my0DExtActor->SetRepresentation(aReperesent);

  switch(myControlMode){
  case eLength:
  case eMultiConnection:
    aProp = aBackProp = my1DProp;
    if(myRepresentation != ePoint)
      aReperesent = SMESH_DeviceActor::eInsideframe;
    break;
  }
  
  if(aQuadraticMode == SMESH_Actor::eLines)
    my1DActor->SetQuadraticArcMode(false);
  else if(aQuadraticMode == SMESH_Actor::eArcs)
    my1DActor->SetQuadraticArcMode(true);

  my1DActor->SetProperty(aProp);
  my1DActor->SetBackfaceProperty(aBackProp);
  my1DActor->SetRepresentation(aReperesent);

  my1DExtActor->SetRepresentation(aReperesent);

  if(myIsPointsVisible)
    myPickableActor = myNodeActor;
  if(GetPointRepresentation())
    myNodeActor->SetVisibility(true);

  SetMapper(myPickableActor->GetMapper());

  SetVisibility(GetVisibility(),false);

  Modified();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void SMESH_ActorDef::SetShrink ( ) [virtual]

Definition at line 1153 of file SMESH_Actor.cxx.

                              {
  if(!myIsShrinkable) return;

  myBaseActor->SetShrink();

  my1DActor->SetShrink();
  my1DExtActor->SetShrink();

  my2DActor->SetShrink();
  my2DExtActor->SetShrink();
  my3DActor->SetShrink();
  my3DExtActor->SetShrink();
  myHighlitableActor->SetShrink();

  myIsShrunk = true;
  Modified();
}

Here is the caller graph for this function:

void SMESH_ActorDef::SetShrinkFactor ( vtkFloatingPointType  theValue) [virtual]

Definition at line 1137 of file SMESH_Actor.cxx.

                                                                 {
  myBaseActor->SetShrinkFactor(theValue);

  my1DActor->SetShrinkFactor(theValue);
  my1DExtActor->SetShrinkFactor(theValue);

  my2DActor->SetShrinkFactor(theValue);
  my2DExtActor->SetShrinkFactor(theValue);
  my3DActor->SetShrinkFactor(theValue);
  my3DExtActor->SetShrinkFactor(theValue);
  my3DExtActor->SetShrinkFactor(theValue);
  myHighlitableActor->SetShrinkFactor(theValue);

  Modified();
}

Here is the caller graph for this function:

void SMESH_ActorDef::SetSufaceColor ( vtkFloatingPointType  r,
vtkFloatingPointType  g,
vtkFloatingPointType  b,
int  delta 
) [virtual]

Definition at line 1734 of file SMESH_Actor.cxx.

                                                                                                                  {
  mySurfaceProp->SetColor(r,g,b);
  if( SMESH_GroupObj* aGroupObj = dynamic_cast<SMESH_GroupObj*>( myVisualObj.get() ) )
    if( aGroupObj->GetElementType() == SMDSAbs_Face ||
        aGroupObj->GetElementType() == SMDSAbs_Volume )
      myNameActor->SetBackgroundColor(r,g,b);
  
  myDeltaBrightness = delta;
  QColor bfc = Qtx::mainColorToSecondary(QColor(int(r*255),int(g*255),int(b*255)), delta);
  myBackSurfaceProp->SetColor( bfc.red() / 255. , bfc.green() / 255. , bfc.blue() / 255. );
  Modified();
}
void SMESH_ActorDef::SetTransform ( VTKViewer_Transform *  theTransform) [virtual]

Definition at line 1071 of file SMESH_Actor.cxx.

                                                                  {
  Superclass::SetTransform(theTransform);

  myNodeActor->SetTransform(theTransform);
  myBaseActor->SetTransform(theTransform);
  
  myHighlitableActor->SetTransform(theTransform);

  myNodeExtActor->SetTransform(theTransform);

  my0DActor->SetTransform(theTransform);
  //my0DExtActor->SetTransform(theTransform);

  my1DActor->SetTransform(theTransform);
  my1DExtActor->SetTransform(theTransform);

  my2DActor->SetTransform(theTransform);
  my2DExtActor->SetTransform(theTransform);
  my3DActor->SetTransform(theTransform);
  my3DExtActor->SetTransform(theTransform);

  Modified();
}
void SMESH_ActorDef::SetVisibility ( int  theMode) [virtual]

Definition at line 1208 of file SMESH_Actor.cxx.

                                             {
  SetVisibility(theMode,true);
}

Here is the caller graph for this function:

void SMESH_ActorDef::SetVisibility ( int  theMode,
bool  theIsUpdateRepersentation 
)

Definition at line 1213 of file SMESH_Actor.cxx.

                                                                             {
  SALOME_Actor::SetVisibility(theMode);

  myNodeActor->VisibilityOff();
  myBaseActor->VisibilityOff();
  
  myNodeExtActor->VisibilityOff();

  my0DActor->VisibilityOff();
  //my0DExtActor->VisibilityOff();

  my1DActor->VisibilityOff();
  my1DExtActor->VisibilityOff();
  
  my2DActor->VisibilityOff();
  my2DExtActor->VisibilityOff();
  my3DActor->VisibilityOff();
  my3DExtActor->VisibilityOff();
  
  myScalarBarActor->VisibilityOff();
  
  if(GetVisibility()){
    if(theIsUpdateRepersentation)
      SetRepresentation(GetRepresentation());
    
    if(myControlMode != eNone){
      switch(myControlMode){
      case eFreeNodes:
      case eCoincidentNodes:
        myNodeExtActor->VisibilityOn();
        break;
      case eFreeEdges:
      case eFreeBorders:
      case eCoincidentElems1D:
        my1DExtActor->VisibilityOn();
        break;
      case eFreeFaces:
      case eBareBorderFace:
      case eOverConstrainedFace:
      case eCoincidentElems2D:
        my2DExtActor->VisibilityOn();
        break;
      case eBareBorderVolume:
      case eOverConstrainedVolume:
      case eCoincidentElems3D:
        my3DExtActor->VisibilityOn();
        break;
      case eLength2D:
      case eMultiConnection2D:
        my1DExtActor->VisibilityOn();
      default:
        if(myControlActor->GetUnstructuredGrid()->GetNumberOfCells())
          myScalarBarActor->VisibilityOn();
      }
    }

    if(myRepresentation != ePoint)
      myPickableActor->VisibilityOn();
    else {
      myNodeActor->VisibilityOn();
    }

    if(myEntityMode & e0DElements){
      my0DActor->VisibilityOn();
    }

    if(myEntityMode & eEdges && GetRepresentation() != ePoint){
      my1DActor->VisibilityOn();
    }
    
    if(myEntityMode & eFaces && GetRepresentation() != ePoint){
      my2DActor->VisibilityOn();
    }
    
    if(myEntityMode & eVolumes && GetRepresentation() != ePoint){
      my3DActor->VisibilityOn();
    }
    
    if(myNodeActor->GetPointsLabeled()){ 
      myNodeActor->VisibilityOn();
    }

    if(my0DActor)
      my0DActor->UpdateLabels();
    
    if(my1DActor)
      my1DActor->UpdateLabels();
    
    if(my2DActor)
      my2DActor->UpdateLabels();
    
    if(my3DActor)
      my3DActor->UpdateLabels();    
  } 
#ifndef DISABLE_PLOT2DVIEWER
  else
    SMESH::ProcessIn2DViewers(this,SMESH::RemoveFrom2dViewer);
#endif
  UpdateHighlight();
  Modified();
}

Here is the call graph for this function:

void SMESH_ActorDef::ShallowCopy ( vtkProp *  prop) [private, virtual]

Definition at line 1101 of file SMESH_Actor.cxx.

void SMESH_ActorDef::UnShrink ( ) [virtual]

Definition at line 1171 of file SMESH_Actor.cxx.

                             {
  if(!myIsShrunk) return;

  myBaseActor->UnShrink();

  my1DActor->UnShrink();
  my1DExtActor->UnShrink();

  my2DActor->UnShrink();
  my2DExtActor->UnShrink();
  my3DActor->UnShrink();
  my3DExtActor->UnShrink();
  myHighlitableActor->UnShrink();

  myIsShrunk = false;
  Modified();
}

Here is the caller graph for this function:

void SMESH_ActorDef::Update ( ) [protected]

Definition at line 1663 of file SMESH_Actor.cxx.

                           {
  if(MYDEBUG) MESSAGE("SMESH_ActorDef::Update");

  if(GetControlMode() != eNone) {
    unsigned long aTime = myTimeStamp->GetMTime();
    unsigned long anObjTime = myVisualObj->GetUnstructuredGrid()->GetMTime();
    if (anObjTime > aTime)
      SetControlMode(GetControlMode(),false);
  }

  if(myNodeActor)
    myNodeActor->UpdateLabels();

  if(my0DActor)
    my0DActor->UpdateLabels();
  
  if(my1DActor)
    my1DActor->UpdateLabels();
  
  if(my2DActor)
    my2DActor->UpdateLabels();

  if(my3DActor)
    my3DActor->UpdateLabels();
  
  if(myIsFacesOriented){
    SetFacesOriented(myIsFacesOriented);
  }
    
  if(myVisualObj->GetEntitiesFlag()) {
    myEntityMode |= myVisualObj->GetEntitiesState();
  }
  
  SetEntityMode(GetEntityMode());
  SetVisibility(GetVisibility());
  
  myTimeStamp->Modified();
  Modified();
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 2053 of file SMESH_Actor.cxx.

{
  if(SMESH::Controls::NumericalFunctor* fun =
     dynamic_cast<SMESH::Controls::NumericalFunctor*>(myFunctor.get()))
  {
    int nbIntervals = myScalarBarActor->GetMaximumNumberOfColors();
    std::vector<int> nbEvents;
    std::vector<double> funValues;
    SMESH_VisualObjDef::TEntityList elems;
    if ( ! dynamic_cast<SMESH_MeshObj*>(myVisualObj.get()))
      dynamic_cast<SMESH_VisualObjDef*>(myVisualObj.get())->GetEntities( fun->GetType(), elems );
    std::vector<int> elemIds;
    for ( SMESH_VisualObjDef::TEntityList::iterator e = elems.begin(); e != elems.end(); ++e)
      elemIds.push_back( (*e)->GetID());
    vtkLookupTable* lookupTable = static_cast<vtkLookupTable*>(myScalarBarActor->GetLookupTable());
    double * range = lookupTable->GetRange();
    fun->GetHistogram(nbIntervals, nbEvents, funValues, elemIds, range);
    myScalarBarActor->SetDistribution(nbEvents);
  }
}

Here is the caller graph for this function:

void SMESH_ActorDef::UpdateHighlight ( ) [protected]

Definition at line 1569 of file SMESH_Actor.cxx.

                                    {
  myHighlitableActor->SetHighlited(false);
  myHighlitableActor->SetVisibility(false);

  bool anIsVisible = GetVisibility();

  switch(myRepresentation){
  case SMESH_DeviceActor::eSurface:
  case SMESH_DeviceActor::eWireframe:
    {
      if(myIsHighlighted) {
        myHighlitableActor->SetProperty(myHighlightProp);
      }else if(myIsPreselected){
        myHighlitableActor->SetProperty(myPreselectProp);
      } else if(anIsVisible){
        (myRepresentation == eSurface) ? 
          myHighlitableActor->SetProperty(myOutLineProp) : myHighlitableActor->SetProperty(myEdgeProp);
      }
      if(GetUnstructuredGrid()->GetNumberOfCells()) {
        myHighlitableActor->SetHighlited(anIsVisible);
        myHighlitableActor->GetExtractUnstructuredGrid()->
          SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::eCells);
        myHighlitableActor->SetRepresentation(SMESH_DeviceActor::eWireframe);
      }
      myHighlitableActor->SetVisibility(anIsVisible);
      break;
    }
  case SMESH_DeviceActor::ePoint:
    {
      if(myIsHighlighted) {
        myNodeActor->SetProperty(myHighlightProp);
      }else if(myIsPreselected) {
        myNodeActor->SetProperty(myPreselectProp);
      } else if(anIsVisible) {
        myNodeActor->SetProperty(myNodeProp);
      }
      myNodeActor->SetRepresentation(SMESH_DeviceActor::ePoint);
      myNodeActor->GetExtractUnstructuredGrid()->SetModeOfExtraction(VTKViewer_ExtractUnstructuredGrid::ePoints);
      break;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SPlot2d_Histogram * SMESH_ActorDef::UpdatePlot2Histogram ( ) [virtual]

Definition at line 2119 of file SMESH_Actor.cxx.

                                                        {

  if(my2dHistogram)
    my2dHistogram->clearAllPoints();
  
  if(SMESH::Controls::NumericalFunctor* fun =
     dynamic_cast<SMESH::Controls::NumericalFunctor*>(myFunctor.get()))
  {
    
    if(!my2dHistogram) {
      my2dHistogram = new SPlot2d_Histogram();
      Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(getIO()->getEntry(),"SMESH",getName());
      my2dHistogram->setIO(anIO);
    }
    
    int nbIntervals = myScalarBarActor->GetMaximumNumberOfColors();
    std::vector<int> nbEvents;
    std::vector<double> funValues;
    SMESH_VisualObjDef::TEntityList elems;
    if ( ! dynamic_cast<SMESH_MeshObj*>(myVisualObj.get()))
      dynamic_cast<SMESH_VisualObjDef*>(myVisualObj.get())->GetEntities( fun->GetType(), elems );
    std::vector<int> elemIds;
    
    for ( SMESH_VisualObjDef::TEntityList::iterator e = elems.begin(); e != elems.end(); ++e)
      elemIds.push_back( (*e)->GetID());

    vtkLookupTable* lookupTable = static_cast<vtkLookupTable*>(myScalarBarActor->GetLookupTable());
    double * range = lookupTable->GetRange();
    fun->GetHistogram(nbIntervals, nbEvents, funValues, elemIds, range);

    for ( int i = 0; i < std::min( nbEvents.size(), funValues.size() -1 ); i++ ) 
      my2dHistogram->addPoint(funValues[i] + (funValues[i+1] - funValues[i])/2.0, static_cast<double>(nbEvents[i]));

    if(funValues.size() >= 2)
      my2dHistogram->setWidth((funValues[1] - funValues[0]) * 0.8) ;

  }
  
  //Color of the histogram
  if(myScalarBarActor->GetDistributionColoringType() == SMESH_MULTICOLOR_TYPE)
    my2dHistogram->setAutoAssign(true);
  else {
    double rgb[3];
    myScalarBarActor->GetDistributionColor(rgb);
    QColor aColor = QColor( (int)( rgb[0]*255 ), (int)( rgb[1]*255 ), (int)( rgb[2]*255 ) );
    my2dHistogram->setColor(aColor);

  }
      
  return my2dHistogram;
}

Here is the call graph for this function:

void SMESH_ActorDef::UpdateScalarBar ( ) [virtual]

Definition at line 1922 of file SMESH_Actor.cxx.

{
  SUIT_ResourceMgr* mgr = SUIT_Session::session()->resourceMgr();
  if( !mgr )
    return;

  vtkTextProperty* aScalarBarTitleProp = vtkTextProperty::New();

  QColor aTColor = mgr->colorValue( "SMESH", "scalar_bar_title_color", QColor( 255, 255, 255 ) );
  aScalarBarTitleProp->SetColor( aTColor.red()/255., aTColor.green()/255., aTColor.blue()/255. );

  aScalarBarTitleProp->SetFontFamilyToArial();

  if ( mgr->hasValue( "SMESH", "scalar_bar_title_font" ) )
  {
    QFont f = mgr->fontValue( "SMESH", "scalar_bar_title_font" );
    if ( f.family() == "Arial" )
      aScalarBarTitleProp->SetFontFamilyToArial();
    else if ( f.family() == "Courier" )
      aScalarBarTitleProp->SetFontFamilyToCourier();
    else if ( f.family() == "Times" )
      aScalarBarTitleProp->SetFontFamilyToTimes();

    if ( f.bold() )
      aScalarBarTitleProp->BoldOn();
    else
      aScalarBarTitleProp->BoldOff();

    if ( f.italic() )
      aScalarBarTitleProp->ItalicOn();
    else
     aScalarBarTitleProp->ItalicOff();

    if ( f.overline() )
      aScalarBarTitleProp->ShadowOn();
    else
      aScalarBarTitleProp->ShadowOff();
  }

  myScalarBarActor->SetTitleTextProperty( aScalarBarTitleProp );
  aScalarBarTitleProp->Delete();

  vtkTextProperty* aScalarBarLabelProp = vtkTextProperty::New();

  aTColor = mgr->colorValue( "SMESH", "scalar_bar_label_color", QColor( 255, 255, 255 ) );
  aScalarBarLabelProp->SetColor( aTColor.red()/255., aTColor.green()/255., aTColor.blue()/255. );

  aScalarBarLabelProp->SetFontFamilyToArial();
  if( mgr->hasValue( "SMESH", "scalar_bar_label_font" ) )
  {
    QFont f = mgr->fontValue( "SMESH", "scalar_bar_label_font" );
    if( f.family() == "Arial" )
      aScalarBarLabelProp->SetFontFamilyToArial();
    else if( f.family() == "Courier" )
      aScalarBarLabelProp->SetFontFamilyToCourier();
    else if( f.family() == "Times" )
      aScalarBarLabelProp->SetFontFamilyToTimes();

    if ( f.bold() )
      aScalarBarLabelProp->BoldOn();
    else
      aScalarBarLabelProp->BoldOff();

    if ( f.italic() )
      aScalarBarLabelProp->ItalicOn();
    else
      aScalarBarLabelProp->ItalicOff();

    if( f.overline() )
      aScalarBarLabelProp->ShadowOn();
    else
      aScalarBarLabelProp->ShadowOff();
  }

  myScalarBarActor->SetLabelTextProperty( aScalarBarLabelProp );
  aScalarBarLabelProp->Delete();

  bool horiz = ( mgr->integerValue( "SMESH", "scalar_bar_orientation" ) == 1 );
  QString name = QString( "scalar_bar_%1_" ).arg( horiz ? "horizontal" : "vertical" );
  if( horiz )
    myScalarBarActor->SetOrientationToHorizontal();
  else
    myScalarBarActor->SetOrientationToVertical();


  vtkFloatingPointType aXVal = horiz ? 0.20 : 0.01;
  if( mgr->hasValue( "SMESH", name + "x" ) )
    aXVal = mgr->doubleValue( "SMESH", name + "x", aXVal );

  vtkFloatingPointType aYVal = horiz ? 0.01 : 0.1;
  if( mgr->hasValue( "SMESH", name + "y" ) )
    aYVal = mgr->doubleValue( "SMESH", name + "y", aYVal );
  myScalarBarActor->SetPosition( aXVal, aYVal );

  vtkFloatingPointType aWVal = horiz ? 0.60 : 0.10;
  if( mgr->hasValue( "SMESH", name + "width" ) )
    aWVal = mgr->doubleValue( "SMESH", name + "width", aWVal );
  myScalarBarActor->SetWidth( aWVal );

  vtkFloatingPointType aHVal = horiz ? 0.12 : 0.80;
  if( mgr->hasValue( "SMESH", name + "height" ) )
    aHVal = mgr->doubleValue( "SMESH", name + "height", aHVal );
  myScalarBarActor->SetHeight( aHVal );

  int anIntVal = 5;
  if( mgr->hasValue( "SMESH", "scalar_bar_num_labels" ) )
    anIntVal = mgr->integerValue( "SMESH", "scalar_bar_num_labels", anIntVal );
  myScalarBarActor->SetNumberOfLabels( anIntVal == 0 ? 5: anIntVal );

  anIntVal = 64;
  if( mgr->hasValue( "SMESH", "scalar_bar_num_colors" ) )
    anIntVal = mgr->integerValue( "SMESH", "scalar_bar_num_colors", anIntVal );
  myScalarBarActor->SetMaximumNumberOfColors( anIntVal == 0 ? 64 : anIntVal );

  bool distributionVisibility = mgr->booleanValue("SMESH","distribution_visibility");
  myScalarBarActor->SetDistributionVisibility(distributionVisibility);

  int coloringType = mgr->integerValue("SMESH", "distribution_coloring_type", 0);
  myScalarBarActor->SetDistributionColoringType(coloringType);
  
  QColor distributionColor = mgr->colorValue("SMESH", "distribution_color",
                                             QColor(255, 255, 255));
  double rgb[3];
  rgb[0]= distributionColor.red()/255.;
  rgb[1]= distributionColor.green()/255.;
  rgb[2]= distributionColor.blue()/255.;
  myScalarBarActor->SetDistributionColor(rgb);

  
}

Here is the call graph for this function:


Friends And Related Function Documentation

friend class SMESH_Actor [friend]

Definition at line 82 of file SMESH_ActorDef.h.

friend class SMESH_VisualObj [friend]

Definition at line 81 of file SMESH_ActorDef.h.


Member Data Documentation

SMESH_CellLabelActor* SMESH_ActorDef::my0DActor [protected]

Definition at line 261 of file SMESH_ActorDef.h.

SMESH_DeviceActor* SMESH_ActorDef::my0DExtActor [protected]

Definition at line 263 of file SMESH_ActorDef.h.

vtkProperty* SMESH_ActorDef::my0DExtProp [protected]

Definition at line 262 of file SMESH_ActorDef.h.

vtkProperty* SMESH_ActorDef::my0DProp [protected]

Definition at line 260 of file SMESH_ActorDef.h.

SMESH_CellLabelActor* SMESH_ActorDef::my1DActor [protected]

Definition at line 256 of file SMESH_ActorDef.h.

SMESH_DeviceActor* SMESH_ActorDef::my1DExtActor [protected]

Definition at line 258 of file SMESH_ActorDef.h.

vtkProperty* SMESH_ActorDef::my1DExtProp [protected]

Definition at line 257 of file SMESH_ActorDef.h.

vtkProperty* SMESH_ActorDef::my1DProp [protected]

Definition at line 255 of file SMESH_ActorDef.h.

SMESH_CellLabelActor* SMESH_ActorDef::my2DActor [protected]

Definition at line 246 of file SMESH_ActorDef.h.

SMESH_DeviceActor* SMESH_ActorDef::my2DExtActor [protected]

Definition at line 247 of file SMESH_ActorDef.h.

vtkProperty* SMESH_ActorDef::my2DExtProp [protected]

Definition at line 245 of file SMESH_ActorDef.h.

SPlot2d_Histogram* SMESH_ActorDef::my2dHistogram [protected]

Definition at line 281 of file SMESH_ActorDef.h.

SMESH_CellLabelActor* SMESH_ActorDef::my3DActor [protected]

Definition at line 248 of file SMESH_ActorDef.h.

SMESH_DeviceActor* SMESH_ActorDef::my3DExtActor [protected]

Definition at line 249 of file SMESH_ActorDef.h.

vtkProperty* SMESH_ActorDef::myBackSurfaceProp [protected]

Definition at line 229 of file SMESH_ActorDef.h.

SMESH_DeviceActor* SMESH_ActorDef::myBaseActor [protected]

Definition at line 233 of file SMESH_ActorDef.h.

Definition at line 277 of file SMESH_ActorDef.h.

SMESH_DeviceActor* SMESH_ActorDef::myControlActor [protected]

Definition at line 250 of file SMESH_ActorDef.h.

eControl SMESH_ActorDef::myControlMode [protected]

Definition at line 243 of file SMESH_ActorDef.h.

Definition at line 278 of file SMESH_ActorDef.h.

Definition at line 286 of file SMESH_ActorDef.h.

vtkProperty* SMESH_ActorDef::myEdgeProp [protected]

Definition at line 230 of file SMESH_ActorDef.h.

unsigned int SMESH_ActorDef::myEntityMode [protected]

Definition at line 265 of file SMESH_ActorDef.h.

unsigned int SMESH_ActorDef::myEntityModeCache [protected]

Definition at line 267 of file SMESH_ActorDef.h.

unsigned int SMESH_ActorDef::myEntityState [protected]

Definition at line 266 of file SMESH_ActorDef.h.

Definition at line 244 of file SMESH_ActorDef.h.

vtkProperty* SMESH_ActorDef::myHighlightProp [protected]

Definition at line 237 of file SMESH_ActorDef.h.

SMESH_DeviceActor* SMESH_ActorDef::myHighlitableActor [protected]

Definition at line 241 of file SMESH_ActorDef.h.

vtkImplicitBoolean* SMESH_ActorDef::myImplicitBoolean [protected]

Definition at line 274 of file SMESH_ActorDef.h.

Definition at line 268 of file SMESH_ActorDef.h.

Definition at line 284 of file SMESH_ActorDef.h.

Definition at line 269 of file SMESH_ActorDef.h.

Definition at line 271 of file SMESH_ActorDef.h.

bool SMESH_ActorDef::myIsShrunk [protected]

Definition at line 272 of file SMESH_ActorDef.h.

vtkLookupTable* SMESH_ActorDef::myLookupTable [protected]

Definition at line 226 of file SMESH_ActorDef.h.

VTK::MarkerTexture SMESH_ActorDef::myMarkerTexture [protected]

Definition at line 288 of file SMESH_ActorDef.h.

SMESH_NodeLabelActor* SMESH_ActorDef::myNodeActor [protected]

Definition at line 234 of file SMESH_ActorDef.h.

SMESH_DeviceActor* SMESH_ActorDef::myNodeExtActor [protected]

Definition at line 253 of file SMESH_ActorDef.h.

vtkProperty* SMESH_ActorDef::myNodeExtProp [protected]

Definition at line 252 of file SMESH_ActorDef.h.

vtkProperty* SMESH_ActorDef::myNodeProp [protected]

Definition at line 231 of file SMESH_ActorDef.h.

vtkProperty* SMESH_ActorDef::myOutLineProp [protected]

Definition at line 238 of file SMESH_ActorDef.h.

SMESH_DeviceActor* SMESH_ActorDef::myPickableActor [protected]

Definition at line 235 of file SMESH_ActorDef.h.

vtkProperty* SMESH_ActorDef::myPreselectProp [protected]

Definition at line 239 of file SMESH_ActorDef.h.

SMESH_ScalarBarActor* SMESH_ActorDef::myScalarBarActor [protected]

Definition at line 225 of file SMESH_ActorDef.h.

vtkProperty* SMESH_ActorDef::mySurfaceProp [protected]

Definition at line 228 of file SMESH_ActorDef.h.

vtkTimeStamp* SMESH_ActorDef::myTimeStamp [protected]

Definition at line 223 of file SMESH_ActorDef.h.

Definition at line 222 of file SMESH_ActorDef.h.


The documentation for this class was generated from the following files: