src/SMESHGUI/SMESHGUI_Swig.cxx

   1 //  SMESH SMESHGUI : GUI for SMESH component
   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.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //
  23 //
  24 //  File   : SMESH_Swig.cxx
  25 //  Author : Nicolas REJNERI
  26 //  Module : SMESH
  27 //  $Header$
  28
  29 #include "SMESHGUI_Swig.hxx"
  30
  31 #include "Utils_ORB_INIT.hxx"
  32 #include "Utils_SINGLETON.hxx"
  33
  34 #include "SMESHGUI.h"
  35 #include "SMESHGUI_Utils.h"
  36 #include "SMESHGUI_GEOMGenUtils.h"
  37 #include "SMESHGUI_Displayer.h"
  38
  39 // SALOME Includes
  40 #include "SUIT_ResourceMgr.h"
  41 #include "SUIT_Session.h"
  42 #include "SUIT_ViewModel.h"
  43 #include "VTKViewer_ViewModel.h"
  44
  45 #include "SALOME_Event.hxx"
  46 #include "SALOME_NamingService.hxx"
  47 #include "SalomeApp_Application.h"
  48 #include "SALOMEDSClient_ClientFactory.hxx"
  49
  50 #include "utilities.h"
  51
  52 // Open CASCADE Includes
  53 #include <TopoDS.hxx>
  54
  55 // QT Includes
  56 #include <qapplication.h>
  57
  58 // IDL Headers
  59 #include <SALOMEconfig.h>
  60 #include CORBA_SERVER_HEADER(SMESH_Gen)
  61 #include CORBA_SERVER_HEADER(SMESH_Mesh)
  62 #include CORBA_SERVER_HEADER(SMESH_Hypothesis)
  63
  64 using namespace std;
  65
  66 static CORBA::ORB_var anORB;
  67
  68 namespace
  69 {
  70   //---------------------------------------------------------------
  71   inline
  72   CORBA::Object_var
  73   StringToObject(const std::string& theIOR)
  74   {
  75     return anORB->string_to_object(theIOR.c_str());
  76   }
  77
  78
  79   //---------------------------------------------------------------
  80   inline
  81   SALOMEDS::SObject_var
  82   GetDomainRoot(const SALOMEDS::SComponent_var& theSComponentMesh,
  83                 const SALOMEDS::StudyBuilder_var& theStudyBuilder,
  84                 CORBA::Long theDomainRootTag,
  85                 const QString& theName,
  86                 const QString& thePixmap)
  87   {
  88     SALOMEDS::SObject_var aDomainRoot;
  89     if (!theSComponentMesh->FindSubObject(theDomainRootTag,aDomainRoot)) {
  90       aDomainRoot = theStudyBuilder->NewObjectToTag(theSComponentMesh,theDomainRootTag);
  91       SALOMEDS::GenericAttribute_var anAttr = theStudyBuilder->FindOrCreateAttribute(aDomainRoot,"AttributeName");
  92       SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
  93       aName->SetValue(theName.latin1());
  94       anAttr = theStudyBuilder->FindOrCreateAttribute(aDomainRoot,"AttributePixMap");
  95       SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
  96       aPixmap->SetPixMap(thePixmap.latin1());
  97       anAttr = theStudyBuilder->FindOrCreateAttribute(aDomainRoot,"AttributeSelectable");
  98       SALOMEDS::AttributeSelectable_var aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
  99       aSelAttr->SetSelectable(false);
 100     }
 101
 102     return aDomainRoot;
 103   }
 104
 105
 106   //---------------------------------------------------------------
 107   inline
 108   SALOMEDS::SObject_var
 109   GetHypothesisRoot(const SALOMEDS::SComponent_var& theSComponentMesh,
 110                     const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 111   {
 112     return GetDomainRoot(theSComponentMesh,
 113                          theStudyBuilder,
 114                          SMESH::Tag_HypothesisRoot,
 115                          QObject::tr("SMESH_MEN_HYPOTHESIS"),
 116                          "ICON_SMESH_TREE_HYPO");
 117   }
 118
 119
 120   //---------------------------------------------------------------
 121   inline
 122   SALOMEDS::SObject_var
 123   GetAlgorithmsRoot(const SALOMEDS::SComponent_var& theSComponentMesh,
 124                     const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 125   {
 126     return GetDomainRoot(theSComponentMesh,
 127                          theStudyBuilder,
 128                          SMESH::Tag_AlgorithmsRoot,
 129                          QObject::tr("SMESH_MEN_ALGORITHMS"),
 130                          "ICON_SMESH_TREE_ALGO");
 131   }
 132
 133
 134   //---------------------------------------------------------------
 135   inline
 136   SALOMEDS::SObject_var
 137   AddToDomain(const std::string& theIOR,
 138               const SALOMEDS::SComponent_var& theSComponentMesh,
 139               const SALOMEDS::StudyBuilder_var& theStudyBuilder,
 140               CORBA::Long theDomainRootTag,
 141               const QString& theDomainName,
 142               const QString& theDomainPixmap)
 143   {
 144     SALOMEDS::SObject_var aDomain = GetDomainRoot(theSComponentMesh,
 145                                                   theStudyBuilder,
 146                                                   SMESH::Tag_AlgorithmsRoot,
 147                                                   theDomainName,
 148                                                   theDomainPixmap);
 149     // Add New Hypothesis
 150     SALOMEDS::SObject_var aSObject = theStudyBuilder->NewObject(aDomain);
 151     SALOMEDS::GenericAttribute_var anAttr = theStudyBuilder->FindOrCreateAttribute(aSObject,"AttributePixMap");
 152     SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 153     CORBA::Object_var anObject = StringToObject(theIOR);
 154     SMESH::SMESH_Hypothesis_var aDomainItem = SMESH::SMESH_Hypothesis::_narrow(anObject.in());
 155     CORBA::String_var aType = aDomainItem->GetName();
 156     QString aPixmapName = theDomainPixmap + "_" + aType.in();
 157     aPixmap->SetPixMap(aPixmapName.latin1());
 158     anAttr = theStudyBuilder->FindOrCreateAttribute(aSObject,"AttributeIOR");
 159     SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 160     anIOR->SetValue(theIOR.c_str());
 161
 162     return aSObject;
 163   }
 164
 165
 166   //---------------------------------------------------------------
 167   SALOMEDS::SObject_var
 168   AddHypothesis(const std::string& theIOR,
 169                 const SALOMEDS::SComponent_var& theSComponentMesh,
 170                 const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 171   {
 172     return AddToDomain(theIOR,
 173                        theSComponentMesh,
 174                        theStudyBuilder,
 175                        SMESH::Tag_HypothesisRoot,
 176                        QObject::tr("SMESH_MEN_HYPOTHESIS"),
 177                        "ICON_SMESH_TREE_HYPO");
 178   }
 179
 180
 181   //---------------------------------------------------------------
 182   SALOMEDS::SObject_var
 183   AddAlgorithms(const std::string& theIOR,
 184                 const SALOMEDS::SComponent_var& theSComponentMesh,
 185                 const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 186   {
 187     return AddToDomain(theIOR,
 188                        theSComponentMesh,
 189                        theStudyBuilder,
 190                        SMESH::Tag_AlgorithmsRoot,
 191                        QObject::tr("SMESH_MEN_ALGORITHMS"),
 192                        "ICON_SMESH_TREE_ALGO");
 193   }
 194
 195
 196   //---------------------------------------------------------------
 197   void
 198   SetDomain(const char* theMeshOrSubMeshEntry,
 199             const char* theDomainEntry,
 200             const SALOMEDS::Study_var& theStudy,
 201             const SALOMEDS::StudyBuilder_var& theStudyBuilder,
 202             long theRefOnAppliedDomainTag,
 203             const QString& theAppliedDomainMEN,
 204             const QString& theAppliedDomainICON)
 205   {
 206     SALOMEDS::SObject_var aMeshOrSubMeshSO = theStudy->FindObjectID(theMeshOrSubMeshEntry);
 207     SALOMEDS::SObject_var aHypothesisSO = theStudy->FindObjectID(theDomainEntry);
 208
 209     if(!aMeshOrSubMeshSO->_is_nil() && !aHypothesisSO->_is_nil()){
 210       //Find or Create Applied Hypothesis root
 211       SALOMEDS::SObject_var anAppliedDomainSO;
 212       if(!aMeshOrSubMeshSO->FindSubObject(theRefOnAppliedDomainTag,anAppliedDomainSO)){
 213         anAppliedDomainSO = theStudyBuilder->NewObjectToTag(aMeshOrSubMeshSO,theRefOnAppliedDomainTag);
 214         SALOMEDS::GenericAttribute_var anAttr =
 215           theStudyBuilder->FindOrCreateAttribute(anAppliedDomainSO,"AttributeName");
 216         SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
 217         aName->SetValue(theAppliedDomainMEN.latin1());
 218         anAttr = theStudyBuilder->FindOrCreateAttribute(anAppliedDomainSO,"AttributeSelectable");
 219         SALOMEDS::AttributeSelectable_var aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
 220         aSelAttr->SetSelectable(false);
 221         anAttr = theStudyBuilder->FindOrCreateAttribute(anAppliedDomainSO,"AttributePixMap");
 222         SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 223         aPixmap->SetPixMap(theAppliedDomainICON.latin1());
 224       }
 225       SALOMEDS::SObject_var aSObject = theStudyBuilder->NewObject(anAppliedDomainSO);
 226       theStudyBuilder->Addreference(aSObject,aHypothesisSO);
 227     }
 228   }
 229
 230
 231   //---------------------------------------------------------------
 232   void
 233   SetHypothesis(const char* theMeshOrSubMeshEntry,
 234                 const char* theDomainEntry,
 235                 const SALOMEDS::Study_var& theStudy,
 236                 const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 237   {
 238     SetDomain(theMeshOrSubMeshEntry,
 239               theDomainEntry,
 240               theStudy,
 241               theStudyBuilder,
 242               SMESH::Tag_RefOnAppliedHypothesis,
 243               QObject::tr("SMESH_MEN_APPLIED_HYPOTHESIS"),
 244               "ICON_SMESH_TREE_HYPO");
 245   }
 246
 247
 248   //---------------------------------------------------------------
 249   void
 250   SetAlgorithms(const char* theMeshOrSubMeshEntry,
 251                 const char* theDomainEntry,
 252                 const SALOMEDS::Study_var& theStudy,
 253                 const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 254   {
 255     SetDomain(theMeshOrSubMeshEntry,
 256               theDomainEntry,
 257               theStudy,
 258               theStudyBuilder,
 259               SMESH::Tag_RefOnAppliedAlgorithms,
 260               QObject::tr("SMESH_MEN_APPLIED_ALGORIHTMS"),
 261               "ICON_SMESH_TREE_ALGO");
 262   }
 263 }
 264
 265
 266 //===============================================================
 267 SMESH_Swig::SMESH_Swig()
 268 {
 269   class TEvent: public SALOME_Event
 270   {
 271     CORBA::ORB_var& myORB;
 272   public:
 273
 274     TEvent(CORBA::ORB_var& theORB):
 275       myORB(theORB)
 276     {}
 277
 278     virtual
 279     void
 280     Execute()
 281     {
 282       try {
 283         ORB_INIT &anORBInit = *SINGLETON_<ORB_INIT>::Instance();
 284         ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
 285         myORB = anORBInit( 0 , 0 );
 286       } catch (...) {
 287         INFOS("internal error : orb not found");
 288       }
 289     }
 290   };
 291
 292   MESSAGE("Constructeur");
 293
 294   if(CORBA::is_nil(anORB))
 295     ProcessVoidEvent(new TEvent(anORB));
 296
 297   ASSERT(!CORBA::is_nil(anORB));
 298 }
 299
 300
 301 //===============================================================
 302 void
 303 SMESH_Swig::Init(int theStudyID)
 304 {
 305   class TEvent: public SALOME_Event
 306   {
 307     int myStudyID;
 308     SALOMEDS::Study_var& myStudy;
 309     SALOMEDS::StudyBuilder_var& myStudyBuilder;
 310     SALOMEDS::SComponent_var& mySComponentMesh;
 311   public:
 312     TEvent(int theStudyID,
 313            SALOMEDS::Study_var& theStudy,
 314            SALOMEDS::StudyBuilder_var& theStudyBuilder,
 315            SALOMEDS::SComponent_var& theSComponentMesh):
 316       myStudyID(theStudyID),
 317       myStudy(theStudy),
 318       myStudyBuilder(theStudyBuilder),
 319       mySComponentMesh(theSComponentMesh)
 320     {}
 321
 322     virtual
 323     void
 324     Execute()
 325     {
 326       SUIT_Session* aSession = SUIT_Session::session();
 327       SUIT_Application* anApplication = aSession->activeApplication();
 328       SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>(anApplication);
 329
 330       SALOME_NamingService* aNamingService = anApp->namingService();
 331       CORBA::Object_var anObject = aNamingService->Resolve("/myStudyManager");
 332       SALOMEDS::StudyManager_var aStudyMgr = SALOMEDS::StudyManager::_narrow(anObject);
 333       myStudy = aStudyMgr->GetStudyByID(myStudyID);
 334
 335       SMESH::SMESH_Gen_var aSMESHGen = SMESHGUI::GetSMESHGen();
 336       aSMESHGen->SetCurrentStudy( myStudy.in() );
 337
 338       myStudyBuilder = myStudy->NewBuilder();
 339
 340       SALOMEDS::GenericAttribute_var anAttr;
 341       SALOMEDS::AttributeName_var    aName;
 342       SALOMEDS::AttributePixMap_var  aPixmap;
 343
 344       SALOMEDS::SComponent_var aSComponent = myStudy->FindComponent("SMESH");
 345       if(aSComponent->_is_nil()){
 346         bool aLocked = myStudy->GetProperties()->IsLocked();
 347         if (aLocked)
 348           myStudy->GetProperties()->SetLocked(false);
 349
 350         aSComponent = myStudyBuilder->NewComponent("SMESH");
 351         anAttr = myStudyBuilder->FindOrCreateAttribute(aSComponent,"AttributeName");
 352         aName = SALOMEDS::AttributeName::_narrow(anAttr);
 353
 354         SMESHGUI* aSMESHGUI = SMESHGUI::GetSMESHGUI(); //SRN: BugID IPAL9186, load a SMESH gui if it hasn't been loaded
 355         if (!aSMESHGUI){
 356           CAM_Module* aModule = anApp->module("Mesh");
 357           if(!aModule)
 358               aModule = anApp->loadModule("Mesh");
 359           aSMESHGUI = dynamic_cast<SMESHGUI*>(aModule);
 360         } //SRN: BugID IPAL9186: end of a fix
 361         aName->SetValue(aSMESHGUI->moduleName());
 362         anAttr = myStudyBuilder->FindOrCreateAttribute(aSComponent,"AttributePixMap");
 363         aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 364         aPixmap->SetPixMap( "ICON_OBJBROWSER_SMESH" );
 365         myStudyBuilder->DefineComponentInstance(aSComponent,aSMESHGen);
 366         if (aLocked)
 367           myStudy->GetProperties()->SetLocked(true);
 368       }
 369
 370       mySComponentMesh = SALOMEDS::SComponent::_narrow(aSComponent);
 371
 372       qApp->processEvents(); // Workaround for bug 12662
 373     }
 374   };
 375
 376   MESSAGE("Init");
 377
 378   ProcessVoidEvent(new TEvent(theStudyID,
 379                               myStudy,
 380                               myStudyBuilder,
 381                               mySComponentMesh));
 382 }
 383
 384
 385 //===============================================================
 386 SMESH_Swig::~SMESH_Swig()
 387 {
 388   MESSAGE("Destructeur");
 389 }
 390
 391
 392 //===============================================================
 393 const char* SMESH_Swig::AddNewMesh(const char* theIOR)
 394 {
 395   MESSAGE("AddNewMesh");
 396
 397   // VSR: added temporarily - to be removed - objects are published automatically by engine
 398   SALOMEDS::SObject_var aSObject = myStudy->FindObjectIOR(theIOR);
 399   if (aSObject->_is_nil()){
 400     //Find or Create Hypothesis root
 401     GetHypothesisRoot(mySComponentMesh,myStudyBuilder);
 402     GetAlgorithmsRoot(mySComponentMesh,myStudyBuilder);
 403
 404     // Add New Mesh
 405     aSObject = myStudyBuilder->NewObject(mySComponentMesh);
 406     SALOMEDS::GenericAttribute_var anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject,"AttributePixMap");
 407     SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 408     aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH" );
 409     anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject, "AttributeIOR");
 410     SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 411     anIOR->SetValue(theIOR);
 412   }
 413
 414   CORBA::String_var anEntry = aSObject->GetID();
 415
 416   return anEntry._retn();
 417 }
 418
 419
 420 //===============================================================
 421 const char* SMESH_Swig::AddNewHypothesis(const char* theIOR)
 422 {
 423   MESSAGE("AddNewHypothesis");
 424
 425   SALOMEDS::SObject_var aSObject = ::AddHypothesis(theIOR,
 426                                                    mySComponentMesh,
 427                                                    myStudyBuilder);
 428   CORBA::String_var anEntry = aSObject->GetID();
 429   return anEntry._retn();
 430 }
 431
 432
 433 //===============================================================
 434 const char* SMESH_Swig::AddNewAlgorithms(const char* theIOR)
 435 {
 436   MESSAGE("AddNewAlgorithms");
 437
 438   SALOMEDS::SObject_var aSObject = ::AddAlgorithms(theIOR,
 439                                                    mySComponentMesh,
 440                                                    myStudyBuilder);
 441   CORBA::String_var anEntry = aSObject->GetID();
 442   return anEntry._retn();
 443 }
 444
 445
 446 //===============================================================
 447 void SMESH_Swig::SetShape(const char* theShapeEntry,
 448                           const char* theMeshEntry)
 449 {
 450   SALOMEDS::SObject_var aMeshSO = myStudy->FindObjectID( theMeshEntry );
 451   SALOMEDS::SObject_var aGeomShapeSO = myStudy->FindObjectID( theShapeEntry );
 452
 453   if(!aMeshSO->_is_nil() && !aGeomShapeSO->_is_nil()){
 454     SALOMEDS::SObject_var aSObject = myStudyBuilder->NewObjectToTag(aMeshSO, SMESH::Tag_RefOnShape);
 455     myStudyBuilder->Addreference(aSObject,aGeomShapeSO);
 456   }
 457 }
 458
 459
 460 //===============================================================
 461 void SMESH_Swig::SetHypothesis(const char* theMeshOrSubMeshEntry,
 462                                const char* theDomainEntry)
 463 {
 464   ::SetHypothesis(theMeshOrSubMeshEntry,
 465                   theDomainEntry,
 466                   myStudy,
 467                   myStudyBuilder);
 468 }
 469
 470
 471 //===============================================================
 472 void SMESH_Swig::SetAlgorithms(const char* theMeshOrSubMeshEntry,
 473                                const char* theDomainEntry)
 474 {
 475   ::SetAlgorithms(theMeshOrSubMeshEntry,
 476                   theDomainEntry,
 477                   myStudy,
 478                   myStudyBuilder);
 479 }
 480
 481
 482 //===============================================================
 483 void
 484 SMESH_Swig::UnSetHypothesis(const char* theDomainEntry)
 485 {
 486   SALOMEDS::SObject_var aDomainSO = myStudy->FindObjectID(theDomainEntry);
 487   if(!aDomainSO->_is_nil())
 488     myStudyBuilder->RemoveObject(aDomainSO);
 489 }
 490
 491 const char* SMESH_Swig::AddSubMesh(const char* theMeshEntry,
 492                                    const char* theSubMeshIOR,
 493                                    int theShapeType)
 494 {
 495   SALOMEDS::SObject_var aMeshSO = myStudy->FindObjectID(theMeshEntry);
 496   if(!aMeshSO->_is_nil()){
 497     long aShapeTag;
 498     QString aSubMeshName;
 499     switch(theShapeType){
 500     case TopAbs_SOLID:
 501       aShapeTag = SMESH::Tag_SubMeshOnSolid;
 502       aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnSolid");
 503       break;
 504     case TopAbs_FACE:
 505       aShapeTag = SMESH::Tag_SubMeshOnFace;
 506       aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnFace");
 507       break;
 508     case TopAbs_EDGE:
 509       aShapeTag = SMESH::Tag_SubMeshOnEdge;
 510       aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnEdge");
 511       break;
 512     case TopAbs_VERTEX:
 513       aShapeTag = SMESH::Tag_SubMeshOnVertex;
 514       aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnVertex");
 515       break;
 516     default:
 517       aShapeTag = SMESH::Tag_SubMeshOnCompound;
 518       aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnCompound");
 519     }
 520
 521     SALOMEDS::SObject_var aSubMeshesRoot;
 522     SALOMEDS::GenericAttribute_var anAttr;
 523     if(!aMeshSO->FindSubObject(aShapeTag,aSubMeshesRoot)){
 524       aSubMeshesRoot = myStudyBuilder->NewObjectToTag(aMeshSO,aShapeTag);
 525       anAttr = myStudyBuilder->FindOrCreateAttribute(aSubMeshesRoot,"AttributeName");
 526       SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
 527       aName->SetValue(aSubMeshName.latin1());
 528       anAttr = myStudyBuilder->FindOrCreateAttribute(aSubMeshesRoot,"AttributeSelectable");
 529       SALOMEDS::AttributeSelectable_var aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
 530       aSelAttr->SetSelectable(false);
 531     }
 532
 533     SALOMEDS::SObject_var aSObject = myStudyBuilder->NewObject(aSubMeshesRoot);
 534     anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject,"AttributeIOR");
 535     SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 536     anIOR->SetValue(theSubMeshIOR);
 537
 538     CORBA::String_var aString = aSObject->GetID();
 539     return aString._retn();
 540   }
 541
 542   return "";
 543 }
 544
 545 const char* SMESH_Swig::AddSubMeshOnShape(const char* theMeshEntry,
 546                                           const char* theGeomShapeEntry,
 547                                           const char* theSubMeshIOR,
 548                                           int ShapeType)
 549 {
 550   SALOMEDS::SObject_var aGeomShapeSO = myStudy->FindObjectID(theGeomShapeEntry);
 551   if(!aGeomShapeSO->_is_nil()){
 552     const char * aSubMeshEntry = AddSubMesh(theMeshEntry,theSubMeshIOR,ShapeType);
 553     SALOMEDS::SObject_var aSubMeshSO = myStudy->FindObjectID(aSubMeshEntry);
 554     if(!aSubMeshSO->_is_nil()){
 555       SetShape(theGeomShapeEntry,aSubMeshEntry);
 556       CORBA::String_var aString = aSubMeshSO->GetID();
 557       return aString._retn();
 558     }
 559   }
 560
 561   return "";
 562 }
 563
 564 void SMESH_Swig::CreateAndDisplayActor( const char* Mesh_Entry )
 565 {
 566   //  SMESH_Actor* Mesh = smeshGUI->ReadScript(aM);
 567   class TEvent: public SALOME_Event
 568   {
 569   private:
 570     const char* _entry;
 571   public:
 572     TEvent(const char* Mesh_Entry) {
 573       _entry = Mesh_Entry;
 574     }
 575     virtual void Execute() {
 576       //SMESH::UpdateView(SMESH::eDisplay, _entry);
 577       SUIT_Session* aSession = SUIT_Session::session();
 578       SUIT_Application* anApplication = aSession->activeApplication();
 579       SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>(anApplication);
 580       SUIT_ViewManager* vman = anApp->getViewManager(VTKViewer_Viewer::Type(),true);
 581       SMESHGUI_Displayer* aDisp = new SMESHGUI_Displayer(anApp);
 582       aDisp->Display(_entry,1);
 583     }
 584   };
 585
 586   ProcessVoidEvent(new TEvent(Mesh_Entry));
 587 }
 588
 589 void SMESH_Swig::SetName(const char* theEntry,
 590                          const char* theName)
 591 {
 592   SALOMEDS::SObject_var aSObject = myStudy->FindObjectID(theEntry);
 593   SALOMEDS::GenericAttribute_var anAttr;
 594   SALOMEDS::AttributeName_var aName;
 595   if(!aSObject->_is_nil()){
 596     anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject,"AttributeName");
 597     aName = SALOMEDS::AttributeName::_narrow(anAttr);
 598     aName->SetValue(theName);
 599   }
 600 }
 601
 602 //================================================================================
 603 /*!
 604  * \brief Set mesh icon according to compute status
 605   * \param Mesh_Entry - entry of a mesh
 606   * \param isComputed - is mesh computed or not
 607  */
 608 //================================================================================
 609
 610 void SMESH_Swig::SetMeshIcon(const char* theMeshEntry,
 611                              const bool theIsComputed,
 612                              const bool isEmpty)
 613 {
 614   class TEvent: public SALOME_Event
 615   {
 616     SALOMEDS::Study_var myStudy;
 617     std::string myMeshEntry;
 618     bool myIsComputed, myIsEmpty;
 619   public:
 620     TEvent(const SALOMEDS::Study_var& theStudy,
 621            const std::string& theMeshEntry,
 622            const bool theIsComputed,
 623            const bool isEmpty):
 624       myStudy(theStudy),
 625       myMeshEntry(theMeshEntry),
 626       myIsComputed(theIsComputed),
 627       myIsEmpty(isEmpty)
 628     {}
 629
 630     virtual
 631     void
 632     Execute()
 633     {
 634       SALOMEDS::SObject_var aMeshSO = myStudy->FindObjectID(myMeshEntry.c_str());
 635       if(!aMeshSO->_is_nil())
 636         if(_PTR(SObject) aMesh = ClientFactory::SObject(aMeshSO))
 637           SMESH::ModifiedMesh(aMesh,myIsComputed,myIsEmpty);
 638     }
 639   };
 640
 641   ProcessVoidEvent(new TEvent(myStudy,
 642                               theMeshEntry,
 643                               theIsComputed,
 644                               isEmpty));
 645 }