}
+//----------------------------------------------------------------------------
VISU_ColoredPL
::~VISU_ColoredPL()
{}
+//----------------------------------------------------------------------------
+unsigned long int
+VISU_ColoredPL
+::GetMTime()
+{
+ unsigned long int aTime = Superclass::GetMTime();
+
+ aTime = std::max(aTime, myMapperTable->GetMTime());
+ aTime = std::max(aTime, myBarTable->GetMTime());
+ aTime = std::max(aTime, myExtractor->GetMTime());
+ aTime = std::max(aTime, myFieldTransform->GetMTime());
+
+ return aTime;
+}
+
+
//----------------------------------------------------------------------------
void
VISU_ColoredPL
{
if(theRange[0] > theRange[1])
return;
+
+ if(VISU::CheckIsSameRange(GetScalarRange(), theRange))
+ return;
myFieldTransform->SetScalarRange(theRange);
myBarTable->SetRange(theRange);
vtkFloatingPointType *aRange = GetScalarRange();
vtkFloatingPointType aScalarRange[2] = {aRange[0], aRange[1]};
if(myBarTable->GetScale() == VTK_SCALE_LOG10)
- VISU_LookupTable::ComputeLogRange(aRange,aScalarRange);
- myMapperTable->SetRange(aScalarRange);
+ VISU_LookupTable::ComputeLogRange(aRange, aScalarRange);
- myMapperTable->Build();
- myBarTable->Build();
+ if(!VISU::CheckIsSameRange(myMapperTable->GetRange(), aScalarRange)){
+ myMapperTable->SetRange(aScalarRange);
+ myMapperTable->Build();
+ myBarTable->Build();
+ }
Superclass::Update();
}
public:
vtkTypeMacro(VISU_ColoredPL, VISU_PipeLine);
+ virtual
+ unsigned long int
+ GetMTime();
+
//----------------------------------------------------------------------------
virtual
int
protected:
VISU_CutLinesPL();
- VISU_CutLinesPL(const VISU_CutLinesPL&);
virtual
void
vtkFloatingPointType myBasePnt[3];
vtkFloatingPointType myPosition;
int myCondition;
+
+private:
+ VISU_CutLinesPL(const VISU_CutLinesPL&); // Not implemented.
+ void operator=(const VISU_CutLinesPL&); // Not implemented.
};
}
+//----------------------------------------------------------------------------
+unsigned long int
+VISU_CutPlanesPL
+::GetMTime()
+{
+ unsigned long int aTime = Superclass::GetMTime();
+
+ aTime = std::max(aTime, myAppendPolyData->GetMTime());
+
+ return aTime;
+}
+
+
//----------------------------------------------------------------------------
void
VISU_CutPlanesPL
{
public:
vtkTypeMacro(VISU_CutPlanesPL, VISU_ScalarMapPL);
- static VISU_CutPlanesPL* New();
+
+ static
+ VISU_CutPlanesPL*
+ New();
virtual
- ~VISU_CutPlanesPL();
+ unsigned long int
+ GetMTime();
+ //----------------------------------------------------------------------------
enum PlaneOrientation {XY, YZ, ZX};
virtual
const std::vector<vtkFloatingPointType>& thePlanePosition,
const std::vector<int>& thePlaneCondition,
vtkFloatingPointType theDisplacement);
+
protected:
VISU_CutPlanesPL();
- VISU_CutPlanesPL(const VISU_CutPlanesPL&);
+
+ virtual
+ ~VISU_CutPlanesPL();
virtual
vtkDataSet*
vtkAppendPolyData *myAppendPolyData;
std::vector<vtkFloatingPointType> myPartPosition;
std::vector<int> myPartCondition;
+
+private:
+ VISU_CutPlanesPL(const VISU_CutPlanesPL&); // Not implemented.
+ void operator=(const VISU_CutPlanesPL&); // Not implemented.
};
#endif
}
+//----------------------------------------------------------------------------
+unsigned long int
+VISU_DeformedShapePL
+::GetMTime()
+{
+ unsigned long int aTime = Superclass::GetMTime();
+
+ aTime = std::max(aTime, myWarpVector->GetMTime());
+ aTime = std::max(aTime, myCellDataToPointData->GetMTime());
+
+ return aTime;
+}
+
+
//----------------------------------------------------------------------------
void
VISU_DeformedShapePL
VISU_DeformedShapePL*
New();
+ virtual
+ unsigned long int
+ GetMTime();
+
+ //----------------------------------------------------------------------------
virtual
void
SetScale(vtkFloatingPointType theScale);
protected:
VISU_DeformedShapePL();
- VISU_DeformedShapePL(const VISU_DeformedShapePL&);
virtual
~VISU_DeformedShapePL();
vtkFloatingPointType myScaleFactor;
vtkWarpVector *myWarpVector;
vtkCellDataToPointData* myCellDataToPointData;
+
+private:
+ VISU_DeformedShapePL(const VISU_DeformedShapePL&); // Not implemented.
+ void operator=(const VISU_DeformedShapePL&); // Not implemented.
};
}
+//----------------------------------------------------------------------------
+unsigned long int
+VISU_GaussPointsPL
+::GetMTime()
+{
+ unsigned long int aTime = Superclass::GetMTime();
+
+ aTime = std::max(aTime, myWarpVector->GetMTime());
+ aTime = std::max(aTime, myGlyph->GetMTime());
+ aTime = std::max(aTime, mySphereSource->GetMTime());
+
+ for(int i = 0; i < 3; i++)
+ aTime = std::max(aTime, myPassFilter[i]->GetMTime());
+
+ return aTime;
+}
+
+
//----------------------------------------------------------------------------
void
VISU_GaussPointsPL
VISU_GaussPointsPL*
New();
+ virtual
+ unsigned long int
+ GetMTime();
+
//----------------------------------------------------------------------------
void
SetGaussPtsIDMapper(const VISU::PGaussPtsIDMapper& theGaussPtsIDMapper);
vtkSphereSource* mySphereSource;
vtkFloatingPointType myMagnificationIncrement;
+
+private:
+ VISU_GaussPointsPL(const VISU_GaussPointsPL&); // Not implemented.
+ void operator=(const VISU_GaussPointsPL&); // Not implemented.
};
#endif
}
+//----------------------------------------------------------------------------
+unsigned long int
+VISU_IsoSurfacesPL
+::GetMTime()
+{
+ unsigned long int aTime = Superclass::GetMTime();
+
+ aTime = std::max(aTime, myCellDataToPointData->GetMTime());
+ aTime = std::max(aTime, myContourFilter->GetMTime());
+
+ return aTime;
+}
+
+
//----------------------------------------------------------------------------
void
VISU_IsoSurfacesPL
VISU_IsoSurfacesPL*
New();
+ virtual
+ unsigned long int
+ GetMTime();
+
+ //----------------------------------------------------------------------------
virtual
int
GetNbParts();
protected:
VISU_IsoSurfacesPL();
- VISU_IsoSurfacesPL(const VISU_IsoSurfacesPL&);
virtual
~VISU_IsoSurfacesPL();
vtkFloatingPointType myRange[2];
vtkCellDataToPointData* myCellDataToPointData;
vtkContourFilter *myContourFilter;
+
+private:
+ VISU_IsoSurfacesPL(const VISU_IsoSurfacesPL&);; // Not implemented.
+ void operator=(const VISU_IsoSurfacesPL&); // Not implemented.
+
};
VISU_PipeLine
::SetIsShrinkable(bool theIsShrinkable)
{
+ if(myIsShrinkable == theIsShrinkable)
+ return;
+
myIsShrinkable = theIsShrinkable;
+ Modified();
}
//----------------------------------------------------------------------------
VISU_Plot3DPL
::~VISU_Plot3DPL()
+{}
+
+
+//----------------------------------------------------------------------------
+unsigned long int
+VISU_Plot3DPL
+::GetMTime()
{
+ unsigned long int aTime = Superclass::GetMTime();
+
+ aTime = std::max(aTime, myCellDataToPointData->GetMTime());
+ aTime = std::max(aTime, myAppendPolyData->GetMTime());
+ aTime = std::max(aTime, myGeometryFilter->GetMTime());
+ aTime = std::max(aTime, myContourFilter->GetMTime());
+ aTime = std::max(aTime, myWarpScalar->GetMTime());
+
+ return aTime;
}
VISU_Plot3DPL*
New();
- virtual
- ~VISU_Plot3DPL();
+ virtual
+ unsigned long int
+ GetMTime();
+ //----------------------------------------------------------------------------
VISU_CutPlanesPL::PlaneOrientation
GetPlaneOrientation();
protected:
VISU_Plot3DPL();
- VISU_Plot3DPL(const VISU_Plot3DPL&);
+ virtual
+ ~VISU_Plot3DPL();
virtual
vtkDataSet*
vtkSmartPointer<vtkGeometryFilter> myGeometryFilter;
vtkSmartPointer<vtkContourFilter> myContourFilter;
vtkSmartPointer<vtkWarpScalar> myWarpScalar;
+
+private:
+ VISU_Plot3DPL(const VISU_Plot3DPL&);; // Not implemented.
+ void operator=(const VISU_Plot3DPL&); // Not implemented.
};
#endif
{}
+//----------------------------------------------------------------------------
+unsigned long int
+VISU_ScalarMapPL
+::GetMTime()
+{
+ unsigned long int aTime = Superclass::GetMTime();
+
+ aTime = std::max(aTime, myAppendFilter->GetMTime());
+ aTime = std::max(aTime, myMergeFilter->GetMTime());
+
+ return aTime;
+}
+
+
//----------------------------------------------------------------------------
void
VISU_ScalarMapPL
VISU_ScalarMapPL*
New();
+ virtual
+ unsigned long int
+ GetMTime();
+
+ //----------------------------------------------------------------------------
virtual
void
Update();
protected:
//----------------------------------------------------------------------------
VISU_ScalarMapPL();
- VISU_ScalarMapPL(const VISU_ScalarMapPL&);
virtual
~VISU_ScalarMapPL();
bool theIsCopyInput);
private:
+ VISU_ScalarMapPL(const VISU_ScalarMapPL&); // Not implemented.
+ void operator=(const VISU_ScalarMapPL&); // Not implemented.
+
vtkSmartPointer<VISU_AppendFilter> myAppendFilter;
vtkSmartPointer<VISU_MergeFilter> myMergeFilter;
};
}
+//----------------------------------------------------------------------------
+unsigned long int
+VISU_StreamLinesPL
+::GetMTime()
+{
+ unsigned long int aTime = Superclass::GetMTime();
+
+ aTime = std::max(aTime, myStream->GetMTime());
+ aTime = std::max(aTime, mySource->GetMTime());
+ aTime = std::max(aTime, myCenters->GetMTime());
+ aTime = std::max(aTime, myGeomFilter->GetMTime());
+ aTime = std::max(aTime, myPointsFilter->GetMTime());
+
+ return aTime;
+}
+
+
//----------------------------------------------------------------------------
void
VISU_StreamLinesPL
VISU_StreamLinesPL*
New();
+ virtual
+ unsigned long int
+ GetMTime();
+
+ //----------------------------------------------------------------------------
virtual
size_t
SetParams(vtkFloatingPointType theIntStep,
protected:
VISU_StreamLinesPL();
- VISU_StreamLinesPL(const VISU_StreamLinesPL&);
virtual
~VISU_StreamLinesPL();
VTKViewer_GeometryFilter *myGeomFilter;
VISU_UsedPointsFilter *myPointsFilter;
vtkFloatingPointType myPercents;
+
+private:
+ VISU_StreamLinesPL(const VISU_StreamLinesPL&); // Not implemented.
+ void operator=(const VISU_StreamLinesPL&); // Not implemented.
};
}
+//----------------------------------------------------------------------------
+unsigned long int
+VISU_VectorsPL
+::GetMTime()
+{
+ unsigned long int aTime = Superclass::GetMTime();
+
+ aTime = std::max(aTime, myBaseGlyph->GetMTime());
+ aTime = std::max(aTime, myTransformedGlyph->GetMTime());
+ aTime = std::max(aTime, myCenters->GetMTime());
+ aTime = std::max(aTime, myGlyphSource->GetMTime());
+ aTime = std::max(aTime, myConeSource->GetMTime());
+ aTime = std::max(aTime, myLineSource->GetMTime());
+ aTime = std::max(aTime, myTransformFilter->GetMTime());
+
+ return aTime;
+}
+
+
//----------------------------------------------------------------------------
void
VISU_VectorsPL
VISU_VectorsPL*
New();
+ virtual
+ unsigned long int
+ GetMTime();
+
+ //----------------------------------------------------------------------------
virtual
void
SetScale(vtkFloatingPointType theScale);
protected:
VISU_VectorsPL();
- VISU_VectorsPL(const VISU_VectorsPL&);
virtual
~VISU_VectorsPL();
vtkCellCenters* myCenters;
VTKViewer_TransformFilter *myTransformFilter;
+
+private:
+ VISU_VectorsPL(const VISU_VectorsPL&); // Not implemented.
+ void operator=(const VISU_VectorsPL&); // Not implemented.
};
RBFieldRange->setEnabled( false );
MinEdit->setEnabled( false );
MaxEdit->setEnabled( false );
+
+ myPrsCopy->SetIsActiveLocalScalarBar(false);
}
MinEdit->setEnabled( true );
MaxEdit->setEnabled( true );
}
+
+ myPrsCopy->SetIsActiveLocalScalarBar(true);
}
VISU_CorbaMedConvertor.cxx \
VISU_PrsObject_i.cc \
VISU_Prs3d_i.cc \
+ VISU_Prs3dUtils.cc \
VISU_ColoredPrs3d_i.cc \
VISU_ScalarMap_i.cc \
VISU_GaussPoints_i.cc \
}
myMemoryMode = theMode;
+ GetStudyDocument()->Modified();
}
VISU::ColoredPrs3dCache::MemoryMode
ClearCache(theMemorySize);
myLimitedMemory = theMemorySize;
+ GetStudyDocument()->Modified();
}
CORBA::Float
// Module : VISU
#include "VISU_ColoredPrs3d_i.hh"
+#include "VISU_Prs3dUtils.hh"
#include "VISU_Result_i.hh"
#include "VISU_ColoredPL.hxx"
GetSpecificPL()->Init();
// To update scalar range according to the new input
- if(!IsTimeStampFixed() && !IsRangeFixed() || theReInit)
+ if(!IsRangeFixed() || theReInit)
SetSourceRange();
GetCResult()->ConnectObserver(this, myResultConnection);
VISU::ColoredPrs3d_i
::SetEntity(VISU::Entity theEntity)
{
- if(myEntity != theEntity){
- myEntity = theEntity;
- myParamsTime.Modified();
- }
+ if(myEntity == theEntity)
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ myEntity = theEntity;
+ myParamsTime.Modified();
}
VISU::ColoredPrs3d_i
::SetFieldName(const char* theFieldName)
{
- if(myFieldName != theFieldName){
- myFieldName = theFieldName;
- myParamsTime.Modified();
- }
+ if(myFieldName == theFieldName)
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ myFieldName = theFieldName;
+ myParamsTime.Modified();
}
VISU::ColoredPrs3d_i
::SetTimeStampNumber(CORBA::Long theTimeStampNumber)
{
- if(myTimeStampNumber != theTimeStampNumber){
- myTimeStampNumber = theTimeStampNumber;
- myParamsTime.Modified();
- }
+ if(myTimeStampNumber == theTimeStampNumber)
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ myTimeStampNumber = theTimeStampNumber;
+ myParamsTime.Modified();
}
SetNbColors(anOrigin->GetNbColors());
SetBarOrientation(anOrigin->GetBarOrientation());
+ // "SetRange" function changes "myIsFixedRange" attribute,
+ // so, it is necessary pay a special attention if "this" equal to "theOrigin"
+ bool anIsFixedRange = anOrigin->IsRangeFixed();
SetRange(anOrigin->GetMin(), anOrigin->GetMax());
- UseFixedRange(anOrigin->IsRangeFixed());
+ UseFixedRange(anIsFixedRange);
SetPosition(anOrigin->GetPosX(), anOrigin->GetPosY());
SetSize(anOrigin->GetWidth(), anOrigin->GetHeight());
return myColoredPL->GetScalarMode();
}
+
//----------------------------------------------------------------------------
void
VISU::ColoredPrs3d_i
else if(theScalarMode > aNbComp)
theScalarMode = 0;
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_ColoredPL, int>
(GetSpecificPL(), &VISU_ColoredPL::SetScalarMode, theScalarMode));
}
VISU::ColoredPrs3d_i
::SetRange(CORBA::Double theMin, CORBA::Double theMax)
{
+ VISU::TSetModified aModified(this);
+
vtkFloatingPointType aScalarRange[2] = {theMin, theMax};
ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_ColoredPL, vtkFloatingPointType*>
(GetSpecificPL(), &VISU_ColoredPL::SetScalarRange, aScalarRange));
VISU::ColoredPrs3d_i
::SetSourceRange()
{
+ VISU::TSetModified aModified(this);
+
if(IsTimeStampFixed()){
GetSpecificPL()->SetSourceRange();
ProcessVoidEvent(new TVoidMemFunEvent<VISU_ColoredPL>
VISU::ColoredPrs3d_i
::SetNbColors(CORBA::Long theNbColors)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_ColoredPL, int>
(GetSpecificPL(), &VISU_ColoredPL::SetNbColors, theNbColors));
}
VISU::ColoredPrs3d_i
::SetBarOrientation(VISU::ColoredPrs3d::Orientation theOrientation)
{
- if(myOrientation != theOrientation){
- myOrientation = theOrientation;
- myParamsTime.Modified();
- }
+ if(myOrientation == theOrientation)
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ myOrientation = theOrientation;
+ myParamsTime.Modified();
}
//----------------------------------------------------------------------------
if(anIsSameValue)
return;
+ VISU::TSetModified aModified(this);
+
myPosition[0] = theX;
myPosition[1] = theY;
myParamsTime.Modified();
if(anIsSameValue)
return;
+ VISU::TSetModified aModified(this);
+
myWidth = theWidth;
myHeight = theHeight;
myParamsTime.Modified();
VISU::ColoredPrs3d_i
::SetLabels(CORBA::Long theNbLabels)
{
- if(myNumberOfLabels != theNbLabels){
- myNumberOfLabels = theNbLabels;
- myParamsTime.Modified();
- }
+ if(myNumberOfLabels == theNbLabels)
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ myNumberOfLabels = theNbLabels;
+ myParamsTime.Modified();
}
//----------------------------------------------------------------------------
aStream<<theTitle<<" "<<VISU_Convertor::GenerateName(aTime)<<std::ends;
std::string aScalarBarTitle = aStream.str();
if(myTitle != theTitle || myScalarBarTitle != aScalarBarTitle){
+ VISU::TSetModified aModified(this);
+
myScalarBarTitle = aScalarBarTitle;
myTitle = theTitle;
myParamsTime.Modified();
VISU::ColoredPrs3d_i
::SetBoldTitle(bool theIsBoldTitle)
{
- if(myIsBoldTitle != theIsBoldTitle){
- myIsBoldTitle = theIsBoldTitle;
- myParamsTime.Modified();
- }
+ if(myIsBoldTitle == theIsBoldTitle)
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ myIsBoldTitle = theIsBoldTitle;
+ myParamsTime.Modified();
}
//----------------------------------------------------------------------------
VISU::ColoredPrs3d_i
::SetItalicTitle(bool theIsItalicTitle)
{
- if(myIsItalicTitle != theIsItalicTitle){
- myIsItalicTitle = theIsItalicTitle;
- myParamsTime.Modified();
- }
+ if(myIsItalicTitle == theIsItalicTitle)
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ myIsItalicTitle = theIsItalicTitle;
+ myParamsTime.Modified();
}
//----------------------------------------------------------------------------
VISU::ColoredPrs3d_i
::SetShadowTitle(bool theIsShadowTitle)
{
- if(myIsShadowTitle != theIsShadowTitle){
- myIsShadowTitle = theIsShadowTitle;
- myParamsTime.Modified();
- }
+ if(myIsShadowTitle == theIsShadowTitle)
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ myIsShadowTitle = theIsShadowTitle;
+ myParamsTime.Modified();
}
//----------------------------------------------------------------------------
VISU::ColoredPrs3d_i
::SetTitFontType(int theTitFontType)
{
- if(myTitFontType != theTitFontType){
- myTitFontType = theTitFontType;
- myParamsTime.Modified();
- }
+ if(myTitFontType == theTitFontType)
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ myTitFontType = theTitFontType;
+ myParamsTime.Modified();
}
//----------------------------------------------------------------------------
if(anIsSameValue)
return;
+ VISU::TSetModified aModified(this);
+
myTitleColor[0] = theR;
myTitleColor[1] = theG;
myTitleColor[2] = theB;
VISU::ColoredPrs3d_i
::SetBoldLabel(bool theIsBoldLabel)
{
- if(myIsBoldLabel != theIsBoldLabel){
- myIsBoldLabel = theIsBoldLabel;
- myParamsTime.Modified();
- }
+ if(myIsBoldLabel == theIsBoldLabel)
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ myIsBoldLabel = theIsBoldLabel;
+ myParamsTime.Modified();
}
//----------------------------------------------------------------------------
VISU::ColoredPrs3d_i
::SetItalicLabel(bool theIsItalicLabel)
{
- if(myIsItalicLabel != theIsItalicLabel){
- myIsItalicLabel = theIsItalicLabel;
- myParamsTime.Modified();
- }
+ if(myIsItalicLabel == theIsItalicLabel)
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ myIsItalicLabel = theIsItalicLabel;
+ myParamsTime.Modified();
}
//----------------------------------------------------------------------------
VISU::ColoredPrs3d_i
::SetShadowLabel(bool theIsShadowLabel)
{
- if(myIsShadowLabel != theIsShadowLabel){
- myIsShadowLabel = theIsShadowLabel;
- myParamsTime.Modified();
- }
+ if(myIsShadowLabel == theIsShadowLabel)
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ myIsShadowLabel = theIsShadowLabel;
+ myParamsTime.Modified();
}
//----------------------------------------------------------------------------
VISU::ColoredPrs3d_i
::SetLblFontType(int theLblFontType)
{
- if(myIsShadowLabel != theLblFontType){
- myLblFontType = theLblFontType;
- myParamsTime.Modified();
- }
+ if(myIsShadowLabel == theLblFontType)
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ myLblFontType = theLblFontType;
+ myParamsTime.Modified();
}
//----------------------------------------------------------------------------
if(anIsSameValue)
return;
+ VISU::TSetModified aModified(this);
+
myLabelColor[0] = theR;
myLabelColor[1] = theG;
myLabelColor[2] = theB;
// Module : VISU
#include "VISU_CutLines_i.hh"
+#include "VISU_Prs3dUtils.hh"
#include "VISU_Result_i.hh"
#include "VISU_Actor.h"
}
};
- ProcessVoidEvent(new TEvent(myCutLinesPL, theOrient, theXAngle, theYAngle));
+ VISU::TSetModified aModified(this);
+ ProcessVoidEvent(new TEvent(myCutLinesPL, theOrient, theXAngle, theYAngle));
}
//---------------------------------------------------------------
}
};
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TEvent(myCutLinesPL, theOrient, theXAngle, theYAngle));
}
VISU::CutLines_i
::SetDisplacement(CORBA::Double theDisp)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun2ArgEvent<VISU_CutLinesPL, vtkFloatingPointType, int>
(GetSpecificPL(), &VISU_CutLinesPL::SetDisplacement, theDisp, 0));
}
VISU::CutLines_i
::SetDisplacement2(CORBA::Double theDisp)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun2ArgEvent<VISU_CutLinesPL, vtkFloatingPointType, int>
(GetSpecificPL(), &VISU_CutLinesPL::SetDisplacement, theDisp, 1));
}
VISU::CutLines_i
::SetBasePlanePosition(CORBA::Double thePlanePosition)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_CutLinesPL, vtkFloatingPointType>
(GetSpecificPL(), &VISU_CutLinesPL::SetPosition, thePlanePosition));
}
::SetLinePosition(CORBA::Long thePlaneNumber,
CORBA::Double thePlanePosition)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun2ArgEvent<VISU_CutLinesPL, int, vtkFloatingPointType>
(GetSpecificPL(), &VISU_CutLinesPL::SetPartPosition, thePlaneNumber, thePlanePosition));
}
VISU::CutLines_i
::SetDefault()
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFunEvent<VISU_CutLinesPL>
(GetSpecificPL(), &VISU_CutLinesPL::SetDefault));
}
VISU::CutLines_i
::SetDefaultPosition(CORBA::Long thePlaneNumber)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_CutLinesPL, int>
(GetSpecificPL(), &VISU_CutLinesPL::SetPartDefault, thePlaneNumber));
}
if(myMapCurvesInverted[theCurveNumber] == theInvert)
return;
+ VISU::TSetModified aModified(this);
+
myMapCurvesInverted[theCurveNumber] = theInvert;
myParamsTime.Modified();
}
if(myUseAbsLength == theAbsLength)
return;
+ VISU::TSetModified aModified(this);
+
myUseAbsLength = theAbsLength;
myParamsTime.Modified();
}
VISU::CutLines_i
::SetNbLines(CORBA::Long theNb)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_CutLinesPL, int>
(GetSpecificPL(), &VISU_CutLinesPL::SetNbParts, theNb));
}
// Module : VISU
#include "VISU_CutPlanesPL.hxx"
-#include "VISU_Result_i.hh"
+#include "VISU_Prs3dUtils.hh"
#include "VISU_CutPlanes_i.hh"
+
+#include "VISU_Result_i.hh"
#include "VISU_Actor.h"
#include "SUIT_ResourceMgr.h"
}
};
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TEvent(GetSpecificPL(),
VISU_CutPlanesPL::PlaneOrientation(theOrient),
theXAngle,
VISU::CutPlanes_i
::SetDisplacement(CORBA::Double theDisp)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun2ArgEvent<VISU_CutPlanesPL, vtkFloatingPointType, int>
(GetSpecificPL(), &VISU_CutPlanesPL::SetDisplacement, theDisp, 0));
}
::SetPlanePosition(CORBA::Long thePlaneNumber,
CORBA::Double thePlanePosition)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun2ArgEvent<VISU_CutPlanesPL, int, vtkFloatingPointType>
(GetSpecificPL(), &VISU_CutPlanesPL::SetPartPosition, thePlaneNumber, thePlanePosition));
}
VISU::CutPlanes_i
::SetDefault(CORBA::Long thePlaneNumber)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_CutPlanesPL, int>
(GetSpecificPL(), &VISU_CutPlanesPL::SetPartDefault, thePlaneNumber));
}
VISU::CutPlanes_i
::SetNbPlanes(CORBA::Long theNb)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_CutPlanesPL, int>
(GetSpecificPL(), &VISU_CutPlanesPL::SetNbParts, theNb));
}
// Module : VISU
#include "VISU_DeformedShape_i.hh"
+#include "VISU_Prs3dUtils.hh"
#include "VISU_Result_i.hh"
#include "VISU_ScalarMapAct.h"
VISU::DeformedShape_i
::SetScale(CORBA::Double theScale)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_DeformedShapePL, vtkFloatingPointType>
(GetSpecificPL(), &VISU_DeformedShapePL::SetScale, theScale));
}
if(anIsSameValue)
return;
+ VISU::TSetModified aModified(this);
+
myColor = theColor;
myParamsTime.Modified();
}
VISU::DeformedShape_i
::SetMapScale(double theMapScale)
{
+ VISU::TSetModified aModified(this);
+
myDeformedShapePL->SetMapScale(theMapScale);
}
#include "VISU_GaussPoints_i.hh"
#include "VISU_ScalarMap_i.hh"
+#include "VISU_Prs3dUtils.hh"
#include "VISU_Result_i.hh"
#include "VISU_GaussPtsAct.h"
VISU::GaussPoints_i
::SetFaceLimit( CORBA::Long theFaceLimit )
{
- if( myFaceLimit != theFaceLimit ){
- myFaceLimit = theFaceLimit;
- myParamsTime.Modified();
- }
+ if( myFaceLimit == theFaceLimit )
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ myFaceLimit = theFaceLimit;
+ myParamsTime.Modified();
}
//----------------------------------------------------------------------------
VISU::GaussPoints_i
::SetIsDeformed( CORBA::Boolean theIsDeformed )
{
+ VISU::TSetModified aModified(this);
+
myGaussPointsPL->SetIsDeformed( theIsDeformed );
}
VISU::GaussPoints_i
::SetScaleFactor( CORBA::Double theScaleFactor )
{
+ VISU::TSetModified aModified(this);
+
myGaussPointsPL->SetScale( theScaleFactor );
}
if(myColor == theColor)
return;
+ VISU::TSetModified aModified(this);
+
myColor = theColor;
myParamsTime.Modified();
}
VISU::GaussPoints_i
::SetIsColored( bool theIsColored )
{
+ VISU::TSetModified aModified(this);
+
myGaussPointsPL->SetIsColored( theIsColored );
}
VISU::GaussPoints_i
::SetMainTexture( const QString& theMainTexture )
{
- bool update = myMainTexture != theMainTexture;
- myMainTexture = theMainTexture;
- return update;
+ if(myMainTexture != theMainTexture){
+ VISU::TSetModified aModified(this);
+
+ myMainTexture = theMainTexture;
+ myParamsTime.Modified();
+ return true;
+ }
+
+ return false;
}
QString
VISU::GaussPoints_i
::SetAlphaTexture( const QString& theAlphaTexture )
{
- bool update = myAlphaTexture != theAlphaTexture;
- myAlphaTexture = theAlphaTexture;
- return update;
+ if(myAlphaTexture != theAlphaTexture){
+ VISU::TSetModified aModified(this);
+
+ myAlphaTexture = theAlphaTexture;
+ myParamsTime.Modified();
+ return true;
+ }
+
+ return false;
}
QString
VISU::GaussPoints_i
::SetAlphaThreshold( CORBA::Double theAlphaThreshold )
{
+ VISU::TSetModified aModified(this);
+
myGaussPointsPL->SetAlphaThreshold( theAlphaThreshold );
}
VISU::GaussPoints_i
::SetResolution( CORBA::Long theResolution )
{
+ VISU::TSetModified aModified(this);
+
myGaussPointsPL->SetResolution( theResolution );
}
VISU::GaussPoints_i
::SetPrimitiveType(VISU::GaussPoints::PrimitiveType thePrimitiveType)
{
+ VISU::TSetModified aModified(this);
+
myGaussPointsPL->SetPrimitiveType( thePrimitiveType );
}
VISU::GaussPoints_i
::SetClamp(CORBA::Double theClamp)
{
+ VISU::TSetModified aModified(this);
+
myGaussPointsPL->SetClamp( theClamp );
}
VISU::GaussPoints_i
::SetGeomSize( CORBA::Double theGeomSize )
{
+ VISU::TSetModified aModified(this);
+
myGaussPointsPL->SetSize( theGeomSize );
}
VISU::GaussPoints_i
::SetMinSize( CORBA::Double theMinSize )
{
+ VISU::TSetModified aModified(this);
+
myGaussPointsPL->SetMinSize( theMinSize );
}
VISU::GaussPoints_i
::SetMaxSize( CORBA::Double theMaxSize )
{
+ VISU::TSetModified aModified(this);
+
myGaussPointsPL->SetMaxSize( theMaxSize );
}
VISU::GaussPoints_i
::SetMagnification( CORBA::Double theMagnification )
{
+ VISU::TSetModified aModified(this);
+
myGaussPointsPL->SetMagnification( theMagnification );
}
VISU::GaussPoints_i
::SetMagnificationIncrement( CORBA::Double theIncrement )
{
+ VISU::TSetModified aModified(this);
+
myGaussPointsPL->SetMagnificationIncrement( theIncrement );
}
anActor->SetBarVisibility(true);
GetPipeLine()->GetMapper()->SetScalarVisibility(1);
- vtkFloatingPointType* aRange = GetSpecificPL()->GetScalarRange();
- aScalarBarCtrl->SetRangeLocal(aRange);
-
+ if(IsRangeFixed()){
+ vtkFloatingPointType* aRange = GetSpecificPL()->GetScalarRange();
+ aScalarBarCtrl->SetRangeLocal(aRange);
+ }else{
+ vtkFloatingPointType aRange[2];
+ GetSpecificPL()->GetSourceRange(aRange);
+ aScalarBarCtrl->SetRangeLocal(aRange);
+ }
+
TMinMax aTMinMax(-VTK_LARGE_FLOAT,VTK_LARGE_FLOAT);
bool anIsMinMaxDone = IsGlobalRangeDefined();
if(anIsMinMaxDone)
if( !updateMainTexture && !updateAlphaTexture )
return;
+ VISU::TSetModified aModified(this);
+
using namespace VISU;
- TTextureValue aTextureValue = GetTexture(theMainTexture,theAlphaTexture);
+ TTextureValue aTextureValue = GetTexture(theMainTexture, theAlphaTexture);
myGaussPointsPL->SetImageData( aTextureValue.GetPointer() );
}
VISU::GaussPoints_i
::SetIsActiveLocalScalarBar(CORBA::Boolean theIsActiveLocalScalarBar)
{
- if(myIsActiveLocalScalarBar != theIsActiveLocalScalarBar){
- myIsActiveLocalScalarBar = theIsActiveLocalScalarBar;
- myParamsTime.Modified();
- }
+ if(myIsActiveLocalScalarBar == theIsActiveLocalScalarBar)
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ myIsActiveLocalScalarBar = theIsActiveLocalScalarBar;
+ myParamsTime.Modified();
}
CORBA::Boolean
VISU::GaussPoints_i
::SetIsDispGlobalScalarBar(CORBA::Boolean theIsDispGlobalScalarBar)
{
- if(myIsDispGlobalScalarBar != theIsDispGlobalScalarBar){
- myIsDispGlobalScalarBar = theIsDispGlobalScalarBar;
- myParamsTime.Modified();
- }
+ if(myIsDispGlobalScalarBar == theIsDispGlobalScalarBar)
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ myIsDispGlobalScalarBar = theIsDispGlobalScalarBar;
+ myParamsTime.Modified();
}
bool
VISU::GaussPoints_i
::SetSourceRange()
{
+ VISU::TSetModified aModified(this);
+
if(IsTimeStampFixed() || GetIsActiveLocalScalarBar())
ProcessVoidEvent(new TVoidMemFunEvent<VISU_ColoredPL>
(GetSpecificPL(), &VISU_ColoredPL::SetSourceRange));
VISU::GaussPoints_i
::SetBiColor(CORBA::Boolean theIsBiColor)
{
+ VISU::TSetModified aModified(this);
+
GetSpecificPL()->SetBicolor(theIsBiColor);
}
VISU::GaussPoints_i
::SetSpacing(CORBA::Double theSpacing)
{
- if(!VISU::CheckIsSameValue(mySpacing, theSpacing)){
- mySpacing = theSpacing;
- myParamsTime.Modified();
- }
+ if(VISU::CheckIsSameValue(mySpacing, theSpacing))
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ mySpacing = theSpacing;
+ myParamsTime.Modified();
}
CORBA::Double
// Author : Alexey PETROV
// Module : VISU
+#include "VISU_IsoSurfaces_i.hh"
+#include "VISU_Prs3dUtils.hh"
+
#include "VISU_IsoSurfacesPL.hxx"
#include "VISU_Result_i.hh"
-#include "VISU_IsoSurfaces_i.hh"
#include "VISU_Actor.h"
#include "SUIT_ResourceMgr.h"
VISU::IsoSurfaces_i
::SetNbSurfaces(CORBA::Long theNb)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_IsoSurfacesPL, int>
(GetSpecificPL(), &VISU_IsoSurfacesPL::SetNbParts, theNb));
}
VISU::IsoSurfaces_i
::SetSubRange(CORBA::Double theMin, CORBA::Double theMax)
{
+ VISU::TSetModified aModified(this);
+
vtkFloatingPointType aRange[2] = {theMin, theMax};
ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_IsoSurfacesPL, vtkFloatingPointType*>
(GetSpecificPL(), &VISU_IsoSurfacesPL::SetRange, aRange));
// Module : VISU
#include "VISU_Mesh_i.hh"
+#include "VISU_Prs3dUtils.hh"
#include "VISU_Result_i.hh"
if(IsSameColor(myCellColor, theColor))
return;
+ VISU::TSetModified aModified(this);
+
myCellColor = theColor;
myParamsTime.Modified();
}
if(IsSameColor(myNodeColor, theColor))
return;
+ VISU::TSetModified aModified(this);
+
myNodeColor = theColor;
myParamsTime.Modified();
}
if(IsSameColor(myLinkColor, theColor))
return;
+ VISU::TSetModified aModified(this);
+
myLinkColor = theColor;
myParamsTime.Modified();
}
if(myPresentType == theType)
return;
+ VISU::TSetModified aModified(this);
+
myPresentType = theType;
myParamsTime.Modified();
}
if(!myIsPartsDone) // If corresponding data is not ready yet
return TSuperClass::GetInput();
- if(UseInitialInput(myPartName2FileName, myPartName2Resolution))
- return TSuperClass::GetInput();
+ //if(UseInitialInput(myPartName2FileName, myPartName2Resolution))
+ // return TSuperClass::GetInput();
MultiResult_i::TRepresentationKey aRepresentationKey =
GetRepresentation(myPartName2FileName, myPartName2Resolution);
//
#include "VISU_Plot3D_i.hh"
+#include "VISU_Prs3dUtils.hh"
#include "VISU_Result_i.hh"
#include "VISU_Plot3DPL.hxx"
}
};
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TEvent(GetSpecificPL(),
VISU_CutPlanesPL::PlaneOrientation(theOrient),
theXAngle,
::SetPlanePosition(CORBA::Double thePlanePosition,
CORBA::Boolean theIsRelative)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun2ArgEvent<VISU_Plot3DPL, vtkFloatingPointType, bool>
(GetSpecificPL(), &VISU_Plot3DPL::SetPlanePosition, thePlanePosition, theIsRelative));
}
VISU::Plot3D_i
::SetScaleFactor(CORBA::Double theScaleFactor)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_Plot3DPL, vtkFloatingPointType>
(GetSpecificPL(), &VISU_Plot3DPL::SetScaleFactor, theScaleFactor));
}
VISU::Plot3D_i
::SetNbOfContours(CORBA::Long theNb)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_Plot3DPL, int>
(GetSpecificPL(), &VISU_Plot3DPL::SetNumberOfContours, theNb));
}
VISU::Plot3D_i
::SetContourPrs(CORBA::Boolean theIsContourPrs)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_Plot3DPL, bool>
(GetSpecificPL(), &VISU_Plot3DPL::SetContourPrs, theIsContourPrs));
}
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+// File : VISU_Prs3dUtils.cc
+// Author : Alexey PETROV
+// Module : VISU
+
+#include "VISU_Prs3dUtils.hh"
+#include "VISU_PipeLine.hxx"
+
+
+namespace VISU
+{
+ //----------------------------------------------------------------------------
+ TSetModified
+ ::TSetModified(VISU::Prs3d_i* thePrs3d):
+ myPrs3d(thePrs3d)
+ {
+ this->Modified();
+ }
+
+
+ //----------------------------------------------------------------------------
+ TSetModified
+ ::~TSetModified()
+ {
+ if(myPrs3d->GetActorEntry() == "")
+ return;
+
+ if(myPrs3d->GetMTime() > this->GetMTime()){
+ SALOMEDS::Study_var aStudy = myPrs3d->GetStudyDocument();
+ aStudy->Modified();
+ }
+ }
+
+
+ //----------------------------------------------------------------------------
+};
--- /dev/null
+// VISU OBJECT : interactive object for VISU entities implementation
+//
+// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 2.1 of the License.
+//
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+//
+// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+//
+//
+// File : VISU_Prs3dUtils.hh
+// Author : Alexey PETROV
+// Module : VISU
+
+#ifndef __VISU_PRS3D_UTILS_H__
+#define __VISU_PRS3D_UTILS_H__
+
+#include "VISU_Prs3d_i.hh"
+
+#include <vtkTimeStamp.h>
+
+
+namespace VISU
+{
+ //----------------------------------------------------------------------------
+ struct TSetModified: vtkTimeStamp
+ {
+ VISU::Prs3d_i* myPrs3d;
+
+ TSetModified(VISU::Prs3d_i* thePrs3d);
+
+ ~TSetModified();
+ };
+
+
+ //----------------------------------------------------------------------------
+}
+
+
+#endif // __VISU_PRS3D_UTILS_H__
// Author : Alexey PETROV
// Module : VISU
-#include "VISU_PipeLine.hxx"
#include "VISU_Prs3d_i.hh"
+#include "VISU_Prs3dUtils.hh"
+#include "VISU_PipeLine.hxx"
#include "VISU_Result_i.hh"
#include "VISU_Actor.h"
::SameAs(const Prs3d_i* theOrigin)
{
if(Prs3d_i* anOrigin = const_cast<Prs3d_i*>(theOrigin)){
+ VISU::TSetModified aModified(this);
+
GetPipeLine()->SameAs(anOrigin->GetPipeLine());
anOrigin->GetOffset(myOffset);
}
VISU::Prs3d_i
::SetCResult(VISU::Result_i* theResult)
{
- if(GetCResult() != theResult){
- if(theResult)
- SetStudyDocument(theResult->GetStudyDocument());
- myResult = theResult;
- myParamsTime.Modified();
- }
+ if(GetCResult() == theResult)
+ return;
+
+ if(theResult)
+ SetStudyDocument(theResult->GetStudyDocument());
+
+ VISU::TSetModified aModified(this);
+
+ myResult = theResult;
+ myParamsTime.Modified();
}
//----------------------------------------------------------------------------
VISU::Prs3d_i
::SetMeshName(const char* theMeshName)
{
- if(myMeshName != theMeshName){
- myMeshName = theMeshName;
- myParamsTime.Modified();
- }
+ if(myMeshName == theMeshName)
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ myMeshName = theMeshName;
+ myParamsTime.Modified();
}
{
unsigned long int aTime = myParamsTime.GetMTime();
if(IsPipeLineExists())
- aTime = std::max(aTime,GetPipeLine()->GetMTime());
+ aTime = std::max(aTime, GetPipeLine()->GetMTime());
return aTime;
}
Handle(SALOME_InteractiveObject)
GetIO();
+ //! Used in derived classes to initilize the IO for actors
+ virtual
+ std::string
+ GetActorEntry();
+
protected:
/*!
Used in Apply method to get know whether it is possible to create presentation
vtkTimeStamp myUpdateTime;
vtkTimeStamp myParamsTime;
- //! Used in derived classes to initilize the IO for actors
- virtual
- std::string
- GetActorEntry();
-
private:
void
SetResultEntry(const std::string& theResultEntry);
{}
+//---------------------------------------------------------------
+VISU::Result_i
+::~Result_i()
+{
+ MESSAGE("Result_i::~Result_i() - this = "<<this);
+ if (GetSourceId() == eRestoredFile)
+ VISU::RemoveFile(myFileInfo.filePath().latin1());
+}
+
+
//---------------------------------------------------------------
void
VISU::Result_i
theRestoringMap);
}
-#include <stdio.h>
-//---------------------------------------------------------------
-VISU::Result_i
-::~Result_i()
-{
- MESSAGE("Result_i::~Result_i() - this = "<<this);
- if (GetSourceId() == eRestoredFile)
- VISU::RemoveFile(myFileInfo.filePath().latin1());
-}
//=======================================================================
//function : GetAxisInfo
// Module : VISU
#include "VISU_ScalarMapOnDeformedShape_i.hh"
+#include "VISU_Prs3dUtils.hh"
+#include "VISU_Result_i.hh"
+
#include "VISU_ScalarMapAct.h"
#include "VISU_ScalarMapOnDeformedShapePL.hxx"
#include "VISU_Convertor.hxx"
-#include "VISU_Result_i.hh"
#include "SUIT_ResourceMgr.h"
#include "SALOME_Event.hxx"
VISU::ScalarMapOnDeformedShape_i
::SetScale(CORBA::Double theScale)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_ScalarMapOnDeformedShapePL, vtkFloatingPointType>
(GetSpecificPL(), &VISU_ScalarMapOnDeformedShapePL::SetScale, theScale));
}
if(!anIsModified)
return;
+ VISU::TSetModified aModified(this);
+
VISU::TEntity aEntity = VISU::TEntity(theEntity);
VISU::Result_i::PInput anInput = GetCResult()->GetInput(GetCMeshName(),
theEntity,
// Module : VISU
#include "VISU_ScalarMap_i.hh"
+#include "VISU_Prs3dUtils.hh"
#include "VISU_Result_i.hh"
VISU::ScalarMap_i
::SetScaling(VISU::Scaling theScaling)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_ScalarMapPL, int>
(GetSpecificPL(), &VISU_ColoredPL::SetScaling, theScaling));
}
// Module : VISU
#include "VISU_StreamLines_i.hh"
+#include "VISU_Prs3dUtils.hh"
#include "VISU_Result_i.hh"
#include "VISU_Actor.h"
::SetSource(VISU::Prs3d_i* thePrs3d)
{
mySourceEntry = "";
- if(thePrs3d){
- SALOMEDS::SObject_var aSObject = thePrs3d->GetSObject();
- CORBA::String_var aString = aSObject->GetID();
- if(mySourceEntry == aString.in())
- return;
-
- mySourceEntry = aString.in();
- myParamsTime.Modified();
- }
+ if(!thePrs3d)
+ return;
+
+ SALOMEDS::SObject_var aSObject = thePrs3d->GetSObject();
+ CORBA::String_var aString = aSObject->GetID();
+ if(mySourceEntry == aString.in())
+ return;
+
+ VISU::TSetModified aModified(this);
+
+ mySourceEntry = aString.in();
+ myParamsTime.Modified();
}
//---------------------------------------------------------------
{
if(!myStreamLinesPL->GetSource() && mySourceEntry == "")
return;
+
if(myStreamLinesPL->GetSource() == myAppendFilter->GetOutput())
return;
+
VISU::Prs3d_var aPrs3d = GetSource();
SetParams(GetIntegrationStep(),
GetPropagationTime(),
// Module : VISU
#include "VISU_Vectors_i.hh"
+#include "VISU_Prs3dUtils.hh"
#include "VISU_Result_i.hh"
#include "VISU_VectorsAct.h"
if(VISU::CheckIsSameValue(myLineWidth, theWidth))
return;
+ VISU::TSetModified aModified(this);
+
myLineWidth = theWidth;
myParamsTime.Modified();
}
VISU::Vectors_i
::SetGlyphType(VISU::Vectors::GlyphType theType)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_VectorsPL, VISU_VectorsPL::GlyphType>
(GetSpecificPL(), &VISU_VectorsPL::SetGlyphType, VISU_VectorsPL::GlyphType(theType)));
}
VISU::Vectors_i
::SetGlyphPos(VISU::Vectors::GlyphPos thePos)
{
+ VISU::TSetModified aModified(this);
+
ProcessVoidEvent(new TVoidMemFun1ArgEvent<VISU_VectorsPL, VISU_VectorsPL::GlyphPos>
(GetSpecificPL(), &VISU_VectorsPL::SetGlyphPos, VISU_VectorsPL::GlyphPos(thePos)));
}
