smesh/src/SMESH_SWIG_WITHIHM/libSMESH_Swig.cxx

// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//

// SMESH SMESH : GUI for SMESH component
// File   : libSMESH_Swig.cxx
// Author : Nicolas REJNERI, Open CASCADE S.A.S.
// SMESH includes
//
#include "libSMESH_Swig.h"

#include <SVTK_Selector.h>

#include <SMESHGUI.h>
#include <SMESHGUI_Utils.h>
#include <SMESHGUI_Displayer.h>
#include <SMESHGUI_VTKUtils.h>
#include <SMESH_Actor.h>

// SALOME KERNEL includes
#include <Utils_ORB_INIT.hxx>
#include <Utils_SINGLETON.hxx>
#include <SALOMEDSClient_ClientFactory.hxx>

#include <utilities.h>

// SALOME GUI includes
#include <SUIT_Session.h>
#include <SUIT_ViewManager.h>
#include <SALOME_Prs.h>
#include <SUIT_ViewWindow.h>
#include <SVTK_ViewWindow.h>
#include <VTKViewer_ViewModel.h>
#include <SALOME_Event.h>
#include <SalomeApp_Application.h>
#include <LightApp_SelectionMgr.h>
#include <SVTK_RenderWindowInteractor.h>
#include <VTKViewer_Algorithm.h>

// OCCT includes
#include <TopAbs.hxx>
#include <TColStd_MapOfInteger.hxx>

// Qt includes
#include <QApplication>

// IDL includes
#include <SALOMEconfig.h>
#include CORBA_SERVER_HEADER(SMESH_Gen)
#include CORBA_SERVER_HEADER(SMESH_Hypothesis)

// VTK includes
#include <vtkActorCollection.h>
#include <vtkRenderer.h>

static CORBA::ORB_var anORB;

namespace
{
  //---------------------------------------------------------------
  inline
  CORBA::Object_var
  StringToObject(const std::string& theIOR)
  {
    return anORB->string_to_object(theIOR.c_str());
  }


  //---------------------------------------------------------------
  inline
  SALOMEDS::SObject_var
  GetDomainRoot(const SALOMEDS::SComponent_var& theSComponentMesh,
                const SALOMEDS::StudyBuilder_var& theStudyBuilder,
                CORBA::Long theDomainRootTag,
                const QString& theName,
                const QString& thePixmap)
  {
    SALOMEDS::SObject_var aDomainRoot;
    if (!theSComponentMesh->FindSubObject(theDomainRootTag,aDomainRoot)) {
      aDomainRoot = theStudyBuilder->NewObjectToTag(theSComponentMesh,theDomainRootTag);
      SALOMEDS::GenericAttribute_var anAttr = theStudyBuilder->FindOrCreateAttribute(aDomainRoot,"AttributeName");
      SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
      aName->SetValue(theName.toLatin1().data());
      aName->UnRegister();
      anAttr = theStudyBuilder->FindOrCreateAttribute(aDomainRoot,"AttributePixMap");
      SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
      aPixmap->SetPixMap(thePixmap.toLatin1().data());
      aPixmap->UnRegister();
      anAttr = theStudyBuilder->FindOrCreateAttribute(aDomainRoot,"AttributeSelectable");
      SALOMEDS::AttributeSelectable_var aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
      aSelAttr->SetSelectable(false);
      aSelAttr->UnRegister();
    }

    return aDomainRoot;
  }


  //---------------------------------------------------------------
  inline
  SALOMEDS::SObject_var
  GetHypothesisRoot(const SALOMEDS::SComponent_var& theSComponentMesh,
                    const SALOMEDS::StudyBuilder_var& theStudyBuilder)
  {
    return GetDomainRoot(theSComponentMesh,
                         theStudyBuilder,
                         SMESH::Tag_HypothesisRoot,
                         QObject::tr("SMESH_MEN_HYPOTHESIS"),
                         "ICON_SMESH_TREE_HYPO");
  }


  //---------------------------------------------------------------
  inline
  SALOMEDS::SObject_var
  GetAlgorithmsRoot(const SALOMEDS::SComponent_var& theSComponentMesh,
                    const SALOMEDS::StudyBuilder_var& theStudyBuilder)
  {
    return GetDomainRoot(theSComponentMesh,
                         theStudyBuilder,
                         SMESH::Tag_AlgorithmsRoot,
                         QObject::tr("SMESH_MEN_ALGORITHMS"),
                         "ICON_SMESH_TREE_ALGO");
  }


  //---------------------------------------------------------------
  inline
  SALOMEDS::SObject_var
  AddToDomain(const std::string&                theIOR,
              const SALOMEDS::SComponent_var&   theSComponentMesh,
              const SALOMEDS::StudyBuilder_var& theStudyBuilder,
              CORBA::Long                       theDomainRootTag,
              const QString&                    theDomainName,
              const QString&                    theDomainPixmap)
  {
    SALOMEDS::SObject_var aDomain = GetDomainRoot(theSComponentMesh,
                                                  theStudyBuilder,
                                                  SMESH::Tag_AlgorithmsRoot,
                                                  theDomainName,
                                                  theDomainPixmap);
    // Add New Hypothesis
    SALOMEDS::SObject_var aSObject = theStudyBuilder->NewObject(aDomain);
    aDomain->UnRegister();
    SALOMEDS::GenericAttribute_var anAttr = theStudyBuilder->FindOrCreateAttribute(aSObject,"AttributePixMap");
    SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
    CORBA::Object_var anObject = StringToObject(theIOR);
    SMESH::SMESH_Hypothesis_var aDomainItem = SMESH::SMESH_Hypothesis::_narrow(anObject.in());
    CORBA::String_var aType = aDomainItem->GetName();
    QString aPixmapName = theDomainPixmap + "_" + aType.in();
    aPixmap->SetPixMap(aPixmapName.toLatin1().data());
    aPixmap->UnRegister();
    anAttr = theStudyBuilder->FindOrCreateAttribute(aSObject,"AttributeIOR");
    SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
    anIOR->SetValue(theIOR.c_str());
    anIOR->UnRegister();

    return aSObject;
  }


