mirror of
https://git.salome-platform.org/gitpub/modules/geom.git
synced 2025-01-09 16:20:35 +05:00
503 lines
15 KiB
C++
503 lines
15 KiB
C++
// GEOM GEOMGUI : GUI for Geometry component
|
|
//
|
|
// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
|
|
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
|
|
//
|
|
// 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.
|
|
//
|
|
// 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.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
|
|
//
|
|
//
|
|
//
|
|
// File : GeometryGUI_Swig.cxx
|
|
// Author : Nicolas REJNERI, Paul RASCLE
|
|
// Module : GEOM
|
|
// $Header$
|
|
|
|
#include "GeometryGUI_Swig.hxx"
|
|
#include "SALOMEGUI_Swig.hxx"
|
|
|
|
#include "GeometryGUI.h"
|
|
|
|
#include <SUIT_Session.h>
|
|
#include <SalomeApp_Application.h>
|
|
#include <SalomeApp_Study.h>
|
|
#include <SalomeApp_ImportOperation.h>
|
|
|
|
#include <OB_Browser.h>
|
|
|
|
#include <OCCViewer_ViewWindow.h>
|
|
#include <OCCViewer_ViewManager.h>
|
|
#include <SOCC_ViewModel.h>
|
|
|
|
#include <VTKViewer_ViewWindow.h>
|
|
#include <VTKViewer_ViewModel.h>
|
|
#include <VTKViewer_RenderWindowInteractor.h>
|
|
#include <SVTK_ViewWindow.h>
|
|
#include <SVTK_RenderWindowInteractor.h>
|
|
|
|
#include "GEOM_Actor.h"
|
|
#include "GEOM_Client.hxx"
|
|
#include "GEOM_AISShape.hxx"
|
|
#include "GEOM_AssemblyBuilder.h"
|
|
#include "GEOM_InteractiveObject.hxx"
|
|
|
|
#include <SALOME_Event.hxx>
|
|
|
|
#include "utilities.h"
|
|
|
|
#include "SALOMEDSClient.hxx"
|
|
|
|
// OCCT Includes
|
|
#include <TopExp_Explorer.hxx>
|
|
#include <TopTools_MapOfShape.hxx>
|
|
#include <TopTools_ListOfShape.hxx>
|
|
#include <TopTools_ListIteratorOfListOfShape.hxx>
|
|
#include <BRepAdaptor_Surface.hxx>
|
|
#include <BRepAdaptor_Curve.hxx>
|
|
#include <GeomAbs_CurveType.hxx>
|
|
#include <GeomAbs_SurfaceType.hxx>
|
|
#include <TopoDS.hxx>
|
|
#include <TopoDS_Edge.hxx>
|
|
#include <TopoDS_Face.hxx>
|
|
#include <TopoDS_Iterator.hxx>
|
|
#include <AIS_ListOfInteractive.hxx>
|
|
#include <AIS_ListIteratorOfListOfInteractive.hxx>
|
|
#include <V3d_Viewer.hxx>
|
|
|
|
using namespace std;
|
|
|
|
|
|
static GEOM_Client ShapeReader;
|
|
|
|
inline OCCViewer_Viewer* GetOCCViewer(SUIT_Application* theApp){
|
|
SUIT_ViewWindow* window = theApp->desktop()->activeWindow();
|
|
if(window && window->getViewManager()->getType() == OCCViewer_Viewer::Type()){
|
|
OCCViewer_ViewWindow* vw = dynamic_cast<OCCViewer_ViewWindow*>( window );
|
|
if ( vw ) {
|
|
OCCViewer_ViewManager* vm = dynamic_cast<OCCViewer_ViewManager*>( vw->getViewManager() );
|
|
if ( vm )
|
|
return vm->getOCCViewer();
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
inline SVTK_ViewWindow* GetSVTKViewWindow(SUIT_Application* theApp){
|
|
SUIT_ViewWindow* window = theApp->desktop()->activeWindow();
|
|
if(window && window->getViewManager()->getType() == VTKViewer_Viewer::Type())
|
|
return dynamic_cast<SVTK_ViewWindow*>( window );
|
|
|
|
return 0;
|
|
}
|
|
|
|
GEOM_Swig::GEOM_Swig()
|
|
{
|
|
// MESSAGE("Constructeur");
|
|
}
|
|
|
|
GEOM_Swig::~GEOM_Swig()
|
|
{
|
|
// MESSAGE("Destructeur");
|
|
}
|
|
|
|
void GEOM_Swig::createAndDisplayGO (const char* Entry)
|
|
{
|
|
class TEvent: public SALOME_Event
|
|
{
|
|
std::string myEntry;
|
|
public:
|
|
TEvent(const char* theEntry):
|
|
myEntry(theEntry)
|
|
{}
|
|
virtual void Execute()
|
|
{
|
|
SUIT_Application* app = SUIT_Session::session()->activeApplication();
|
|
if (!app) return;
|
|
|
|
SalomeApp_Study* ActiveStudy = dynamic_cast<SalomeApp_Study*>(app->activeStudy());
|
|
if (!ActiveStudy) return;
|
|
|
|
_PTR(Study) aStudy(ActiveStudy->studyDS());
|
|
_PTR(StudyBuilder) aStudyBuilder = aStudy->NewBuilder();
|
|
|
|
GEOM::GEOM_Gen_var Geom = GeometryGUI::GetGeomGen();
|
|
if (CORBA::is_nil(Geom))
|
|
return;
|
|
|
|
string aFatherIOR;
|
|
_PTR(SComponent) father = aStudy->FindComponent("GEOM");
|
|
aStudyBuilder->DefineComponentInstance
|
|
(father, SalomeApp_Application::orb()->object_to_string(Geom));
|
|
father->ComponentIOR(aFatherIOR);
|
|
|
|
_PTR(SObject) obj = aStudy->FindObjectID(myEntry);
|
|
_PTR(GenericAttribute) anAttr;
|
|
|
|
// Create new actor
|
|
if (!obj->FindAttribute(anAttr, "AttributeIOR"))
|
|
return;
|
|
_PTR(AttributeIOR) anIOR(anAttr);
|
|
string anIORValue = anIOR->Value();
|
|
|
|
GEOM::GEOM_Object_var aShape = Geom->GetIORFromString(anIORValue.c_str());
|
|
TopoDS_Shape Shape = ShapeReader.GetShape(Geom,aShape);
|
|
if (obj) {
|
|
if (obj->FindAttribute(anAttr, "AttributeName")) {
|
|
_PTR(AttributeName) aName (anAttr);
|
|
string aNameValue = aName->Value();
|
|
// open transaction
|
|
/*SUIT_Operation* op = new SalomeApp_ImportOperation (app);
|
|
op->start();
|
|
|
|
_PTR(SObject) newObj1 = aStudyBuilder->NewObject(father);
|
|
aStudyBuilder->Addreference(newObj1, obj);
|
|
// commit transaction
|
|
op->commit();*/
|
|
Handle(GEOM_InteractiveObject) anIO =
|
|
new GEOM_InteractiveObject (const_cast<char*>(anIORValue.c_str()),
|
|
const_cast<char*>(aFatherIOR.c_str()),
|
|
"GEOM",
|
|
const_cast<char*>( obj->GetID().c_str()));
|
|
|
|
if (SVTK_ViewWindow* svtkViewWindow = GetSVTKViewWindow(app)) {
|
|
|
|
SVTK_RenderWindowInteractor* aRenderInter= svtkViewWindow->getRWInteractor();
|
|
int aMode = aRenderInter->GetDisplayMode();
|
|
|
|
vtkActorCollection* theActors =
|
|
GEOM_AssemblyBuilder::BuildActors(Shape,0,aMode,true);
|
|
theActors->InitTraversal();
|
|
while (vtkActor* anActor = theActors->GetNextActor()) {
|
|
GEOM_Actor* GActor = GEOM_Actor::SafeDownCast(anActor);
|
|
GActor->setName(const_cast<char*>(aNameValue.c_str()));
|
|
GActor->setIO(anIO);
|
|
aRenderInter->Display(GActor);
|
|
}
|
|
aRenderInter->Update();
|
|
cout << 8.2 << endl;
|
|
} else if (OCCViewer_Viewer* occViewer = GetOCCViewer(app)) {
|
|
Handle(AIS_InteractiveContext) ic = occViewer->getAISContext();
|
|
Handle(GEOM_AISShape) aSh =
|
|
new GEOM_AISShape (Shape,const_cast<char*>(aNameValue.c_str()));
|
|
aSh->setName(const_cast<char*>(aNameValue.c_str()));
|
|
aSh->setIO(anIO);
|
|
ic->Display(aSh);
|
|
ic->AddOrRemoveCurrentObject(aSh,true);
|
|
}
|
|
// update object browser
|
|
SalomeApp_Application* app = NULL; //dynamic_cast<SalomeApp_Application*>(app);
|
|
if (app) {
|
|
CAM_Module* module = app->module("Geometry");
|
|
SalomeApp_Module* appMod = dynamic_cast<SalomeApp_Module*>(module);
|
|
if (appMod)
|
|
appMod->updateObjBrowser(true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
|
|
// MESSAGE("createAndDisplayGO");
|
|
ProcessVoidEvent(new TEvent (Entry));
|
|
|
|
class TEventUpdateBrowser: public SALOME_Event
|
|
{
|
|
public:
|
|
TEventUpdateBrowser() {}
|
|
virtual void Execute() {
|
|
SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>(SUIT_Session::session()->activeApplication());
|
|
if (app) {
|
|
CAM_Module* module = app->module("Geometry");
|
|
SalomeApp_Module* appMod = dynamic_cast<SalomeApp_Module*>(module);
|
|
if (appMod) appMod->updateObjBrowser(true);
|
|
}
|
|
}
|
|
};
|
|
|
|
ProcessVoidEvent(new TEventUpdateBrowser ());
|
|
}
|
|
|
|
|
|
int GEOM_Swig::getIndexTopology(const char* SubIOR, const char* IOR)
|
|
{
|
|
GEOM::GEOM_Gen_var Geom = GeometryGUI::GetGeomGen();
|
|
if ( CORBA::is_nil( Geom ) )
|
|
return -1;
|
|
|
|
GEOM::GEOM_Object_var aMainShape = Geom->GetIORFromString(IOR);
|
|
TopoDS_Shape shape = ShapeReader.GetShape(Geom, aMainShape);
|
|
|
|
GEOM::GEOM_Object_var aSubShape = Geom->GetIORFromString(SubIOR);
|
|
TopoDS_Shape subshape = ShapeReader.GetShape(Geom, aSubShape);
|
|
|
|
int index = 1;
|
|
if(subshape.ShapeType() == TopAbs_COMPOUND) {
|
|
TopoDS_Iterator it;
|
|
TopTools_ListOfShape CL;
|
|
CL.Append(shape);
|
|
TopTools_ListIteratorOfListOfShape itC;
|
|
for(itC.Initialize(CL); itC.More(); itC.Next()) {
|
|
for(it.Initialize(itC.Value()); it.More(); it.Next()) {
|
|
if (it.Value().ShapeType() == TopAbs_COMPOUND) {
|
|
if (it.Value().IsSame(subshape))
|
|
return index;
|
|
else
|
|
index++;
|
|
CL.Append(it.Value());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
TopExp_Explorer Exp(shape, subshape.ShapeType());
|
|
TopTools_MapOfShape M;
|
|
while(Exp.More()) {
|
|
if(M.Add(Exp.Current())) {
|
|
if(Exp.Current().IsSame(subshape))
|
|
return index;
|
|
index++;
|
|
}
|
|
Exp.Next();
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
const char* GEOM_Swig::getShapeTypeString(const char* IOR)
|
|
{
|
|
GEOM::GEOM_Gen_var Geom = GeometryGUI::GetGeomGen();
|
|
if ( CORBA::is_nil( Geom ) )
|
|
return 0;
|
|
|
|
GEOM::GEOM_Object_var aShape = Geom->GetIORFromString(IOR);
|
|
TopoDS_Shape shape = ShapeReader.GetShape(Geom, aShape);
|
|
|
|
if( shape.IsNull() ) {
|
|
return "Null Shape" ;
|
|
}
|
|
|
|
switch (shape.ShapeType() )
|
|
{
|
|
case TopAbs_COMPOUND:
|
|
{ return "Compound" ;}
|
|
case TopAbs_COMPSOLID:
|
|
{ return "Compound Solid" ;}
|
|
case TopAbs_SOLID:
|
|
{ return "Solid" ;}
|
|
case TopAbs_SHELL:
|
|
{ return "Shell" ;}
|
|
case TopAbs_FACE:
|
|
{
|
|
BRepAdaptor_Surface surf(TopoDS::Face(shape));
|
|
if ( surf.GetType() == GeomAbs_Plane ) {
|
|
return "Plane" ;
|
|
} else if ( surf.GetType() == GeomAbs_Cylinder ) {
|
|
return "Cylindrical Face" ;
|
|
} else if ( surf.GetType() == GeomAbs_Sphere ) {
|
|
return "Spherical Face" ;
|
|
} else if ( surf.GetType() == GeomAbs_Torus ) {
|
|
return "Toroidal Face" ;
|
|
} else if ( surf.GetType() == GeomAbs_Cone ) {
|
|
return "Conical Face" ;
|
|
} else {
|
|
return "GEOM::FACE" ;
|
|
}
|
|
}
|
|
case TopAbs_WIRE:
|
|
{ return "Wire" ;}
|
|
case TopAbs_EDGE:
|
|
{
|
|
BRepAdaptor_Curve curv(TopoDS::Edge(shape));
|
|
if ( curv.GetType() == GeomAbs_Line ) {
|
|
if ( (Abs(curv.FirstParameter()) >= 1E6 ) ||
|
|
(Abs(curv.LastParameter()) >= 1E6 )) {
|
|
return "Line" ;
|
|
} else
|
|
return "Edge" ;
|
|
} else if ( curv.GetType() == GeomAbs_Circle ) {
|
|
if ( curv.IsClosed() )
|
|
return "Circle" ;
|
|
else
|
|
return "Arc" ;
|
|
} else {
|
|
return "Edge" ;
|
|
}
|
|
}
|
|
case TopAbs_VERTEX:
|
|
{ return "Vertex" ;}
|
|
case TopAbs_SHAPE:
|
|
{ return "Shape" ;}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
const char* GEOM_Swig::getShapeTypeIcon(const char* IOR)
|
|
{
|
|
GEOM::GEOM_Gen_var Geom = GeometryGUI::GetGeomGen();
|
|
if ( CORBA::is_nil( Geom ) )
|
|
return "None";
|
|
|
|
GEOM::GEOM_Object_var aShape = Geom->GetIORFromString(IOR);
|
|
TopoDS_Shape shape = ShapeReader.GetShape(Geom, aShape);
|
|
|
|
if( shape.IsNull() ) {
|
|
return "None" ;
|
|
}
|
|
|
|
switch (shape.ShapeType() )
|
|
{
|
|
case TopAbs_COMPOUND:
|
|
{ return "ICON_OBJBROWSER_COMPOUND" ;}
|
|
case TopAbs_COMPSOLID:
|
|
{ return "ICON_OBJBROWSER_COMPSOLID" ;}
|
|
case TopAbs_SOLID:
|
|
{ return "ICON_OBJBROWSER_SOLID" ;}
|
|
case TopAbs_SHELL:
|
|
{ return "ICON_OBJBROWSER_SHELL" ;}
|
|
case TopAbs_FACE:
|
|
{ return "ICON_OBJBROWSER_FACE" ;}
|
|
case TopAbs_WIRE:
|
|
{ return "ICON_OBJBROWSER_WIRE" ;}
|
|
case TopAbs_EDGE:
|
|
{ return "ICON_OBJBROWSER_EDGE" ;}
|
|
case TopAbs_VERTEX:
|
|
{ return "ICON_OBJBROWSER_VERTEX" ;}
|
|
}
|
|
|
|
return "None";
|
|
}
|
|
|
|
void GEOM_Swig::setDisplayMode(const char* theEntry, int theMode)
|
|
{
|
|
SUIT_Application* app = SUIT_Session::session()->activeApplication();
|
|
if ( !app ) return;
|
|
|
|
Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(theEntry, "GEOM", "");
|
|
|
|
class TEvent: public SALOME_Event{
|
|
SUIT_Application* myApp;
|
|
Handle(SALOME_InteractiveObject) myIO;
|
|
int myParam;
|
|
public:
|
|
TEvent(SUIT_Application* theApp, const Handle(SALOME_InteractiveObject)& theIO, int theParam):
|
|
myApp(theApp), myIO(theIO), myParam(theParam)
|
|
{}
|
|
virtual void Execute(){
|
|
if(SVTK_ViewWindow* svtkViewWindow = GetSVTKViewWindow(myApp)){
|
|
SVTK_RenderWindowInteractor* myRenderInter= svtkViewWindow->getRWInteractor();
|
|
myRenderInter->SetDisplayMode(myIO,myParam);
|
|
myRenderInter->Update();
|
|
}
|
|
else if(OCCViewer_Viewer* occViewer = GetOCCViewer(myApp)) {
|
|
SOCC_Viewer* soccViewer = dynamic_cast<SOCC_Viewer*>( occViewer );
|
|
if (soccViewer)
|
|
soccViewer->switchRepresentation(myIO,myParam);
|
|
}
|
|
}
|
|
};
|
|
|
|
ProcessVoidEvent(new TEvent(app,anIO,theMode));
|
|
}
|
|
|
|
void GEOM_Swig::setColor(const char* theEntry, int red, int green, int blue)
|
|
{
|
|
SUIT_Application* app = SUIT_Session::session()->activeApplication();
|
|
if ( !app ) return;
|
|
|
|
Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(theEntry, "GEOM", "");
|
|
|
|
QColor aColor(red,green,blue);
|
|
|
|
class TEvent: public SALOME_Event{
|
|
SUIT_Application* myApp;
|
|
Handle(SALOME_InteractiveObject) myIO;
|
|
QColor myParam;
|
|
public:
|
|
TEvent(SUIT_Application* theApp, const Handle(SALOME_InteractiveObject)& theIO, const QColor& theParam):
|
|
myApp(theApp), myIO(theIO), myParam(theParam)
|
|
{}
|
|
virtual void Execute(){
|
|
if(SVTK_ViewWindow* svtkViewWindow = GetSVTKViewWindow(myApp)){
|
|
SVTK_RenderWindowInteractor* myRenderInter= svtkViewWindow->getRWInteractor();
|
|
myRenderInter->SetColor(myIO,myParam);
|
|
myRenderInter->Update();
|
|
}else if(OCCViewer_Viewer* occViewer = GetOCCViewer(myApp)){
|
|
Handle(AIS_InteractiveContext) ic = occViewer->getAISContext();
|
|
AIS_ListOfInteractive List;
|
|
ic->DisplayedObjects(List);
|
|
AIS_ListIteratorOfListOfInteractive ite(List);
|
|
for ( ; ite.More(); ite.Next() ) {
|
|
Handle(SALOME_InteractiveObject) anObj =
|
|
Handle(SALOME_InteractiveObject)::DownCast( ite.Value()->GetOwner() );
|
|
if ( !anObj.IsNull() && anObj->hasEntry() && anObj->isSame( myIO ) ) {
|
|
Quantity_Color CSFColor = Quantity_Color ( myParam.red() / 255.,
|
|
myParam.green() / 255.,
|
|
myParam.blue() / 255.,
|
|
Quantity_TOC_RGB );
|
|
ite.Value()->SetColor( CSFColor );
|
|
if ( ite.Value()->IsKind( STANDARD_TYPE(GEOM_AISShape) ) )
|
|
Handle(GEOM_AISShape)::DownCast( ite.Value() )->SetShadingColor( CSFColor );
|
|
ite.Value()->Redisplay( Standard_True );
|
|
occViewer->update();
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
ProcessVoidEvent(new TEvent(app,anIO,aColor));
|
|
}
|
|
|
|
void GEOM_Swig::setTransparency(const char* theEntry, float transp)
|
|
{
|
|
SUIT_Application* app = SUIT_Session::session()->activeApplication();
|
|
if ( !app ) return;
|
|
|
|
Handle(SALOME_InteractiveObject) anIO = new SALOME_InteractiveObject(theEntry, "GEOM", "");
|
|
|
|
class TEvent: public SALOME_Event{
|
|
SUIT_Application* myApp;
|
|
Handle(SALOME_InteractiveObject) myIO;
|
|
float myParam;
|
|
public:
|
|
TEvent(SUIT_Application* theApp, const Handle(SALOME_InteractiveObject)& theIO, float theParam):
|
|
myApp(theApp), myIO(theIO), myParam(theParam)
|
|
{}
|
|
virtual void Execute(){
|
|
if(SVTK_ViewWindow* svtkViewWindow = GetSVTKViewWindow(myApp)){
|
|
SVTK_RenderWindowInteractor* myRenderInter= svtkViewWindow->getRWInteractor();
|
|
myRenderInter->SetTransparency(myIO,myParam);
|
|
myRenderInter->Update();
|
|
}else if(OCCViewer_Viewer* occViewer = GetOCCViewer(myApp)) {
|
|
SOCC_Viewer* soccViewer = dynamic_cast<SOCC_Viewer*>( occViewer );
|
|
if (soccViewer)
|
|
soccViewer->setTransparency(myIO,myParam);
|
|
}
|
|
}
|
|
};
|
|
|
|
ProcessVoidEvent(new TEvent(app,anIO,transp));
|
|
}
|
|
|
|
|
|
bool GEOM_Swig::initGeomGen()
|
|
{
|
|
return GeometryGUI::InitGeomGen();
|
|
}
|