-// Copyright (C) 2007-2012 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
#include "GEOM_Actor.h"
#include <Material_ResourceMgr.h>
+#include <Material_Model.h>
#include <SUIT_Desktop.h>
#include <SUIT_MessageBox.h>
#include <QFileInfo>
#include <QString>
#include <QPainter>
+#include <QSignalMapper>
#include <AIS_Drawer.hxx>
#include <AIS_ListOfInteractive.hxx>
#include <GEOM_version.h>
-
#include "GEOMImpl_Types.hxx"
extern "C" {
bool GeometryGUI::InitGeomGen()
{
GeometryGUI aGG;
- if( CORBA::is_nil( myComponentGeom ) ) return false;
+ if ( CORBA::is_nil( myComponentGeom ) ) return false;
return true;
}
return aDSStudy._retn();
}
-void GeometryGUI::Modified( bool theIsUpdateActions )
+void GeometryGUI::Modified (bool theIsUpdateActions)
{
- if( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
- if( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
+ if ( SalomeApp_Application* app = dynamic_cast<SalomeApp_Application*>( SUIT_Session::session()->activeApplication() ) ) {
+ if ( SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) ) {
appStudy->Modified();
- if( theIsUpdateActions )
+ if ( theIsUpdateActions )
app->updateActions();
}
}
// purpose : Constructor
//=======================================================================
GeometryGUI::GeometryGUI() :
- SalomeApp_Module( "GEOM" ),
- LightApp_Module( "GEOM" )
+ SalomeApp_Module( "GEOM" )
{
if ( CORBA::is_nil( myComponentGeom ) )
{
myDisplayer = 0;
myLocalSelectionMode = GEOM_ALLOBJECTS;
+
+ connect( Material_ResourceMgr::resourceMgr(), SIGNAL( changed() ), this, SLOT( updateMaterials() ) );
}
//=======================================================================
bool ViewOCC = ( window && window->getViewManager()->getType() == OCCViewer_Viewer::Type() );
bool ViewVTK = ( window && window->getViewManager()->getType() == SVTK_Viewer::Type() );
- if( ViewOCC ) {
+ if ( ViewOCC ) {
OCCViewer_ViewWindow* vw = dynamic_cast<OCCViewer_ViewWindow*>( window );
if ( vw ) {
Handle(V3d_View) view3d = vw->getViewPort()->getView();
view3d->SetProj(DZ.X(), DZ.Y(), DZ.Z());
view3d->SetUp(DY.X(), DY.Y(), DY.Z());
- vw->onViewFitAll();
+ vw->onViewFitAll();
}
}
- else if( ViewVTK ) {
+ else if ( ViewVTK ) {
SVTK_ViewWindow* vw = dynamic_cast<SVTK_ViewWindow*>( window );
if ( vw ) {
vtkCamera* camera = vw->getRenderer()->GetActiveCamera();
// function : GeometryGUI::OnGUIEvent()
// purpose : manage all events on GUI [static]
//=======================================================================
-void GeometryGUI::OnGUIEvent( int id )
+void GeometryGUI::OnGUIEvent( int id, const QVariant& theParam )
{
SUIT_Application* anApp = application();
if (!anApp) return;
case GEOMOp::OpSelectAll: // POPUP MENU - SELECT ONLY - SELECT ALL
case GEOMOp::OpDelete: // MENU EDIT - DELETE
case GEOMOp::OpCheckGeom: // MENU TOOLS - CHECK GEOMETRY
+ case GEOMOp::OpMaterialsLibrary: // MENU TOOLS - MATERIALS LIBRARY
case GEOMOp::OpDeflection: // POPUP MENU - DEFLECTION COEFFICIENT
case GEOMOp::OpColor: // POPUP MENU - COLOR
case GEOMOp::OpSetTexture: // POPUP MENU - SETTEXTURE
case GEOMOp::OpPublishObject: // ROOT GEOM OBJECT - POPUP MENU - PUBLISH
case GEOMOp::OpPointMarker: // POPUP MENU - POINT MARKER
case GEOMOp::OpMaterialProperties: // POPUP MENU - MATERIAL PROPERTIES
+ case GEOMOp::OpPredefMaterial: // POPUP MENU - <SOME MATERIAL>
+ case GEOMOp::OpPredefMaterCustom: // POPUP MENU - MATERIAL PROPERTIES - CUSTOM...
case GEOMOp::OpEdgeWidth: // POPUP MENU - LINE WIDTH - EDGE WIDTH
case GEOMOp::OpIsosWidth: // POPUP MENU - LINE WIDTH - ISOS WIDTH
case GEOMOp::OpBringToFront: // POPUP MENU - BRING TO FRONT
case GEOMOp::OpRevolution: // MENU GENERATION - REVOLUTION
case GEOMOp::OpFilling: // MENU GENERATION - FILLING
case GEOMOp::OpPipe: // MENU GENERATION - PIPE
+ case GEOMOp::OpPipePath: // MENU GENERATION - RESTORE PATH
libName = "GenerationGUI";
break;
case GEOMOp::Op2dSketcher: // MENU ENTITY - SKETCHER
case GEOMOp::OpLimitTolerance: // MENU REPAIR - LIMIT TOLERANCE
case GEOMOp::OpRemoveExtraEdges: // MENU REPAIR - REMOVE EXTRA EDGES
case GEOMOp::OpFuseEdges: // MENU REPAIR - FUSE COLLINEAR EDGES
+ case GEOMOp::OpUnionFaces: // MENU REPAIR - UNION FACES
libName = "RepairGUI";
break;
case GEOMOp::OpProperties: // MENU MEASURE - PROPERTIES
// call method of corresponding GUI library
if ( library ) {
- library->OnGUIEvent( id, desk );
-
- // Update a list of materials for "Preferences" dialog
- if ( id == GEOMOp::OpMaterialProperties ) {
- LightApp_Preferences* pref = preferences();
- if ( pref ) {
- Material_ResourceMgr aMatResMgr;
- setPreferenceProperty( pref->rootItem()->findItem( tr( "PREF_MATERIAL" ), true )->id(),
- "strings",
- aMatResMgr.materials() );
- }
- }
+ if( !theParam.isValid() )
+ library->OnGUIEvent( id, desk );
+ else
+ library->OnGUIEvent( id, desk, theParam);
}
else
SUIT_MessageBox::critical( desk, tr( "GEOM_ERROR" ), tr( "GEOM_ERR_LIB_NOT_FOUND" ), tr( "GEOM_BUT_OK" ) );
void GeometryGUI::createOriginAndBaseVectors()
{
SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
- if( appStudy ) {
+ if ( appStudy ) {
_PTR(Study) studyDS = appStudy->studyDS();
- if( studyDS && !CORBA::is_nil( GetGeomGen() ) ) {
+ if ( studyDS && !CORBA::is_nil( GetGeomGen() ) ) {
GEOM::GEOM_IBasicOperations_var aBasicOperations = GetGeomGen()->GetIBasicOperations( studyDS->StudyId() );
- if( !aBasicOperations->_is_nil() ) {
+ if ( !aBasicOperations->_is_nil() ) {
SUIT_ResourceMgr* aResourceMgr = SUIT_Session::session()->resourceMgr();
double aLength = aResourceMgr->doubleValue( "Geometry", "base_vectors_length", 1.0 );
GEOM::GEOM_Object_var anOrigin = aBasicOperations->MakePointXYZ( 0.0, 0.0, 0.0 );
createGeomAction( GEOMOp::OpRevolution, "REVOLUTION" );
createGeomAction( GEOMOp::OpFilling, "FILLING" );
createGeomAction( GEOMOp::OpPipe, "PIPE" );
+ createGeomAction( GEOMOp::OpPipePath, "PIPE_PATH" );
createGeomAction( GEOMOp::OpGroupCreate, "GROUP_CREATE" );
createGeomAction( GEOMOp::OpGroupEdit, "GROUP_EDIT" );
createGeomAction( GEOMOp::OpOrientation, "CHANGE_ORIENTATION" );
createGeomAction( GEOMOp::OpRemoveExtraEdges, "REMOVE_EXTRA_EDGES" );
createGeomAction( GEOMOp::OpFuseEdges, "FUSE_EDGES" );
+ createGeomAction( GEOMOp::OpUnionFaces, "UNION_FACES" );
createGeomAction( GEOMOp::OpPointCoordinates, "POINT_COORDS" );
createGeomAction( GEOMOp::OpProperties, "BASIC_PROPS" );
createGeomAction( GEOMOp::OpCheckGeom, "CHECK_GEOMETRY" );
#endif
+ createGeomAction( GEOMOp::OpMaterialsLibrary, "MATERIALS_LIBRARY" );
createGeomAction( GEOMOp::OpDMWireframe, "WIREFRAME" );
createGeomAction( GEOMOp::OpDMShading, "SHADING" );
createGeomAction( GEOMOp::OpDMShadingWithEdges, "SHADING_WITH_EDGES" );
createGeomAction( GEOMOp::OpUnpublishObject, "POP_UNPUBLISH_OBJ" );
createGeomAction( GEOMOp::OpPublishObject, "POP_PUBLISH_OBJ" );
createGeomAction( GEOMOp::OpPointMarker, "POP_POINT_MARKER" );
- createGeomAction( GEOMOp::OpMaterialProperties, "POP_MATERIAL_PROPERTIES" );
+ createGeomAction( GEOMOp::OpMaterialProperties, "POP_MATERIAL_PROPERTIES" );
+ createGeomAction( GEOMOp::OpPredefMaterCustom, "POP_PREDEF_MATER_CUSTOM" );
createGeomAction( GEOMOp::OpPipeTShape, "PIPETSHAPE" );
createMenu( GEOMOp::OpRevolution, genId, -1 );
createMenu( GEOMOp::OpFilling, genId, -1 );
createMenu( GEOMOp::OpPipe, genId, -1 );
+#if OCC_VERSION_LARGE > 0x06050300
+ createMenu( GEOMOp::OpPipePath, genId, -1 );
+#endif
// int advId = createMenu( tr( "MEN_ADVANCED" ), newEntId, -1 );
createMenu( GEOMOp::OpShell, buildId, -1 );
createMenu( GEOMOp::OpSolid, buildId, -1 );
createMenu( GEOMOp::OpCompound, buildId, -1 );
-
+
createMenu( separator(), newEntId, -1 );
-
+
createMenu( GEOMOp::OpPictureImport, newEntId, -1 );
#ifdef WITH_OPENCV
createMenu( GEOMOp::OpFeatureDetect, newEntId, -1 );
createMenu( GEOMOp::OpOrientation, repairId, -1 );
createMenu( GEOMOp::OpRemoveExtraEdges, repairId, -1 );
createMenu( GEOMOp::OpFuseEdges, repairId, -1 );
+ createMenu( GEOMOp::OpUnionFaces, repairId, -1 );
int measurId = createMenu( tr( "MEN_MEASURES" ), -1, -1, 10 );
createMenu( GEOMOp::OpPointCoordinates, measurId, -1 );
createMenu( GEOMOp::OpGetNonBlocks, measurId, -1 );
createMenu( GEOMOp::OpCheckSelfInters, measurId, -1 );
-#ifdef _DEBUG_ // PAL16821
int toolsId = createMenu( tr( "MEN_TOOLS" ), -1, -1, 50 );
+#if defined(_DEBUG_) || defined(_DEBUG) // PAL16821
createMenu( separator(), toolsId, -1 );
createMenu( GEOMOp::OpCheckGeom, toolsId, -1 );
#endif
+
+ createMenu( separator(), toolsId, -1 );
+ createMenu( GEOMOp::OpMaterialsLibrary, toolsId, -1 );
+ createMenu( separator(), toolsId, -1 );
int viewId = createMenu( tr( "MEN_VIEW" ), -1, -1 );
createMenu( separator(), viewId, -1 );
*/
// ---- create toolbars --------------------------
-
+
int basicTbId = createTool( tr( "TOOL_BASIC" ) );
createTool( GEOMOp::OpPoint, basicTbId );
createTool( GEOMOp::OpLine, basicTbId );
createTool( GEOMOp::OpPlane, basicTbId );
createTool( GEOMOp::OpLCS, basicTbId );
createTool( GEOMOp::OpOriginAndVectors, basicTbId );
-
+
// int sketchTbId = createTool( tr( "TOOL_SKETCH" ) );
// createTool( GEOMOp::Op2dSketcher, sketchTbId );
// createTool( GEOMOp::Op3dSketcher, sketchTbId );
-
+
int primTbId = createTool( tr( "TOOL_PRIMITIVES" ) );
createTool( GEOMOp::OpBox, primTbId );
createTool( GEOMOp::OpCylinder, primTbId );
createTool( GEOMOp::OpRectangle, primTbId );
createTool( GEOMOp::OpDisk, primTbId );
createTool( GEOMOp::OpPipeTShape, primTbId ); //rnc
-
+
int blocksTbId = createTool( tr( "TOOL_BLOCKS" ) );
createTool( GEOMOp::OpDividedDisk, blocksTbId );
createTool( GEOMOp::OpDividedCylinder, blocksTbId );
-
+
// int advancedTbId = createTool( tr( "TOOL_ADVANCED" ) ); //rnc
// createTool( GEOMOp::OpPipeTShape, advancedTbId );
-
+
int boolTbId = createTool( tr( "TOOL_BOOLEAN" ) );
createTool( GEOMOp::OpFuse, boolTbId );
createTool( GEOMOp::OpCommon, boolTbId );
createTool( GEOMOp::OpCut, boolTbId );
createTool( GEOMOp::OpSection, boolTbId );
-
- int genTbId = createTool( tr( "TOOL_GENERATION" ) );
+
+ int genTbId = createTool( tr( "TOOL_GENERATION" ) );
createTool( GEOMOp::OpPrism, genTbId );
createTool( GEOMOp::OpRevolution, genTbId );
createTool( GEOMOp::OpFilling, genTbId );
createTool( GEOMOp::OpPipe, genTbId );
-
+#if OCC_VERSION_LARGE > 0x06050300
+ createTool( GEOMOp::OpPipePath, genTbId );
+#endif
+
int transTbId = createTool( tr( "TOOL_TRANSFORMATION" ) );
createTool( GEOMOp::OpTranslate, transTbId );
createTool( GEOMOp::OpRotate, transTbId );
createTool( separator(), transTbId );
createTool( GEOMOp::OpMultiTranslate, transTbId );
createTool( GEOMOp::OpMultiRotate, transTbId );
-
+
int operTbId = createTool( tr( "TOOL_OPERATIONS" ) );
createTool( GEOMOp::OpExplode, operTbId );
createTool( GEOMOp::OpPartition, operTbId );
createTool( GEOMOp::OpArchimede, operTbId );
createTool( GEOMOp::OpShapesOnShape, operTbId );
createTool( GEOMOp::OpSharedShapes, operTbId );
-
+
int featTbId = createTool( tr( "TOOL_FEATURES" ) );
createTool( GEOMOp::OpFillet1d, featTbId );
createTool( GEOMOp::OpFillet2d, featTbId );
createTool( GEOMOp::OpChamfer, featTbId );
createTool( GEOMOp::OpExtrudedBoss, featTbId );
createTool( GEOMOp::OpExtrudedCut, featTbId );
-
+
int buildTbId = createTool( tr( "TOOL_BUILD" ) );
createTool( GEOMOp::OpEdge, buildTbId );
createTool( GEOMOp::OpWire, buildTbId );
#ifdef WITH_OPENCV
createTool( GEOMOp::OpFeatureDetect, picturesTbId );
#endif
-
+
// int advancedTbId = createTool( tr( "TOOL_ADVANCED" ) );
//@@ insert new functions before this line @@ do not remove this line @@ do not remove this line @@ do not remove this line @@ do not remove this line @@//
mgr->insert( action( GEOMOp::OpDelete ), -1, -1 ); // delete
mgr->setRule( action( GEOMOp::OpDelete ), QString("$type in {'Shape' 'Group'} and selcount>0"), QtxPopupMgr::VisibleRule );
mgr->insert( action( GEOMOp::OpGroupCreatePopup ), -1, -1 ); // create group
- mgr->setRule( action( GEOMOp::OpGroupCreatePopup ), QString("client='ObjectBrowser' and type='Shape' and selcount=1 and isOCC=true"), QtxPopupMgr::VisibleRule );
+ mgr->setRule( action( GEOMOp::OpGroupCreatePopup ), QString("type='Shape' and selcount=1 and isOCC=true"), QtxPopupMgr::VisibleRule );
mgr->insert( action( GEOMOp::OpDiscloseChildren ), -1, -1 ); // disclose child items
mgr->setRule( action( GEOMOp::OpDiscloseChildren ), QString("client='ObjectBrowser' and type='Shape' and selcount=1 and hasConcealedChildren=true"), QtxPopupMgr::VisibleRule );
mgr->setRule(action(GEOMOp::OpBringToFront), bringRule, QtxPopupMgr::VisibleRule );
mgr->setRule(action(GEOMOp::OpBringToFront), "topLevel=true", QtxPopupMgr::ToggleRule );
mgr->insert( action(GEOMOp::OpClsBringToFront ), -1, -1 ); // clear bring to front
- mgr->setRule( action(GEOMOp::OpClsBringToFront ), clientOCC, QtxPopupMgr::VisibleRule );
+ mgr->setRule( action(GEOMOp::OpClsBringToFront ), clientOCC, QtxPopupMgr::VisibleRule );
#endif
mgr->insert( separator(), -1, -1 ); // -----------
dispmodeId = mgr->insert( tr( "MEN_DISPLAY_MODE" ), -1, -1 ); // display mode menu
mgr->insert( action( GEOMOp::OpWireframe ), dispmodeId, -1 ); // wireframe
- mgr->setRule( action( GEOMOp::OpWireframe ), clientOCCorVTK_AndSomeVisible, QtxPopupMgr::VisibleRule );
+ mgr->setRule( action( GEOMOp::OpWireframe ), clientOCCorVTK_AndSomeVisible + " and ($component={'GEOM'})", QtxPopupMgr::VisibleRule );
mgr->setRule( action( GEOMOp::OpWireframe ), clientOCCorVTK + " and displaymode='Wireframe'", QtxPopupMgr::ToggleRule );
mgr->insert( action( GEOMOp::OpShading ), dispmodeId, -1 ); // shading
- mgr->setRule( action( GEOMOp::OpShading ), clientOCCorVTK_AndSomeVisible, QtxPopupMgr::VisibleRule );
+ mgr->setRule( action( GEOMOp::OpShading ), clientOCCorVTK_AndSomeVisible + " and ($component={'GEOM'})", QtxPopupMgr::VisibleRule );
mgr->setRule( action( GEOMOp::OpShading ), clientOCCorVTK + " and displaymode='Shading'", QtxPopupMgr::ToggleRule );
mgr->insert( action( GEOMOp::OpShadingWithEdges ), dispmodeId, -1 ); // shading with edges
- mgr->setRule( action( GEOMOp::OpShadingWithEdges ), clientOCCorVTK_AndSomeVisible, QtxPopupMgr::VisibleRule );
+ mgr->setRule( action( GEOMOp::OpShadingWithEdges ), clientOCCorVTK_AndSomeVisible + " and ($component={'GEOM'})", QtxPopupMgr::VisibleRule );
mgr->setRule( action( GEOMOp::OpShadingWithEdges ), clientOCCorVTK + " and displaymode='ShadingWithEdges'", QtxPopupMgr::ToggleRule );
mgr->insert( action( GEOMOp::OpTexture ), dispmodeId, -1 ); // wireframe
mgr->setRule( action( GEOMOp::OpTexture ), clientOCC_AndSomeVisible, QtxPopupMgr::VisibleRule );
mgr->setRule( action( GEOMOp::OpTexture), clientOCC + " and displaymode='Texture'", QtxPopupMgr::ToggleRule );
mgr->insert( separator(), dispmodeId, -1 );
mgr->insert( action( GEOMOp::OpVectors ), dispmodeId, -1 ); // vectors
- mgr->setRule( action( GEOMOp::OpVectors ), clientOCCorVTK_AndSomeVisible, QtxPopupMgr::VisibleRule );
+ mgr->setRule( action( GEOMOp::OpVectors ), clientOCCorVTK_AndSomeVisible + " and ($component={'GEOM'})", QtxPopupMgr::VisibleRule );
mgr->setRule( action( GEOMOp::OpVectors ), clientOCCorVTK + " and isVectorsMode", QtxPopupMgr::ToggleRule );
mgr->insert( separator(), -1, -1 ); // -----------
+
mgr->insert( action( GEOMOp::OpColor ), -1, -1 ); // color
mgr->setRule( action( GEOMOp::OpColor ), clientOCCorVTKorOB_AndSomeVisible + " and ($component={'GEOM'})" + "and isPhysicalMaterial=false", QtxPopupMgr::VisibleRule );
mgr->insert( action( GEOMOp::OpTransparency ), -1, -1 ); // transparency
- mgr->setRule( action( GEOMOp::OpTransparency ), clientOCCorVTK_AndSomeVisible, QtxPopupMgr::VisibleRule );
+ mgr->setRule( action( GEOMOp::OpTransparency ), clientOCCorVTK_AndSomeVisible + " and ($component={'GEOM'})", QtxPopupMgr::VisibleRule );
mgr->insert( action( GEOMOp::OpIsos ), -1, -1 ); // isos
- mgr->setRule( action( GEOMOp::OpIsos ), clientOCCorVTK_AndSomeVisible + " and selcount>0 and isVisible", QtxPopupMgr::VisibleRule );
+ mgr->setRule( action( GEOMOp::OpIsos ), clientOCCorVTK_AndSomeVisible + " and selcount>0 and isVisible" + " and ($component={'GEOM'})", QtxPopupMgr::VisibleRule );
mgr->insert( action( GEOMOp::OpDeflection ), -1, -1 ); // deflection
- mgr->setRule( action( GEOMOp::OpDeflection ), clientOCCorVTK_AndSomeVisible + " and selcount>0 and isVisible", QtxPopupMgr::VisibleRule );
+ mgr->setRule( action( GEOMOp::OpDeflection ), clientOCCorVTK_AndSomeVisible + " and selcount>0 and isVisible" + " and ($component={'GEOM'})", QtxPopupMgr::VisibleRule );
mgr->insert( action( GEOMOp::OpPointMarker ), -1, -1 ); // point marker
//mgr->setRule( action( GEOMOp::OpPointMarker ), QString( "selcount>0 and $typeid in {%1}" ).arg(GEOM_POINT ), QtxPopupMgr::VisibleRule );
mgr->setRule( action( GEOMOp::OpPointMarker ), QString( "selcount>0 and ( $typeid in {%1} or compoundOfVertices=true ) " ).arg(GEOM::VERTEX).arg(GEOM::COMPOUND), QtxPopupMgr::VisibleRule );
- mgr->insert( action( GEOMOp::OpMaterialProperties ), -1, -1 ); // material properties
- mgr->setRule( action( GEOMOp::OpMaterialProperties ), clientOCCorVTK_AndSomeVisible + " and ($component={'GEOM'}) and selcount>0 and isVisible", QtxPopupMgr::VisibleRule );
- mgr->insert( action( GEOMOp::OpSetTexture ), -1, -1 ); // texture
+
+ // material properties
+ mgr->insert( action( GEOMOp::OpMaterialProperties ), -1, -1 );
+ mgr->setRule( action( GEOMOp::OpMaterialProperties ), clientOCCorVTK_AndSomeVisible + " and ($component={'GEOM'})", QtxPopupMgr::VisibleRule );
+
+ // texture
+ mgr->insert( action( GEOMOp::OpSetTexture ), -1, -1 );
mgr->setRule( action( GEOMOp::OpSetTexture ), clientOCCorOB_AndSomeVisible + " and ($component={'GEOM'})", QtxPopupMgr::VisibleRule );
int lineW = mgr->insert( tr( "MEN_LINE_WIDTH" ), -1, -1 ); // line width menu
mgr->insert( action( GEOMOp::OpEdgeWidth ), lineW, -1 ); // edge width
- mgr->setRule( action( GEOMOp::OpEdgeWidth ), clientOCCorVTK_AndSomeVisible, QtxPopupMgr::VisibleRule );
+ mgr->setRule( action( GEOMOp::OpEdgeWidth ), clientOCCorVTK_AndSomeVisible + " and ($component={'GEOM'})", QtxPopupMgr::VisibleRule );
mgr->insert( action( GEOMOp::OpIsosWidth ), lineW, -1 ); // isos width
- mgr->setRule( action( GEOMOp::OpIsosWidth ), clientOCCorVTK_AndSomeVisible, QtxPopupMgr::VisibleRule );
-
+ mgr->setRule( action( GEOMOp::OpIsosWidth ), clientOCCorVTK_AndSomeVisible + " and ($component={'GEOM'})", QtxPopupMgr::VisibleRule );
+
mgr->insert( separator(), -1, -1 ); // -----------
mgr->insert( action( GEOMOp::OpAutoColor ), -1, -1 ); // auto color
mgr->setRule( action( GEOMOp::OpAutoColor ), autoColorPrefix + " and isAutoColor=false", QtxPopupMgr::VisibleRule );
mgr->insert( action( GEOMOp::OpUnpublishObject ), -1, -1 ); // Unpublish object
mgr->setRule( action( GEOMOp::OpUnpublishObject ), QString("client='ObjectBrowser' and $type in {'Shape' 'Group'} and selcount>0"), QtxPopupMgr::VisibleRule );
-
mgr->insert( action( GEOMOp::OpPublishObject ), -1, -1 ); // Publish object
mgr->setRule( action( GEOMOp::OpPublishObject ), QString("client='ObjectBrowser' and isComponent=true"), QtxPopupMgr::VisibleRule );
mgr->hide( mgr->actionId( action( myEraseAll ) ) );
-
SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr();
- if(resMgr) {
+ if (resMgr) {
GEOM_AISShape::setTopLevelDisplayMode((GEOM_AISShape::TopLevelDispMode)resMgr->integerValue("Geometry", "toplevel_dm", 0));
QColor c = resMgr->colorValue( "Geometry", "toplevel_color", QColor( 170, 85, 0 ) );
GEOM_AISShape::setTopLevelColor(SalomeApp_Tools::color(c));
// import Python module that manages GEOM plugins (need to be here because SalomePyQt API uses active module)
PyGILState_STATE gstate = PyGILState_Ensure();
- PyObject* pluginsmanager=PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
- if(pluginsmanager==NULL)
+ PyObject* pluginsmanager = PyImport_ImportModuleNoBlock((char*)"salome_pluginsmanager");
+ if (pluginsmanager == NULL)
PyErr_Print();
- else
- {
- PyObject* result=PyObject_CallMethod( pluginsmanager, (char*)"initialize", (char*)"isss",1,"geom",tr("MEN_NEW_ENTITY").toStdString().c_str(),tr("GEOM_PLUGINS_OTHER").toStdString().c_str());
- if(result==NULL)
- PyErr_Print();
- Py_XDECREF(result);
- }
+ else {
+ PyObject* result =
+ PyObject_CallMethod(pluginsmanager, (char*)"initialize", (char*)"isss", 1, "geom",
+ tr("MEN_NEW_ENTITY").toStdString().c_str(),
+ tr("GEOM_PLUGINS_OTHER").toStdString().c_str());
+ if (result == NULL)
+ PyErr_Print();
+ Py_XDECREF(result);
+ }
PyGILState_Release(gstate);
// end of GEOM plugins loading
// 0020836 (Basic vectors and origin)
SUIT_ResourceMgr* aResourceMgr = SUIT_Session::session()->resourceMgr();
- if( aResourceMgr->booleanValue( "Geometry", "auto_create_base_objects", false ) ) {
+ if ( aResourceMgr->booleanValue( "Geometry", "auto_create_base_objects", false ) ) {
SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
- if( appStudy ) {
+ if ( appStudy ) {
_PTR(Study) studyDS = appStudy->studyDS();
- if( studyDS ) {
+ if ( studyDS ) {
_PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM");
- if( !aSComponent ) // create objects automatically only if there is no GEOM component
+ if ( !aSComponent ) // create objects automatically only if there is no GEOM component
createOriginAndBaseVectors();
}
}
return true;
}
-
//=======================================================================
// function : GeometryGUI::deactivateModule()
// purpose : Called when GEOM module is deactivated
this, SLOT( OnMouseMove( SUIT_ViewWindow*, QMouseEvent* ) ) );
connect( vm, SIGNAL( mouseRelease ( SUIT_ViewWindow*, QMouseEvent* ) ),
this, SLOT( OnMouseRelease( SUIT_ViewWindow*, QMouseEvent* ) ) );
-
+
LightApp_SelectionMgr* sm = getApp()->selectionMgr();
myOCCSelectors.append( new GEOMGUI_OCCSelector( ((OCCViewer_ViewManager*)vm)->getOCCViewer(), sm ) );
if ( GEOMGUI_OCCSelector* sr = itOCCSel.next() )
if ( sr->viewer() == viewer )
{
- delete myOCCSelectors.takeAt( myOCCSelectors.indexOf( sr ) );
+ /*delete*/ myOCCSelectors.takeAt( myOCCSelectors.indexOf( sr ) );
break;
}
}
if ( LightApp_VTKSelector* sr = itVTKSel.next() )
if ( sr->viewer() == viewer )
{
- delete myVTKSelectors.takeAt( myVTKSelectors.indexOf( sr ) );
+ /*delete*/ myVTKSelectors.takeAt( myVTKSelectors.indexOf( sr ) );
break;
}
}
SalomeApp_Module::contextMenuPopup( client, menu, title );
SALOME_ListIO lst;
getApp()->selectionMgr()->selectedObjects( lst );
+
+ //Add submenu for predefined materials
+ bool isPredefMat = SUIT_Session::session()->resourceMgr()->booleanValue( "Geometry", "predef_materials" );
+ if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() > 0 ) {
+ QtxPopupMgr* mgr = popupMgr();
+ //get parrent for submenu
+ QAction* act = mgr->action( mgr->actionId( action( GEOMOp::OpMaterialProperties ) ) );
+ //Clear old menu
+ QMenu* oldMenu = act->menu() ;
+ if( oldMenu ) {
+ delete oldMenu;
+ }
+ if( isPredefMat ){
+ QMenu* matMenu = new QMenu();
+ QSignalMapper* signalMapper = new QSignalMapper( matMenu );
+
+ //Get current material model for the object
+ QVariant v;
+ LightApp_Application* anApp = dynamic_cast<LightApp_Application*>( getApp() );
+ if ( anApp && anApp->activeViewManager() ) {
+ LightApp_Study* aStudy = dynamic_cast<LightApp_Study*>( anApp->activeStudy() );
+ if( aStudy ) {
+ v = aStudy->getObjectProperty( anApp->activeViewManager()->getGlobalId(), lst.Last()->getEntry(), GEOM::propertyName( GEOM::Material ), QVariant() );
+ }
+ }
+ QString curModel = "";
+ if ( v.canConvert<QString>() ) curModel = v.toString();
+ // get list of all predefined materials
+ QStringList materials = Material_ResourceMgr::resourceMgr()->materials();
+ bool found = false;
+ foreach ( QString material, materials )
+ {
+ QAction* menAct = matMenu->addAction( material );
+ connect(menAct, SIGNAL( toggled( bool ) ), signalMapper, SLOT( map() ) );
+ signalMapper->setMapping( menAct, material );
+ menAct->setCheckable( true );
+ // Set checked if this material is current
+ Material_Model aModel;
+ aModel.fromResources( material );
+ if ( !found && aModel.toProperties() == curModel ) {
+ menAct->setChecked( true );
+ found = true;
+ }
+ }
+ matMenu->insertAction( matMenu->addSeparator(), action( GEOMOp::OpPredefMaterCustom ) );
+ matMenu->insertSeparator( action( GEOMOp::OpPredefMaterCustom ) );
+ connect( signalMapper, SIGNAL( mapped( const QString & ) ),
+ this, SLOT( OnSetMaterial( const QString & ) ) );
+ act->setMenu( matMenu );
+ }
+ }
+ //Set name
if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) {
Handle(SALOME_InteractiveObject) io = lst.First();
SalomeApp_Study* appStudy = dynamic_cast<SalomeApp_Study*>( application()->activeStudy() );
}
}
+void GeometryGUI::OnSetMaterial(const QString& theName)
+{
+ OnGUIEvent( GEOMOp::OpPredefMaterial, QVariant( theName ) );
+}
+
+
void GeometryGUI::createPreferences()
{
int tabId = addPreference( tr( "PREF_TAB_SETTINGS" ) );
int defl = addPreference( tr( "PREF_DEFLECTION" ), genGroup,
LightApp_Preferences::DblSpin, "Geometry", "deflection_coeff" );
+ addPreference( tr( "PREF_PREDEF_MATERIALS" ), genGroup,
+ LightApp_Preferences::Bool, "Geometry", "predef_materials" );
+
int material = addPreference( tr( "PREF_MATERIAL" ), genGroup,
- LightApp_Preferences::Selector,
- "Geometry", "material" );
-
+ LightApp_Preferences::Selector,
+ "Geometry", "material" );
+
+ addPreference( tr( "PREF_EDITGROUP_COLOR" ), genGroup,
+ LightApp_Preferences::Color, "Geometry", "editgroup_color" );
+
const int nb = 4;
int wd[nb];
int iter=0;
wd[iter++] = addPreference( tr( "PREF_EDGE_WIDTH" ), genGroup,
- LightApp_Preferences::IntSpin, "Geometry", "edge_width" );
+ LightApp_Preferences::IntSpin, "Geometry", "edge_width" );
wd[iter++] = addPreference( tr( "PREF_ISOLINES_WIDTH" ), genGroup,
- LightApp_Preferences::IntSpin, "Geometry", "isolines_width" );
+ LightApp_Preferences::IntSpin, "Geometry", "isolines_width" );
wd[iter++] = addPreference( tr( "PREF_PREVIEW_EDGE_WIDTH" ), genGroup,
- LightApp_Preferences::IntSpin, "Geometry", "preview_edge_width" );
-
+ LightApp_Preferences::IntSpin, "Geometry", "preview_edge_width" );
+
wd[iter++] = addPreference( tr( "PREF_MEASURES_LINE_WIDTH" ), genGroup,
- LightApp_Preferences::IntSpin, "Geometry", "measures_line_width" );
+ LightApp_Preferences::IntSpin, "Geometry", "measures_line_width" );
- for(int i = 0; i < nb; i++) {
- setPreferenceProperty( wd[i], "min", 1 );
+ for (int i = 0; i < nb; i++) {
+ setPreferenceProperty( wd[i], "min", 1 );
setPreferenceProperty( wd[i], "max", 5 );
}
-
+
+ int isoGroup = addPreference( tr( "PREF_ISOS" ), tabId );
+ setPreferenceProperty( isoGroup, "columns", 2 );
+ int isoU = addPreference( tr( "PREF_ISOS_U" ), isoGroup,
+ LightApp_Preferences::IntSpin, "Geometry", "iso_number_u" );
+ setPreferenceProperty( isoU, "min", 0 );
+ setPreferenceProperty( isoU, "max", 100000 );
+ int isoV = addPreference( tr( "PREF_ISOS_V" ), isoGroup,
+ LightApp_Preferences::IntSpin, "Geometry", "iso_number_v" );
+ setPreferenceProperty( isoV, "min", 0 );
+ setPreferenceProperty( isoV, "max", 100000 );
// Quantities with individual precision settings
int precGroup = addPreference( tr( "GEOM_PREF_GROUP_PRECISION" ), tabId );
setPreferenceProperty( dispmode, "strings", aModesList );
setPreferenceProperty( dispmode, "indexes", anIndexesList );
-
// Set property for top level display mode
QStringList aTopModesList;
aTopModesList.append( tr("MEN_SHOW_ADD_WACTOR") );
setPreferenceProperty( step, "precision", 3 );
// Set property for deflection value for spinboxes
- setPreferenceProperty( defl, "min", DEFLECTION_MIN );
+ setPreferenceProperty( defl, "min", GEOM::minDeflection() );
setPreferenceProperty( defl, "max", 1.0 );
setPreferenceProperty( defl, "step", 1.0e-04 );
setPreferenceProperty( defl, "precision", 6 );
// Set property for default material
- Material_ResourceMgr aMatResMgr;
- setPreferenceProperty( material, "strings", aMatResMgr.materials() );
-
+ setPreferenceProperty( material, "strings", Material_ResourceMgr::resourceMgr()->materials() );
+
// Set property vertex marker type
QList<QVariant> aMarkerTypeIndicesList;
QList<QVariant> aMarkerTypeIconsList;
addPreference( tr( "PREF_AUTO_CREATE" ), originGroup,
LightApp_Preferences::Bool, "Geometry", "auto_create_base_objects" );
-
int operationsGroup = addPreference( tr( "PREF_GROUP_OPERATIONS" ), tabId );
setPreferenceProperty( operationsGroup, "columns", 2 );
if (param == QString("SettingsGeomStep")) {
double spin_step = aResourceMgr->doubleValue(section, param, 100.);
EmitSignalDefaultStepValueChanged(spin_step);
- } else if(param == QString("toplevel_color")) {
+ }
+ else if (param == QString("toplevel_color")) {
QColor c = aResourceMgr->colorValue( "Geometry", "toplevel_color", QColor( 170, 85, 0 ) );
GEOM_AISShape::setTopLevelColor(SalomeApp_Tools::color(c));
- } else if(param == QString("toplevel_dm")) {
+ }
+ else if (param == QString("toplevel_dm")) {
GEOM_AISShape::setTopLevelDisplayMode((GEOM_AISShape::TopLevelDispMode)aResourceMgr->integerValue("Geometry", "toplevel_dm", 0));
}
- }
+ }
}
LightApp_Displayer* GeometryGUI::displayer()
{
- if( !myDisplayer )
+ if ( !myDisplayer )
myDisplayer = new GEOM_Displayer( dynamic_cast<SalomeApp_Study*>( getApp()->activeStudy() ) );
return myDisplayer;
}
{
myLocalSelectionMode = mode;
}
+
int GeometryGUI::getLocalSelectionMode() const
{
return myLocalSelectionMode;
std::string entry = ip->encodeEntry(o_it.key().toLatin1().data(), componentName);
_PTR(GenericAttribute) anAttr;
- if( !obj->FindAttribute(anAttr, "AttributeIOR"))
+ if (!obj->FindAttribute(anAttr, "AttributeIOR"))
continue;
- std::string param,occParam = vType.toLatin1().data();
- occParam += NAME_SEPARATOR;
- occParam += QString::number(aMgrId).toLatin1().data();
- occParam += NAME_SEPARATOR;
+ QString param, occParam = vType;
+ occParam += GEOM::sectionSeparator();
+ occParam += QString::number(aMgrId);
+ occParam += GEOM::sectionSeparator();
- if(aProps.contains(VISIBILITY_PROP)) {
- param = occParam + VISIBILITY_PROP;
- ip->setParameter(entry, param, aProps.value(VISIBILITY_PROP).toInt() == 1 ? "On" : "Off");
+ if (aProps.contains(GEOM::propertyName( GEOM::Visibility ))) {
+ param = occParam + GEOM::propertyName( GEOM::Visibility );
+ ip->setParameter(entry, param.toStdString(), aProps.value(GEOM::propertyName( GEOM::Visibility )).toBool() ? "On" : "Off");
}
- if(aProps.contains(DISPLAY_MODE_PROP)) {
- param = occParam + DISPLAY_MODE_PROP;
- ip->setParameter(entry, param, QString::number(aProps.value(DISPLAY_MODE_PROP).toInt()).toLatin1().data());
+ if (aProps.contains(GEOM::propertyName( GEOM::DisplayMode ))) {
+ param = occParam + GEOM::propertyName( GEOM::DisplayMode );
+ ip->setParameter(entry, param.toStdString(), aProps.value(GEOM::propertyName( GEOM::DisplayMode )).toString().toStdString());
}
- if(aProps.contains(COLOR_PROP)) {
- QColor c = aProps.value(COLOR_PROP).value<QColor>();
- QString colorStr = QString::number(c.red()/255.);
- colorStr += DIGIT_SEPARATOR; colorStr += QString::number(c.green()/255.);
- colorStr += DIGIT_SEPARATOR; colorStr += QString::number(c.blue()/255.);
- param = occParam + COLOR_PROP;
- ip->setParameter(entry, param, colorStr.toLatin1().data());
+ if (aProps.contains(GEOM::propertyName( GEOM::Color ))) {
+ QColor c = aProps.value(GEOM::propertyName( GEOM::Color )).value<QColor>();
+ QStringList val;
+ val << QString::number(c.redF());
+ val << QString::number(c.greenF());
+ val << QString::number(c.blueF());
+ param = occParam + GEOM::propertyName( GEOM::Color );
+ ip->setParameter(entry, param.toStdString(), val.join( GEOM::subSectionSeparator()).toStdString());
}
- if(vType == SVTK_Viewer::Type()) {
- if(aProps.contains(OPACITY_PROP)) {
- param = occParam + OPACITY_PROP;
- ip->setParameter(entry, param, QString::number(1. - aProps.value(TRANSPARENCY_PROP).toDouble()).toLatin1().data());
+ if (vType == SVTK_Viewer::Type()) {
+ if (aProps.contains(GEOM::propertyName( GEOM::Opacity ))) {
+ param = occParam + GEOM::propertyName( GEOM::Opacity );
+ ip->setParameter(entry, param.toStdString(), QString::number(1. - aProps.value(GEOM::propertyName( GEOM::Transparency )).toDouble()).toStdString());
}
} else if (vType == SOCC_Viewer::Type()) {
- if(aProps.contains(TRANSPARENCY_PROP)) {
- param = occParam + TRANSPARENCY_PROP;
- ip->setParameter(entry, param, QString::number(aProps.value(TRANSPARENCY_PROP).toDouble()).toLatin1().data());
+ if (aProps.contains(GEOM::propertyName( GEOM::Transparency ))) {
+ param = occParam + GEOM::propertyName( GEOM::Transparency );
+ ip->setParameter(entry, param.toStdString(), aProps.value(GEOM::propertyName( GEOM::Transparency )).toString().toStdString());
}
- if(aProps.contains(TOP_LEVEL_PROP)) {
- param = occParam + TOP_LEVEL_PROP;
- Standard_Boolean val = aProps.value(TOP_LEVEL_PROP).value<Standard_Boolean>();
- if (val == Standard_True)
- ip->setParameter(entry, param, "1");
- }
+ if (aProps.contains(GEOM::propertyName( GEOM::TopLevel ))) {
+ param = occParam + GEOM::propertyName( GEOM::TopLevel );
+ ip->setParameter(entry, param.toStdString(), aProps.value(GEOM::propertyName( GEOM::TopLevel )).toString().toStdString());
+ }
}
- if(aProps.contains(ISOS_PROP)) {
- param = occParam + ISOS_PROP;
- ip->setParameter(entry, param, aProps.value(ISOS_PROP).toString().toLatin1().data());
+ if (aProps.contains(GEOM::propertyName( GEOM::NbIsos ))) {
+ param = occParam + GEOM::propertyName( GEOM::NbIsos );
+ ip->setParameter(entry, param.toStdString(), aProps.value(GEOM::propertyName( GEOM::NbIsos )).toString().toStdString());
}
- if(aProps.contains(VECTOR_MODE_PROP)) {
- param = occParam + VECTOR_MODE_PROP;
- ip->setParameter(entry, param, QString::number(aProps.value(VECTOR_MODE_PROP).toInt()).toLatin1().data());
+ if (aProps.contains(GEOM::propertyName( GEOM::EdgesDirection ))) {
+ param = occParam + GEOM::propertyName( GEOM::EdgesDirection );
+ ip->setParameter(entry, param.toStdString(), aProps.value(GEOM::propertyName( GEOM::EdgesDirection )).toString().toStdString());
}
- if(aProps.contains(DEFLECTION_COEFF_PROP)) {
- param = occParam + DEFLECTION_COEFF_PROP;
- ip->setParameter(entry, param, QString::number(aProps.value(DEFLECTION_COEFF_PROP).toDouble()).toLatin1().data());
+ if (aProps.contains(GEOM::propertyName( GEOM::Deflection ))) {
+ param = occParam + GEOM::propertyName( GEOM::Deflection );
+ ip->setParameter(entry, param.toStdString(), aProps.value(GEOM::propertyName( GEOM::Deflection )).toString().toStdString());
}
//Marker type of the vertex - ONLY for the "Vertex" and "Compound of the Vertex"
- if(aProps.contains(MARKER_TYPE_PROP)) {
- param = occParam + MARKER_TYPE_PROP;
- ip->setParameter(entry, param, aProps.value(MARKER_TYPE_PROP).toString().toLatin1().data());
+ if (aProps.contains(GEOM::propertyName( GEOM::PointMarker ))) {
+ param = occParam + GEOM::propertyName( GEOM::PointMarker );
+ ip->setParameter(entry, param.toStdString(), aProps.value(GEOM::propertyName( GEOM::PointMarker )).toString().toStdString());
}
- if(aProps.contains(MATERIAL_PROP)) {
- param = occParam + MATERIAL_PROP;
- ip->setParameter(entry, param, aProps.value(MATERIAL_PROP).toString().toLatin1().data());
+ if (aProps.contains(GEOM::propertyName( GEOM::Material ))) {
+ param = occParam + GEOM::propertyName( GEOM::Material );
+ ip->setParameter(entry, param.toStdString(), aProps.value(GEOM::propertyName( GEOM::Material )).toString().toStdString());
}
- if(aProps.contains( EDGE_WIDTH_PROP )) {
- param = occParam + EDGE_WIDTH_PROP;
- ip->setParameter(entry, param, aProps.value(EDGE_WIDTH_PROP).toString().toLatin1().data());
+ if (aProps.contains(GEOM::propertyName( GEOM::LineWidth ))) {
+ param = occParam + GEOM::propertyName( GEOM::LineWidth );
+ ip->setParameter(entry, param.toStdString(), aProps.value(GEOM::propertyName( GEOM::LineWidth )).toString().toStdString());
}
-
- if(aProps.contains( ISOS_WIDTH_PROP )) {
- param = occParam + ISOS_WIDTH_PROP;
- ip->setParameter(entry, param, aProps.value(ISOS_WIDTH_PROP).toString().toLatin1().data());
+
+ if (aProps.contains(GEOM::propertyName( GEOM::IsosWidth ))) {
+ param = occParam + GEOM::propertyName( GEOM::IsosWidth );
+ ip->setParameter(entry, param.toStdString(), aProps.value(GEOM::propertyName( GEOM::IsosWidth )).toString().toStdString());
}
} // object iterator
} // for (views)
{
// visual parameters are stored in strings as follows: ViewerType_ViewIndex_ParamName.
// '_' is used as separator and should not be used in viewer type or parameter names.
- QStringList lst = QString((*namesIt).c_str()).split(NAME_SEPARATOR, QString::SkipEmptyParts);
+ QStringList lst = QString((*namesIt).c_str()).split( GEOM::sectionSeparator(), QString::SkipEmptyParts);
if (lst.size() != 3)
continue;
if (!ok) // bad conversion of view index to integer
continue;
- if((viewIndex + 1) > aListOfMap.count()) {
+ if ((viewIndex + 1) > aListOfMap.count()) {
aListOfMap.resize(viewIndex + 1);
}
QString val((*valuesIt).c_str());
- if(paramNameStr == VISIBILITY_PROP){
- aListOfMap[viewIndex].insert(VISIBILITY_PROP, val == "On" ? 1 : 0);
-
- } else if(paramNameStr == OPACITY_PROP) {
- aListOfMap[viewIndex].insert(TRANSPARENCY_PROP, 1. - val.toDouble());
-
- } else if(paramNameStr == TRANSPARENCY_PROP) {
- aListOfMap[viewIndex].insert( TRANSPARENCY_PROP, val.toDouble() );
-
- } else if(paramNameStr == TOP_LEVEL_PROP) {
- aListOfMap[viewIndex].insert( TRANSPARENCY_PROP, val == "1" ? Standard_True : Standard_False );
-
- } else if(paramNameStr == DISPLAY_MODE_PROP) {
- aListOfMap[viewIndex].insert( DISPLAY_MODE_PROP, val.toInt());
-
- } else if(paramNameStr == ISOS_PROP) {
- aListOfMap[viewIndex].insert( ISOS_PROP, val);
-
- } else if(paramNameStr == COLOR_PROP) {
- QStringList rgb = val.split(DIGIT_SEPARATOR);
- if(rgb.count() == 3) {
- QColor c(int(rgb[0].toDouble()*255), int(rgb[1].toDouble()*255), int(rgb[2].toDouble()*255));
- aListOfMap[viewIndex].insert( COLOR_PROP, c);
+ if (paramNameStr == GEOM::propertyName( GEOM::Visibility )) {
+ aListOfMap[viewIndex].insert(GEOM::propertyName( GEOM::Visibility ), val == "On");
+ } else if (paramNameStr == GEOM::propertyName( GEOM::Opacity )) {
+ aListOfMap[viewIndex].insert(GEOM::propertyName( GEOM::Transparency ), 1. - val.toDouble());
+ } else if (paramNameStr == GEOM::propertyName( GEOM::Transparency )) {
+ aListOfMap[viewIndex].insert( GEOM::propertyName( GEOM::Transparency ), val.toDouble() );
+ } else if (paramNameStr == GEOM::propertyName( GEOM::TopLevel )) {
+ aListOfMap[viewIndex].insert( GEOM::propertyName( GEOM::TopLevel ), val == "true" || val == "1");
+ } else if (paramNameStr == GEOM::propertyName( GEOM::DisplayMode )) {
+ aListOfMap[viewIndex].insert( GEOM::propertyName( GEOM::DisplayMode ), val.toInt());
+ } else if (paramNameStr == GEOM::propertyName( GEOM::NbIsos )) {
+ aListOfMap[viewIndex].insert( GEOM::propertyName( GEOM::NbIsos ), val);
+ } else if (paramNameStr == GEOM::propertyName( GEOM::Color )) {
+ QStringList rgb = val.split(GEOM::subSectionSeparator());
+ if (rgb.count() == 3) {
+ QColor c = QColor::fromRgbF(rgb[0].toDouble(), rgb[1].toDouble(), rgb[2].toDouble());
+ aListOfMap[viewIndex].insert( GEOM::propertyName( GEOM::Color ), c);
}
- } else if(paramNameStr == VECTOR_MODE_PROP) {
- aListOfMap[viewIndex].insert( VECTOR_MODE_PROP, val.toInt());
-
- } else if(paramNameStr == DEFLECTION_COEFF_PROP) {
- aListOfMap[viewIndex].insert( DEFLECTION_COEFF_PROP, val.toDouble());
- } else if(paramNameStr == MARKER_TYPE_PROP) {
- aListOfMap[viewIndex].insert( MARKER_TYPE_PROP, val);
- } else if(paramNameStr == MATERIAL_PROP) {
- aListOfMap[viewIndex].insert( MATERIAL_PROP, val);
- } else if(paramNameStr == EDGE_WIDTH_PROP) {
- aListOfMap[viewIndex].insert( EDGE_WIDTH_PROP , val);
- } else if(paramNameStr == ISOS_WIDTH_PROP) {
- aListOfMap[viewIndex].insert( ISOS_WIDTH_PROP , val);
+ } else if (paramNameStr == GEOM::propertyName( GEOM::EdgesDirection )) {
+ aListOfMap[viewIndex].insert( GEOM::propertyName( GEOM::EdgesDirection ), val == "true" || val == "1");
+ } else if (paramNameStr == GEOM::propertyName( GEOM::Deflection )) {
+ aListOfMap[viewIndex].insert( GEOM::propertyName( GEOM::Deflection ), val.toDouble());
+ } else if (paramNameStr == GEOM::propertyName( GEOM::PointMarker )) {
+ aListOfMap[viewIndex].insert( GEOM::propertyName( GEOM::PointMarker ), val);
+ } else if (paramNameStr == GEOM::propertyName( GEOM::Material )) {
+ aListOfMap[viewIndex].insert( GEOM::propertyName( GEOM::Material ), val);
+ } else if (paramNameStr == GEOM::propertyName( GEOM::LineWidth )) {
+ aListOfMap[viewIndex].insert( GEOM::propertyName( GEOM::LineWidth ), val.toInt());
+ } else if (paramNameStr == GEOM::propertyName( GEOM::IsosWidth )) {
+ aListOfMap[viewIndex].insert( GEOM::propertyName( GEOM::IsosWidth ), val.toInt());
}
-
-
-
} // for names/parameters iterator
QList<SUIT_ViewManager*> lst = getApp()->viewManagers();
appStudy->setObjectPropMap(index, entry, aListOfMap[index]);
//Get Visibility property of the current PropMap
- if (aListOfMap[index].value(VISIBILITY_PROP) == 1) {
+ if (aListOfMap[index].value(GEOM::propertyName( GEOM::Visibility )) == 1) {
SUIT_ViewManager* vman = lst.at(index);
SUIT_ViewModel* vmodel = vman->getViewModel();
displayer()->Display(entry, true, dynamic_cast<SALOME_View*>(vmodel));
}
}
-
} // for entries iterator
// update all VTK and OCC views
/*!
\brief Return action by id
\param id identifier of the action
- \return action
+ \return action
*/
QAction* GeometryGUI::getAction(const int id) {
return action(id);
}
+/*!
+ \brief GEOM module message handler
+
+ This method can be re-implemented in the subclasses.
+ This is a GEOM module message handler.
+
+ \param msg the message received.
+*/
+void GeometryGUI::message(const QString& msg)
+{
+ // dispatch message
+ QStringList data = msg.split("/");
+ const int nbStrings = data.count();
+
+ if (nbStrings > 0) {
+ if (data[0] == "modified") {
+ // get mesh entry
+ QString anIOR = nbStrings > 1 ? data[1] : QString();
+
+ if ( anIOR.isEmpty() ) {
+ return;
+ }
+
+ // Get the geom object.
+ GEOM::GEOM_Object_ptr anObj = GeometryGUI::GetObjectFromIOR (anIOR);
+
+ // Clear the shape buffer
+ GeometryGUI::ClearShapeBuffer (anObj);
+ }
+ }
+}
+
+/*!
+ \brief Clears the shape buffer.
+
+ This is a static method. It clears the shape buffer.
+
+ \param theObj the object
+*/
+void GeometryGUI::ClearShapeBuffer( GEOM::GEOM_Object_ptr theObj )
+{
+ if ( CORBA::is_nil( theObj ) )
+ return;
+
+ CORBA::String_var IOR = SalomeApp_Application::orb()->object_to_string( theObj );
+ TCollection_AsciiString asciiIOR( (char *)IOR.in() );
+ GEOM_Client::get_client().RemoveShapeFromBuffer( asciiIOR );
+
+ SALOMEDSClient_StudyManager *aManager = SalomeApp_Application::studyMgr();
+
+ if (!aManager)
+ return;
+
+ _PTR(Study) aStudy = aManager->GetStudyByID(theObj->GetStudyID());
+
+ if ( !aStudy )
+ return;
+
+ _PTR(SObject) aSObj ( aStudy->FindObjectIOR( std::string( IOR ) ) );
+ if ( !aSObj )
+ return;
+
+ _PTR(ChildIterator) anIt ( aStudy->NewChildIterator( aSObj ) );
+ for ( anIt->InitEx( true ); anIt->More(); anIt->Next() ) {
+ _PTR(GenericAttribute) anAttr;
+ if ( anIt->Value()->FindAttribute(anAttr, "AttributeIOR") ) {
+ _PTR(AttributeIOR) anIOR ( anAttr );
+ TCollection_AsciiString asciiIOR( (char*)anIOR->Value().c_str() );
+ GEOM_Client::get_client().RemoveShapeFromBuffer( asciiIOR );
+ }
+ }
+}
+
+/*!
+ \brief Returns the object from IOR.
+
+ This is a static method. It returns the object from its IOR.
+
+ \param IOR object IOR
+ \return GEOM object.
+*/
+GEOM::GEOM_Object_ptr GeometryGUI::GetObjectFromIOR( const QString& IOR )
+{
+ GEOM::GEOM_Object_var geomObj;
+ if ( !IOR.isEmpty() ) {
+ CORBA::Object_var corbaObj = SalomeApp_Application::orb()->string_to_object
+ ( IOR.toLatin1().constData() );
+ if ( !CORBA::is_nil( corbaObj ) )
+ geomObj = GEOM::GEOM_Object::_narrow( corbaObj );
+ }
+ return geomObj._retn();
+}
+
+/*!
+ \brief Returns IOR of the object.
+
+ This is a static method. It returns the object's IOR.
+
+ \param object the GEOM object.
+ \return object's IOR.
+*/
+QString GeometryGUI::GetIORFromObject( GEOM::GEOM_Object_ptr object )
+{
+ QString IOR;
+ if ( !CORBA::is_nil( object ) ) {
+ CORBA::String_var anIOR =
+ SalomeApp_Application::orb()->object_to_string( object );
+ IOR = anIOR.in();
+ }
+ return IOR;
+}
+
/*!
\brief Check if this object is can't be renamed in place
bool GeometryGUI::renameAllowed( const QString& entry) const {
SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() );
- SalomeApp_Study* appStudy = app ? dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) : 0;
+ SalomeApp_Study* appStudy = app ? dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) : 0;
SalomeApp_DataObject* obj = appStudy ? dynamic_cast<SalomeApp_DataObject*>(appStudy->findObjectByEntry(entry)) : 0;
-
+
return (app && appStudy && obj && !appStudy->isComponent(entry) && !obj->isReference());
}
-
/*!
Rename object by entry.
\param entry entry of the object
\param name new name of the object
\brief Return \c true if rename operation finished successfully, \c false otherwise.
*/
-bool GeometryGUI::renameObject( const QString& entry, const QString& name) {
-
+bool GeometryGUI::renameObject( const QString& entry, const QString& name)
+{
bool result = false;
-
- SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication());
+
+ SalomeApp_Application* app =
+ dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication());
SalomeApp_Study* appStudy = app ? dynamic_cast<SalomeApp_Study*>( app->activeStudy() ) : 0;
-
- if(!appStudy)
+
+ if (!appStudy)
return result;
-
+
_PTR(Study) aStudy = appStudy->studyDS();
-
- if(!aStudy)
+
+ if (!aStudy)
return result;
bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked();
return result;
}
+void GeometryGUI::updateMaterials()
+{
+ LightApp_Preferences* pref = preferences();
+ if ( pref ) {
+ QStringList materials = Material_ResourceMgr::resourceMgr()->materials();
+ QString currentMaterial = SUIT_Session::session()->resourceMgr()->stringValue( "Geometry", "material" );
+ if ( !materials.contains( currentMaterial ) )
+ // user material set as default in the preferences, might be removed
+ SUIT_Session::session()->resourceMgr()->setValue( "Geometry", "material", QString( "Plastic" ) );
+
+ QtxPreferenceItem* prefItem = pref->rootItem()->findItem( tr( "PREF_MATERIAL" ), true );
+ if ( prefItem ) {
+ setPreferenceProperty( prefItem->id(),
+ "strings", materials );
+ prefItem->retrieve();
+ }
+ }
+}