  //---------------------------------------------------------------
  SALOMEDS::SObject_var
  AddHypothesis(const std::string& theIOR,
                const SALOMEDS::SComponent_var& theSComponentMesh,
                const SALOMEDS::StudyBuilder_var& theStudyBuilder)
  {
    return AddToDomain(theIOR,
                       theSComponentMesh,
                       theStudyBuilder,
                       SMESH::Tag_HypothesisRoot,
                       QObject::tr("SMESH_MEN_HYPOTHESIS"),
                       "ICON_SMESH_TREE_HYPO");
  }


  //---------------------------------------------------------------
  SALOMEDS::SObject_var
  AddAlgorithms(const std::string& theIOR,
                const SALOMEDS::SComponent_var& theSComponentMesh,
                const SALOMEDS::StudyBuilder_var& theStudyBuilder)
  {
    return AddToDomain(theIOR,
                       theSComponentMesh,
                       theStudyBuilder,
                       SMESH::Tag_AlgorithmsRoot,
                       QObject::tr("SMESH_MEN_ALGORITHMS"),
                       "ICON_SMESH_TREE_ALGO");
  }


  //---------------------------------------------------------------
  void
  SetDomain(const char*                       theMeshOrSubMeshEntry,
            const char*                       theDomainEntry,
            const SALOMEDS::Study_var&        theStudy,
            const SALOMEDS::StudyBuilder_var& theStudyBuilder,
            long                              theRefOnAppliedDomainTag,
            const QString&                    theAppliedDomainMEN,
            const QString&                    theAppliedDomainICON)
  {
    SALOMEDS::SObject_var aMeshOrSubMeshSO = theStudy->FindObjectID(theMeshOrSubMeshEntry);
    SALOMEDS::SObject_var    aHypothesisSO = theStudy->FindObjectID(theDomainEntry);

    if(!aMeshOrSubMeshSO->_is_nil() && !aHypothesisSO->_is_nil()){
      //Find or Create Applied Hypothesis root
      SALOMEDS::SObject_var anAppliedDomainSO;
      if( !aMeshOrSubMeshSO->FindSubObject( theRefOnAppliedDomainTag, anAppliedDomainSO ))
      {
        anAppliedDomainSO = theStudyBuilder->NewObjectToTag(aMeshOrSubMeshSO,theRefOnAppliedDomainTag);
        SALOMEDS::GenericAttribute_var anAttr =
          theStudyBuilder->FindOrCreateAttribute(anAppliedDomainSO,"AttributeName");
        SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
        aName->SetValue(theAppliedDomainMEN.toLatin1().data());
        aName->UnRegister();
        anAttr = theStudyBuilder->FindOrCreateAttribute(anAppliedDomainSO,"AttributeSelectable");
        SALOMEDS::AttributeSelectable_var aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
        aSelAttr->SetSelectable(false);
        aSelAttr->UnRegister();
        anAttr = theStudyBuilder->FindOrCreateAttribute(anAppliedDomainSO,"AttributePixMap");
        SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
        aPixmap->SetPixMap(theAppliedDomainICON.toLatin1().data());
        aPixmap->UnRegister();
      }
      SALOMEDS::SObject_var aSObject = theStudyBuilder->NewObject(anAppliedDomainSO);
      theStudyBuilder->Addreference(aSObject,aHypothesisSO);
      aSObject->UnRegister();
      anAppliedDomainSO->UnRegister();
    }
    if ( !aMeshOrSubMeshSO->_is_nil() ) aMeshOrSubMeshSO->UnRegister();
    if ( !aHypothesisSO->_is_nil())     aHypothesisSO->UnRegister();
  }


  //---------------------------------------------------------------
  void
  SetHypothesis(const char*                       theMeshOrSubMeshEntry,
                const char*                       theDomainEntry,
                const SALOMEDS::Study_var&        theStudy,
                const SALOMEDS::StudyBuilder_var& theStudyBuilder)
  {
    SetDomain(theMeshOrSubMeshEntry,
              theDomainEntry,
              theStudy,
              theStudyBuilder,
              SMESH::Tag_RefOnAppliedHypothesis,
              QObject::tr("SMESH_MEN_APPLIED_HYPOTHESIS"),
              "ICON_SMESH_TREE_HYPO");
  }


