src/VISU_I/VISU_Gen_i.cc

   1 //  VISU OBJECT : interactive object for VISU entities implementation
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  21 //
  22 //
  23 //  File   : VISU_Gen_i.cc
  24 //  Author : Alexey PETROV
  25 //  Module : VISU
  26
  27 #include "VISU_Gen_i.hh"
  28 #include "VISU_Result_i.hh"
  29 #include "VISU_PrsObject_i.hh"
  30 #include "VISU_ViewManager_i.hh"
  31
  32 #include "VISU_Prs3d_i.hh"
  33 #include "VISU_Mesh_i.hh"
  34 #include "VISU_ScalarMap_i.hh"
  35 #include "VISU_IsoSurfaces_i.hh"
  36 #include "VISU_DeformedShape_i.hh"
  37 #include "VISU_CutPlanes_i.hh"
  38 #include "VISU_CutLines_i.hh"
  39 #include "VISU_Vectors_i.hh"
  40 #include "VISU_StreamLines_i.hh"
  41 #include "VISU_Table_i.hh"
  42 #include "VISU_TimeAnimation.h"
  43
  44 #include "VISU_Actor.h"
  45
  46 #include "HDFascii.hxx"
  47 #include "SALOMEDS_Tool.hxx"
  48
  49 #include "SALOMEDSClient_AttributeName.hxx"
  50 #include "SALOMEDSClient_AttributePixMap.hxx"
  51
  52 #include "SUIT_Session.h"
  53 #include "SalomeApp_Study.h"
  54 #include "SalomeApp_Application.h"
  55 #include "SalomeApp_SelectionMgr.h"
  56 #include "SVTK_ViewModel.h"
  57 #include "SVTK_ViewWindow.h"
  58 #include "SALOME_Event.hxx"
  59 #include "SALOME_ListIO.hxx"
  60 #include "SALOME_ListIteratorOfListIO.hxx"
  61
  62 #include "utilities.h"
  63
  64 // IDL Headers
  65 #include <omnithread.h>
  66 #include CORBA_SERVER_HEADER(SALOME_Session)
  67 #include CORBA_SERVER_HEADER(SALOME_ModuleCatalog)
  68
  69 // QT Includes
  70 #include <qstring.h>
  71 #include <qfileinfo.h>
  72
  73 // VTK Includes
  74 #include <vtkRenderer.h>
  75 #include <vtkActorCollection.h>
  76
  77 // OCCT Includes
  78 #include <TCollection_AsciiString.hxx>
  79 #include <TColStd_SequenceOfAsciiString.hxx>
  80
  81 // STL Includes
  82 #include <strstream>
  83
  84 #include "Utils_ExceptHandlers.hxx"
  85
  86 using namespace std;
  87
  88 static QFileInfo aFileInfo;
  89
  90 #ifdef _DEBUG_
  91 static int MYDEBUG = 1;
  92 #else
  93 static int MYDEBUG = 0;
  94 #endif
  95
  96 UNEXPECT_CATCH(SalomeException, SALOME::SALOME_Exception);
  97
  98 extern "C" VISU::VISU_Gen_ptr GetImpl(CORBA::ORB_ptr theORB,
  99                                       PortableServer::POA_ptr thePOA,
 100                                       SALOME_NamingService* theNamingService,
 101                                       QMutex* theMutex)
 102 {
 103   if(MYDEBUG) MESSAGE("extern \"C\" GetImpl");
 104   VISU::VISU_Gen_i *aVISU_Gen = new VISU::VISU_Gen_i(theORB,thePOA,theNamingService,theMutex);
 105   //return VISU::VISU_Gen::_duplicate(aVISU_Gen->_this());
 106   return aVISU_Gen->_this();
 107 }
 108
 109 namespace VISU{
 110   static string VisuTmpDir;
 111
 112   static CORBA::Boolean myIsMultiFile;
 113   const CORBA::Boolean IsMultifile() { return myIsMultiFile;}
 114
 115   //===========================================================================
 116   _PTR(SComponent) ClientFindOrCreateVisuComponent (_PTR(Study) theStudyDocument)
 117   {
 118     _PTR(SComponent) aSComponent = theStudyDocument->FindComponent("VISU");
 119     if (!aSComponent) {
 120       _PTR(StudyBuilder) aStudyBuilder = theStudyDocument->NewBuilder();
 121       aStudyBuilder->NewCommand();
 122       int aLocked = theStudyDocument->GetProperties()->IsLocked();
 123       if (aLocked) theStudyDocument->GetProperties()->SetLocked(false);
 124       aSComponent = aStudyBuilder->NewComponent("VISU");
 125       _PTR(GenericAttribute) anAttr =
 126         aStudyBuilder->FindOrCreateAttribute(aSComponent, "AttributeName");
 127       _PTR(AttributeName) aName (anAttr);
 128
 129       CORBA::ORB_var anORB = Base_i::GetORB();
 130       SALOME_NamingService *NamingService = new SALOME_NamingService( anORB );
 131       CORBA::Object_var objVarN = NamingService->Resolve("/Kernel/ModulCatalog");
 132       SALOME_ModuleCatalog::ModuleCatalog_var Catalogue =
 133         SALOME_ModuleCatalog::ModuleCatalog::_narrow(objVarN);
 134       SALOME_ModuleCatalog::Acomponent_var Comp = Catalogue->GetComponent( "VISU" );
 135       if (!Comp->_is_nil()) {
 136         aName->SetValue(Comp->componentusername());
 137       }
 138
 139       anAttr = aStudyBuilder->FindOrCreateAttribute(aSComponent, "AttributePixMap");
 140       _PTR(AttributePixMap) aPixmap (anAttr);
 141       aPixmap->SetPixMap( "ICON_OBJBROWSER_Visu" );
 142
 143       VISU_Gen_var aVisuGen = Base_i::GetVisuGenImpl()->_this();
 144       aStudyBuilder->DefineComponentInstance(aSComponent, aVisuGen->GetID());
 145       if (aLocked) theStudyDocument->GetProperties()->SetLocked(true);
 146       aStudyBuilder->CommitCommand();
 147     }
 148     return aSComponent;
 149   }
 150
 151   SALOMEDS::SComponent_var FindOrCreateVisuComponent(SALOMEDS::Study_ptr theStudyDocument){
 152     SALOMEDS::SComponent_var aSComponent = theStudyDocument->FindComponent("VISU");
 153     if (aSComponent->_is_nil()) {
 154       SALOMEDS::StudyBuilder_var aStudyBuilder = theStudyDocument->NewBuilder();
 155       aStudyBuilder->NewCommand();
 156       int aLocked = theStudyDocument->GetProperties()->IsLocked();
 157       if (aLocked) theStudyDocument->GetProperties()->SetLocked(false);
 158       aSComponent = aStudyBuilder->NewComponent("VISU");
 159       SALOMEDS::GenericAttribute_var anAttr = aStudyBuilder->FindOrCreateAttribute(aSComponent, "AttributeName");
 160       SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
 161
 162       //NRI      aName->SetValue("Visu");
 163       CORBA::ORB_var anORB = Base_i::GetORB();
 164       SALOME_NamingService *NamingService = new SALOME_NamingService( anORB );
 165       CORBA::Object_var objVarN = NamingService->Resolve("/Kernel/ModulCatalog");
 166       SALOME_ModuleCatalog::ModuleCatalog_var Catalogue  = SALOME_ModuleCatalog::ModuleCatalog::_narrow(objVarN);
 167       SALOME_ModuleCatalog::Acomponent_var Comp = Catalogue->GetComponent( "VISU" );
 168       if ( !Comp->_is_nil() ) {
 169         aName->SetValue( Comp->componentusername() );
 170       }
 171
 172       anAttr = aStudyBuilder->FindOrCreateAttribute(aSComponent, "AttributePixMap");
 173       SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 174       aPixmap->SetPixMap( "ICON_OBJBROWSER_Visu" );
 175
 176       VISU_Gen_var aVisuGen = Base_i::GetVisuGenImpl()->_this();
 177       aStudyBuilder->DefineComponentInstance(aSComponent,aVisuGen);
 178       if (aLocked) theStudyDocument->GetProperties()->SetLocked(true);
 179       aStudyBuilder->CommitCommand();
 180     }
 181     return aSComponent;
 182   }
 183
 184   void RegistryStorable() {
 185     Storable::Registry(Result_i::myComment.c_str(),&(Result_i::Restore));
 186     Storable::Registry(Mesh_i::myComment.c_str(),&(Restore<Mesh_i>));
 187     Storable::Registry(ScalarMap_i::myComment.c_str(),&(Restore<ScalarMap_i>));
 188     Storable::Registry(DeformedShape_i::myComment.c_str(),&(Restore<DeformedShape_i>));
 189     Storable::Registry(CutPlanes_i::myComment.c_str(),&(Restore<CutPlanes_i>));
 190     Storable::Registry(CutLines_i::myComment.c_str(),&(Restore<CutLines_i>));
 191     Storable::Registry(IsoSurfaces_i::myComment.c_str(),&(Restore<IsoSurfaces_i>));
 192     Storable::Registry(StreamLines_i::myComment.c_str(),&(Restore<StreamLines_i>));
 193     Storable::Registry(Vectors_i::myComment.c_str(),&(Restore<Vectors_i>));
 194     Storable::Registry(Table_i::myComment.c_str(),&(Table_i::Restore));
 195     Storable::Registry(Curve_i::myComment.c_str(),&(Curve_i::Restore));
 196     Storable::Registry(Container_i::myComment.c_str(),&(Container_i::Restore));
 197   }
 198
 199
 200   //===========================================================================
 201   VISU_Gen_i::VISU_Gen_i(CORBA::ORB_ptr theORB, PortableServer::POA_ptr thePOA,
 202                          SALOME_NamingService* theNamingService, QMutex* theMutex) :
 203     Engines_Component_i()
 204   {
 205     if(MYDEBUG) MESSAGE("VISU_Gen_i::VISU_Gen_i : "<<theMutex);
 206     Base_i::myMutex = theMutex;  //apo
 207     Base_i::myOrb = CORBA::ORB::_duplicate(theORB);
 208     Base_i::myPoa = PortableServer::POA::_duplicate(thePOA);
 209     Base_i::myNamingService = theNamingService;
 210     static SALOME_LifeCycleCORBA aEnginesLifeCycle(theNamingService);
 211     Base_i::myEnginesLifeCycle = &aEnginesLifeCycle;
 212     Base_i::myVisuGenImpl = this;
 213     RegistryStorable();
 214
 215     CORBA::Object_var anObj = myNamingService->Resolve("/myStudyManager");
 216     SALOMEDS::StudyManager_var aStudyManager = SALOMEDS::StudyManager::_narrow(anObj);
 217     SALOMEDS::ListOfOpenStudies_var aListOfOpenStudies = aStudyManager->GetOpenStudies();
 218     if(aListOfOpenStudies->length() > 0) {
 219       CORBA::String_var aStudyName = aListOfOpenStudies[0];
 220       //aFileInfo.setFile(aStudyName.in());
 221       myStudyDocument = aStudyManager->GetStudyByName(aStudyName/*aFileInfo.baseName()*/);
 222     }else
 223       if(MYDEBUG) MESSAGE("VISU_Gen_i::VISU_Gen_i : there is no opened study in StudyManager !!!");
 224   }
 225
 226   VISU_Gen_i::~VISU_Gen_i(){
 227     if(MYDEBUG) MESSAGE("VISU_Gen_i::~VISU_Gen_i");
 228   }
 229   //===========================================================================
 230   CORBA::Boolean VISU_Gen_i::Load(SALOMEDS::SComponent_ptr theComponent,
 231                                   const SALOMEDS::TMPFile & theStream,
 232                                   const char* theURL,
 233                                   bool isMultiFile)
 234   {
 235     Mutex mt(myMutex);
 236     SALOMEDS::Study_var aStudy = theComponent->GetStudy();
 237     SALOMEDS::StudyBuilder_var  aStudyBuilder = aStudy->NewBuilder();
 238     const char* aDir = isMultiFile? theURL: SALOMEDS_Tool::GetTmpDir().c_str();
 239     TCollection_AsciiString aTmpDir(const_cast<char*>(aDir));
 240     VisuTmpDir = aTmpDir.ToCString();
 241     SALOMEDS::ListOfFileNames_var aSeq =
 242       SALOMEDS_Tool::PutStreamToFiles(theStream, aTmpDir.ToCString(),isMultiFile);
 243     myIsMultiFile = isMultiFile;
 244     return true;
 245   }
 246
 247   CORBA::Boolean VISU_Gen_i::LoadASCII(SALOMEDS::SComponent_ptr theComponent,
 248                                        const SALOMEDS::TMPFile & theStream,
 249                                        const char* theURL,
 250                                        bool isMultiFile)
 251   {
 252     return Load(theComponent, theStream, theURL, isMultiFile);
 253   }
 254
 255   char* VISU_Gen_i::LocalPersistentIDToIOR(SALOMEDS::SObject_ptr theSObject,
 256                                            const char* aLocalPersistentID,
 257                                            CORBA::Boolean isMultiFile,
 258                                            CORBA::Boolean isASCII)
 259   {
 260     CORBA::String_var aString("");
 261     if(strcmp(aLocalPersistentID,"") != 0) {
 262       Mutex mt(myMutex);
 263       Storable* aStorable =
 264         Storable::Create(theSObject,VisuTmpDir.c_str(),aLocalPersistentID);
 265       if(aStorable != NULL) aString = aStorable->GetID();
 266     }
 267     return aString._retn();
 268   }
 269   //===========================================================================
 270   SALOMEDS::TMPFile* VISU_Gen_i::Save(SALOMEDS::SComponent_ptr theComponent,
 271                                       const char* theURL,
 272                                       bool isMultiFile)
 273   {
 274     Mutex mt(myMutex);
 275     const char* aDir = isMultiFile? theURL: SALOMEDS_Tool::GetTmpDir().c_str();
 276     TCollection_AsciiString aTmpDir(const_cast<char*>(aDir));
 277     if(MYDEBUG) MESSAGE("VISU_Gen_i::Save - "<<aTmpDir);
 278     int aCounter = 0;
 279     TColStd_SequenceOfAsciiString aFileNames;
 280     SALOMEDS::Study_var aStudy = theComponent->GetStudy();
 281
 282     //CORBA::Boolean anIsValidScript;
 283     //Engines::TMPFile_var aDump = DumpPython(aStudy,false,anIsValidScript);
 284
 285     SALOMEDS::ChildIterator_var itBig = aStudy->NewChildIterator(theComponent);
 286     for (; itBig->More(); itBig->Next()) {
 287       SALOMEDS::SObject_var gotBranch = itBig->Value();
 288       CORBA::Object_var anObj = SObjectToObject(gotBranch);
 289       if(CORBA::is_nil(anObj)) continue;
 290       if(Result_i* pResult = dynamic_cast<Result_i*>(GetServant(anObj).in())){
 291         switch(pResult->GetCreationId()){
 292         case Result_i::eImportFile:
 293         case Result_i::eCopyAndImportFile: {
 294           const QFileInfo& aFileInfo = pResult->GetFileInfo();
 295           QString aPrefix("");
 296           if (isMultiFile) aPrefix = SALOMEDS_Tool::GetNameFromPath(aStudy->URL()).c_str();
 297           QString aFileName = aPrefix + "_" + (pResult->GetName()).c_str();
 298           static QString aCommand;
 299           aCommand.sprintf("cp %s %s%s",aFileInfo.filePath().latin1(),aTmpDir.ToCString(),aFileName.latin1());
 300
 301           int aRes = system(aCommand);
 302           if(aRes){
 303             if(MYDEBUG) MESSAGE("VISU_Gen_i::Save - Cann't execute the command :"<<aCommand);
 304             continue;
 305           }else
 306             if(MYDEBUG) MESSAGE("VISU_Gen_i::Save - aCommand = "<<aCommand);
 307
 308           TCollection_AsciiString aString(strdup(aFileName.latin1()));
 309           aFileNames.Append(aString);
 310         }}
 311       }
 312     }
 313     SALOMEDS::TMPFile_var aStreamFile = new SALOMEDS::TMPFile(0);
 314     if(MYDEBUG) MESSAGE("VISU_Gen_i::Save - aFileNames.Length() - "<<aFileNames.Length());
 315     if(aFileNames.Length() > 0){
 316       SALOMEDS::ListOfFileNames_var aSeq = new SALOMEDS::ListOfFileNames;
 317       aSeq->length(aFileNames.Length());
 318       for(aCounter = aFileNames.Length(); aCounter > 0; aCounter--)
 319         aSeq[aCounter-1] = CORBA::string_dup(aFileNames.Value(aCounter).ToCString());
 320       aStreamFile = SALOMEDS_Tool::PutFilesToStream(aTmpDir.ToCString(), aSeq.in(), isMultiFile);
 321       if(!isMultiFile)
 322         SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.ToCString(), aSeq.in(), true);
 323     }
 324     return aStreamFile._retn();
 325   }
 326
 327   SALOMEDS::TMPFile* VISU_Gen_i::SaveASCII(SALOMEDS::SComponent_ptr theComponent,
 328                                            const char* theURL,
 329                                            bool isMultiFile)
 330   {
 331     Mutex mt(myMutex);
 332     const char* aDir = isMultiFile? theURL: SALOMEDS_Tool::GetTmpDir().c_str();
 333     TCollection_AsciiString aTmpDir(const_cast<char*>(aDir));
 334     if(MYDEBUG) MESSAGE("VISU_Gen_i::Save - "<<aTmpDir);
 335     int aCounter = 0;
 336     TColStd_SequenceOfAsciiString aFileNames;
 337     SALOMEDS::Study_var aStudy = theComponent->GetStudy();
 338     SALOMEDS::ChildIterator_var itBig = aStudy->NewChildIterator(theComponent);
 339     for (; itBig->More(); itBig->Next()) {
 340       SALOMEDS::SObject_var gotBranch = itBig->Value();
 341       CORBA::Object_var anObj = SObjectToObject(gotBranch);
 342       if(CORBA::is_nil(anObj)) continue;
 343       if(Result_i* pResult = dynamic_cast<Result_i*>(GetServant(anObj).in())){
 344         switch(pResult->GetCreationId()){
 345         case Result_i::eImportFile:
 346         case Result_i::eCopyAndImportFile: {
 347           const QFileInfo& aFileInfo = pResult->GetFileInfo();
 348           QString aPrefix("");
 349           if (isMultiFile) aPrefix = SALOMEDS_Tool::GetNameFromPath(aStudy->URL()).c_str();
 350           QString aFileName = aPrefix + "_" + (pResult->GetName()).c_str();
 351           static QString aCommand;
 352           aCommand.sprintf("cp %s %s%s",aFileInfo.filePath().latin1(),aTmpDir.ToCString(),aFileName.latin1());
 353
 354           int aRes = system(aCommand);
 355           if(aRes){
 356             if(MYDEBUG) MESSAGE("VISU_Gen_i::Save - Can't execute the command :"<<aCommand);
 357             continue;
 358           }else
 359             if(MYDEBUG) MESSAGE("VISU_Gen_i::Save - "<<aCommand);
 360
 361           TCollection_AsciiString aString(strdup(aFileName.latin1()));
 362
 363           HDFascii::ConvertFromHDFToASCII(strdup((aTmpDir + aString).ToCString()), true);
 364
 365           aFileNames.Append(aString);
 366         }}
 367       }
 368     }
 369     SALOMEDS::TMPFile_var aStreamFile = new SALOMEDS::TMPFile(0);
 370     if(MYDEBUG) MESSAGE("VISU_Gen_i::Save - aFileNames.Length() - "<<aFileNames.Length());
 371     if(aFileNames.Length() > 0){
 372       SALOMEDS::ListOfFileNames_var aSeq = new SALOMEDS::ListOfFileNames;
 373       aSeq->length(aFileNames.Length());
 374       for(aCounter = aFileNames.Length(); aCounter > 0; aCounter--)
 375         aSeq[aCounter-1] = CORBA::string_dup(aFileNames.Value(aCounter).ToCString());
 376       aStreamFile = SALOMEDS_Tool::PutFilesToStream(aTmpDir.ToCString(), aSeq.in(), isMultiFile);
 377       if(!isMultiFile)
 378         SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.ToCString(), aSeq.in(), true);
 379     }
 380     return aStreamFile._retn();
 381   }
 382
 383   char* VISU_Gen_i::IORToLocalPersistentID(SALOMEDS::SObject_ptr theSObject,
 384                                            const char* IORString,
 385                                            CORBA::Boolean isMultiFile,
 386                                            CORBA::Boolean isASCII)
 387   {
 388     CORBA::String_var aString(IORString);
 389     if(strcmp(IORString,"") != 0){
 390       CORBA::ORB_ptr anORB = GetORB();
 391       CORBA::Object_var anObj = anORB->string_to_object(aString);
 392       if(!CORBA::is_nil(anObj)){
 393         if(Storable* pStorable = dynamic_cast<Storable*>(GetServant(anObj).in())){
 394           Mutex mt(myMutex);
 395           aString = pStorable->ToString().c_str();
 396           return aString._retn();
 397         }
 398       }
 399     }
 400     return aString._retn();
 401   }
 402
 403   char* VISU_Gen_i::GetID(){
 404     return Base_i::GetID();
 405   }
 406
 407   void VISU_Gen_i::SetCurrentStudy (SALOMEDS::Study_ptr theStudy)
 408   {
 409     class TEvent: public SALOME_Event {
 410       QString myStudyName;
 411     public:
 412       TEvent(const QString& theStudyName):myStudyName(theStudyName)
 413         {}
 414       virtual void Execute()
 415         {
 416           bool isActive = false;
 417           SUIT_Session* aSession = SUIT_Session::session();
 418           QPtrList<SUIT_Application> anApplications = aSession->applications();
 419           QPtrListIterator<SUIT_Application> anIter (anApplications);
 420           SUIT_Application* aFirstApp = anIter.current();
 421           while (SUIT_Application* anApp = anIter.current()) {
 422             ++anIter;
 423             if (SUIT_Study* aSStudy = anApp->activeStudy()) {
 424               if (SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>(aSStudy)) {
 425                 MESSAGE("There is an application with active study : " << aStudy->studyName());
 426                 if (myStudyName == aStudy->studyName()) {
 427                   isActive = true;
 428                   break;
 429                 }
 430               }
 431             }
 432           }
 433           if (!isActive) {
 434             MESSAGE("!!! anApp->onLoadDoc(myStudyName) !!!");
 435             // Has to be loaded in an empty or in a new application
 436             SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>(aFirstApp);
 437             anApp->onLoadDoc(myStudyName);
 438           }
 439         }
 440     };
 441
 442     if (!CORBA::is_nil(theStudy))
 443     {
 444       CORBA::String_var aName = theStudy->Name();
 445       QString aStudyName (aName.in());
 446       MESSAGE("StudyId = " << theStudy->StudyId() << "; Name = '" << aName.in() << "'");
 447       myStudyDocument = SALOMEDS::Study::_duplicate(theStudy);
 448
 449       ProcessVoidEvent(new TEvent(aStudyName));
 450     } else {
 451       MESSAGE("CORBA::is_nil(theStudy)");
 452     }
 453   }
 454
 455   SALOMEDS::Study_ptr VISU_Gen_i::GetCurrentStudy(){
 456     return SALOMEDS::Study::_duplicate(myStudyDocument);
 457   }
 458
 459   ViewManager_ptr VISU_Gen_i::GetViewManager(){
 460     Mutex mt(myMutex);
 461     ViewManager_i * aViewManager = new ViewManager_i(myStudyDocument);
 462     return ViewManager::_duplicate(aViewManager->_this());
 463   }
 464
 465   SALOMEDS::SObject_ptr VISU_Gen_i::ImportTables(const char* theFileName){
 466     if(myStudyDocument->GetProperties()->IsLocked())
 467       return SALOMEDS::SObject::_nil();
 468     Mutex mt(myMutex);
 469     SALOMEDS::SObject_var aRes = VISU::ImportTables(theFileName,myStudyDocument);
 470     return aRes._retn();
 471   }
 472
 473   CORBA::Boolean VISU_Gen_i::ExportTableToFile(SALOMEDS::SObject_ptr theTable,
 474                                                const char* theFileName)
 475   {
 476     return VISU::ExportTableToFile(theTable, theFileName);
 477   }
 478
 479   Result_ptr VISU_Gen_i::ImportFile(const char* theFileName){
 480     if(myStudyDocument->GetProperties()->IsLocked())
 481       return Result::_nil();
 482     Mutex mt(myMutex);
 483     aFileInfo.setFile(theFileName);
 484     Result_i* pResult = new Result_i(myStudyDocument,
 485                                      Result_i::eFile,
 486                                      Result_i::eImportFile);
 487     if(pResult->Create(theFileName) != NULL)
 488       return pResult->_this();
 489     else{
 490       pResult->_remove_ref();
 491       return VISU::Result::_nil();
 492     }
 493   }
 494
 495   Result_ptr VISU_Gen_i::CopyAndImportFile(const char* theFileName){
 496     if(myStudyDocument->GetProperties()->IsLocked())
 497       return Result::_nil();
 498     Mutex mt(myMutex);
 499     VISU::Result_var aResult;
 500     aFileInfo.setFile(theFileName);
 501     Result_i* pResult = new Result_i(myStudyDocument,
 502                                      Result_i::eRestoredFile,
 503                                      Result_i::eCopyAndImportFile);
 504     if(pResult->Create(theFileName) != NULL)
 505       aResult = pResult->_this();
 506     return aResult._retn();
 507   }
 508
 509   Result_ptr VISU_Gen_i::ClientImportMed (_PTR(SObject) theMedSObject)
 510   {
 511     SALOMEDS::SObject_ptr aMedSObject = GetSObject(theMedSObject);
 512     return ImportMed(aMedSObject);
 513   }
 514
 515   Result_ptr VISU_Gen_i::ImportMed (SALOMEDS::SObject_ptr theMedSObject)
 516   {
 517     if (myStudyDocument->GetProperties()->IsLocked())
 518       return Result::_nil();
 519     Mutex mt(myMutex);
 520     Result_i* pResult = new Result_i(myStudyDocument,
 521                                      Result_i::eComponent,
 522                                      Result_i::eImportMed);
 523     if (pResult->Create(theMedSObject) != NULL) {
 524       return pResult->_this();
 525     } else {
 526       pResult->_remove_ref();
 527       return VISU::Result::_nil();
 528     }
 529   }
 530
 531   Result_ptr VISU_Gen_i::ImportMedField (SALOME_MED::FIELD_ptr theField)
 532   {
 533     if (myStudyDocument->GetProperties()->IsLocked())
 534       return Result::_nil();
 535     Mutex mt(myMutex);
 536     Result_i* pResult = new Result_i(myStudyDocument,
 537                                      Result_i::eComponent,
 538                                      Result_i::eImportMedField);
 539     if (pResult->Create(theField) != NULL) {
 540       return pResult->_this();
 541     } else {
 542       pResult->_remove_ref();
 543       return VISU::Result::_nil();
 544     }
 545   }
 546
 547   Mesh_ptr VISU_Gen_i::MeshOnEntity(Result_ptr theResult,
 548                                     const char* theMeshName,
 549                                     VISU::Entity theEntity)
 550   {
 551     if(myStudyDocument->GetProperties()->IsLocked())
 552       return Mesh::_nil();
 553     Mutex mt(myMutex);
 554     if(Result_i* pResult = dynamic_cast<Result_i*>(GetServant(theResult).in())){
 555       Mesh_i* aPresent = new Mesh_i(pResult);
 556       if(aPresent->Create(theMeshName,theEntity) != NULL)
 557         return aPresent->_this();
 558       else{
 559         aPresent->_remove_ref();
 560       }
 561     }
 562     return VISU::Mesh::_nil();
 563   }
 564
 565   Mesh_ptr VISU_Gen_i::FamilyMeshOnEntity(Result_ptr theResult,
 566                                           const char* theMeshName,
 567                                           VISU::Entity theEntity,
 568                                           const char* theFamilyName)
 569   {
 570     if(myStudyDocument->GetProperties()->IsLocked())
 571       return Mesh::_nil();
 572     Mutex mt(myMutex);
 573     if(Result_i* pResult = dynamic_cast<Result_i*>(GetServant(theResult).in())){
 574       Mesh_i* aPresent = new Mesh_i(pResult);
 575       if(aPresent->Create(theMeshName,theEntity,theFamilyName) != NULL)
 576         return aPresent->_this();
 577       else{
 578         aPresent->_remove_ref();
 579       }
 580     }
 581     return VISU::Mesh::_nil();
 582   }
 583
 584   Mesh_ptr VISU_Gen_i::GroupMesh(Result_ptr theResult,
 585                                  const char* theMeshName,
 586                                  const char* theGroupName)
 587   {
 588     if(myStudyDocument->GetProperties()->IsLocked())
 589       return Mesh::_nil();
 590     Mutex mt(myMutex);
 591     if(Result_i* pResult = dynamic_cast<Result_i*>(GetServant(theResult).in())){
 592       Mesh_i* aPresent = new Mesh_i(pResult);
 593       if(aPresent->Create(theMeshName,theGroupName) != NULL)
 594         return aPresent->_this();
 595       else{
 596         aPresent->_remove_ref();
 597       }
 598     }
 599     return VISU::Mesh::_nil();
 600   }
 601
 602   ScalarMap_ptr VISU_Gen_i::ScalarMapOnField(Result_ptr theResult,
 603                                              const char* theMeshName,
 604                                              VISU::Entity theEntity,
 605                                              const char* theFieldName,
 606                                              CORBA::Double theIteration)
 607   {
 608     return Prs3dOnField<VISU::ScalarMap_i>(theResult,theMeshName,theEntity,theFieldName,theIteration,true)._retn();
 609   }
 610
 611   DeformedShape_ptr VISU_Gen_i::DeformedShapeOnField(Result_ptr theResult,
 612                                                      const char* theMeshName,
 613                                                      VISU::Entity theEntity,
 614                                                      const char* theFieldName,
 615                                                      CORBA::Double theIteration)
 616   {
 617     return Prs3dOnField<VISU::DeformedShape_i>(theResult,theMeshName,theEntity,theFieldName,theIteration)._retn();
 618   }
 619
 620   Vectors_ptr VISU_Gen_i::VectorsOnField(Result_ptr theResult,
 621                                          const char* theMeshName,
 622                                          VISU::Entity theEntity,
 623                                          const char* theFieldName,
 624                                          CORBA::Double theIteration)
 625   {
 626     return Prs3dOnField<VISU::Vectors_i>(theResult,theMeshName,theEntity,theFieldName,theIteration)._retn();
 627   }
 628
 629   IsoSurfaces_ptr VISU_Gen_i::IsoSurfacesOnField(Result_ptr theResult,
 630                                                  const char* theMeshName,
 631                                                  VISU::Entity theEntity,
 632                                                  const char* theFieldName,
 633                                                  CORBA::Double theIteration)
 634   {
 635     return Prs3dOnField<VISU::IsoSurfaces_i>(theResult,theMeshName,theEntity,theFieldName,theIteration)._retn();
 636   }
 637
 638   StreamLines_ptr VISU_Gen_i::StreamLinesOnField(Result_ptr theResult,
 639                                                  const char* theMeshName,
 640                                                  VISU::Entity theEntity,
 641                                                  const char* theFieldName,
 642                                                  CORBA::Double theIteration)
 643   {
 644     return Prs3dOnField<VISU::StreamLines_i>(theResult,theMeshName,theEntity,theFieldName,theIteration)._retn();
 645   }
 646
 647   CutPlanes_ptr VISU_Gen_i::CutPlanesOnField(Result_ptr theResult,
 648                                              const char* theMeshName,
 649                                              VISU::Entity theEntity,
 650                                              const char* theFieldName,
 651                                              CORBA::Double theIteration)
 652   {
 653     return Prs3dOnField<VISU::CutPlanes_i>(theResult,theMeshName,theEntity,theFieldName,theIteration)._retn();
 654   }
 655
 656   CutLines_ptr VISU_Gen_i::CutLinesOnField(Result_ptr theResult,
 657                                            const char* theMeshName,
 658                                            VISU::Entity theEntity,
 659                                            const char* theFieldName,
 660                                            CORBA::Double theIteration)
 661   {
 662     return Prs3dOnField<VISU::CutLines_i>(theResult,theMeshName,theEntity,theFieldName,theIteration)._retn();
 663   }
 664
 665   Table_ptr VISU_Gen_i::CreateTable(const char* theTableEntry){
 666     if(myStudyDocument->GetProperties()->IsLocked())
 667       return Table::_nil();
 668     Mutex mt(myMutex);
 669     Table_i* pPresent = new Table_i(myStudyDocument,theTableEntry);
 670     if(pPresent->Create() != NULL)
 671       return pPresent->_this();
 672     else{
 673       pPresent->_remove_ref();
 674       return VISU::Table::_nil();
 675     }
 676   }
 677
 678   Curve_ptr VISU_Gen_i::CreateCurve(Table_ptr theTable,
 679                                     CORBA::Long theHRow,
 680                                     CORBA::Long theVRow)
 681   {
 682     if(myStudyDocument->GetProperties()->IsLocked())
 683       return Curve::_nil();
 684     Mutex mt(myMutex);
 685     PortableServer::POA_ptr aPOA = GetPOA();
 686     Table_i* pTable = dynamic_cast<Table_i*>(aPOA->reference_to_servant(theTable));
 687     Curve_i* pPresent = new Curve_i(myStudyDocument,pTable,theHRow,theVRow);
 688     if(pPresent->Create() != NULL)
 689       return pPresent->_this();
 690     else{
 691       pPresent->_remove_ref();
 692       return VISU::Curve::_nil();
 693     }
 694   }
 695
 696   Container_ptr VISU_Gen_i::CreateContainer(){
 697     if(myStudyDocument->GetProperties()->IsLocked())
 698       return Container::_nil();
 699     Mutex mt(myMutex);
 700     Container_i* pPresent = new Container_i(myStudyDocument);
 701     if(pPresent->Create() != NULL)
 702       return pPresent->_this();
 703     else{
 704       pPresent->_remove_ref();
 705       return VISU::Container::_nil();
 706     }
 707   }
 708
 709   Animation_ptr VISU_Gen_i::CreateAnimation(View3D_ptr theView3D){
 710     if(myStudyDocument->GetProperties()->IsLocked())
 711       return Animation::_nil();
 712     Mutex mt(myMutex);
 713     if(VISU_TimeAnimation_i* anAnim = new VISU_TimeAnimation_i(myStudyDocument,theView3D)){
 714       return anAnim->_this();
 715     }else
 716       return VISU::Animation::_nil();
 717   }
 718
 719   void DeletePrs3d (Prs3d_ptr thePrs3d)
 720   {
 721     Prs3d_i* aPrs3d = dynamic_cast<Prs3d_i*>(GetServant(thePrs3d).in());
 722     if (!aPrs3d)
 723       return;
 724
 725     // 1. Find appropriate application (code like in VISU_ViewManager_i.cxx)
 726     SALOMEDS::Study_var myStudyDocument = aPrs3d->GetStudyDocument();
 727     SalomeApp_Application* anApp = NULL;
 728     CORBA::String_var studyName = myStudyDocument->Name();
 729     std::string aStudyName = studyName.in();
 730     SUIT_Session* aSession = SUIT_Session::session();
 731     QPtrList<SUIT_Application> anApplications = aSession->applications();
 732     QPtrListIterator<SUIT_Application> anIter (anApplications);
 733     while (SUIT_Application* aSUITApp = anIter.current()) {
 734       ++anIter;
 735       if (SUIT_Study* aSStudy = aSUITApp->activeStudy()) {
 736         if (SalomeApp_Study* aStudy = dynamic_cast<SalomeApp_Study*>(aSStudy)) {
 737           if (_PTR(Study) aCStudy = aStudy->studyDS()) {
 738             if (aStudyName == aCStudy->Name()) {
 739               anApp = dynamic_cast<SalomeApp_Application*>(aSUITApp);
 740               break;
 741             }
 742           }
 743         }
 744       }
 745     }
 746     if (!anApp)
 747       return;
 748
 749     // 2. Remove corresponding IO from selection
 750     SALOMEDS::SObject_var aSObject = aPrs3d->GetSObject();
 751     CORBA::String_var anEntry = aSObject->GetID();
 752
 753     SalomeApp_SelectionMgr* aSelectionMgr = anApp->selectionMgr();
 754     SALOME_ListIO aListIO, aNewListIO;
 755     aSelectionMgr->selectedObjects(aListIO);
 756
 757     for (SALOME_ListIteratorOfListIO it (aListIO); it.More(); it.Next()) {
 758       if (it.Value()->hasEntry()) {
 759         std::string aCurEntry (it.Value()->getEntry());
 760         if (aCurEntry != std::string( anEntry.in() ) ) {
 761           aNewListIO.Append(it.Value());
 762         }
 763       }
 764     }
 765
 766     aSelectionMgr->setSelectedObjects(aNewListIO);
 767
 768     // 3. Remove Actors
 769     ViewManagerList aViewManagerList;
 770     anApp->viewManagers(SVTK_Viewer::Type(), aViewManagerList);
 771     QPtrListIterator<SUIT_ViewManager> anVMIter (aViewManagerList);
 772     for (; anVMIter.current(); ++anVMIter) {
 773       SUIT_ViewManager* aViewManager = anVMIter.current();
 774       QPtrVector<SUIT_ViewWindow> aViews = aViewManager->getViews();
 775       for (int i = 0, iEnd = aViews.size(); i < iEnd; i++) {
 776         if (SUIT_ViewWindow* aViewWindow = aViews.at(i)) {
 777           if (SVTK_ViewWindow* vw = dynamic_cast<SVTK_ViewWindow*>(aViewWindow)) {
 778             //VISU_Actor* anActor = aVISUViewManager->GetActor(aPrs3d, vw);
 779             VISU_Actor* anActor = NULL;
 780             vtkActorCollection *anActColl = vw->getRenderer()->GetActors();
 781             anActColl->InitTraversal();
 782             vtkActor *aVTKActor = anActColl->GetNextActor();
 783             for (; !anActor && aVTKActor; aVTKActor = anActColl->GetNextActor()) {
 784               if (VISU_Actor* anVISUActor = dynamic_cast<VISU_Actor*>(aVTKActor)) {
 785                 if (aPrs3d == anVISUActor->GetPrs3d()) {
 786                   anActor = anVISUActor->GetParent();
 787                 }
 788               }
 789             }
 790             if (anActor) {
 791               vw->RemoveActor(anActor);
 792               anActor->Delete();
 793             }
 794           }
 795         }
 796       }
 797     }
 798
 799     aPrs3d->RemoveFromStudy();
 800     aPrs3d->Destroy();
 801
 802     //jfa tmp:theModule->updateObjBrowser(); //update Object browser
 803   }
 804
 805   void VISU_Gen_i::DeleteResult (Result_ptr theResult)
 806   {
 807     class TEvent: public SALOME_Event {
 808       Result_ptr myResult;
 809     public:
 810       TEvent(Result_ptr theResult): myResult(theResult) {}
 811       virtual void Execute(){
 812         if (Result_i* aResult = dynamic_cast<Result_i*>(GetServant(myResult).in())) {
 813           SALOMEDS::SObject_var aSObject = aResult->GetSObject();
 814           SALOMEDS::Study_var aStudyDocument = aSObject->GetStudy();
 815           SALOMEDS::ChildIterator_var aChildIter = aStudyDocument->NewChildIterator(aSObject);
 816           for(aChildIter->InitEx(true); aChildIter->More(); aChildIter->Next()){
 817             SALOMEDS::SObject_var aChildSObject = aChildIter->Value();
 818             CORBA::Object_var aChildObj = VISU::SObjectToObject(aChildSObject);
 819             if(CORBA::is_nil(aChildObj)) continue;
 820             VISU::Prs3d_var aPrs3d = VISU::Prs3d::_narrow(aChildObj);
 821             if(CORBA::is_nil(aPrs3d)) continue;
 822             VISU::DeletePrs3d(aPrs3d);
 823           }
 824
 825           aResult->RemoveFromStudy();
 826           aResult->Destroy();
 827
 828           //jfa tmp:if (QAD_Desktop* aDesktop = QAD_Application::getDesktop())
 829           //jfa tmp:  if (QAD_Study* aStudy = aDesktop->findStudy(aStudyDocument))
 830           //jfa tmp:    aStudy->updateObjBrowser(); //update Object browser
 831         }
 832       }
 833     };
 834
 835     if (myStudyDocument->GetProperties()->IsLocked())
 836       return;
 837     Mutex mt(myMutex); // jfa ???
 838
 839     ProcessVoidEvent(new TEvent(theResult));
 840   }
 841
 842   void VISU_Gen_i::DeletePrs3d (Prs3d_ptr thePrs3d)
 843   {
 844     class TEvent: public SALOME_Event {
 845       Prs3d_ptr myPrs3d;
 846     public:
 847       TEvent(Prs3d_ptr thePrs3d): myPrs3d(thePrs3d) {}
 848       virtual void Execute() {
 849         VISU::DeletePrs3d(myPrs3d);
 850       }
 851     };
 852
 853     if (myStudyDocument->GetProperties()->IsLocked())
 854       return;
 855     Mutex mt(myMutex); // jfa ???
 856
 857     ProcessVoidEvent(new TEvent(thePrs3d));
 858   }
 859
 860   void VISU_Gen_i::Close(SALOMEDS::SComponent_ptr theComponent){
 861   }
 862
 863   char* VISU_Gen_i::ComponentDataType(){
 864     return CORBA::string_dup("VISU");
 865   }
 866
 867   bool VISU_Gen_i::CanPublishInStudy(CORBA::Object_ptr theIOR) {
 868     Result_var aResultObj = Result::_narrow(theIOR);
 869     return !(aResultObj->_is_nil());
 870   }
 871
 872   SALOMEDS::SObject_ptr VISU_Gen_i::PublishInStudy(SALOMEDS::Study_ptr theStudy,
 873                                                    SALOMEDS::SObject_ptr theSObject,
 874                                                    CORBA::Object_ptr theObject,
 875                                                    const char* theName)
 876     throw (SALOME::SALOME_Exception)
 877   {
 878     Unexpect aCatch(SalomeException);
 879     if(MYDEBUG) MESSAGE("VISU_Gen_i::PublishInStudy : "<<myMutex);
 880     Mutex mt(myMutex);
 881     SALOMEDS::SObject_var aResultSO;
 882     Result_i* aResultObj = dynamic_cast<Result_i*>(GetServant(theObject).in());
 883     if (!aResultObj) return aResultSO._retn();
 884     const QFileInfo& aFileInfo = aResultObj->GetFileInfo();
 885     CORBA::String_var anEntry = aResultObj->Create(aFileInfo.filePath().latin1())->GetID();
 886     aResultSO = theStudy->FindObjectID(anEntry);
 887     return aResultSO._retn();
 888   }
 889
 890   CORBA::Boolean VISU_Gen_i::CanCopy(SALOMEDS::SObject_ptr theObject) {
 891     Mutex mt(myMutex);
 892     SALOMEDS::GenericAttribute_var anAttr;
 893     if (!theObject->FindAttribute(anAttr, "AttributeIOR")) return false;
 894     try {
 895       SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 896       CORBA::String_var aValue = anIOR->Value();
 897       if(strcmp(aValue,"") != 0){
 898         CORBA::Object_ptr anObj = GetORB()->string_to_object(aValue);
 899         if (!CORBA::is_nil(anObj)){
 900           Result_var aResultObj = Result::_narrow(anObj);
 901           if(!aResultObj->_is_nil()){
 902             if(Result_i* pResult = dynamic_cast<Result_i*>(GetServant(aResultObj).in())){
 903               switch(pResult->GetCreationId()){
 904               case Result_i::eImportFile:
 905               case Result_i::eCopyAndImportFile:
 906                 return true;
 907               }
 908             }
 909           }
 910         }
 911       }
 912     }catch(std::exception& exc){
 913       INFOS("Follow exception was occured :\n"<<exc.what());
 914     }catch (...){
 915       INFOS("Unknown exception was occured!");
 916     }
 917     return false;
 918   }
 919
 920   SALOMEDS::TMPFile* VISU_Gen_i::CopyFrom(SALOMEDS::SObject_ptr theObject, CORBA::Long& theObjectID) {
 921     Mutex mt(myMutex);
 922     theObjectID = 0;
 923     SALOMEDS::TMPFile_var aStreamFile = new SALOMEDS::TMPFile;
 924     SALOMEDS::ListOfFileNames_var aSeq = new SALOMEDS::ListOfFileNames;
 925
 926     PortableServer::POA_ptr aPOA = GetPOA();
 927
 928     SALOMEDS::GenericAttribute_var anAttr;
 929     if (!theObject->FindAttribute(anAttr,"AttributeIOR")) return NULL;
 930     SALOMEDS::AttributeIOR_var anIORAttr = SALOMEDS::AttributeIOR::_narrow(anAttr);
 931     CORBA::Object_var aCorbaObj;
 932     try {
 933       aCorbaObj = GetORB()->string_to_object(anIORAttr->Value());
 934     } catch(...) {
 935       aStreamFile->length(1);
 936       aStreamFile[0] = strdup("E")[0];
 937       return aStreamFile._retn();
 938     }
 939     if (CORBA::is_nil(aCorbaObj)) {
 940       return NULL;
 941     }
 942
 943     Storable* pStorable = dynamic_cast<Storable*>(GetServant(aCorbaObj).in());
 944     if (!pStorable) {
 945       return NULL;
 946     }
 947
 948     string aTmpDir = SALOMEDS_Tool::GetTmpDir();
 949     string aCopyPersist =  aTmpDir + "copy_persistent";
 950
 951     ofstream stmOut2(aCopyPersist.c_str(),ios::out);
 952     string aStr = pStorable->ToString().c_str();
 953     stmOut2<<aStr<<endl;
 954     stmOut2.close();
 955
 956     if (Result_i* aResultObj = dynamic_cast<Result_i*>(aPOA->reference_to_servant(aCorbaObj))) {
 957       string aFileName = string(SALOMEDS_Tool::GetNameFromPath(theObject->GetStudy()->URL())) + "_";
 958       if(strlen(aFileName.c_str()) == 1) aFileName="";
 959       const QFileInfo& aFileInfo = aResultObj->GetFileInfo();
 960       aFileName += aFileInfo.fileName().latin1();
 961       static QString aCommand;
 962       string aFullFileName =  aTmpDir + aFileName;
 963       aCommand.sprintf("cp %s %s",
 964                        aFileInfo.filePath().latin1(),
 965                        aFullFileName.c_str());
 966       if(system(aCommand) == -1) {
 967         if(MYDEBUG) MESSAGE("VISU_Gen_i::Copy - Cann't execute the command :"<<aCommand);
 968         return NULL;
 969       }
 970       aSeq->length(2);
 971       aSeq[0] = "copy_persistent";
 972       aSeq[1] = aFileName.c_str();
 973     } else {
 974       aSeq->length(1);
 975       aSeq[0] = "copy_persistent";
 976     }
 977
 978     aStreamFile = SALOMEDS_Tool::PutFilesToStream(aTmpDir.c_str(), aSeq.in(), false);
 979     SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.c_str(), aSeq.in(), true);
 980
 981     // Assign an ID = 1 the the type VISU::Result
 982     theObjectID = 1;
 983
 984
 985     SALOMEDS::SComponent_var aSComponent = theObject->GetStudy()->FindComponent("VISU");
 986     return aStreamFile._retn();
 987   }
 988
 989   CORBA::Boolean VISU_Gen_i::CanPaste(const char* theComponentName, CORBA::Long theObjectID) {
 990     // The VISU component can paste only objects copied by VISU component
 991     // and with the object type = 1
 992     if (strcmp(theComponentName, ComponentDataType()) != 0 || theObjectID != 1)
 993       return false;
 994     return true;
 995   }
 996
 997   SALOMEDS::SObject_ptr VISU_Gen_i::PasteInto(const SALOMEDS::TMPFile& theStream,
 998                                               CORBA::Long theObjectID,
 999                                               SALOMEDS::SObject_ptr theObject)
