src/SMESH_SWIG_WITHIHM/libSMESH_Swig.cxx

   1 // Copyright (C) 2007-2013  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       aName->UnRegister();
  87       anAttr = theStudyBuilder->FindOrCreateAttribute(aDomainRoot,"AttributePixMap");
  88       SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
  89       aPixmap->SetPixMap(thePixmap.toLatin1().data());
  90       aPixmap->UnRegister();
  91       anAttr = theStudyBuilder->FindOrCreateAttribute(aDomainRoot,"AttributeSelectable");
  92       SALOMEDS::AttributeSelectable_var aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
  93       aSelAttr->SetSelectable(false);
  94       aSelAttr->UnRegister();
  95     }
  96
  97     return aDomainRoot;
  98   }
  99
 100
 101   //---------------------------------------------------------------
 102   inline
 103   SALOMEDS::SObject_var
 104   GetHypothesisRoot(const SALOMEDS::SComponent_var& theSComponentMesh,
 105                     const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 106   {
 107     return GetDomainRoot(theSComponentMesh,
 108                          theStudyBuilder,
 109                          SMESH::Tag_HypothesisRoot,
 110                          QObject::tr("SMESH_MEN_HYPOTHESIS"),
 111                          "ICON_SMESH_TREE_HYPO");
 112   }
 113
 114
 115   //---------------------------------------------------------------
 116   inline
 117   SALOMEDS::SObject_var
 118   GetAlgorithmsRoot(const SALOMEDS::SComponent_var& theSComponentMesh,
 119                     const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 120   {
 121     return GetDomainRoot(theSComponentMesh,
 122                          theStudyBuilder,
 123                          SMESH::Tag_AlgorithmsRoot,
 124                          QObject::tr("SMESH_MEN_ALGORITHMS"),
 125                          "ICON_SMESH_TREE_ALGO");
 126   }
 127
 128
 129   //---------------------------------------------------------------
 130   inline
 131   SALOMEDS::SObject_var
 132   AddToDomain(const std::string&                theIOR,
 133               const SALOMEDS::SComponent_var&   theSComponentMesh,
 134               const SALOMEDS::StudyBuilder_var& theStudyBuilder,
 135               CORBA::Long                       theDomainRootTag,
 136               const QString&                    theDomainName,
 137               const QString&                    theDomainPixmap)
 138   {
 139     SALOMEDS::SObject_var aDomain = GetDomainRoot(theSComponentMesh,
 140                                                   theStudyBuilder,
 141                                                   SMESH::Tag_AlgorithmsRoot,
 142                                                   theDomainName,
 143                                                   theDomainPixmap);
 144     // Add New Hypothesis
 145     SALOMEDS::SObject_var aSObject = theStudyBuilder->NewObject(aDomain);
 146     aDomain->UnRegister();
 147     SALOMEDS::GenericAttribute_var anAttr = theStudyBuilder->FindOrCreateAttribute(aSObject,"AttributePixMap");
 148     SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 149     CORBA::Object_var anObject = StringToObject(theIOR);
 150     SMESH::SMESH_Hypothesis_var aDomainItem = SMESH::SMESH_Hypothesis::_narrow(anObject.in());
 151     CORBA::String_var aType = aDomainItem->GetName();
 152     QString aPixmapName = theDomainPixmap + "_" + aType.in();
 153     aPixmap->SetPixMap(aPixmapName.toLatin1().data());
 154     aPixmap->UnRegister();
 155     anAttr = theStudyBuilder->FindOrCreateAttribute(aSObject,"AttributeIOR");
 156     SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 157     anIOR->SetValue(theIOR.c_str());
 158     anIOR->UnRegister();
 159
 160     return aSObject;
 161   }
 162
 163
 164   //---------------------------------------------------------------
 165   SALOMEDS::SObject_var
 166   AddHypothesis(const std::string& theIOR,
 167                 const SALOMEDS::SComponent_var& theSComponentMesh,
 168                 const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 169   {
 170     return AddToDomain(theIOR,
 171                        theSComponentMesh,
 172                        theStudyBuilder,
 173                        SMESH::Tag_HypothesisRoot,
 174                        QObject::tr("SMESH_MEN_HYPOTHESIS"),
 175                        "ICON_SMESH_TREE_HYPO");
 176   }
 177
 178
 179   //---------------------------------------------------------------
 180   SALOMEDS::SObject_var
 181   AddAlgorithms(const std::string& theIOR,
 182                 const SALOMEDS::SComponent_var& theSComponentMesh,
 183                 const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 184   {
 185     return AddToDomain(theIOR,
 186                        theSComponentMesh,
 187                        theStudyBuilder,
 188                        SMESH::Tag_AlgorithmsRoot,
 189                        QObject::tr("SMESH_MEN_ALGORITHMS"),
 190                        "ICON_SMESH_TREE_ALGO");
 191   }
 192
 193
 194   //---------------------------------------------------------------
 195   void
 196   SetDomain(const char*                       theMeshOrSubMeshEntry,
 197             const char*                       theDomainEntry,
 198             const SALOMEDS::Study_var&        theStudy,
 199             const SALOMEDS::StudyBuilder_var& theStudyBuilder,
 200             long                              theRefOnAppliedDomainTag,
 201             const QString&                    theAppliedDomainMEN,
 202             const QString&                    theAppliedDomainICON)
 203   {
 204     SALOMEDS::SObject_var aMeshOrSubMeshSO = theStudy->FindObjectID(theMeshOrSubMeshEntry);
 205     SALOMEDS::SObject_var    aHypothesisSO = theStudy->FindObjectID(theDomainEntry);
 206
 207     if(!aMeshOrSubMeshSO->_is_nil() && !aHypothesisSO->_is_nil()){
 208       //Find or Create Applied Hypothesis root
 209       SALOMEDS::SObject_var anAppliedDomainSO;
 210       if( !aMeshOrSubMeshSO->FindSubObject( theRefOnAppliedDomainTag, anAppliedDomainSO ))
 211       {
 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.toLatin1().data());
 217         aName->UnRegister();
 218         anAttr = theStudyBuilder->FindOrCreateAttribute(anAppliedDomainSO,"AttributeSelectable");
 219         SALOMEDS::AttributeSelectable_var aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
 220         aSelAttr->SetSelectable(false);
 221         aSelAttr->UnRegister();
 222         anAttr = theStudyBuilder->FindOrCreateAttribute(anAppliedDomainSO,"AttributePixMap");
 223         SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 224         aPixmap->SetPixMap(theAppliedDomainICON.toLatin1().data());
 225         aPixmap->UnRegister();
 226       }
 227       SALOMEDS::SObject_var aSObject = theStudyBuilder->NewObject(anAppliedDomainSO);
 228       theStudyBuilder->Addreference(aSObject,aHypothesisSO);
 229       aSObject->UnRegister();
 230       anAppliedDomainSO->UnRegister();
 231     }
 232     if ( !aMeshOrSubMeshSO->_is_nil() ) aMeshOrSubMeshSO->UnRegister();
 233     if ( !aHypothesisSO->_is_nil())     aHypothesisSO->UnRegister();
 234   }
 235
 236
 237   //---------------------------------------------------------------
 238   void
 239   SetHypothesis(const char*                       theMeshOrSubMeshEntry,
 240                 const char*                       theDomainEntry,
 241                 const SALOMEDS::Study_var&        theStudy,
 242                 const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 243   {
 244     SetDomain(theMeshOrSubMeshEntry,
 245               theDomainEntry,
 246               theStudy,
 247               theStudyBuilder,
 248               SMESH::Tag_RefOnAppliedHypothesis,
 249               QObject::tr("SMESH_MEN_APPLIED_HYPOTHESIS"),
 250               "ICON_SMESH_TREE_HYPO");
 251   }
 252
 253
 254   //---------------------------------------------------------------
 255   void
 256   SetAlgorithms(const char*                       theMeshOrSubMeshEntry,
 257                 const char*                       theDomainEntry,
 258                 const SALOMEDS::Study_var&        theStudy,
 259                 const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 260   {
 261     SetDomain(theMeshOrSubMeshEntry,
 262               theDomainEntry,
 263               theStudy,
 264               theStudyBuilder,
 265               SMESH::Tag_RefOnAppliedAlgorithms,
 266               QObject::tr("SMESH_MEN_APPLIED_ALGORIHTMS"),
 267               "ICON_SMESH_TREE_ALGO");
 268   }
 269 }
 270
 271
 272 //===============================================================
 273 SMESH_Swig::SMESH_Swig()
 274 {
 275   class TEvent: public SALOME_Event
 276   {
 277     CORBA::ORB_var& myORB;
 278   public:
 279
 280     TEvent(CORBA::ORB_var& theORB):
 281       myORB(theORB)
 282     {}
 283
 284     virtual
 285     void
 286     Execute()
 287     {
 288       try {
 289         ORB_INIT &anORBInit = *SINGLETON_<ORB_INIT>::Instance();
 290         ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
 291         myORB = anORBInit( 0, 0 );
 292       } catch (...) {
 293         INFOS("internal error : orb not found");
 294       }
 295     }
 296   };
 297
 298   MESSAGE("Constructeur");
 299
 300   if(CORBA::is_nil(anORB))
 301     ProcessVoidEvent(new TEvent(anORB));
 302
 303   ASSERT(!CORBA::is_nil(anORB));
 304 }
 305
 306
 307 //===============================================================
 308 void
 309 SMESH_Swig::Init(int theStudyID)
 310 {
 311   class TEvent: public SALOME_Event
 312   {
 313     int                         myStudyID;
 314     SALOMEDS::Study_var&        myStudy;
 315     SALOMEDS::StudyBuilder_var& myStudyBuilder;
 316     SALOMEDS::SComponent_var&   mySComponentMesh;
 317   public:
 318     TEvent(int                         theStudyID,
 319            SALOMEDS::Study_var&        theStudy,
 320            SALOMEDS::StudyBuilder_var& theStudyBuilder,
 321            SALOMEDS::SComponent_var&   theSComponentMesh):
 322       myStudyID       (theStudyID),
 323       myStudy         (theStudy),
 324       myStudyBuilder  (theStudyBuilder),
 325       mySComponentMesh(theSComponentMesh)
 326     {}
 327
 328     ~TEvent()
 329     {
 330       if ( !mySComponentMesh->_is_nil() ) mySComponentMesh->UnRegister();
 331     }
 332
 333     virtual
 334     void
 335     Execute()
 336     {
 337       SUIT_Session* aSession          = SUIT_Session::session();
 338       SUIT_Application* anApplication = aSession->activeApplication();
 339       SalomeApp_Application* anApp    = dynamic_cast<SalomeApp_Application*>(anApplication);
 340
 341       SALOME_NamingService* aNamingService = anApp->namingService();
 342       CORBA::Object_var anObject           = aNamingService->Resolve("/myStudyManager");
 343       SALOMEDS::StudyManager_var aStudyMgr = SALOMEDS::StudyManager::_narrow(anObject);
 344       myStudy = aStudyMgr->GetStudyByID(myStudyID);
 345
 346       SMESH::SMESH_Gen_var aSMESHGen = SMESHGUI::GetSMESHGen();
 347       aSMESHGen->SetCurrentStudy( myStudy.in() );
 348
 349       myStudyBuilder = myStudy->NewBuilder();
 350
 351       SALOMEDS::GenericAttribute_var anAttr;
 352       SALOMEDS::AttributeName_var    aName;
 353       SALOMEDS::AttributePixMap_var  aPixmap;
 354
 355       SALOMEDS::SComponent_var aSComponent = myStudy->FindComponent("SMESH");
 356       if ( aSComponent->_is_nil() )
 357       {
 358         bool aLocked = myStudy->GetProperties()->IsLocked();
 359         if (aLocked)
 360           myStudy->GetProperties()->SetLocked(false);
 361
 362         SMESHGUI* aSMESHGUI = SMESHGUI::GetSMESHGUI();
 363         //SRN: BugID IPAL9186, load a SMESH gui if it hasn't been loaded
 364         if (!aSMESHGUI) {
 365           CAM_Module* aModule = anApp->module("Mesh");
 366           if(!aModule)
 367             aModule = anApp->loadModule("Mesh");
 368           aSMESHGUI = dynamic_cast<SMESHGUI*>(aModule);
 369         } //SRN: BugID IPAL9186: end of a fix
 370
 371         aSComponent = myStudyBuilder->NewComponent("SMESH");
 372
 373         anAttr = myStudyBuilder->FindOrCreateAttribute(aSComponent,"AttributeName");
 374         aName  = SALOMEDS::AttributeName::_narrow(anAttr);
 375         aName->SetValue(aSMESHGUI->moduleName().toLatin1().data());
 376         aName->UnRegister();
 377
 378         anAttr = myStudyBuilder->FindOrCreateAttribute(aSComponent,"AttributePixMap");
 379         aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 380         aPixmap->SetPixMap( "ICON_OBJBROWSER_SMESH" );
 381         aPixmap->UnRegister();
 382
 383         myStudyBuilder->DefineComponentInstance(aSComponent,aSMESHGen);
 384         if (aLocked)
 385           myStudy->GetProperties()->SetLocked(true);
 386       }
 387
 388       mySComponentMesh = SALOMEDS::SComponent::_narrow(aSComponent);
 389
 390       qApp->processEvents(); // Workaround for bug 12662
 391     }
 392   };
 393
 394   MESSAGE("Init");
 395
 396   ProcessVoidEvent(new TEvent(theStudyID,
 397                               myStudy,
 398                               myStudyBuilder,
 399                               mySComponentMesh));
 400 }
 401
 402
 403 //===============================================================
 404 SMESH_Swig::~SMESH_Swig()
 405 {
 406   MESSAGE("Destructeur");
 407 }
 408
 409
 410 //===============================================================
 411 const char* SMESH_Swig::AddNewMesh(const char* theIOR)
 412 {
 413   MESSAGE("AddNewMesh");
 414
 415   // VSR: added temporarily - to be removed - objects are published automatically by engine
 416   SALOMEDS::SObject_var aSObject = myStudy->FindObjectIOR(theIOR);
 417   if (aSObject->_is_nil())
 418   {
 419     //Find or Create Hypothesis root
 420     SALOMEDS::SObject_var hroot = GetHypothesisRoot(mySComponentMesh,myStudyBuilder);
 421     SALOMEDS::SObject_var aroot = GetAlgorithmsRoot(mySComponentMesh,myStudyBuilder);
 422     hroot->UnRegister();
 423     aroot->UnRegister();
 424
 425     // Add New Mesh
 426     aSObject = myStudyBuilder->NewObject(mySComponentMesh);
 427     SALOMEDS::GenericAttribute_var anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject,"AttributePixMap");
 428     SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 429     aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH" );
 430     aPixmap->UnRegister();
 431
 432     anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject, "AttributeIOR");
 433     SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 434     anIOR->SetValue(theIOR);
 435     anIOR->UnRegister();
 436   }
 437
 438   CORBA::String_var anEntry = aSObject->GetID();
 439   aSObject->UnRegister();
 440
 441   return anEntry._retn();
 442 }
 443
 444
 445 //===============================================================
 446 const char* SMESH_Swig::AddNewHypothesis(const char* theIOR)
 447 {
 448   MESSAGE("AddNewHypothesis");
 449
 450   SALOMEDS::SObject_var aSObject = ::AddHypothesis(theIOR,
 451                                                    mySComponentMesh,
 452                                                    myStudyBuilder);
 453   CORBA::String_var anEntry = aSObject->GetID();
 454   aSObject->UnRegister();
 455
 456   return anEntry._retn();
 457 }
 458
 459
 460 //===============================================================
 461 const char* SMESH_Swig::AddNewAlgorithms(const char* theIOR)
 462 {
 463   MESSAGE("AddNewAlgorithms");
 464
 465   SALOMEDS::SObject_var aSObject = ::AddAlgorithms(theIOR,
 466                                                    mySComponentMesh,
 467                                                    myStudyBuilder);
 468   CORBA::String_var anEntry = aSObject->GetID();
 469   aSObject->UnRegister();
 470
 471   return anEntry._retn();
 472 }
 473
 474
 475 //===============================================================
 476 void SMESH_Swig::SetShape(const char* theShapeEntry,
 477                           const char* theMeshEntry)
 478 {
 479   SALOMEDS::SObject_var aGeomShapeSO = myStudy->FindObjectID( theShapeEntry );
 480   SALOMEDS::SObject_var      aMeshSO = myStudy->FindObjectID( theMeshEntry );
 481
 482   if(!aMeshSO->_is_nil() && !aGeomShapeSO->_is_nil()){
 483     SALOMEDS::SObject_var aSObject = myStudyBuilder->NewObjectToTag(aMeshSO, SMESH::Tag_RefOnShape);
 484     myStudyBuilder->Addreference(aSObject,aGeomShapeSO);
 485     aSObject->UnRegister();
 486   }
 487   if ( !aMeshSO->_is_nil() )      aMeshSO->UnRegister();
 488   if ( !aGeomShapeSO->_is_nil() ) aGeomShapeSO->UnRegister();
 489 }
 490
 491
 492 //===============================================================
 493 void SMESH_Swig::SetHypothesis(const char* theMeshOrSubMeshEntry,
 494                                const char* theDomainEntry)
 495 {
 496   ::SetHypothesis(theMeshOrSubMeshEntry,
 497                   theDomainEntry,
 498                   myStudy,
 499                   myStudyBuilder);
 500 }
 501
 502
 503 //===============================================================
 504 void SMESH_Swig::SetAlgorithms(const char* theMeshOrSubMeshEntry,
 505                                const char* theDomainEntry)
 506 {
 507   ::SetAlgorithms(theMeshOrSubMeshEntry,
 508                   theDomainEntry,
 509                   myStudy,
 510                   myStudyBuilder);
 511 }
 512
 513
 514 //===============================================================
 515 void
 516 SMESH_Swig::UnSetHypothesis(const char* theDomainEntry)
 517 {
 518   SALOMEDS::SObject_var aDomainSO = myStudy->FindObjectID(theDomainEntry);
 519   if(!aDomainSO->_is_nil())
 520     myStudyBuilder->RemoveObject(aDomainSO);
 521 }
 522
 523 const char* SMESH_Swig::AddSubMesh(const char* theMeshEntry,
 524                                    const char* theSubMeshIOR,
 525                                    int theShapeType)
 526 {
 527   SALOMEDS::SObject_var aMeshSO = myStudy->FindObjectID(theMeshEntry);
 528   if(!aMeshSO->_is_nil()) {
 529     long aShapeTag;
 530     QString aSubMeshName;
 531     switch(theShapeType) {
 532     case TopAbs_SOLID:
 533       aShapeTag    = SMESH::Tag_SubMeshOnSolid;
 534       aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnSolid");
 535       break;
 536     case TopAbs_FACE:
 537       aShapeTag    = SMESH::Tag_SubMeshOnFace;
 538       aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnFace");
 539       break;
 540     case TopAbs_EDGE:
 541       aShapeTag    = SMESH::Tag_SubMeshOnEdge;
 542       aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnEdge");
 543       break;
 544     case TopAbs_VERTEX:
 545       aShapeTag    = SMESH::Tag_SubMeshOnVertex;
 546       aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnVertex");
 547       break;
 548     default:
 549       aShapeTag    = SMESH::Tag_SubMeshOnCompound;
 550       aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnCompound");
 551     }
 552
 553     SALOMEDS::GenericAttribute_var anAttr;
 554     SALOMEDS::SObject_var aSubMeshesRoot;
 555     if ( !aMeshSO->FindSubObject( aShapeTag, aSubMeshesRoot ) )
 556     {
 557       aSubMeshesRoot = myStudyBuilder->NewObjectToTag(aMeshSO,aShapeTag);
 558       anAttr = myStudyBuilder->FindOrCreateAttribute(aSubMeshesRoot,"AttributeName");
 559       SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
 560       aName->SetValue(aSubMeshName.toLatin1().data());
 561       aName->UnRegister();
 562       anAttr = myStudyBuilder->FindOrCreateAttribute(aSubMeshesRoot,"AttributeSelectable");
 563       SALOMEDS::AttributeSelectable_var aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
 564       aSelAttr->SetSelectable(false);
 565       aSelAttr->UnRegister();
 566     }
 567     aSubMeshesRoot->UnRegister();
 568     aMeshSO->UnRegister();
 569
 570     SALOMEDS::SObject_var aSObject = myStudyBuilder->NewObject(aSubMeshesRoot);
 571     anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject,"AttributeIOR");
 572     SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 573     anIOR->SetValue(theSubMeshIOR);
 574     anIOR->UnRegister();
 575
 576     CORBA::String_var aString = aSObject->GetID();
 577     aSObject->UnRegister();
 578
 579     return aString._retn();
 580   }
 581
 582   return "";
 583 }
 584
 585 const char* SMESH_Swig::AddSubMeshOnShape(const char* theMeshEntry,
 586                                           const char* theGeomShapeEntry,
 587                                           const char* theSubMeshIOR,
 588                                           int         ShapeType)
 589 {
 590   SALOMEDS::SObject_var aGeomShapeSO = myStudy->FindObjectID(theGeomShapeEntry);
 591   if(!aGeomShapeSO->_is_nil())
 592   {
 593     const char *       aSubMeshEntry = AddSubMesh(theMeshEntry,theSubMeshIOR,ShapeType);
 594     SALOMEDS::SObject_var aSubMeshSO = myStudy->FindObjectID(aSubMeshEntry);
 595     if ( !aSubMeshSO->_is_nil()) {
 596       SetShape( theGeomShapeEntry, aSubMeshEntry );
 597       CORBA::String_var aString = aSubMeshSO->GetID();
 598       aSubMeshSO->UnRegister();
 599       return aString._retn();
 600     }
 601     aGeomShapeSO->UnRegister();
 602   }
 603
 604   return "";
 605 }
 606
 607 void SMESH_Swig::CreateAndDisplayActor( const char* Mesh_Entry )
 608 {
 609   //  SMESH_Actor* Mesh = smeshGUI->ReadScript(aM);
 610   class TEvent: public SALOME_Event
 611   {
 612   private:
 613     const char* _entry;
 614   public:
 615     TEvent(const char* Mesh_Entry) {
 616       _entry = Mesh_Entry;
 617     }
 618     virtual void Execute() {
 619       //SMESH::UpdateView(SMESH::eDisplay, _entry);
 620       SUIT_Session* aSession          = SUIT_Session::session();
 621       SUIT_Application* anApplication = aSession->activeApplication();
 622       SalomeApp_Application* anApp    = dynamic_cast<SalomeApp_Application*>(anApplication);
 623       /*SUIT_ViewManager* vman        = */anApp->getViewManager(VTKViewer_Viewer::Type(),true);
 624       SMESHGUI_Displayer* aDisp       = new SMESHGUI_Displayer(anApp);
 625       aDisp->Display(_entry,1);
 626     }
 627   };
 628
 629   ProcessVoidEvent(new TEvent(Mesh_Entry));
 630 }
 631
 632 void SMESH_Swig::EraseActor( const char* Mesh_Entry, const bool allViewers )
 633 {
 634   class TEvent: public SALOME_Event
 635   {
 636   private:
 637     const char* _entry;
 638     bool        _allViewers;
 639   public:
 640     TEvent(const char* Mesh_Entry, const bool allViewers ) {
 641       _entry = Mesh_Entry;
 642       _allViewers = allViewers;
 643     }
 644     virtual void Execute() {
 645       SUIT_Session* aSession          = SUIT_Session::session();
 646       SUIT_Application* anApplication = aSession->activeApplication();
 647       SalomeApp_Application* anApp    = dynamic_cast<SalomeApp_Application*>(anApplication);
 648       SMESHGUI_Displayer* aDisp       = new SMESHGUI_Displayer(anApp);
 649       ViewManagerList aManagers;
 650       if ( !_allViewers ) {
 651         aManagers << anApp->activeViewManager();
 652       }
 653       else {
 654         aManagers = anApp->viewManagers();
 655       }
 656       foreach( SUIT_ViewManager* aMgr, aManagers ) {
 657         if ( aMgr && aMgr->getType() == VTKViewer_Viewer::Type() ) {
 658           SALOME_View* aSalomeView = dynamic_cast<SALOME_View*>(aMgr->getViewModel());
 659           if (aSalomeView) {
 660             aDisp->Erase(_entry,true, true, aSalomeView);
 661           }
 662         }
 663       }
 664     }
 665   };
 666
 667   ProcessVoidEvent(new TEvent(Mesh_Entry, allViewers));
 668 }
 669
 670 void SMESH_Swig::SetName(const char* theEntry,
 671                          const char* theName)
 672 {
 673   SALOMEDS::SObject_var aSObject = myStudy->FindObjectID(theEntry);
 674   SALOMEDS::GenericAttribute_var anAttr;
 675   SALOMEDS::AttributeName_var aName;
 676   if(!aSObject->_is_nil()){
 677     anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject,"AttributeName");
 678     aName = SALOMEDS::AttributeName::_narrow(anAttr);
 679     aName->SetValue(theName);
 680     aName->UnRegister();
 681     aSObject->UnRegister();
 682   }
 683 }
 684
 685 //================================================================================
 686 /*!
 687  * \brief Set mesh icon according to compute status
 688   * \param Mesh_Entry - entry of a mesh
 689   * \param isComputed - is mesh computed or not
 690  */
 691 //================================================================================
 692
 693 void SMESH_Swig::SetMeshIcon(const char* theMeshEntry,
 694                              const bool  theIsComputed,
 695                              const bool  isEmpty)
 696 {
 697   class TEvent: public SALOME_Event
 698   {
 699     SALOMEDS::Study_var myStudy;
 700     std::string         myMeshEntry;
 701     bool                myIsComputed, myIsEmpty;
 702   public:
 703     TEvent(const SALOMEDS::Study_var& theStudy,
 704            const std::string&         theMeshEntry,
 705            const bool                 theIsComputed,
 706            const bool                 isEmpty):
 707       myStudy     (theStudy),
 708       myMeshEntry (theMeshEntry),
 709       myIsComputed(theIsComputed),
 710       myIsEmpty   (isEmpty)
 711     {}
 712
 713     virtual
 714     void
 715     Execute()
 716     {
 717       SALOMEDS::SObject_ptr aMeshSO = myStudy->FindObjectID(myMeshEntry.c_str());
 718       if(_PTR(SObject) aMesh = ClientFactory::SObject(aMeshSO))
 719         SMESH::ModifiedMesh(aMesh,myIsComputed,myIsEmpty);
 720       // aMeshSO->UnRegister();  ~aMesh() already called UnRegister()!
 721     }
 722   };
 723
 724   ProcessVoidEvent(new TEvent(myStudy,
 725                               theMeshEntry,
 726                               theIsComputed,
 727                               isEmpty));
 728 }