  //---------------------------------------------------------------
  void
  SetAlgorithms(const char*                       theMeshOrSubMeshEntry,
                const char*                       theDomainEntry,
                const SALOMEDS::Study_var&        theStudy,
                const SALOMEDS::StudyBuilder_var& theStudyBuilder)
  {
    SetDomain(theMeshOrSubMeshEntry,
              theDomainEntry,
              theStudy,
              theStudyBuilder,
              SMESH::Tag_RefOnAppliedAlgorithms,
              QObject::tr("SMESH_MEN_APPLIED_ALGORIHTMS"),
              "ICON_SMESH_TREE_ALGO");
  }
}


//===============================================================
SMESH_Swig::SMESH_Swig()
{
  class TEvent: public SALOME_Event
  {
    CORBA::ORB_var& myORB;
  public:

    TEvent(CORBA::ORB_var& theORB):
      myORB(theORB)
    {}

    virtual
    void
    Execute()
    {
      try {
        ORB_INIT &anORBInit = *SINGLETON_<ORB_INIT>::Instance();
        ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
        myORB = anORBInit( 0, 0 );
      } catch (...) {
        INFOS("internal error : orb not found");
      }
    }
  };

  //MESSAGE("Constructeur");

  if(CORBA::is_nil(anORB))
    ProcessVoidEvent(new TEvent(anORB));

  ASSERT(!CORBA::is_nil(anORB));
}


//===============================================================
void
SMESH_Swig::Init(int theStudyID)
{
  class TEvent: public SALOME_Event
  {
    int                         myStudyID;
    SALOMEDS::Study_var&        myStudy;
    SALOMEDS::StudyBuilder_var& myStudyBuilder;
    SALOMEDS::SComponent_var&   mySComponentMesh;
  public:
    TEvent(int                         theStudyID,
           SALOMEDS::Study_var&        theStudy,
           SALOMEDS::StudyBuilder_var& theStudyBuilder,
           SALOMEDS::SComponent_var&   theSComponentMesh):
      myStudyID       (theStudyID),
      myStudy         (theStudy),
      myStudyBuilder  (theStudyBuilder),
      mySComponentMesh(theSComponentMesh)
    {}

    ~TEvent()
    {
      if ( !mySComponentMesh->_is_nil() ) mySComponentMesh->UnRegister();
    }

    virtual
    void
    Execute()
    {
      SUIT_Session* aSession          = SUIT_Session::session();
      SUIT_Application* anApplication = aSession->activeApplication();
      SalomeApp_Application* anApp    = dynamic_cast<SalomeApp_Application*>(anApplication);

      SALOME_NamingService* aNamingService = anApp->namingService();
      CORBA::Object_var anObject           = aNamingService->Resolve("/myStudyManager");
      SALOMEDS::StudyManager_var aStudyMgr = SALOMEDS::StudyManager::_narrow(anObject);
      myStudy = aStudyMgr->GetStudyByID(myStudyID);

      SMESH::SMESH_Gen_var aSMESHGen = SMESHGUI::GetSMESHGen();
      aSMESHGen->SetCurrentStudy( myStudy.in() );

      myStudyBuilder = myStudy->NewBuilder();

      SALOMEDS::GenericAttribute_var anAttr;
      SALOMEDS::AttributeName_var    aName;
      SALOMEDS::AttributePixMap_var  aPixmap;

      SALOMEDS::SComponent_var aSComponent = myStudy->FindComponent("SMESH");
      if ( aSComponent->_is_nil() )
      {
        bool aLocked = myStudy->GetProperties()->IsLocked();
        if (aLocked)
          myStudy->GetProperties()->SetLocked(false);

        SMESHGUI* aSMESHGUI = SMESHGUI::GetSMESHGUI();
        //SRN: BugID IPAL9186, load a SMESH gui if it hasn't been loaded
        if (!aSMESHGUI) {
          CAM_Module* aModule = anApp->module("Mesh");
          if(!aModule)
            aModule = anApp->loadModule("Mesh");
          aSMESHGUI = dynamic_cast<SMESHGUI*>(aModule);
        } //SRN: BugID IPAL9186: end of a fix

        aSComponent = myStudyBuilder->NewComponent("SMESH");

        anAttr = myStudyBuilder->FindOrCreateAttribute(aSComponent,"AttributeName");
        aName  = SALOMEDS::AttributeName::_narrow(anAttr);
        aName->SetValue(aSMESHGUI->moduleName().toLatin1().data());
        aName->UnRegister();

        anAttr = myStudyBuilder->FindOrCreateAttribute(aSComponent,"AttributePixMap");
        aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
        aPixmap->SetPixMap( "ICON_OBJBROWSER_SMESH" );
        aPixmap->UnRegister();

        SALOMEDS::UseCaseBuilder_var useCaseBuilder = myStudy->GetUseCaseBuilder();
        useCaseBuilder->SetRootCurrent();
        useCaseBuilder->Append( aSComponent.in() );
  
        myStudyBuilder->DefineComponentInstance(aSComponent,aSMESHGen);
        if (aLocked)
          myStudy->GetProperties()->SetLocked(true);
      }

      mySComponentMesh = SALOMEDS::SComponent::_narrow(aSComponent);

      qApp->processEvents(); // Workaround for bug 12662
    }
  };

  //MESSAGE("Init");

  ProcessVoidEvent(new TEvent(theStudyID,
                              myStudy,
                              myStudyBuilder,
                              mySComponentMesh));
}


//===============================================================
SMESH_Swig::~SMESH_Swig()
{
  //MESSAGE("Destructeur");
}