1000   {
1001     Mutex mt(myMutex);
1002     SALOMEDS::SObject_var aResultSO;
1003     if (theObjectID != 1)
1004       return aResultSO._retn();
1005
1006     string aTmpDir = SALOMEDS_Tool::GetTmpDir();
1007     SALOMEDS::ListOfFileNames_var aSeq = SALOMEDS_Tool::PutStreamToFiles(theStream, aTmpDir.c_str(), false);
1008
1009     ifstream stmIn((aTmpDir + string("copy_persistent")).c_str());
1010     stmIn.seekg(0, ios::end);
1011     int aLength = stmIn.tellg();
1012     stmIn.seekg(0, ios::beg);
1013     char* aString = new char[aLength+1];
1014     stmIn.read(aString, aLength);
1015     aString[aLength] = 0;
1016     myIsMultiFile = false;
1017
1018     string aFileName(aTmpDir);
1019     string aBasicFileName;
1020     if(aSeq->length() > 1) {
1021       aBasicFileName = aSeq[1].in();
1022       aFileName += aBasicFileName;
1023     }
1024
1025     SALOMEDS::SComponent_var aComponent = theObject->GetFatherComponent();
1026     SALOMEDS::Study_var aStudy = theObject->GetStudy();
1027     SALOMEDS::StudyBuilder_var aStudyBuilder = aStudy->NewBuilder();
1028     CORBA::String_var aComponentID(aComponent->GetID()), aSObjID(theObject->GetID());
1029
1030     if (strcmp(aComponentID, aSObjID) == 0) //create the new result SObject
1031       aResultSO = aStudyBuilder->NewObject(aComponent);
1032     else
1033       aResultSO = SALOMEDS::SObject::_duplicate(theObject);
1034
1035     //Just for Result::Restore to find the Comment attribute :(
1036     SALOMEDS::GenericAttribute_var anAttr = aStudyBuilder->FindOrCreateAttribute(aResultSO, "AttributeComment");
1037
1038     Storable* aStorable = Storable::Create(aResultSO,aFileName,aString);
1039
1040     SALOMEDS::ListOfFileNames_var aSeqToRm = new SALOMEDS::ListOfFileNames;
1041     aSeqToRm->length(1);
1042     aSeqToRm[0] = "copy_persistent";
1043
1044     SALOMEDS_Tool::RemoveTemporaryFiles(aTmpDir.c_str(), aSeqToRm.in(), true);
1045
1046     anAttr = aStudyBuilder->FindOrCreateAttribute(aResultSO, "AttributeIOR");
1047     SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
1048     CORBA::String_var anIORValue(aStorable->GetID());
1049     anIOR->SetValue(anIORValue);
1050     return aResultSO._retn();
1051   }
1052
1053 }