src/ENGINE/VISU_Engine_i.cc

   1 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   2 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   3 //
   4 //  This library is free software; you can redistribute it and/or
   5 //  modify it under the terms of the GNU Lesser General Public
   6 //  License as published by the Free Software Foundation; either
   7 //  version 2.1 of the License.
   8 //
   9 //  This library is distributed in the hope that it will be useful,
  10 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 //  Lesser General Public License for more details.
  13 //
  14 //  You should have received a copy of the GNU Lesser General Public
  15 //  License along with this library; if not, write to the Free Software
  16 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 //
  18 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  19
  20 #include "VISU_Engine_i.hh"
  21 #include "utilities.h"
  22
  23 #include CORBA_SERVER_HEADER(SALOME_Session)
  24 #include CORBA_SERVER_HEADER(SALOME_ModuleCatalog)
  25
  26 #include "SALOME_NamingService.hxx"
  27 #include "Utils_ExceptHandlers.hxx"
  28
  29 using namespace std;
  30
  31 #ifdef _DEBUG_
  32 static int MYDEBUG = 1;
  33 #else
  34 static int MYDEBUG = 0;
  35 #endif
  36
  37 UNEXPECT_CATCH(SalomeException, SALOME::SALOME_Exception);
  38
  39 extern "C" {
  40   PortableServer::ObjectId *
  41   VISUEngine_factory(CORBA::ORB_ptr orb, PortableServer::POA_ptr poa, PortableServer::ObjectId * contId,
  42                      const char *instanceName, const char *interfaceName)
  43   {
  44     if(MYDEBUG) MESSAGE("VisuEngine_factory : "<<interfaceName);
  45     VISU::VISU_Gen_i * pVISU_Gen = new VISU::VISU_Gen_i(orb, poa, contId, instanceName, interfaceName);
  46     return pVISU_Gen->getId() ;
  47   }
  48 }
  49
  50 namespace VISU{
  51   //===========================================================================
  52   VISU_Gen_i::VISU_Gen_i(CORBA::ORB_ptr orb,
  53                          PortableServer::POA_ptr poa,
  54                          PortableServer::ObjectId * contId,
  55                          const char *instanceName,
  56                          const char *interfaceName) :
  57     Engines_Component_i(orb, poa, contId, instanceName, interfaceName)
  58   {
  59     _thisObj = this ;
  60     _id = _poa->activate_object(_thisObj);
  61     SALOME_NamingService aNamingService(orb);
  62     CORBA::Object_ptr anObject = aNamingService.Resolve("/Kernel/Session");
  63     SALOME::Session_var aSession = SALOME::Session::_narrow(anObject);
  64     //aSession->GetInterface();
  65     Engines::Component_var aComponent = aSession->GetComponent("libVISUEngineImpl.so");
  66     myVisuGen = VISU::VISU_Gen::_narrow(aComponent);
  67   }
  68
  69   VISU_Gen_i::~VISU_Gen_i(){
  70     if(MYDEBUG) MESSAGE("VISU_Gen_i::~VISU_Gen_i");
  71   }
  72
  73   VISU::VISUType VISU_Gen_i::GetType() {
  74         return myVisuGen->GetType();
  75   };
  76
  77   //===========================================================================
  78   bool VISU_Gen_i::Load(SALOMEDS::SComponent_ptr theComponent,
  79                         const SALOMEDS::TMPFile & theStream,
  80                         const char* theURL,
  81                         bool isMultiFile)
  82   {
  83     return myVisuGen->Load(theComponent,theStream,theURL,isMultiFile);
  84   }
  85
  86   bool VISU_Gen_i::LoadASCII(SALOMEDS::SComponent_ptr theComponent,
  87                              const SALOMEDS::TMPFile & theStream,
  88                              const char* theURL,
  89                              bool isMultiFile)
  90   {
  91     return Load(theComponent, theStream, theURL, isMultiFile);
  92   }
  93
  94   char* VISU_Gen_i::LocalPersistentIDToIOR(SALOMEDS::SObject_ptr theSObject,
  95                                            const char* aLocalPersistentID,
  96                                            CORBA::Boolean isMultiFile,
  97                                            CORBA::Boolean isASCII)
  98   {
  99     return myVisuGen->LocalPersistentIDToIOR(theSObject, aLocalPersistentID, isMultiFile, isASCII);
 100   }
 101
 102
 103   //===========================================================================
 104   SALOMEDS::TMPFile* VISU_Gen_i::Save(SALOMEDS::SComponent_ptr theComponent,
 105                                       const char* theURL,
 106                                       bool isMultiFile)
 107   {
 108     return myVisuGen->Save(theComponent,theURL,isMultiFile);
 109   }
 110
 111   SALOMEDS::TMPFile* VISU_Gen_i::SaveASCII(SALOMEDS::SComponent_ptr theComponent,
 112                                            const char* theURL,
 113                                            bool isMultiFile)
 114   {
 115     return myVisuGen->Save(theComponent,theURL,isMultiFile);
 116   }
 117
 118
 119   char* VISU_Gen_i::IORToLocalPersistentID(SALOMEDS::SObject_ptr theSObject,
 120                                            const char* IORString,
 121                                            CORBA::Boolean isMultiFile,
 122                                            CORBA::Boolean isASCII)
 123   {
 124     return myVisuGen->IORToLocalPersistentID(theSObject, IORString, isMultiFile, isASCII);
 125   }
 126
 127
 128   char* VISU_Gen_i::GetID(){
 129     return myVisuGen->GetID();
 130   }
 131
 132
 133   void VISU_Gen_i::SetCurrentStudy(SALOMEDS::Study_ptr theStudy){
 134     myVisuGen->SetCurrentStudy(theStudy);
 135   }
 136
 137
 138   SALOMEDS::Study_ptr VISU_Gen_i::GetCurrentStudy(){
 139     return myVisuGen->GetCurrentStudy();
 140   }
 141
 142
 143   ViewManager_ptr VISU_Gen_i::GetViewManager(){
 144     return myVisuGen->GetViewManager();
 145   }
 146
 147
 148   SALOMEDS::SObject_ptr VISU_Gen_i::ImportTables(const char* theFileName){
 149     return myVisuGen->ImportTables(theFileName);
 150   }
 151
 152
 153   CORBA::Boolean VISU_Gen_i::ExportTableToFile(SALOMEDS::SObject_ptr theTable,
 154                                                const char* theFileName)
 155   {
 156     return myVisuGen->ExportTableToFile(theTable, theFileName);
 157   }
 158
 159
 160   Result_ptr VISU_Gen_i::ImportFile(const char* theFileName){
 161     return myVisuGen->ImportFile(theFileName);
 162   }
 163
 164
 165   Result_ptr VISU_Gen_i::CreateResult(const char* theFileName){
 166     return myVisuGen->CreateResult(theFileName);
 167   }
 168
 169
 170   Result_ptr VISU_Gen_i::CopyAndImportFile(const char* theFileName){
 171     return myVisuGen->CopyAndImportFile(theFileName);
 172   }
 173
 174
 175   Result_ptr VISU_Gen_i::ImportMed(SALOMEDS::SObject_ptr theMedSObject){
 176     return myVisuGen->ImportMed(theMedSObject);
 177   }
 178
 179
 180   Result_ptr VISU_Gen_i::ImportMedField(SALOME_MED::FIELD_ptr theField){
 181     return myVisuGen->ImportMedField(theField);
 182   }
 183
 184
 185   Mesh_ptr VISU_Gen_i::MeshOnEntity(Result_ptr theResult,
 186                                     const char* theMeshName,
 187                                     VISU::Entity theEntity)
 188   {
 189     return myVisuGen->MeshOnEntity(theResult,theMeshName,theEntity);
 190   }
 191
 192
 193   Mesh_ptr VISU_Gen_i::FamilyMeshOnEntity(Result_ptr theResult,
 194                                           const char* theMeshName,
 195                                           VISU::Entity theEntity,
 196                                           const char* theFamilyName)
 197   {
 198     return myVisuGen->FamilyMeshOnEntity(theResult,theMeshName,theEntity,theFamilyName);
 199   }
 200
 201
 202   Mesh_ptr VISU_Gen_i::GroupMesh(Result_ptr theResult,
 203                                  const char* theMeshName,
 204                                  const char* theGroupName)
 205   {
 206     return myVisuGen->GroupMesh(theResult,theMeshName,theGroupName);
 207   }
 208
 209
 210   ScalarMap_ptr VISU_Gen_i::ScalarMapOnField(Result_ptr theResult,
 211                                              const char* theMeshName,
 212                                              VISU::Entity theEntity,
 213                                              const char* theFieldName,
 214                                              CORBA::Double theIteration)
 215   {
 216     return myVisuGen->ScalarMapOnField(theResult,theMeshName,theEntity,theFieldName,theIteration);
 217   }
 218
 219
 220   GaussPoints_ptr VISU_Gen_i::GaussPointsOnField(Result_ptr theResult,
 221                                                  const char* theMeshName,
 222                                                  VISU::Entity theEntity,
 223                                                  const char* theFieldName,
 224                                                  CORBA::Double theIteration)
 225   {
 226     return myVisuGen->GaussPointsOnField(theResult,theMeshName,theEntity,theFieldName,theIteration);
 227   }
 228
 229
 230   DeformedShape_ptr VISU_Gen_i::DeformedShapeOnField(Result_ptr theResult,
 231                                                      const char* theMeshName,
 232                                                      VISU::Entity theEntity,
 233                                                      const char* theFieldName,
 234                                                      CORBA::Double theIteration)
 235   {
 236     return myVisuGen->DeformedShapeOnField(theResult,theMeshName,theEntity,theFieldName,theIteration);
 237   }
 238
 239
 240   Vectors_ptr VISU_Gen_i::VectorsOnField(Result_ptr theResult,
 241                                          const char* theMeshName,
 242                                          VISU::Entity theEntity,
 243                                          const char* theFieldName,
 244                                          CORBA::Double theIteration)
 245   {
 246     return myVisuGen->VectorsOnField(theResult,theMeshName,theEntity,theFieldName,theIteration);
 247   }
 248
 249   IsoSurfaces_ptr VISU_Gen_i::IsoSurfacesOnField(Result_ptr theResult,
 250                                                  const char* theMeshName,
 251                                                  VISU::Entity theEntity,
 252                                                  const char* theFieldName,
 253                                                  CORBA::Double theIteration)
 254   {
 255     return myVisuGen->IsoSurfacesOnField(theResult,theMeshName,theEntity,theFieldName,theIteration);
 256   }
 257
 258
 259   StreamLines_ptr VISU_Gen_i::StreamLinesOnField(Result_ptr theResult,
 260                                                  const char* theMeshName,
 261                                                  VISU::Entity theEntity,
 262                                                  const char* theFieldName,
 263                                                  CORBA::Double theIteration)
 264   {
 265     return myVisuGen->StreamLinesOnField(theResult,theMeshName,theEntity,theFieldName,theIteration);
 266   }
 267
 268
 269   CutPlanes_ptr VISU_Gen_i::CutPlanesOnField(Result_ptr theResult,
 270                                              const char* theMeshName,
 271                                              VISU::Entity theEntity,
 272                                              const char* theFieldName,
 273                                              CORBA::Double theIteration)
 274   {
 275     return myVisuGen->CutPlanesOnField(theResult,theMeshName,theEntity,theFieldName,theIteration);
 276   }
 277
 278
 279   CutLines_ptr VISU_Gen_i::CutLinesOnField(Result_ptr theResult,
 280                                            const char* theMeshName,
 281                                            VISU::Entity theEntity,
 282                                            const char* theFieldName,
 283                                            CORBA::Double theIteration)
 284   {
 285     return myVisuGen->CutLinesOnField(theResult,theMeshName,theEntity,theFieldName,theIteration);
 286   }
 287
 288
 289   Plot3D_ptr VISU_Gen_i::Plot3DOnField(Result_ptr theResult,
 290                                        const char* theMeshName,
 291                                        VISU::Entity theEntity,
 292                                        const char* theFieldName,
 293                                        CORBA::Double theIteration)
 294   {
 295     return myVisuGen->Plot3DOnField(theResult,theMeshName,theEntity,theFieldName,theIteration);
 296   }
 297
 298
 299   Table_ptr VISU_Gen_i::CreateTable(const char* theTableEntry){
 300     return myVisuGen->CreateTable(theTableEntry);
 301   }
 302
 303
 304   Curve_ptr VISU_Gen_i::CreateCurve(Table_ptr theTable,
 305                                     CORBA::Long theHRow,
 306                                     CORBA::Long theVRow)
 307   {
 308     return myVisuGen->CreateCurve(theTable,theHRow,theVRow);
 309   }
 310
 311
 312   Container_ptr VISU_Gen_i::CreateContainer(){
 313     return myVisuGen->CreateContainer();
 314   }
 315
 316
 317   Animation_ptr VISU_Gen_i::CreateAnimation(View3D_ptr theView3D){
 318     return myVisuGen->CreateAnimation(theView3D);
 319   }
 320
 321
 322   void VISU_Gen_i::DeleteResult(Result_ptr theResult){
 323     myVisuGen->DeleteResult(theResult);
 324   }
 325
 326
 327   void VISU_Gen_i::DeletePrs3d(Prs3d_ptr thePrs3d){
 328     myVisuGen->DeletePrs3d(thePrs3d);
 329   }
 330
 331
 332   void VISU_Gen_i::Close(SALOMEDS::SComponent_ptr theComponent){
 333     myVisuGen->Close(theComponent);
 334   }
 335
 336
 337   char* VISU_Gen_i::ComponentDataType(){
 338     return CORBA::string_dup("VISU");
 339   }
 340
 341
 342   CORBA::Boolean VISU_Gen_i::CanPublishInStudy(CORBA::Object_ptr theIOR) {
 343     return myVisuGen->CanPublishInStudy(theIOR);
 344   }
 345
 346
 347   SALOMEDS::SObject_ptr VISU_Gen_i::PublishInStudy(SALOMEDS::Study_ptr theStudy,
 348                                                    SALOMEDS::SObject_ptr theSObject,
 349                                                    CORBA::Object_ptr theObject,
 350                                                    const char* theName)
 351     throw (SALOME::SALOME_Exception)
 352   {
 353     return myVisuGen->PublishInStudy(theStudy, theSObject, theObject, theName);
 354   }
 355
 356
 357   CORBA::Boolean VISU_Gen_i::CanCopy(SALOMEDS::SObject_ptr theObject) {
 358     return myVisuGen->CanCopy(theObject);
 359   }
 360
 361
 362   SALOMEDS::TMPFile* VISU_Gen_i::CopyFrom(SALOMEDS::SObject_ptr theObject, CORBA::Long& theObjectID) {
 363     return myVisuGen->CopyFrom(theObject, theObjectID);
 364   }
 365
 366
 367   CORBA::Boolean VISU_Gen_i::CanPaste(const char* theComponentName, CORBA::Long theObjectID) {
 368     return myVisuGen->CanPaste(theComponentName, theObjectID);
 369   }
 370
 371
 372   SALOMEDS::SObject_ptr VISU_Gen_i::PasteInto(const SALOMEDS::TMPFile& theStream,
 373                                               CORBA::Long theObjectID,
 374                                               SALOMEDS::SObject_ptr theObject)
 375   {
 376     return myVisuGen->PasteInto(theStream,theObjectID,theObject);
 377   }
 378   Engines::TMPFile* VISU_Gen_i::DumpPython(CORBA::Object_ptr theStudy,
 379                                            CORBA::Boolean theIsPublished,
 380                                            CORBA::Boolean& theIsValidScript)
 381   {
 382     return myVisuGen->DumpPython(theStudy, theIsPublished, theIsValidScript);
 383   }
 384
 385 };