//===============================================================
const char* SMESH_Swig::AddNewMesh(const char* theIOR)
{

  // VSR: added temporarily - to be removed - objects are published automatically by engine
  SALOMEDS::SObject_var aSObject = myStudy->FindObjectIOR(theIOR);
  if (aSObject->_is_nil())
  {
    //Find or Create Hypothesis root
    SALOMEDS::SObject_var hroot = GetHypothesisRoot(mySComponentMesh,myStudyBuilder);
    SALOMEDS::SObject_var aroot = GetAlgorithmsRoot(mySComponentMesh,myStudyBuilder);
    hroot->UnRegister();
    aroot->UnRegister();

    // Add New Mesh
    aSObject = myStudyBuilder->NewObject(mySComponentMesh);
    SALOMEDS::GenericAttribute_var anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject,"AttributePixMap");
    SALOMEDS::AttributePixMap_var aPixmap = SALOMEDS::AttributePixMap::_narrow(anAttr);
    aPixmap->SetPixMap( "ICON_SMESH_TREE_MESH" );
    aPixmap->UnRegister();

    anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject, "AttributeIOR");
    SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
    anIOR->SetValue(theIOR);
    anIOR->UnRegister();
  }

  CORBA::String_var anEntry = aSObject->GetID();
  aSObject->UnRegister();

  return anEntry._retn();
}


//===============================================================
const char* SMESH_Swig::AddNewHypothesis(const char* theIOR)
{
  SALOMEDS::SObject_var aSObject = ::AddHypothesis(theIOR,
                                                   mySComponentMesh,
                                                   myStudyBuilder);
  CORBA::String_var anEntry = aSObject->GetID();
  aSObject->UnRegister();

  return anEntry._retn();
}


//===============================================================
const char* SMESH_Swig::AddNewAlgorithms(const char* theIOR)
{
  SALOMEDS::SObject_var aSObject = ::AddAlgorithms(theIOR,
                                                   mySComponentMesh,
                                                   myStudyBuilder);
  CORBA::String_var anEntry = aSObject->GetID();
  aSObject->UnRegister();

  return anEntry._retn();
}


//===============================================================
void SMESH_Swig::SetShape(const char* theShapeEntry,
                          const char* theMeshEntry)
{
  SALOMEDS::SObject_var aGeomShapeSO = myStudy->FindObjectID( theShapeEntry );
  SALOMEDS::SObject_var      aMeshSO = myStudy->FindObjectID( theMeshEntry );

  if(!aMeshSO->_is_nil() && !aGeomShapeSO->_is_nil()){
    SALOMEDS::SObject_var aSObject = myStudyBuilder->NewObjectToTag(aMeshSO, SMESH::Tag_RefOnShape);
    myStudyBuilder->Addreference(aSObject,aGeomShapeSO);
    aSObject->UnRegister();
  }
  if ( !aMeshSO->_is_nil() )      aMeshSO->UnRegister();
  if ( !aGeomShapeSO->_is_nil() ) aGeomShapeSO->UnRegister();
}


//===============================================================
void SMESH_Swig::SetHypothesis(const char* theMeshOrSubMeshEntry,
                               const char* theDomainEntry)
{
  ::SetHypothesis(theMeshOrSubMeshEntry,
                  theDomainEntry,
                  myStudy,
                  myStudyBuilder);
}


//===============================================================
void SMESH_Swig::SetAlgorithms(const char* theMeshOrSubMeshEntry,
                               const char* theDomainEntry)
{
  ::SetAlgorithms(theMeshOrSubMeshEntry,
                  theDomainEntry,
                  myStudy,
                  myStudyBuilder);
}


//===============================================================
void
SMESH_Swig::UnSetHypothesis(const char* theDomainEntry)
{
  SALOMEDS::SObject_var aDomainSO = myStudy->FindObjectID(theDomainEntry);
  if(!aDomainSO->_is_nil())
    myStudyBuilder->RemoveObject(aDomainSO);
}

const char* SMESH_Swig::AddSubMesh(const char* theMeshEntry,
                                   const char* theSubMeshIOR,
                                   int theShapeType)
{
  SALOMEDS::SObject_var aMeshSO = myStudy->FindObjectID(theMeshEntry);
  if(!aMeshSO->_is_nil()) {
    long aShapeTag;
    QString aSubMeshName;
    switch(theShapeType) {
    case TopAbs_SOLID:
      aShapeTag    = SMESH::Tag_SubMeshOnSolid;
      aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnSolid");
      break;
    case TopAbs_FACE:
      aShapeTag    = SMESH::Tag_SubMeshOnFace;
      aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnFace");
      break;
    case TopAbs_EDGE:
      aShapeTag    = SMESH::Tag_SubMeshOnEdge;
      aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnEdge");
      break;
    case TopAbs_VERTEX:
      aShapeTag    = SMESH::Tag_SubMeshOnVertex;
      aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnVertex");
      break;
    default:
      aShapeTag    = SMESH::Tag_SubMeshOnCompound;
      aSubMeshName = QObject::tr("SMESH_MEN_SubMeshesOnCompound");
    }

    SALOMEDS::GenericAttribute_var anAttr;
    SALOMEDS::SObject_var aSubMeshesRoot;
    if ( !aMeshSO->FindSubObject( aShapeTag, aSubMeshesRoot ) )
    {
      aSubMeshesRoot = myStudyBuilder->NewObjectToTag(aMeshSO,aShapeTag);
      anAttr = myStudyBuilder->FindOrCreateAttribute(aSubMeshesRoot,"AttributeName");
      SALOMEDS::AttributeName_var aName = SALOMEDS::AttributeName::_narrow(anAttr);
      aName->SetValue(aSubMeshName.toLatin1().data());
      aName->UnRegister();
      anAttr = myStudyBuilder->FindOrCreateAttribute(aSubMeshesRoot,"AttributeSelectable");
      SALOMEDS::AttributeSelectable_var aSelAttr = SALOMEDS::AttributeSelectable::_narrow(anAttr);
      aSelAttr->SetSelectable(false);
      aSelAttr->UnRegister();
    }
    aSubMeshesRoot->UnRegister();
    aMeshSO->UnRegister();

    SALOMEDS::SObject_var aSObject = myStudyBuilder->NewObject(aSubMeshesRoot);
    anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject,"AttributeIOR");
    SALOMEDS::AttributeIOR_var anIOR = SALOMEDS::AttributeIOR::_narrow(anAttr);
    anIOR->SetValue(theSubMeshIOR);
    anIOR->UnRegister();

    CORBA::String_var aString = aSObject->GetID();
    aSObject->UnRegister();

    return aString._retn();
  }

  return "";
}

