src/SMESH_SWIG_WITHIHM/libSMESH_Swig.cxx

   1 // Copyright (C) 2007-2015  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, or (at your option) any later version.
   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
  28 #include <SMESHGUI.h>
  29 #include <SMESHGUI_Utils.h>
  30 #include <SMESHGUI_Displayer.h>
  31 #include <SMESHGUI_VTKUtils.h>
  32 #include <SMESH_Actor.h>
  33
  34 // SALOME KERNEL includes
  35 #include <Utils_ORB_INIT.hxx>
  36 #include <Utils_SINGLETON.hxx>
  37 #include <SALOMEDSClient_ClientFactory.hxx>
  38
  39 #include <utilities.h>
  40
  41 // SALOME GUI includes
  42 #include <SUIT_Session.h>
  43 #include <SUIT_ViewManager.h>
  44 #include <SALOME_Prs.h>
  45 #include <SUIT_ViewWindow.h>
  46 #include <SVTK_ViewWindow.h>
  47 #include <VTKViewer_ViewModel.h>
  48 #include <SALOME_Event.h>
  49 #include <SalomeApp_Application.h>
  50 #include <LightApp_SelectionMgr.h>
  51 #include <SVTK_RenderWindowInteractor.h>
  52
  53 // OCCT includes
  54 #include <TopAbs.hxx>
  55 #include <TColStd_MapOfInteger.hxx>
  56
  57 // Qt includes
  58 #include <QApplication>
  59
  60 // IDL includes
  61 #include <SALOMEconfig.h>
  62 #include CORBA_SERVER_HEADER(SMESH_Gen)
  63 #include CORBA_SERVER_HEADER(SMESH_Hypothesis)
  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.toLatin1().data());
  93       aName->UnRegister();
  94       anAttr = theStudyBuilder->FindOrCreateAttribute(aDomainRoot,"AttributePixMap");
  95       SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
  96       aPixmap->SetPixMap(thePixmap.toLatin1().data());
  97       aPixmap->UnRegister();
  98       anAttr = theStudyBuilder->FindOrCreateAttribute(aDomainRoot,"AttributeSelectable");
  99       SALOMEDS::AttributeSelectable_var aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
 100       aSelAttr->SetSelectable(false);
 101       aSelAttr->UnRegister();
 102     }
 103
 104     return aDomainRoot;
 105   }
 106
 107
 108   //---------------------------------------------------------------
 109   inline
 110   SALOMEDS::SObject_var
 111   GetHypothesisRoot(const SALOMEDS::SComponent_var& theSComponentMesh,
 112                     const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 113   {
 114     return GetDomainRoot(theSComponentMesh,
 115                          theStudyBuilder,
 116                          SMESH::Tag_HypothesisRoot,
 117                          QObject::tr("SMESH_MEN_HYPOTHESIS"),
 118                          "ICON_SMESH_TREE_HYPO");
 119   }
 120
 121
 122   //---------------------------------------------------------------
 123   inline
 124   SALOMEDS::SObject_var
 125   GetAlgorithmsRoot(const SALOMEDS::SComponent_var& theSComponentMesh,
 126                     const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 127   {
 128     return GetDomainRoot(theSComponentMesh,
 129                          theStudyBuilder,
 130                          SMESH::Tag_AlgorithmsRoot,
 131                          QObject::tr("SMESH_MEN_ALGORITHMS"),
 132                          "ICON_SMESH_TREE_ALGO");
 133   }
 134
 135
 136   //---------------------------------------------------------------
 137   inline
 138   SALOMEDS::SObject_var
 139   AddToDomain(const std::string&                theIOR,
 140               const SALOMEDS::SComponent_var&   theSComponentMesh,
 141               const SALOMEDS::StudyBuilder_var& theStudyBuilder,
 142               CORBA::Long                       theDomainRootTag,
 143               const QString&                    theDomainName,
 144               const QString&                    theDomainPixmap)
 145   {
 146     SALOMEDS::SObject_var aDomain = GetDomainRoot(theSComponentMesh,
 147                                                   theStudyBuilder,
 148                                                   SMESH::Tag_AlgorithmsRoot,
 149                                                   theDomainName,
 150                                                   theDomainPixmap);
 151     // Add New Hypothesis
 152     SALOMEDS::SObject_var aSObject = theStudyBuilder->NewObject(aDomain);
 153     aDomain->UnRegister();
 154     SALOMEDS::GenericAttribute_var anAttr = theStudyBuilder->FindOrCreateAttribute(aSObject,"AttributePixMap");
 155     SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 156     CORBA::Object_var anObject = StringToObject(theIOR);
 157     SMESH::SMESH_Hypothesis_var aDomainItem = SMESH::SMESH_Hypothesis::_narrow(anObject.in());
 158     CORBA::String_var aType = aDomainItem->GetName();
 159     QString aPixmapName = theDomainPixmap + "_" + aType.in();
 160     aPixmap->SetPixMap(aPixmapName.toLatin1().data());
 161     aPixmap->UnRegister();
 162     anAttr = theStudyBuilder->FindOrCreateAttribute(aSObject,"AttributeIOR");
 163     SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 164     anIOR->SetValue(theIOR.c_str());
 165     anIOR->UnRegister();
 166
 167     return aSObject;
 168   }
 169
 170
 171   //---------------------------------------------------------------
 172   SALOMEDS::SObject_var
 173   AddHypothesis(const std::string& theIOR,
 174                 const SALOMEDS::SComponent_var& theSComponentMesh,
 175                 const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 176   {
 177     return AddToDomain(theIOR,
 178                        theSComponentMesh,
 179                        theStudyBuilder,
 180                        SMESH::Tag_HypothesisRoot,
 181                        QObject::tr("SMESH_MEN_HYPOTHESIS"),
 182                        "ICON_SMESH_TREE_HYPO");
 183   }
 184
 185
 186   //---------------------------------------------------------------
 187   SALOMEDS::SObject_var
 188   AddAlgorithms(const std::string& theIOR,
 189                 const SALOMEDS::SComponent_var& theSComponentMesh,
 190                 const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 191   {
 192     return AddToDomain(theIOR,
 193                        theSComponentMesh,
 194                        theStudyBuilder,
 195                        SMESH::Tag_AlgorithmsRoot,
 196                        QObject::tr("SMESH_MEN_ALGORITHMS"),
 197                        "ICON_SMESH_TREE_ALGO");
 198   }
 199
 200
 201   //---------------------------------------------------------------
 202   void
 203   SetDomain(const char*                       theMeshOrSubMeshEntry,
 204             const char*                       theDomainEntry,
 205             const SALOMEDS::Study_var&        theStudy,
 206             const SALOMEDS::StudyBuilder_var& theStudyBuilder,
 207             long                              theRefOnAppliedDomainTag,
 208             const QString&                    theAppliedDomainMEN,
 209             const QString&                    theAppliedDomainICON)
 210   {
 211     SALOMEDS::SObject_var aMeshOrSubMeshSO = theStudy->FindObjectID(theMeshOrSubMeshEntry);
 212     SALOMEDS::SObject_var    aHypothesisSO = theStudy->FindObjectID(theDomainEntry);
 213
 214     if(!aMeshOrSubMeshSO->_is_nil() && !aHypothesisSO->_is_nil()){
 215       //Find or Create Applied Hypothesis root
 216       SALOMEDS::SObject_var anAppliedDomainSO;
 217       if( !aMeshOrSubMeshSO->FindSubObject( theRefOnAppliedDomainTag, anAppliedDomainSO ))
 218       {
 219         anAppliedDomainSO = theStudyBuilder->NewObjectToTag(aMeshOrSubMeshSO,theRefOnAppliedDomainTag);
 220         SALOMEDS::GenericAttribute_var anAttr =
 221           theStudyBuilder->FindOrCreateAttribute(anAppliedDomainSO,"AttributeName");
 222         SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
 223         aName->SetValue(theAppliedDomainMEN.toLatin1().data());
 224         aName->UnRegister();
 225         anAttr = theStudyBuilder->FindOrCreateAttribute(anAppliedDomainSO,"AttributeSelectable");
 226         SALOMEDS::AttributeSelectable_var aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
 227         aSelAttr->SetSelectable(false);
 228         aSelAttr->UnRegister();
 229         anAttr = theStudyBuilder->FindOrCreateAttribute(anAppliedDomainSO,"AttributePixMap");
 230         SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 231         aPixmap->SetPixMap(theAppliedDomainICON.toLatin1().data());
 232         aPixmap->UnRegister();
 233       }
 234       SALOMEDS::SObject_var aSObject = theStudyBuilder->NewObject(anAppliedDomainSO);
 235       theStudyBuilder->Addreference(aSObject,aHypothesisSO);
 236       aSObject->UnRegister();
 237       anAppliedDomainSO->UnRegister();
 238     }
 239     if ( !aMeshOrSubMeshSO->_is_nil() ) aMeshOrSubMeshSO->UnRegister();
 240     if ( !aHypothesisSO->_is_nil())     aHypothesisSO->UnRegister();
 241   }
 242
 243
 244   //---------------------------------------------------------------
 245   void
 246   SetHypothesis(const char*                       theMeshOrSubMeshEntry,
 247                 const char*                       theDomainEntry,
 248                 const SALOMEDS::Study_var&        theStudy,
 249                 const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 250   {
 251     SetDomain(theMeshOrSubMeshEntry,
 252               theDomainEntry,
 253               theStudy,
 254               theStudyBuilder,
 255               SMESH::Tag_RefOnAppliedHypothesis,
 256               QObject::tr("SMESH_MEN_APPLIED_HYPOTHESIS"),
 257               "ICON_SMESH_TREE_HYPO");
 258   }
 259
 260
 261   //---------------------------------------------------------------
 262   void
 263   SetAlgorithms(const char*                       theMeshOrSubMeshEntry,
 264                 const char*                       theDomainEntry,
 265                 const SALOMEDS::Study_var&        theStudy,
 266                 const SALOMEDS::StudyBuilder_var& theStudyBuilder)
 267   {
 268     SetDomain(theMeshOrSubMeshEntry,
 269               theDomainEntry,
 270               theStudy,
 271               theStudyBuilder,
 272               SMESH::Tag_RefOnAppliedAlgorithms,
 273               QObject::tr("SMESH_MEN_APPLIED_ALGORIHTMS"),
 274               "ICON_SMESH_TREE_ALGO");
 275   }
 276 }
 277
 278
 279 //===============================================================
 280 SMESH_Swig::SMESH_Swig()
 281 {
 282   class TEvent: public SALOME_Event
 283   {
 284     CORBA::ORB_var& myORB;
 285   public:
 286
 287     TEvent(CORBA::ORB_var& theORB):
 288       myORB(theORB)
 289     {}
 290
 291     virtual
 292     void
 293     Execute()
 294     {
 295       try {
 296         ORB_INIT &anORBInit = *SINGLETON_<ORB_INIT>::Instance();
 297         ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
 298         myORB = anORBInit( 0, 0 );
 299       } catch (...) {
 300         INFOS("internal error : orb not found");
 301       }
 302     }
 303   };
 304
 305   MESSAGE("Constructeur");
 306
 307   if(CORBA::is_nil(anORB))
 308     ProcessVoidEvent(new TEvent(anORB));
 309
 310   ASSERT(!CORBA::is_nil(anORB));
 311 }
 312
 313
 314 //===============================================================
 315 void
 316 SMESH_Swig::Init(int theStudyID)
 317 {
 318   class TEvent: public SALOME_Event
 319   {
 320     int                         myStudyID;
 321     SALOMEDS::Study_var&        myStudy;
 322     SALOMEDS::StudyBuilder_var& myStudyBuilder;
 323     SALOMEDS::SComponent_var&   mySComponentMesh;
 324   public:
 325     TEvent(int                         theStudyID,
 326            SALOMEDS::Study_var&        theStudy,
 327            SALOMEDS::StudyBuilder_var& theStudyBuilder,
 328            SALOMEDS::SComponent_var&   theSComponentMesh):
 329       myStudyID       (theStudyID),
 330       myStudy         (theStudy),
 331       myStudyBuilder  (theStudyBuilder),
 332       mySComponentMesh(theSComponentMesh)
 333     {}
 334
 335     ~TEvent()
 336     {
 337       if ( !mySComponentMesh->_is_nil() ) mySComponentMesh->UnRegister();
 338     }
 339
 340     virtual
 341     void
 342     Execute()
 343     {
 344       SUIT_Session* aSession          = SUIT_Session::session();
 345       SUIT_Application* anApplication = aSession->activeApplication();
 346       SalomeApp_Application* anApp    = dynamic_cast<SalomeApp_Application*>(anApplication);
 347
 348       SALOME_NamingService* aNamingService = anApp->namingService();
 349       CORBA::Object_var anObject           = aNamingService->Resolve("/myStudyManager");
 350       SALOMEDS::StudyManager_var aStudyMgr = SALOMEDS::StudyManager::_narrow(anObject);
 351       myStudy = aStudyMgr->GetStudyByID(myStudyID);
 352
 353       SMESH::SMESH_Gen_var aSMESHGen = SMESHGUI::GetSMESHGen();
 354       aSMESHGen->SetCurrentStudy( myStudy.in() );
 355
 356       myStudyBuilder = myStudy->NewBuilder();
 357
 358       SALOMEDS::GenericAttribute_var anAttr;
 359       SALOMEDS::AttributeName_var    aName;
 360       SALOMEDS::AttributePixMap_var  aPixmap;
 361
 362       SALOMEDS::SComponent_var aSComponent = myStudy->FindComponent("SMESH");
 363       if ( aSComponent->_is_nil() )
 364       {
 365         bool aLocked = myStudy->GetProperties()->IsLocked();
 366         if (aLocked)
 367           myStudy->GetProperties()->SetLocked(false);
 368
 369         SMESHGUI* aSMESHGUI = SMESHGUI::GetSMESHGUI();
 370         //SRN: BugID IPAL9186, load a SMESH gui if it hasn't been loaded
 371         if (!aSMESHGUI) {
 372           CAM_Module* aModule = anApp->module("Mesh");
 373           if(!aModule)
 374             aModule = anApp->loadModule("Mesh");
 375           aSMESHGUI = dynamic_cast<SMESHGUI*>(aModule);
 376         } //SRN: BugID IPAL9186: end of a fix
 377
 378         aSComponent = myStudyBuilder->NewComponent("SMESH");
 379
 380         anAttr = myStudyBuilder->FindOrCreateAttribute(aSComponent,"AttributeName");
 381         aName  = SALOMEDS::AttributeName::_narrow(anAttr);
 382         aName->SetValue(aSMESHGUI->moduleName().toLatin1().data());
 383         aName->UnRegister();
 384
 385         anAttr = myStudyBuilder->FindOrCreateAttribute(aSComponent,"AttributePixMap");
 386         aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 387         aPixmap->SetPixMap( "ICON_OBJBROWSER_SMESH" );
 388         aPixmap->UnRegister();
 389
 390         SALOMEDS::UseCaseBuilder_var useCaseBuilder = myStudy->GetUseCaseBuilder();
 391         useCaseBuilder->SetRootCurrent();
 392         useCaseBuilder->Append( aSComponent.in() );
 393
 394         myStudyBuilder->DefineComponentInstance(aSComponent,aSMESHGen);
 395         if (aLocked)
 396           myStudy->GetProperties()->SetLocked(true);
 397       }
 398
 399       mySComponentMesh = SALOMEDS::SComponent::_narrow(aSComponent);
 400
 401       qApp->processEvents(); // Workaround for bug 12662
 402     }
 403   };
 404
 405   MESSAGE("Init");
 406
 407   ProcessVoidEvent(new TEvent(theStudyID,
 408                               myStudy,
 409                               myStudyBuilder,
 410                               mySComponentMesh));
 411 }
 412
 413
 414 //===============================================================
 415 SMESH_Swig::~SMESH_Swig()
 416 {
 417   MESSAGE("Destructeur");
 418 }
 419
 420
 421 //===============================================================
 422 const char* SMESH_Swig::AddNewMesh(const char* theIOR)
 423 {
 424   MESSAGE("AddNewMesh");
 425
 426   // VSR: added temporarily - to be removed - objects are published automatically by engine
 427   SALOMEDS::SObject_var aSObject = myStudy->FindObjectIOR(theIOR);
 428   if (aSObject->_is_nil())
 429   {
 430     //Find or Create Hypothesis root
 431     SALOMEDS::SObject_var hroot = GetHypothesisRoot(mySComponentMesh,myStudyBuilder);
 432     SALOMEDS::SObject_var aroot = GetAlgorithmsRoot(mySComponentMesh,myStudyBuilder);
 433     hroot->UnRegister();
 434     aroot->UnRegister();
 435
 436     // Add New Mesh
 437     aSObject = myStudyBuilder->NewObject(mySComponentMesh);
 438     SALOMEDS::GenericAttribute_var anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject,"AttributePixMap");
 439     SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
 440     aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH" );
 441     aPixmap->UnRegister();
 442
 443     anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject, "AttributeIOR");
 444     SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 445     anIOR->SetValue(theIOR);
 446     anIOR->UnRegister();
 447   }
 448
 449   CORBA::String_var anEntry = aSObject->GetID();
 450   aSObject->UnRegister();
 451
 452   return anEntry._retn();
 453 }
 454
 455
 456 //===============================================================
 457 const char* SMESH_Swig::AddNewHypothesis(const char* theIOR)
 458 {
 459   MESSAGE("AddNewHypothesis");
 460
 461   SALOMEDS::SObject_var aSObject = ::AddHypothesis(theIOR,
 462                                                    mySComponentMesh,
 463                                                    myStudyBuilder);
 464   CORBA::String_var anEntry = aSObject->GetID();
 465   aSObject->UnRegister();
 466
 467   return anEntry._retn();
 468 }
 469
 470
 471 //===============================================================
 472 const char* SMESH_Swig::AddNewAlgorithms(const char* theIOR)
 473 {
 474   MESSAGE("AddNewAlgorithms");
 475
 476   SALOMEDS::SObject_var aSObject = ::AddAlgorithms(theIOR,
 477                                                    mySComponentMesh,
 478                                                    myStudyBuilder);
 479   CORBA::String_var anEntry = aSObject->GetID();
 480   aSObject->UnRegister();
 481
 482   return anEntry._retn();
 483 }
 484
 485
 486 //===============================================================
 487 void SMESH_Swig::SetShape(const char* theShapeEntry,
 488                           const char* theMeshEntry)
 489 {
 490   SALOMEDS::SObject_var aGeomShapeSO = myStudy->FindObjectID( theShapeEntry );
 491   SALOMEDS::SObject_var      aMeshSO = myStudy->FindObjectID( theMeshEntry );
 492
 493   if(!aMeshSO->_is_nil() && !aGeomShapeSO->_is_nil()){
 494     SALOMEDS::SObject_var aSObject = myStudyBuilder->NewObjectToTag(aMeshSO, SMESH::Tag_RefOnShape);
 495     myStudyBuilder->Addreference(aSObject,aGeomShapeSO);
 496     aSObject->UnRegister();
 497   }
 498   if ( !aMeshSO->_is_nil() )      aMeshSO->UnRegister();
 499   if ( !aGeomShapeSO->_is_nil() ) aGeomShapeSO->UnRegister();
 500 }
 501
 502
 503 //===============================================================
 504 void SMESH_Swig::SetHypothesis(const char* theMeshOrSubMeshEntry,
 505                                const char* theDomainEntry)
 506 {
 507   ::SetHypothesis(theMeshOrSubMeshEntry,
 508                   theDomainEntry,
 509                   myStudy,
 510                   myStudyBuilder);
 511 }
 512
 513
 514 //===============================================================
 515 void SMESH_Swig::SetAlgorithms(const char* theMeshOrSubMeshEntry,
 516                                const char* theDomainEntry)
 517 {
 518   ::SetAlgorithms(theMeshOrSubMeshEntry,
 519                   theDomainEntry,
 520                   myStudy,
 521                   myStudyBuilder);
 522 }
 523
 524
 525 //===============================================================
 526 void
 527 SMESH_Swig::UnSetHypothesis(const char* theDomainEntry)
 528 {
 529   SALOMEDS::SObject_var aDomainSO = myStudy->FindObjectID(theDomainEntry);
 530   if(!aDomainSO->_is_nil())
 531     myStudyBuilder->RemoveObject(aDomainSO);
 532 }
 533
 534 const char* SMESH_Swig::AddSubMesh(const char* theMeshEntry,
 535                                    const char* theSubMeshIOR,
 536                                    int theShapeType)
 537 {
 538   SALOMEDS::SObject_var aMeshSO = myStudy->FindObjectID(theMeshEntry);
 539   if(!aMeshSO->_is_nil()) {
 540     long aShapeTag;
 541     QString aSubMeshName;
 542     switch(theShapeType) {
 543     case TopAbs_SOLID:
 544       aShapeTag    = SMESH::Tag_SubMeshOnSolid;
 545       aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnSolid");
 546       break;
 547     case TopAbs_FACE:
 548       aShapeTag    = SMESH::Tag_SubMeshOnFace;
 549       aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnFace");
 550       break;
 551     case TopAbs_EDGE:
 552       aShapeTag    = SMESH::Tag_SubMeshOnEdge;
 553       aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnEdge");
 554       break;
 555     case TopAbs_VERTEX:
 556       aShapeTag    = SMESH::Tag_SubMeshOnVertex;
 557       aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnVertex");
 558       break;
 559     default:
 560       aShapeTag    = SMESH::Tag_SubMeshOnCompound;
 561       aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnCompound");
 562     }
 563
 564     SALOMEDS::GenericAttribute_var anAttr;
 565     SALOMEDS::SObject_var aSubMeshesRoot;
 566     if ( !aMeshSO->FindSubObject( aShapeTag, aSubMeshesRoot ) )
 567     {
 568       aSubMeshesRoot = myStudyBuilder->NewObjectToTag(aMeshSO,aShapeTag);
 569       anAttr = myStudyBuilder->FindOrCreateAttribute(aSubMeshesRoot,"AttributeName");
 570       SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
 571       aName->SetValue(aSubMeshName.toLatin1().data());
 572       aName->UnRegister();
 573       anAttr = myStudyBuilder->FindOrCreateAttribute(aSubMeshesRoot,"AttributeSelectable");
 574       SALOMEDS::AttributeSelectable_var aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
 575       aSelAttr->SetSelectable(false);
 576       aSelAttr->UnRegister();
 577     }
 578     aSubMeshesRoot->UnRegister();
 579     aMeshSO->UnRegister();
 580
 581     SALOMEDS::SObject_var aSObject = myStudyBuilder->NewObject(aSubMeshesRoot);
 582     anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject,"AttributeIOR");
 583     SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
 584     anIOR->SetValue(theSubMeshIOR);
 585     anIOR->UnRegister();
 586
 587     CORBA::String_var aString = aSObject->GetID();
 588     aSObject->UnRegister();
 589
 590     return aString._retn();
 591   }
 592
 593   return "";
 594 }
 595
 596 const char* SMESH_Swig::AddSubMeshOnShape(const char* theMeshEntry,
 597                                           const char* theGeomShapeEntry,
 598                                           const char* theSubMeshIOR,
 599                                           int         ShapeType)
 600 {
 601   SALOMEDS::SObject_var aGeomShapeSO = myStudy->FindObjectID(theGeomShapeEntry);
 602   if(!aGeomShapeSO->_is_nil())
 603   {
 604     const char *       aSubMeshEntry = AddSubMesh(theMeshEntry,theSubMeshIOR,ShapeType);
 605     SALOMEDS::SObject_var aSubMeshSO = myStudy->FindObjectID(aSubMeshEntry);
 606     if ( !aSubMeshSO->_is_nil()) {
 607       SetShape( theGeomShapeEntry, aSubMeshEntry );
 608       CORBA::String_var aString = aSubMeshSO->GetID();
 609       aSubMeshSO->UnRegister();
 610       return aString._retn();
 611     }
 612     aGeomShapeSO->UnRegister();
 613   }
 614
 615   return "";
 616 }
 617
 618 void SMESH_Swig::CreateAndDisplayActor( const char* Mesh_Entry )
 619 {
 620   //  SMESH_Actor* Mesh = smeshGUI->ReadScript(aM);
 621   class TEvent: public SALOME_Event
 622   {
 623   private:
 624     const char* _entry;
 625   public:
 626     TEvent(const char* Mesh_Entry) {
 627       _entry = Mesh_Entry;
 628     }
 629     virtual void Execute() {
 630       //SMESH::UpdateView(SMESH::eDisplay, _entry);
 631       SUIT_Session* aSession          = SUIT_Session::session();
 632       SUIT_Application* anApplication = aSession->activeApplication();
 633       SalomeApp_Application* anApp    = dynamic_cast<SalomeApp_Application*>(anApplication);
 634       /*SUIT_ViewManager* vman        = */anApp->getViewManager(VTKViewer_Viewer::Type(),true);
 635       SMESHGUI_Displayer* aDisp       = new SMESHGUI_Displayer(anApp);
 636       aDisp->Display(_entry,1);
 637     }
 638   };
 639
 640   ProcessVoidEvent(new TEvent(Mesh_Entry));
 641 }
 642
 643 void SMESH_Swig::EraseActor( const char* Mesh_Entry, const bool allViewers )
 644 {
 645   class TEvent: public SALOME_Event
 646   {
 647   private:
 648     const char* _entry;
 649     bool        _allViewers;
 650   public:
 651     TEvent(const char* Mesh_Entry, const bool allViewers ) {
 652       _entry = Mesh_Entry;
 653       _allViewers = allViewers;
 654     }
 655     virtual void Execute() {
 656       SUIT_Session* aSession          = SUIT_Session::session();
 657       SUIT_Application* anApplication = aSession->activeApplication();
 658       SalomeApp_Application* anApp    = dynamic_cast<SalomeApp_Application*>(anApplication);
 659       SMESHGUI_Displayer* aDisp       = new SMESHGUI_Displayer(anApp);
 660       ViewManagerList aManagers;
 661       if ( !_allViewers ) {
 662         aManagers << anApp->activeViewManager();
 663       }
 664       else {
 665         aManagers = anApp->viewManagers();
 666       }
 667       foreach( SUIT_ViewManager* aMgr, aManagers ) {
 668         if ( aMgr && aMgr->getType() == VTKViewer_Viewer::Type() ) {
 669           SALOME_View* aSalomeView = dynamic_cast<SALOME_View*>(aMgr->getViewModel());
 670           if (aSalomeView) {
 671             aDisp->Erase(_entry,true, true, aSalomeView);
 672           }
 673         }
 674       }
 675     }
 676   };
 677
 678   ProcessVoidEvent(new TEvent(Mesh_Entry, allViewers));
 679 }
 680
 681 void SMESH_Swig::SetName(const char* theEntry,
 682                          const char* theName)
 683 {
 684   SALOMEDS::SObject_var aSObject = myStudy->FindObjectID(theEntry);
 685   SALOMEDS::GenericAttribute_var anAttr;
 686   SALOMEDS::AttributeName_var aName;
 687   if(!aSObject->_is_nil()){
 688     anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject,"AttributeName");
 689     aName = SALOMEDS::AttributeName::_narrow(anAttr);
 690     aName->SetValue(theName);
 691     aName->UnRegister();
 692     aSObject->UnRegister();
 693   }
 694 }
 695
 696 //================================================================================
 697 /*!
 698  * \brief Set mesh icon according to compute status
 699   * \param Mesh_Entry - entry of a mesh
 700   * \param isComputed - is mesh computed or not
 701  */
 702 //================================================================================
 703
 704 void SMESH_Swig::SetMeshIcon(const char* theMeshEntry,
 705                              const bool  theIsComputed,
 706                              const bool  isEmpty)
 707 {
 708   class TEvent: public SALOME_Event
 709   {
 710     SALOMEDS::Study_var myStudy;
 711     std::string         myMeshEntry;
 712     bool                myIsComputed, myIsEmpty;
 713   public:
 714     TEvent(const SALOMEDS::Study_var& theStudy,
 715            const std::string&         theMeshEntry,
 716            const bool                 theIsComputed,
 717            const bool                 isEmpty):
 718       myStudy     (theStudy),
 719       myMeshEntry (theMeshEntry),
 720       myIsComputed(theIsComputed),
 721       myIsEmpty   (isEmpty)
 722     {}
 723
 724     virtual
 725     void
 726     Execute()
 727     {
 728       SALOMEDS::SObject_ptr aMeshSO = myStudy->FindObjectID(myMeshEntry.c_str());
 729       if(_PTR(SObject) aMesh = ClientFactory::SObject(aMeshSO))
 730         SMESH::ModifiedMesh(aMesh,myIsComputed,myIsEmpty);
 731       // aMeshSO->UnRegister();  ~aMesh() already called UnRegister()!
 732     }
 733   };
 734
 735   ProcessVoidEvent(new TEvent(myStudy,
 736                               theMeshEntry,
 737                               theIsComputed,
 738                               isEmpty));
 739 }
 740
 741 /*!
 742   \brief Helper class for selection event.
 743 */
 744 class TSelectListEvent: public SALOME_Event
 745 {
 746   const char*       myId;
 747   std::vector<int>  myIdsList;
 748   bool              myIsAppend;
 749
 750 public:
 751   TSelectListEvent(const char* id, std::vector<int> ids, bool append) :
 752     myId(id),
 753     myIdsList(ids),
 754     myIsAppend(append)
 755   {}
 756   virtual void Execute()
 757   {
 758     SMESHGUI* aSMESHGUI = SMESHGUI::GetSMESHGUI();
 759     if( !aSMESHGUI )
 760       return;
 761
 762     LightApp_SelectionMgr* selMgr = SMESH::GetSelectionMgr( aSMESHGUI );
 763     if( !selMgr )
 764       return;
 765
 766     selMgr->clearFilters();
 767
 768     SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aSMESHGUI );
 769     if(!aViewWindow)
 770       return;
 771
 772     SMESH_Actor* anActor = SMESH::FindActorByEntry( myId );
 773
 774     if (!anActor || !anActor->hasIO())
 775       return;
 776
 777     Handle(SALOME_InteractiveObject) anIO = anActor->getIO();
 778     SALOME_ListIO aList;
 779     aList.Append(anIO);
 780     selMgr->setSelectedObjects(aList, false);
 781
 782     if ( aViewWindow->SelectionMode() ==  ActorSelection ) {
 783       return;
 784     }
 785
 786     TColStd_MapOfInteger aMap;
 787     std::vector<int>::const_iterator anIter;
 788     for (anIter = myIdsList.begin(); anIter != myIdsList.end(); ++anIter) {
 789       aMap.Add(*anIter);
 790     }
 791
 792     // Set new selection
 793     SVTK_Selector* aSelector  = aViewWindow->GetSelector();
 794     aSelector->AddOrRemoveIndex(anIO, aMap, myIsAppend);
 795     aViewWindow->highlight( anIO, true, true );
 796     aViewWindow->GetInteractor()->onEmitSelectionChanged();
 797   }
 798 };
 799
 800 /*!
 801   \brief Select the elements on the mesh, sub-mesh or group.
 802   \param id object entry
 803   \param ids list of the element ids
 804   \param mode selection mode
 805 */
 806 void SMESH_Swig::select( const char* id, std::vector<int> ids, bool append ) {
 807   ProcessVoidEvent( new TSelectListEvent( id, ids, append ) );
 808 }
 809
 810 /*!
 811   \brief Select the elements on the mesh, sub-mesh or group.
 812   \param id object entry
 813   \param id id of the element
 814   \param mode selection mode
 815 */
 816 void SMESH_Swig::select( const char* id, int id1, bool append ) {
 817   std::vector<int> ids;
 818   ids.push_back( id1 );
 819   ProcessVoidEvent( new TSelectListEvent( id, ids, append ) );
 820 }
 821
 822
 823 class TGetSelectionModeEvent : public SALOME_Event
 824 {
 825 public:
 826   typedef int TResult;
 827   TResult myResult;
 828   TGetSelectionModeEvent() : myResult( -1 ) {}
 829   virtual void Execute()
 830   {
 831     SMESHGUI* aSMESHGUI = SMESHGUI::GetSMESHGUI();
 832     if( !aSMESHGUI )
 833       return;
 834
 835     SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aSMESHGUI );
 836     if(!aViewWindow)
 837       return;
 838
 839     myResult = aViewWindow->SelectionMode();
 840   }
 841 };
 842
 843 /*!
 844   \brief Get selection mode of the active VTK View window.
 845 */
 846 int SMESH_Swig::getSelectionMode() {
 847   return ProcessEvent( new TGetSelectionModeEvent() );
 848 }