-// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
+// 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.
+// 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
//
#include "libSMESH_Swig.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 <SALOME_KernelServices.hxx>
#include <utilities.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>
// OCCT includes
#include <TopAbs.hxx>
+#include <TColStd_MapOfInteger.hxx>
// Qt includes
#include <QApplication>
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);
+ SALOMEDS::SObject_var aMeshOrSubMeshSO = KERNEL::getStudyServant()->FindObjectID(theMeshOrSubMeshEntry);
+ SALOMEDS::SObject_var aHypothesisSO = KERNEL::getStudyServant()->FindObjectID(theDomainEntry);
if(!aMeshOrSubMeshSO->_is_nil() && !aHypothesisSO->_is_nil()){
//Find or Create Applied Hypothesis root
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"),
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"),
}
};
- MESSAGE("Constructeur");
+ //MESSAGE("Constructeur");
if(CORBA::is_nil(anORB))
ProcessVoidEvent(new TEvent(anORB));
//===============================================================
void
-SMESH_Swig::Init(int theStudyID)
+SMESH_Swig::Init()
{
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,
+ TEvent(SALOMEDS::StudyBuilder_var& theStudyBuilder,
SALOMEDS::SComponent_var& theSComponentMesh):
- myStudyID (theStudyID),
- myStudy (theStudy),
myStudyBuilder (theStudyBuilder),
mySComponentMesh(theSComponentMesh)
{}
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);
+ SALOMEDS::Study_var aStudy = KERNEL::getStudyServant();
SMESH::SMESH_Gen_var aSMESHGen = SMESHGUI::GetSMESHGen();
- aSMESHGen->SetCurrentStudy( myStudy.in() );
- myStudyBuilder = myStudy->NewBuilder();
+ myStudyBuilder = aStudy->NewBuilder();
SALOMEDS::GenericAttribute_var anAttr;
SALOMEDS::AttributeName_var aName;
SALOMEDS::AttributePixMap_var aPixmap;
- SALOMEDS::SComponent_var aSComponent = myStudy->FindComponent("SMESH");
+ SALOMEDS::SComponent_var aSComponent = aStudy->FindComponent("SMESH");
if ( aSComponent->_is_nil() )
{
- bool aLocked = myStudy->GetProperties()->IsLocked();
+ bool aLocked = aStudy->GetProperties()->IsLocked();
if (aLocked)
- myStudy->GetProperties()->SetLocked(false);
+ aStudy->GetProperties()->SetLocked(false);
SMESHGUI* aSMESHGUI = SMESHGUI::GetSMESHGUI();
//SRN: BugID IPAL9186, load a SMESH gui if it hasn't been loaded
aPixmap->SetPixMap( "ICON_OBJBROWSER_SMESH" );
aPixmap->UnRegister();
- SALOMEDS::UseCaseBuilder_var useCaseBuilder = myStudy->GetUseCaseBuilder();
+ SALOMEDS::UseCaseBuilder_var useCaseBuilder = KERNEL::getStudyServant()->GetUseCaseBuilder();
useCaseBuilder->SetRootCurrent();
useCaseBuilder->Append( aSComponent.in() );
myStudyBuilder->DefineComponentInstance(aSComponent,aSMESHGen);
if (aLocked)
- myStudy->GetProperties()->SetLocked(true);
+ KERNEL::getStudyServant()->GetProperties()->SetLocked(true);
}
mySComponentMesh = SALOMEDS::SComponent::_narrow(aSComponent);
}
};
- MESSAGE("Init");
+ //MESSAGE("Init");
- ProcessVoidEvent(new TEvent(theStudyID,
- myStudy,
- myStudyBuilder,
+ ProcessVoidEvent(new TEvent(myStudyBuilder,
mySComponentMesh));
}
//===============================================================
SMESH_Swig::~SMESH_Swig()
{
- MESSAGE("Destructeur");
+ //MESSAGE("Destructeur");
}
//===============================================================
const char* SMESH_Swig::AddNewMesh(const char* theIOR)
{
- MESSAGE("AddNewMesh");
// VSR: added temporarily - to be removed - objects are published automatically by engine
- SALOMEDS::SObject_var aSObject = myStudy->FindObjectIOR(theIOR);
+ SALOMEDS::SObject_var aSObject = KERNEL::getStudyServant()->FindObjectIOR(theIOR);
if (aSObject->_is_nil())
{
//Find or Create Hypothesis root
//===============================================================
const char* SMESH_Swig::AddNewHypothesis(const char* theIOR)
{
- MESSAGE("AddNewHypothesis");
-
SALOMEDS::SObject_var aSObject = ::AddHypothesis(theIOR,
mySComponentMesh,
myStudyBuilder);
//===============================================================
const char* SMESH_Swig::AddNewAlgorithms(const char* theIOR)
{
- MESSAGE("AddNewAlgorithms");
-
SALOMEDS::SObject_var aSObject = ::AddAlgorithms(theIOR,
mySComponentMesh,
myStudyBuilder);
void SMESH_Swig::SetShape(const char* theShapeEntry,
const char* theMeshEntry)
{
- SALOMEDS::SObject_var aGeomShapeSO = myStudy->FindObjectID( theShapeEntry );
- SALOMEDS::SObject_var aMeshSO = myStudy->FindObjectID( theMeshEntry );
+ SALOMEDS::SObject_var aGeomShapeSO = KERNEL::getStudyServant()->FindObjectID( theShapeEntry );
+ SALOMEDS::SObject_var aMeshSO = KERNEL::getStudyServant()->FindObjectID( theMeshEntry );
if(!aMeshSO->_is_nil() && !aGeomShapeSO->_is_nil()){
SALOMEDS::SObject_var aSObject = myStudyBuilder->NewObjectToTag(aMeshSO, SMESH::Tag_RefOnShape);
{
::SetHypothesis(theMeshOrSubMeshEntry,
theDomainEntry,
- myStudy,
myStudyBuilder);
}
{
::SetAlgorithms(theMeshOrSubMeshEntry,
theDomainEntry,
- myStudy,
myStudyBuilder);
}
void
SMESH_Swig::UnSetHypothesis(const char* theDomainEntry)
{
- SALOMEDS::SObject_var aDomainSO = myStudy->FindObjectID(theDomainEntry);
+ SALOMEDS::SObject_var aDomainSO = KERNEL::getStudyServant()->FindObjectID(theDomainEntry);
if(!aDomainSO->_is_nil())
myStudyBuilder->RemoveObject(aDomainSO);
}
const char* theSubMeshIOR,
int theShapeType)
{
- SALOMEDS::SObject_var aMeshSO = myStudy->FindObjectID(theMeshEntry);
+ SALOMEDS::SObject_var aMeshSO = KERNEL::getStudyServant()->FindObjectID(theMeshEntry);
if(!aMeshSO->_is_nil()) {
long aShapeTag;
QString aSubMeshName;
const char* theSubMeshIOR,
int ShapeType)
{
- SALOMEDS::SObject_var aGeomShapeSO = myStudy->FindObjectID(theGeomShapeEntry);
+ SALOMEDS::SObject_var aGeomShapeSO = KERNEL::getStudyServant()->FindObjectID(theGeomShapeEntry);
if(!aGeomShapeSO->_is_nil())
{
const char * aSubMeshEntry = AddSubMesh(theMeshEntry,theSubMeshIOR,ShapeType);
- SALOMEDS::SObject_var aSubMeshSO = myStudy->FindObjectID(aSubMeshEntry);
+ SALOMEDS::SObject_var aSubMeshSO = KERNEL::getStudyServant()->FindObjectID(aSubMeshEntry);
if ( !aSubMeshSO->_is_nil()) {
SetShape( theGeomShapeEntry, aSubMeshEntry );
CORBA::String_var aString = aSubMeshSO->GetID();
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);
void SMESH_Swig::SetName(const char* theEntry,
const char* theName)
{
- SALOMEDS::SObject_var aSObject = myStudy->FindObjectID(theEntry);
+ SALOMEDS::SObject_var aSObject = KERNEL::getStudyServant()->FindObjectID(theEntry);
SALOMEDS::GenericAttribute_var anAttr;
SALOMEDS::AttributeName_var aName;
if(!aSObject->_is_nil()){
{
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,
+ TEvent(const std::string& theMeshEntry,
const bool theIsComputed,
const bool isEmpty):
- myStudy (theStudy),
myMeshEntry (theMeshEntry),
myIsComputed(theIsComputed),
myIsEmpty (isEmpty)
void
Execute()
{
- SALOMEDS::SObject_ptr aMeshSO = myStudy->FindObjectID(myMeshEntry.c_str());
+ SALOMEDS::SObject_ptr aMeshSO = KERNEL::getStudyServant()->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,
+ ProcessVoidEvent(new TEvent(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()
+ {
+ SMESHGUI* aSMESHGUI = SMESHGUI::GetSMESHGUI();
+ if( !aSMESHGUI )
+ return;
+
+ LightApp_SelectionMgr* selMgr = SMESH::GetSelectionMgr( aSMESHGUI );
+ if( !selMgr )
+ return;
+
+ selMgr->clearFilters();
+
+ SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aSMESHGUI );
+ 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 ) );
+}
+
+
+class TGetSelectionModeEvent : public SALOME_Event
+{
+public:
+ typedef int TResult;
+ TResult myResult;
+ TGetSelectionModeEvent() : myResult( -1 ) {}
+ virtual void Execute()
+ {
+ SMESHGUI* aSMESHGUI = SMESHGUI::GetSMESHGUI();
+ if( !aSMESHGUI )
+ return;
+
+ SVTK_ViewWindow* aViewWindow = SMESH::GetViewWindow( aSMESHGUI );
+ if(!aViewWindow)
+ return;
+
+ myResult = aViewWindow->SelectionMode();
+ }
+};
+
+/*!
+ \brief Get selection mode of the active VTK View window.
+*/
+int SMESH_Swig::getSelectionMode() {
+ return ProcessEvent( new TGetSelectionModeEvent() );
+}
