X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FVISU_I%2FVISU_Prs3d_i.cc;h=3ec20db4328e6cf4dab98590b1cd9df54c54ab9c;hb=d90eeb25287fa1f390fe7a336547e74161708e44;hp=1bdd88b8620cfb67340c3e95225f5072df705be1;hpb=e208a04edd5d8cebc0185834ecdf3faec4514f99;p=modules%2Fvisu.git

diff --git a/src/VISU_I/VISU_Prs3d_i.cc b/src/VISU_I/VISU_Prs3d_i.cc
index 1bdd88b8..3ec20db4 100644
--- a/src/VISU_I/VISU_Prs3d_i.cc
+++ b/src/VISU_I/VISU_Prs3d_i.cc
@@ -1,6 +1,6 @@
-//  VISU OBJECT : interactive object for VISU entities implementation
+//  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
 //
-//  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
+//  Copyright (C) 2003-2007  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
@@ -17,30 +17,29 @@
 //  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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
-//
+//  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
+//  VISU OBJECT : interactive object for VISU entities implementation
 //  File   : VISU_Prs3d_i.cc
 //  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"
 
-#include "SALOME_Event.hxx"
+#include "SALOME_Event.h"
 
 #include <vtkActorCollection.h>
+#include <vtkUnstructuredGrid.h>
 #include <vtkDataSet.h>
 #include <vtkMapper.h>
 
 #include <boost/bind.hpp>
 
-using namespace VISU;
-using namespace std;
-
 #ifdef _DEBUG_
 static int MYDEBUG = 1;
 #else
@@ -49,75 +48,282 @@ static int MYDEBUG = 0;
 
 
 //----------------------------------------------------------------------------
-VISU::Prs3d_i
-::Prs3d_i(Result_i* theResult,
-	  SALOMEDS::SObject_ptr theSObject) :
-  PrsObject_i(theResult->GetStudyDocument()),
-  mySObject(SALOMEDS::SObject::_duplicate(theSObject)),
+VISU::Prs3d_i::Prs3d_i() :
+  PrsObject_i(SALOMEDS::Study::_nil()),
   myActorCollection(vtkActorCollection::New()),
-  myResult(theResult),
-  myAddToStudy(true),
-  myPipeLine(NULL)
+  myIsActiveSatate(true)
 {
   if(MYDEBUG) MESSAGE("Prs3d_i::Prs3d_i - this = "<<this);
   myOffset[0] = myOffset[1] = myOffset[2] = 0;
   myActorCollection->Delete();
-  myResult->Register();
 }
 
+
+//----------------------------------------------------------------------------
+void
 VISU::Prs3d_i
-::Prs3d_i(Result_i* theResult,
-	  bool theAddToStudy) :
-  PrsObject_i(theResult->GetStudyDocument()),
-  myActorCollection(vtkActorCollection::New()),
-  mySObject(SALOMEDS::SObject::_nil()),
-  myAddToStudy(theAddToStudy),
-  myResult(theResult),
-  myPipeLine(NULL)
+::SameAs(const Prs3d_i* theOrigin)
 {
-  if(MYDEBUG) MESSAGE("Prs3d_i::Prs3d_i - this = "<<this);
-  myOffset[0] = myOffset[1] = myOffset[2] = 0;
-  myActorCollection->Delete();
-  myResult->Register();
+  if(Prs3d_i* anOrigin = const_cast<Prs3d_i*>(theOrigin)){
+    VISU::TSetModified aModified(this);
+
+    GetPipeLine()->SameAs(anOrigin->GetPipeLine());
+    anOrigin->GetOffset(myOffset);
+  }
+}
+
+
+//----------------------------------------------------------------------------
+namespace VISU
+{
+  struct TInvokeSignalEvent: public SALOME_Event
+  {
+    typedef boost::signal0<void> TSignal;
+    const TSignal& mySignal;
+    
+    TInvokeSignalEvent(const TSignal& theSignal):
+      mySignal(theSignal)
+    {}
+    
+    virtual
+    void
+    Execute()
+    {
+      mySignal();
+    }
+  };
+}
+
+//----------------------------------------------------------------------------
+VISU::Prs3d_i::~Prs3d_i()
+{
+  if(MYDEBUG) MESSAGE("Prs3d_i::~Prs3d_i - this = "<<this);
+  ProcessVoidEvent(new TInvokeSignalEvent(myRemoveActorsFromRendererSignal));
+  if(myResult) myResult->Destroy();
+}
+
+
+//----------------------------------------------------------------------------
+bool 
+VISU::Prs3d_i
+::SetInput(bool theReInit)
+{
+  if(GetCResult()){
+    if(myMeshName != ""){
+      myPreviousResult = myResult;
+      myPreviousMeshName = myMeshName;
+      return true;
+    }
+  }
+  return false;
+}
+
+
+//----------------------------------------------------------------------------
+void 
+VISU::Prs3d_i
+::OnRestoreInput()
+{
+  SetCResult(myPreviousResult);
+  myMeshName = myPreviousMeshName;
 }
 