const char* SMESH_Swig::AddSubMeshOnShape(const char* theMeshEntry,
                                          const char* theGeomShapeEntry,
                                          const char* theSubMeshIOR,
                                          int         ShapeType)
{
  SALOMEDS::SObject_var aGeomShapeSO = myStudy->FindObjectID(theGeomShapeEntry);
  if(!aGeomShapeSO->_is_nil())
  {
    const char *       aSubMeshEntry = AddSubMesh(theMeshEntry,theSubMeshIOR,ShapeType);
    SALOMEDS::SObject_var aSubMeshSO = myStudy->FindObjectID(aSubMeshEntry);
    if ( !aSubMeshSO->_is_nil()) {
      SetShape( theGeomShapeEntry, aSubMeshEntry );
      CORBA::String_var aString = aSubMeshSO->GetID();
      aSubMeshSO->UnRegister();
      return aString._retn();
    }
    aGeomShapeSO->UnRegister();
  }

  return "";
}

/*!
  \brief Gets window with specified identifier
  \internal
  \param id window identifier
  \return pointer on the window
*/

SUIT_ViewWindow* getWnd( const int id )
{
  SUIT_ViewWindow* resWnd = 0;
  SUIT_Session* aSession          = SUIT_Session::session();
  SUIT_Application* anApplication = aSession->activeApplication();
  SalomeApp_Application* app    = dynamic_cast<SalomeApp_Application*>(anApplication);
  if ( app ) {
    ViewManagerList vmlist = app->viewManagers();
    foreach( SUIT_ViewManager* vm, vmlist ) {
      QVector<SUIT_ViewWindow*> vwlist = vm->getViews();
      foreach ( SUIT_ViewWindow* vw, vwlist ) {
        if ( id == vw->getId() ) {
          resWnd = vw;
          break;
        }
      }
    }
  }
  return resWnd;
}

class TGetActorAspect: public SALOME_Event
{
public:
  typedef actorAspect TResult;
  TResult myResult;
  const char* _entry;
  int _wid;
  TGetActorAspect( const char* Mesh_Entry, int viewId )
  {
    _entry = Mesh_Entry;
    _wid = viewId;
  }
  virtual void Execute()
    {
      SMESH_Actor* anActor;
      if (_wid)
        {
          SUIT_ViewWindow* w = getWnd(_wid);
          anActor = SMESH::FindActorByEntry( w, _entry );
        }
      else
        anActor = SMESH::FindActorByEntry( _entry );
      if ( !anActor )
        {
          MESSAGE("GetActorAspect: no actor corresponding to: " << _entry);
          return;
        }
      anActor->GetSufaceColor(myResult.surfaceColor.r,
                              myResult.surfaceColor.g,
                              myResult.surfaceColor.b,
                              myResult.surfaceColor.delta);
      anActor->GetVolumeColor(myResult.volumeColor.r,
                              myResult.volumeColor.g,
                              myResult.volumeColor.b,
                              myResult.volumeColor.delta);
      anActor->GetEdgeColor(myResult.edgeColor.r,
                            myResult.edgeColor.g,
                            myResult.edgeColor.b);
      anActor->GetNodeColor(myResult.nodeColor.r,
                            myResult.nodeColor.g,
                            myResult.nodeColor.b);
      myResult.opacity= anActor->GetOpacity();
      MESSAGE("opacity: " << myResult.opacity);
    }
};

actorAspect SMESH_Swig::GetActorAspect( const char* Mesh_Entry, int viewId )
{
  return ProcessEvent(new TGetActorAspect( Mesh_Entry, viewId));
}

