src/SMESH_SWIG_WITHIHM/libSMESH_Swig.cxx

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