+
+//----------------------------------------------------------------------------
+CORBA::Boolean 
+VISU::Prs3d_i
+::Apply(bool theReInit)
+{
+  try{
+    if(SetInput(theReInit)){
+      if(myActorCollection->GetNumberOfItems())
+	UpdateActors();
+      return true;
+    }
+  }catch(std::exception& exc){
+    INFOS("Follow exception was occured :\n"<<exc.what());
+  }catch(...){
+    INFOS("Unknown exception was occured!");
+  }
+  OnRestoreInput();
+  return false;
+}
+
+
+//----------------------------------------------------------------------------
 void
 VISU::Prs3d_i
-::SameAs(const Prs3d_i* theOrigin)
+::SetCResult(VISU::Result_i* theResult)
 {
-  if (Prs3d_i* aOrigin = const_cast<Prs3d_i*>(theOrigin)) {
-    myPipeLine->SameAs(aOrigin->GetPL());
-    aOrigin->GetOffset(myOffset);
+  if(GetCResult() == theResult)
+    return;
+
+  if(theResult) {
+    SetStudyDocument(theResult->GetStudyDocument());
+    theResult->Register();
+  }
+  if(myResult) {
+    myResult->Destroy();
   }
+  
+  VISU::TSetModified aModified(this);
+  
+  myResult = theResult;
+  myParamsTime.Modified();
 }
 
+//----------------------------------------------------------------------------
+void
 VISU::Prs3d_i
-::~Prs3d_i() 
+::SetResultEntry(const std::string& theResultEntry)
 {
-  if(MYDEBUG) MESSAGE("Prs3d_i::~Prs3d_i - this = "<<this);
-  myRemoveActorsFromRendererSignal();
-  myPipeLine->Delete();
-  myResult->Destroy();
+  SetCResult(VISU::GetResult(GetStudyDocument(), theResultEntry));
+}
+
+//----------------------------------------------------------------------------
+std::string
+VISU::Prs3d_i
+::GetResultEntry()
+{
+  if(VISU::Result_i* aResult = GetCResult())
+    return aResult->GetEntry();
+  return "";
+}
+
+//----------------------------------------------------------------------------
+VISU::Result_i* 
+VISU::Prs3d_i
+::GetCResult() const 
+{ 
+  return myResult;
+}
+
+
+//----------------------------------------------------------------------------
+void
+VISU::Prs3d_i
+::SetResultObject(VISU::Result_ptr theResult)
+{
+  SetCResult(dynamic_cast<VISU::Result_i*>(GetServant(theResult).in()));
 }
 
 
+//----------------------------------------------------------------------------
+VISU::Result_ptr
+VISU::Prs3d_i
+::GetResultObject()
+{
+  return GetCResult()->_this();
+}
+
+
+//----------------------------------------------------------------------------
+void 
+VISU::Prs3d_i
+::SetMeshName(const char* theMeshName)
+{
+  if(myMeshName == theMeshName)
+    return;
+
+  VISU::TSetModified aModified(this);
+
+  myMeshName = theMeshName;
+  myParamsTime.Modified();
+}
+
+
+//----------------------------------------------------------------------------
+char*
+VISU::Prs3d_i
+::GetMeshName()
+{
+  return CORBA::string_dup(myMeshName.c_str());
+}
+
+
+//----------------------------------------------------------------------------
+std::string
+VISU::Prs3d_i
+::GetCMeshName() const
+{
+  return myMeshName;
+}
+
+
+//----------------------------------------------------------------------------
+unsigned long int 
+VISU::Prs3d_i
+::GetMTime()
+{
+  unsigned long int aTime = myParamsTime.GetMTime();
+  if(IsPipeLineExists())
+    aTime = std::max(aTime, GetPipeLine()->GetMTime());
+  return aTime;
+}
+
+//----------------------------------------------------------------------------
+bool 
+VISU::Prs3d_i
+::GetActiveState()
+{
+  return myIsActiveSatate;
+}
+
+//----------------------------------------------------------------------------
+void 
+VISU::Prs3d_i
+::SetActiveState(bool theState)
+{
+  myIsActiveSatate = theState;
+}
+
 //----------------------------------------------------------------------------
 VISU::Storable* 
 VISU::Prs3d_i
-::Restore(const Storable::TRestoringMap& theMap)
+::Restore(SALOMEDS::SObject_ptr theSObject,
+	  const Storable::TRestoringMap& theMap)
 {
-  myName = VISU::Storable::FindValue(theMap,"myName").latin1();
+  SALOMEDS::Study_var aStudy = theSObject->GetStudy();
+  SetStudyDocument(aStudy);
+
+  bool anIsExists = false;
+  QString aResultEntry = VISU::Storable::FindValue(theMap,"myResultEntry", &anIsExists);
+  if(!anIsExists){
+    SALOMEDS::SObject_var aSObject = SALOMEDS::SObject::_duplicate(theSObject);
+    for(; aSObject->Depth() > 2 && !aResultEntry.isEmpty(); aSObject = aSObject->GetFather()){
+      CORBA::Object_var anObject = VISU::SObjectToObject(aSObject);
+      if(CORBA::is_nil(anObject))
+	continue;
+
+      VISU::Result_var aResult = VISU::Result::_narrow(anObject);
+      if(CORBA::is_nil(aResult))
+	continue;
+
+      CORBA::String_var anEntry = aSObject->GetID();
+      aResultEntry = anEntry.in();
+    }
+  }
+  SetResultEntry(aResultEntry.toLatin1().data());
+  if(!GetCResult())
+    return NULL;
+
+  SetMeshName((const char*)VISU::Storable::FindValue(theMap,"myMeshName").toLatin1());
+  SetName((const char*)VISU::Storable::FindValue(theMap,"myName").toLatin1(), false);
   myOffset[0] = VISU::Storable::FindValue(theMap,"myOffset[0]").toFloat();
   myOffset[1] = VISU::Storable::FindValue(theMap,"myOffset[1]").toFloat();
   myOffset[2] = VISU::Storable::FindValue(theMap,"myOffset[2]").toFloat();
+  myParamsTime.Modified();
   return this;
 }
 
+//----------------------------------------------------------------------------
 void
 VISU::Prs3d_i
 ::ToStream(std::ostringstream& theStr)
 {
-  Storable::DataToStream( theStr, "myName",   myName.c_str() );
+  Storable::DataToStream( theStr, "myResultEntry", GetResultEntry().c_str() );
+  Storable::DataToStream( theStr, "myMeshName", GetCMeshName().c_str() );
+  Storable::DataToStream( theStr, "myName", GetName().c_str() );
   Storable::DataToStream( theStr, "myOffset[0]", myOffset[0] );
   Storable::DataToStream( theStr, "myOffset[1]", myOffset[1] );
   Storable::DataToStream( theStr, "myOffset[2]", myOffset[2] );
@@ -125,41 +331,35 @@ VISU::Prs3d_i
 
 
 //----------------------------------------------------------------------------
-SALOMEDS::SObject_var 
+SALOMEDS::SObject_var
 VISU::Prs3d_i
 ::GetSObject()
 {
-  if(CORBA::is_nil(mySObject.in())){
-    const SALOMEDS::Study_var& aStudy = myResult->GetStudyDocument();
+  const SALOMEDS::Study_var& aStudy = GetStudyDocument();
+  if(!CORBA::is_nil(aStudy.in())){
     CORBA::String_var anIOR = GetID();
-    mySObject = aStudy->FindObjectIOR(anIOR);
+    return aStudy->FindObjectIOR(anIOR);
   }
-  return mySObject;
-}
-
-Result_i* 
-VISU::Prs3d_i
-::GetResult() const 
-{ 
-  return myResult;
-}
-
-const std::string& 
-VISU::Prs3d_i
-::GetMeshName() const 
-{ 
-  return myMeshName; 
+  return SALOMEDS::SObject::_nil();
 }
 
 
 //----------------------------------------------------------------------------
 void
 VISU::Prs3d_i
-::Update() 
+::Update()
 {
+  if(GetMTime() < myUpdateTime.GetMTime())
+    return;
+
   if(MYDEBUG) MESSAGE("Prs3d_i::Update - this = "<<this);
+
   try{
-    myPipeLine->Update();
+    ProcessVoidEvent(new TVoidMemFunEvent<VISU_PipeLine>
+		     (GetPipeLine(), &VISU_PipeLine::Update));
+    myUpdateTime.Modified();
+  }catch(std::exception&){
+    throw;
   }catch(...){
     throw std::runtime_error("Prs3d_i::Update >> unexpected exception was caught!!!");
   }
@@ -169,81 +369,124 @@ VISU::Prs3d_i
 //----------------------------------------------------------------------------
 void
 VISU::Prs3d_i
-::CheckDataSet() 
+::CheckDataSet()
 {
-  vtkMapper *aMapper = myPipeLine->GetMapper();
+  vtkMapper *aMapper = GetPipeLine()->GetMapper();
   vtkDataSet *aDataSet = aMapper->GetInput();
   if (!aDataSet)
     throw std::runtime_error("There is no input data !!!");
+
   aDataSet->Update();
   static float eps = VTK_LARGE_FLOAT * 0.1 ;
   if (!aDataSet->GetNumberOfCells())
     throw std::runtime_error("There are no visible elements");
+
   if (aDataSet->GetLength() > eps)
     throw std::runtime_error("Diagonal of the actor is too large !!!");
 }
 
+
+//----------------------------------------------------------------------------
 void
 VISU::Prs3d_i
-::RemoveFromStudy() 
+::RemoveFromStudy()
 {
-  struct TRemoveFromStudy: public SALOME_Event
+  struct TEvent: public TInvokeSignalEvent
   {
     VISU::Prs3d_i* myRemovable;
-    typedef boost::signal0<void> TRemoveFromStudySignal;
-    const TRemoveFromStudySignal& myRemoveFromStudySignal;
-
-    TRemoveFromStudy(VISU::Prs3d_i* theRemovable,
-		     const TRemoveFromStudySignal& theRemoveFromStudySignal):
-      myRemovable(theRemovable),
-      myRemoveFromStudySignal(theRemoveFromStudySignal)
+  
+    TEvent(const TSignal& theSignal,
+	   VISU::Prs3d_i* theRemovable):
+      TInvokeSignalEvent(theSignal),
+      myRemovable(theRemovable)
     {}
-    
+  
     virtual
     void
     Execute()
     {
-      myRemoveFromStudySignal();
+      //TInvokeSignalEvent::Execute();
       myRemovable->Destroy();
     }
   };
 
-  ProcessVoidEvent(new TRemoveFromStudy(this,myRemoveActorsFromRendererSignal));
+  ProcessVoidEvent(new TEvent(myRemoveActorsFromRendererSignal, this));
 }
 
 
 //----------------------------------------------------------------------------
-VISU_PipeLine* 
+VISU_PipeLine*
+VISU::Prs3d_i
+::GetPipeLine() const
+{
+  if(!myPipeLine.GetPointer())
+    throw std::runtime_error("VISU::Prs3d_i::myPipeLine == NULL !!!");
+
+  return myPipeLine.GetPointer();
+}
+
+//----------------------------------------------------------------------------
+void
+VISU::Prs3d_i
+::SetPipeLine(VISU_PipeLine* thePipeLine)
+{
+  myPipeLine = thePipeLine;
+  if(thePipeLine)
+    thePipeLine->Delete();
+}
+
+//----------------------------------------------------------------------------
+bool 
 VISU::Prs3d_i
-::GetPipeLine()
+::IsPipeLineExists()
 {
-  return GetPL();
+  return myPipeLine.GetPointer() != NULL;
 }
 
+//----------------------------------------------------------------------------
 VISU_PipeLine* 
 VISU::Prs3d_i
-::GetPL()
+::GetActorPipeLine()
 {
-  return myPipeLine;
+  return GetPipeLine();
 }
 
-vtkUnstructuredGrid* 
-VISU::Prs3d_i::
-GetInput()
+//----------------------------------------------------------------------------
+vtkDataSet* 
+VISU::Prs3d_i
+::GetInput()
 {
-  return myPipeLine->GetInput();
+  return GetPipeLine()->GetInput();
+}
+
+//----------------------------------------------------------------------------
+Handle(SALOME_InteractiveObject)
+VISU::Prs3d_i
+::GetIO()
+{
+  if( myIO.IsNull() )
+    myIO = new SALOME_InteractiveObject(GetActorEntry().c_str(), "VISU", GetName().c_str());
+
+  return myIO;
+}
+
+//----------------------------------------------------------------------------
+std::string
+VISU::Prs3d_i
+::GetActorEntry()
+{
+  return GetEntry();
 }
 
 
 //----------------------------------------------------------------------------
 void
 VISU::Prs3d_i
-::CreateActor(VISU_Actor* theActor, const Handle(SALOME_InteractiveObject)& theIO)
+::CreateActor(VISU_Actor* theActor)
 {
   try{
-    Handle(SALOME_InteractiveObject) anIO = theIO;
-    if(anIO.IsNull() && (!mySObject->_is_nil())){
-      anIO = new SALOME_InteractiveObject(mySObject->GetID(),"VISU",GetName());
+    Handle(SALOME_InteractiveObject) anIO = GetIO();
+    if(!anIO.IsNull() && anIO->hasEntry()){
       theActor->setIO(anIO);
     }
 
@@ -252,16 +495,18 @@ VISU::Prs3d_i
 
     theActor->SetPrs3d(this);
     theActor->SetShrinkFactor();
-    theActor->SetPosition(myOffset);
-    theActor->SetPipeLine(GetPipeLine());
+    theActor->SetPosition(myOffset[0],myOffset[1],myOffset[2]);
+    theActor->SetPipeLine(GetActorPipeLine());
+    if(theActor->GetPipeLine() != GetPipeLine()){
+       // To decrease actor'ss pipeline reference counter
+      theActor->GetPipeLine()->Delete();
+    }
 
     theActor->SetFactory(this);
-    myUpdateActorsSignal.connect(boost::bind(&VISU_Actor::UpdateFromFactory,theActor));
-    myRemoveActorsFromRendererSignal.connect(boost::bind(&VISU_Actor::RemoveFromRender,theActor));
+    theActor->ConnectToFactory(myUpdateActorsSignal, myRemoveActorsFromRendererSignal);
 
     myActorCollection->AddItem(theActor);
     theActor->Delete();
-
   }catch(std::bad_alloc& ex){
     throw std::runtime_error("CreateActor >> No enough memory");
     throw ex;
@@ -272,31 +517,35 @@ VISU::Prs3d_i
   }
 }
 
+//----------------------------------------------------------------------------
 void
 VISU::Prs3d_i
-::RemoveActor(VISU_Actor* theActor) 
+::RemoveActor(VISU_ActorBase* theActor)
 {
-  if(MYDEBUG) MESSAGE("Prs3d_i::RemoveActor - this = "<<this<<"; theActor = "<<theActor);
+  if(MYDEBUG) MESSAGE("Prs3d_i::RemoveActor - this = "<<this<<"; theActor = "<<theActor<<"; "<<theActor->GetReferenceCount());
   myActorCollection->RemoveItem(theActor);
 }
 
+//----------------------------------------------------------------------------
 void
 VISU::Prs3d_i
 ::RemoveActors()
 {
   if(MYDEBUG) MESSAGE("Prs3d_i::RemoveActors - this = "<<this);
-  myRemoveActorsFromRendererSignal();
+  ProcessVoidEvent(new TInvokeSignalEvent(myRemoveActorsFromRendererSignal));
   myActorCollection->RemoveAllItems();
 }
 
+//----------------------------------------------------------------------------
 void
 VISU::Prs3d_i
-::UpdateActor(VISU_Actor* theActor) 
+::UpdateActor(VISU_ActorBase* theActor)
 {
-  if(MYDEBUG) MESSAGE("Prs3d_i::UpdateActor - this = "<<this<<"; theActor = "<<theActor);
-  theActor->ShallowCopyPL(myPipeLine);
-  theActor->SetPosition(myOffset);
-  theActor->Modified();
+  if(VISU_Actor* anActor = dynamic_cast<VISU_Actor*>(theActor)){
+    if(MYDEBUG) MESSAGE("Prs3d_i::UpdateActor - this = "<<this<<"; theActor = "<<anActor);
+    anActor->SetPosition(myOffset[0],myOffset[1],myOffset[2]);
+    anActor->ShallowCopyPL(GetPipeLine());
+  }
 }
 
 void
@@ -306,7 +555,7 @@ VISU::Prs3d_i
   if(MYDEBUG) MESSAGE("Prs3d_i::UpdateActors - this = "<<this);
   Update();
   CheckDataSet();
-  myUpdateActorsSignal();
+  ProcessVoidEvent(new TInvokeSignalEvent(myUpdateActorsSignal));
 }
 
 
@@ -316,76 +565,98 @@ void
 VISU::Prs3d_i
 ::RemoveAllClippingPlanes()
 {
-  myPipeLine->RemoveAllClippingPlanes();
+  GetPipeLine()->RemoveAllClippingPlanes();
 }
 
+//----------------------------------------------------------------------------
 bool
 VISU::Prs3d_i
 ::AddClippingPlane(vtkPlane* thePlane)
 {
-  return myPipeLine->AddClippingPlane(thePlane);
+  return GetPipeLine()->AddClippingPlane(thePlane);
 }
 
+//----------------------------------------------------------------------------
 vtkIdType
 VISU::Prs3d_i
 ::GetNumberOfClippingPlanes() const
 {
-  return myPipeLine->GetNumberOfClippingPlanes();
+  return GetPipeLine()->GetNumberOfClippingPlanes();
 }
 
+//----------------------------------------------------------------------------
 vtkPlane* 
 VISU::Prs3d_i::
 GetClippingPlane(vtkIdType theID) const
 {
-  return myPipeLine->GetClippingPlane(theID);
+  return GetPipeLine()->GetClippingPlane(theID);
 }
 
+//----------------------------------------------------------------------------
+void VISU::Prs3d_i::RemoveClippingPlane(vtkIdType theID)
+{
+  GetPipeLine()->RemoveClippingPlane(theID);
+}
+
+//----------------------------------------------------------------------------
 void
 VISU::Prs3d_i
-::SetPlaneParam (float theDir[3], float theDist, vtkPlane* thePlane) 
+::SetPlaneParam(vtkFloatingPointType theDir[3], 
+		vtkFloatingPointType theDist, 
+		vtkPlane* thePlane) 
 {
-  myPipeLine->SetPlaneParam(theDir, theDist, thePlane);
+  GetPipeLine()->SetPlaneParam(theDir, theDist, thePlane);
 }
 
 
 //----------------------------------------------------------------------------
 void
 VISU::Prs3d_i
-::GetBounds(float aBounds[6])
+::GetBounds(vtkFloatingPointType aBounds[6])
 {
-  myPipeLine->GetMapper()->GetBounds(aBounds);
+  GetPipeLine()->GetMapper()->GetBounds(aBounds);
 }
 
+//----------------------------------------------------------------------------
 void 
 VISU::Prs3d_i
-::SetOffset(const float* theOffsets)
+::SetOffset(const CORBA::Float* theOffsets)
 {
   myOffset[0] = theOffsets[0];
   myOffset[1] = theOffsets[1];
   myOffset[2] = theOffsets[2];
+  myParamsTime.Modified();
 }
 
+//----------------------------------------------------------------------------
 void
 VISU::Prs3d_i
-::SetOffset(float theDx, float theDy, float theDz)
+::SetOffset(CORBA::Float theDx,
+	    CORBA::Float theDy,
+	    CORBA::Float theDz)
 {
   myOffset[0] = theDx;
   myOffset[1] = theDy;
   myOffset[2] = theDz;
+  myParamsTime.Modified();
 }
 
+//----------------------------------------------------------------------------
 void
 VISU::Prs3d_i
-::GetOffset(float* theOffsets)
+::GetOffset(CORBA::Float* theOffsets)
 {
   theOffsets[0] = myOffset[0];
   theOffsets[1] = myOffset[1];
   theOffsets[2] = myOffset[2];
 }
 
+//----------------------------------------------------------------------------
 void 
 VISU::Prs3d_i
-::GetOffset(float& theDx, float& theDy, float& theDz)
+::GetOffset(CORBA::Float& theDx,
+	    CORBA::Float& theDy,
+	    CORBA::Float& theDz)
 {
   theDx = myOffset[0];
   theDy = myOffset[1];
@@ -394,12 +665,30 @@ VISU::Prs3d_i
 
 
 //----------------------------------------------------------------------------
-VISU::Result_i* 
-VISU::GetResult(SALOMEDS::SObject_ptr theSObject)
+CORBA::Float
+VISU::Prs3d_i
+::GetMemorySize()
 {
-  VISU::Result_var aResult = FindResult(theSObject);
-  if(!aResult->_is_nil())
-    return dynamic_cast<VISU::Result_i*>(VISU::GetServant(aResult.in()).in());
-  return NULL;
+  // To calculate memory used by VISU PipeLine
+  CORBA::Float aSize = GetPipeLine()->GetMemorySize();
+  //cout<<"Prs3d_i::GetMemorySize - "<<this<<"; GetPipeLine = "<<aSize / (1024.0 * 1024.0)<<endl;
+
+  // To calculate memory used by VISU Actos
+  int anEnd = myActorCollection->GetNumberOfItems();
+  for(int anId = 0; anId < anEnd; anId++)
+    if(vtkObject* anObject = myActorCollection->GetItemAsObject(anId))
+      if(VISU_Actor* anActor = dynamic_cast<VISU_Actor*>(anObject)){
+	aSize += anActor->GetMemorySize();
+	//cout<<"Prs3d_i::GetMemorySize - "<<this<<"; anActor = "<<aSize / (1024.0 * 1024.0)<<endl;
+      }
+
+  // Convert to mega bytes
+  return aSize / (1024.0 * 1024.0);
 }
 
+int
+VISU::Prs3d_i
+::GetNumberOfActors()
+{
+  return myActorCollection->GetNumberOfItems();
+}