void SMESH_Swig::SetActorAspect( const actorAspect& actorPres, const char* Mesh_Entry, int viewId )
{
  class TSetActorAspect: public SALOME_Event
  {
  public:
    const char* _entry;
    actorAspect _actorPres;
    int _wid;
    TSetActorAspect(const actorAspect& actorPres, const char* Mesh_Entry, int viewId )
    {
      _entry = Mesh_Entry;
      _actorPres = actorPres;
      _wid = viewId;
    }
    virtual void Execute()
    {
      SMESH_Actor* anActor;
      if (_wid)
        {
          SUIT_ViewWindow* w = getWnd(_wid);
          anActor = SMESH::FindActorByEntry( w, _entry );
        }
      else
        anActor = SMESH::FindActorByEntry( _entry );
      if ( !anActor )
        {
          MESSAGE("SetActorAspect: no actor corresponding to: " << _entry);
          return;
        }
      anActor->SetSufaceColor(_actorPres.surfaceColor.r,
                              _actorPres.surfaceColor.g,
                              _actorPres.surfaceColor.b,
                              _actorPres.surfaceColor.delta);
      anActor->SetVolumeColor(_actorPres.volumeColor.r,
                              _actorPres.volumeColor.g,
                              _actorPres.volumeColor.b,
                              _actorPres.volumeColor.delta);
      anActor->SetEdgeColor(_actorPres.edgeColor.r,
                            _actorPres.edgeColor.g,
                            _actorPres.edgeColor.b);
      anActor->SetNodeColor(_actorPres.nodeColor.r,
                            _actorPres.nodeColor.g,
                            _actorPres.nodeColor.b);
      anActor->SetOpacity(_actorPres.opacity);
      if (_wid)
        {
          SUIT_ViewWindow* w = getWnd(_wid);
          w->repaint();
        }
      else
        {
          SUIT_Session* aSession          = SUIT_Session::session();
          SUIT_Application* anApplication = aSession->activeApplication();
          SalomeApp_Application* anApp    = dynamic_cast<SalomeApp_Application*>(anApplication);
          SUIT_ViewManager* vman          = anApp->getViewManager(VTKViewer_Viewer::Type(),true);
          vman->getActiveView()->repaint();
        }
    }
  };

  ProcessVoidEvent(new TSetActorAspect(actorPres, Mesh_Entry, viewId));
}

void SMESH_Swig::CreateAndDisplayActor( const char* Mesh_Entry )
{
  //  SMESH_Actor* Mesh = smeshGUI->ReadScript(aM);
  class TEvent: public SALOME_Event
  {
  private:
    const char* _entry;
  public:
    TEvent(const char* Mesh_Entry) {
      _entry = Mesh_Entry;
    }
    virtual void Execute() {
      //SMESH::UpdateView(SMESH::eDisplay, _entry);
      SUIT_Session* aSession          = SUIT_Session::session();
      SUIT_Application* anApplication = aSession->activeApplication();
      SalomeApp_Application* anApp    = dynamic_cast<SalomeApp_Application*>(anApplication);
      /*SUIT_ViewManager* vman        = */anApp->getViewManager(VTKViewer_Viewer::Type(),true);
      SMESHGUI_Displayer* aDisp       = new SMESHGUI_Displayer(anApp);
      aDisp->Display(_entry,1);
    }
  };

  ProcessVoidEvent(new TEvent(Mesh_Entry));
}

void SMESH_Swig::EraseActor( const char* Mesh_Entry, const bool allViewers )
{
  class TEvent: public SALOME_Event
  {
  private:
    const char* _entry;
    bool        _allViewers;
  public:
    TEvent(const char* Mesh_Entry, const bool allViewers ) {
      _entry = Mesh_Entry;
      _allViewers = allViewers;
    }
    virtual void Execute() {
      SUIT_Session* aSession          = SUIT_Session::session();
      SUIT_Application* anApplication = aSession->activeApplication();
      SalomeApp_Application* anApp    = dynamic_cast<SalomeApp_Application*>(anApplication);
      SMESHGUI_Displayer* aDisp       = new SMESHGUI_Displayer(anApp);
      ViewManagerList aManagers;
      if ( !_allViewers ) {
        aManagers << anApp->activeViewManager();
      }
      else {
        aManagers = anApp->viewManagers();
      }
      foreach( SUIT_ViewManager* aMgr, aManagers ) {
        if ( aMgr && aMgr->getType() == VTKViewer_Viewer::Type() ) {
          SALOME_View* aSalomeView = dynamic_cast<SALOME_View*>(aMgr->getViewModel());
          if (aSalomeView) {
            aDisp->Erase(_entry,true, true, aSalomeView);
          }
        }
      }
    }
  };

  ProcessVoidEvent(new TEvent(Mesh_Entry, allViewers));
}

void SMESH_Swig::UpdateActor( const char* Mesh_Entry ) {
  class TEvent: public SALOME_Event
  {
  private:
    const char* _entry;
  public:
    TEvent( const char* Mesh_Entry ) {
      _entry = Mesh_Entry;
    }
    virtual void Execute() {
      Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject
        ( _entry, "SMESH", "" );
      SMESH::Update( anIO, true );
    }
  };

  ProcessVoidEvent( new TEvent(Mesh_Entry) );
}

void SMESH_Swig::SetName(const char* theEntry,
                         const char* theName)
{
  SALOMEDS::SObject_var aSObject = myStudy->FindObjectID(theEntry);
  SALOMEDS::GenericAttribute_var anAttr;
  SALOMEDS::AttributeName_var aName;
  if(!aSObject->_is_nil()){
    anAttr = myStudyBuilder->FindOrCreateAttribute(aSObject,"AttributeName");
    aName = SALOMEDS::AttributeName::_narrow(anAttr);
    aName->SetValue(theName);
    aName->UnRegister();
    aSObject->UnRegister();
  }
}

