src/SMESHGUI/SMESHGUI_Swig.cxx

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