//================================================================================
/*!
 * \brief Set mesh icon according to compute status
  * \param Mesh_Entry - entry of a mesh
  * \param isComputed - is mesh computed or not
 */
//================================================================================

void SMESH_Swig::SetMeshIcon(const char* theMeshEntry,
                             const bool  theIsComputed,
                             const bool  isEmpty)
{
  class TEvent: public SALOME_Event
  {
    SALOMEDS::Study_var myStudy;
    std::string         myMeshEntry;
    bool                myIsComputed, myIsEmpty;
  public:
    TEvent(const SALOMEDS::Study_var& theStudy,
           const std::string&         theMeshEntry,
           const bool                 theIsComputed,
           const bool                 isEmpty):
      myStudy     (theStudy),
      myMeshEntry (theMeshEntry),
      myIsComputed(theIsComputed),
      myIsEmpty   (isEmpty)
    {}

    virtual
    void
    Execute()
    {
      SALOMEDS::SObject_ptr aMeshSO = myStudy->FindObjectID(myMeshEntry.c_str());
      if(_PTR(SObject) aMesh = ClientFactory::SObject(aMeshSO))
        SMESH::ModifiedMesh(aMesh,myIsComputed,myIsEmpty);
      // aMeshSO->UnRegister();  ~aMesh() already called UnRegister()!
    }
  };

  ProcessVoidEvent(new TEvent(myStudy,
                              theMeshEntry,
                              theIsComputed,
                              isEmpty));
}

/*!
  \brief Helper class for selection event.
*/
class TSelectListEvent: public SALOME_Event
{
  const char*       myId;
  std::vector<int>  myIdsList;
  bool              myIsAppend;

public:
  TSelectListEvent(const char* id, std::vector<int> ids, bool append) :
    myId(id),
    myIdsList(ids),
    myIsAppend(append)
  {}
  virtual void Execute()
  {
    
    LightApp_SelectionMgr* selMgr = 0;
    SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
    if( anApp )
      selMgr = dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );

    if( !selMgr )
      return;
    
    selMgr->clearFilters();

    SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow();
    if(!aViewWindow)
      return;

    SMESH_Actor* anActor = SMESH::FindActorByEntry( myId );
    
    if (!anActor || !anActor->hasIO())
      return;
    
    Handle(SALOME_InteractiveObject) anIO = anActor->getIO();
    SALOME_ListIO aList;
    aList.Append(anIO);
    selMgr->setSelectedObjects(aList, false);

    if ( aViewWindow->SelectionMode() ==  ActorSelection ) {
      return;
    }
        
    TColStd_MapOfInteger aMap;
    std::vector<int>::const_iterator anIter;
    for (anIter = myIdsList.begin(); anIter != myIdsList.end(); ++anIter) {
      aMap.Add(*anIter);
    }

    // Set new selection
    SVTK_Selector* aSelector  = aViewWindow->GetSelector();
    aSelector->AddOrRemoveIndex(anIO, aMap, myIsAppend);
    aViewWindow->highlight( anIO, true, true );
    aViewWindow->GetInteractor()->onEmitSelectionChanged();
  }
};

/*!
  \brief Select the elements on the mesh, sub-mesh or group.
  \param id object entry
  \param ids list of the element ids
  \param mode selection mode
*/
void SMESH_Swig::select( const char* id, std::vector<int> ids, bool append ) {
  ProcessVoidEvent( new TSelectListEvent( id, ids, append ) );
}
  
/*!
  \brief Select the elements on the mesh, sub-mesh or group.
  \param id object entry
  \param id id of the element
  \param mode selection mode
*/
void SMESH_Swig::select( const char* id, int id1, bool append ) {
  std::vector<int> ids;
  ids.push_back( id1 );
  ProcessVoidEvent( new TSelectListEvent( id, ids, append ) );
}

/*!
  \brief Helper class for selection edges of cell event
*/
class TSelectListOfPairEvent: public SALOME_Event
{
  const char*                        myId;
  std::vector<std::pair<int, int> >  myIdsList;
  bool                               myIsAppend;

public:
  TSelectListOfPairEvent(const char* id, std::vector<std::pair<int, int> > ids, bool append) :
    myId(id),
    myIdsList(ids),
    myIsAppend(append)
  {}
  virtual void Execute()
  {
    
    LightApp_SelectionMgr* selMgr = 0;
    SalomeApp_Application* anApp = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() );
    if( anApp )
      selMgr = dynamic_cast<LightApp_SelectionMgr*>( anApp->selectionMgr() );

    if( !selMgr )
      return;
    
    selMgr->clearFilters();

    SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow();
    if(!aViewWindow)
      return;

    SMESH_Actor* anActor = SMESH::FindActorByEntry( myId );
    
    if (!anActor || !anActor->hasIO())
      return;
    
    Handle(SALOME_InteractiveObject) anIO = anActor->getIO();
    SALOME_ListIO aList;
    aList.Append(anIO);
    selMgr->setSelectedObjects(aList, false);

    if ( aViewWindow->SelectionMode() !=  EdgeOfCellSelection ) {
      return;
    }
        
    SVTK_IndexedMapOfIds aMap;
    std::vector<std::pair<int, int> >::const_iterator anIter;
    for (anIter = myIdsList.begin(); anIter != myIdsList.end(); ++anIter) {
      std::vector<int> aCompositeId;
      aCompositeId.push_back((*anIter).first);
      aCompositeId.push_back((*anIter).second);
      aMap.Add(aCompositeId);
    }

    // Set new selection
    SVTK_Selector* aSelector  = aViewWindow->GetSelector();
    aSelector->AddOrRemoveCompositeIndex(anIO, aMap, myIsAppend);
    aViewWindow->highlight( anIO, true, true );
    aViewWindow->GetInteractor()->onEmitSelectionChanged();
  }
};

/*!
  \brief Select the elements on the mesh, sub-mesh or group.
  \param id object entry
  \param ids list of the element ids
  \param mode selection mode
*/
void SMESH_Swig::select( const char* id, std::vector<std::pair<int,int> > ids, bool append ) {
  ProcessVoidEvent( new TSelectListOfPairEvent( id, ids, append ) );
}

class TGetSelectionModeEvent : public SALOME_Event
{
public:
  typedef SelectionMode TResult;
  TResult myResult;
  TGetSelectionModeEvent() : myResult( Undefined ) {}
  virtual void Execute()
  {
    SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( );
    if(!aViewWindow)
      return;
    
    myResult = (SelectionMode) aViewWindow->SelectionMode();
  }
};

/*!
  \brief Get selection mode of the active VTK View window.
*/
SelectionMode SMESH_Swig::getSelectionMode() {
  return ProcessEvent( new TGetSelectionModeEvent() );
}


/*!
 * Event to set selection mode
*/
class TSetSelectionModeEvent : public SALOME_Event
{
  SelectionMode mySelectionMode;

public:

  TSetSelectionModeEvent(const SelectionMode selectionMode) :
    mySelectionMode(selectionMode) 
  {}

  virtual void Execute()
  {
    SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow();
    if(!aViewWindow)
      return;

    Selection_Mode prevMode = aViewWindow->SelectionMode();
    bool changePointRepresentation = ( prevMode == NodeSelection && mySelectionMode != Node ) ||
      (prevMode != NodeSelection && mySelectionMode == Node);
      
    if( changePointRepresentation ) {
      vtkRenderer *aRenderer = aViewWindow->getRenderer();
      VTK::ActorCollectionCopy aCopy(aRenderer->GetActors());
      vtkActorCollection *aCollection = aCopy.GetActors();
      aCollection->InitTraversal();
      while(vtkActor *anAct = aCollection->GetNextActor()){
	if(SMESH_Actor *anActor = dynamic_cast<SMESH_Actor*>(anAct)){
	  if(anActor->GetVisibility()){
	    anActor->SetPointRepresentation(mySelectionMode == Node);
	  }
	}
      }
    }
    aViewWindow->SetSelectionMode(mySelectionMode);
  }
};

void SMESH_Swig::setSelectionMode(SelectionMode selectionMode){
  ProcessVoidEvent( new TSetSelectionModeEvent( selectionMode ) ); 
}

class TGetSelectedEvent : public SALOME_Event
{
public:
  typedef std::vector<int> TResult;
  TResult myResult;
  const char* myId;
  
  TGetSelectedEvent( const char* id) : 
    myResult( std::vector<int>() ),
    myId(id)
  {}
  
  virtual void Execute()
  {
    SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow();
    if( !aViewWindow )
      return;

    SVTK_Selector* aSelector  = aViewWindow->GetSelector();    
    if( !aSelector )
      return;

    SMESH_Actor* anActor = SMESH::FindActorByEntry( myId );
    
    if ( !anActor || !anActor->hasIO() )
      return;

    TColStd_IndexedMapOfInteger aMapIndex;
    aSelector->GetIndex(anActor->getIO(),aMapIndex);

    for( int i = 1; i <= aMapIndex.Extent(); i++ )
      myResult.push_back( aMapIndex( i ) );
  }
};

std::vector<int> SMESH_Swig::getSelected( const char* Mesh_Entry ) {
  return ProcessEvent( new TGetSelectedEvent(Mesh_Entry) );
}

class TGetSelectedPairEvent : public SALOME_Event
{
public:
  typedef std::vector<std::pair<int, int> > TResult;
  TResult myResult;
  const char* myId;
  
  TGetSelectedPairEvent( const char* id) : 
    myResult( std::vector<std::pair<int,int> >() ),
    myId(id)
  {}
  
  virtual void Execute()
  {
    SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow();
    if( !aViewWindow )
      return;

    if(aViewWindow->SelectionMode() != EdgeOfCellSelection )
      return;

    SVTK_Selector* aSelector  = aViewWindow->GetSelector();    
    if( !aSelector )
      return;

    SMESH_Actor* anActor = SMESH::FindActorByEntry( myId );
    
    if ( !anActor || !anActor->hasIO() )
      return;

    SVTK_IndexedMapOfIds aMapIndex;
    aSelector->GetCompositeIndex(anActor->getIO(),aMapIndex);

    for( int i = 1; i <= aMapIndex.Extent(); i++ )
      myResult.push_back( std::make_pair<int,int>( (int)aMapIndex( i )[0], (int)aMapIndex( i )[1]) );
  }
};

std::vector<std::pair<int,int> > SMESH_Swig::getSelectedEdgeOfCell( const char* Mesh_Entry ) {
  return ProcessEvent( new TGetSelectedPairEvent(Mesh_Entry) );
}