X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FGEOMGUI%2FGeometryGUI.cxx;h=d13a0fd99da80993ea3e627af4c169ae0728955d;hb=bed71e55e89040080f5b0ca691d9654b59a26a0d;hp=6f9d09bde62700925c27aa0f3578a3ae535aa377;hpb=6ceb0d775030ef212be8e999ac432201d4257f86;p=modules%2Fgeom.git diff --git a/src/GEOMGUI/GeometryGUI.cxx b/src/GEOMGUI/GeometryGUI.cxx index 6f9d09bde..d13a0fd99 100644 --- a/src/GEOMGUI/GeometryGUI.cxx +++ b/src/GEOMGUI/GeometryGUI.cxx @@ -1,40 +1,44 @@ -// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE +// Copyright (C) 2007-2012 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 +// Copyright (C) 2003-2007 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 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. +// 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 +// 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 +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // +// File : GeometryGUI.cxx +// Author : Vadim SANDLER, Open CASCADE S.A.S. (vadim.sandler@opencascade.com) -// GEOM GEOMGUI : GUI for Geometry component -// File : GeometryGUI.cxx -// Author : Vadim SANDLER, Open CASCADE S.A.S. (vadim.sandler@opencascade.com) -// #include // E.A. must be included before Python.h to fix compilation on windows +#ifdef HAVE_FINITE +#undef HAVE_FINITE // VSR: avoid compilation warning on Linux : "HAVE_FINITE" redefined +#endif #include "Python.h" #include "GeometryGUI.h" #include "GeometryGUI_Operations.h" #include "GEOMGUI_OCCSelector.h" #include "GEOMGUI_Selection.h" +#include "GEOM_Constants.h" #include "GEOM_Displayer.h" #include "GEOM_AISShape.hxx" #include "GEOM_Actor.h" +#include + #include #include #include @@ -55,7 +59,9 @@ #include #include +#include #include +#include #include #include @@ -69,8 +75,11 @@ #include #include +#include + // External includes #include +#include #include #include #include @@ -84,19 +93,30 @@ #include #include #include + +#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1 +#include +#else #include +#endif #include #include #include +#include + #include "GEOMImpl_Types.hxx" extern "C" { Standard_EXPORT CAM_Module* createModule() { return new GeometryGUI(); } + + Standard_EXPORT char* getModuleVersion() { + return (char*)GEOM_VERSION_STR; + } } GeometryGUI::StudyTextureMap GeometryGUI::myTextureMap; @@ -114,7 +134,7 @@ GEOM::GEOM_Gen_var GeometryGUI::GetGeomGen() bool GeometryGUI::InitGeomGen() { GeometryGUI aGG; - if( CORBA::is_nil( myComponentGeom ) ) return false; + if ( CORBA::is_nil( myComponentGeom ) ) return false; return true; } @@ -152,6 +172,17 @@ SALOMEDS::Study_var GeometryGUI::ClientStudyToStudy (_PTR(Study) theStudy) return aDSStudy._retn(); } +void GeometryGUI::Modified (bool theIsUpdateActions) +{ + if ( SalomeApp_Application* app = dynamic_cast( SUIT_Session::session()->activeApplication() ) ) { + if ( SalomeApp_Study* appStudy = dynamic_cast( app->activeStudy() ) ) { + appStudy->Modified(); + if ( theIsUpdateActions ) + app->updateActions(); + } + } +} + //======================================================================= // function : GeometryGUI::GeometryGUI() // purpose : Constructor @@ -162,8 +193,9 @@ GeometryGUI::GeometryGUI() : { if ( CORBA::is_nil( myComponentGeom ) ) { - Engines::Component_var comp = SalomeApp_Application::lcc()->FindOrLoad_Component( "FactoryServer", "GEOM" ); - myComponentGeom = GEOM::GEOM_Gen::_narrow( comp ); + Engines::EngineComponent_var comp = + SalomeApp_Application::lcc()->FindOrLoad_Component( "FactoryServer", "GEOM" ); + myComponentGeom = GEOM::GEOM_Gen::_narrow( comp ); } myActiveDialogBox = 0; @@ -248,18 +280,17 @@ void GeometryGUI::ActiveWorkingPlane() 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( 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(); } } - else if( ViewVTK ) { + else if ( ViewVTK ) { SVTK_ViewWindow* vw = dynamic_cast( window ); if ( vw ) { vtkCamera* camera = vw->getRenderer()->GetActiveCamera(); @@ -341,13 +372,15 @@ void GeometryGUI::OnGUIEvent( int id ) // if current viewframe is not of OCC and not of VTK type - return immediately // fix for IPAL8958 - allow some commands to execute even when NO viewer is active (rename for example) QList NotViewerDependentCommands; - NotViewerDependentCommands << GEOMOp::OpRename - << GEOMOp::OpDelete - << GEOMOp::OpShow - << GEOMOp::OpShowOnly - << GEOMOp::OpShowChildren - << GEOMOp::OpHideChildren - << GEOMOp::OpPointMarker; + NotViewerDependentCommands << GEOMOp::OpDelete + << GEOMOp::OpShow + << GEOMOp::OpShowOnly + << GEOMOp::OpShowOnlyChildren + << GEOMOp::OpDiscloseChildren + << GEOMOp::OpConcealChildren + << GEOMOp::OpUnpublishObject + << GEOMOp::OpPublishObject + << GEOMOp::OpPointMarker; if ( !ViewOCC && !ViewVTK && !NotViewerDependentCommands.contains( id ) ) return; @@ -360,151 +393,189 @@ void GeometryGUI::OnGUIEvent( int id ) QString libName; // find corresponding GUI library switch ( id ) { - case GEOMOp::OpImport: // MENU FILE - IMPORT - case GEOMOp::OpExport: // MENU FILE - EXPORT - case GEOMOp::OpSelectVertex: // POPUP MENU - SELECT ONLY - VERTEX - case GEOMOp::OpSelectEdge: // POPUP MENU - SELECT ONLY - EDGE - case GEOMOp::OpSelectWire: // POPUP MENU - SELECT ONLY - WIRE - case GEOMOp::OpSelectFace: // POPUP MENU - SELECT ONLY - FACE - case GEOMOp::OpSelectShell: // POPUP MENU - SELECT ONLY - SHELL - case GEOMOp::OpSelectSolid: // POPUP MENU - SELECT ONLY - SOLID - case GEOMOp::OpSelectCompound: // POPUP MENU - SELECT ONLY - COMPOUND - case GEOMOp::OpSelectAll: // POPUP MENU - SELECT ONLY - SELECT ALL - case GEOMOp::OpDelete: // MENU EDIT - DELETE - case GEOMOp::OpCheckGeom: // MENU TOOLS - CHECK GEOMETRY - case GEOMOp::OpDeflection: // POPUP MENU - DEFLECTION COEFFICIENT - case GEOMOp::OpColor: // POPUP MENU - COLOR - case GEOMOp::OpTransparency: // POPUP MENU - TRANSPARENCY - case GEOMOp::OpIsos: // POPUP MENU - ISOS - case GEOMOp::OpAutoColor: // POPUP MENU - AUTO COLOR - case GEOMOp::OpNoAutoColor: // POPUP MENU - DISABLE AUTO COLOR - case GEOMOp::OpShowChildren: // POPUP MENU - SHOW CHILDREN - case GEOMOp::OpHideChildren: // POPUP MENU - HIDE CHILDREN - case GEOMOp::OpPointMarker: // POPUP MENU - POINT MARKER - case GEOMOp::OpRename: // POPUP MENU - RENAME + case GEOMOp::OpOriginAndVectors: // MENU BASIC - ORIGIN AND BASE VECTORS + createOriginAndBaseVectors(); // internal operation + return; + case GEOMOp::OpImport: // MENU FILE - IMPORT + case GEOMOp::OpExport: // MENU FILE - EXPORT + case GEOMOp::OpSelectVertex: // POPUP MENU - SELECT ONLY - VERTEX + case GEOMOp::OpSelectEdge: // POPUP MENU - SELECT ONLY - EDGE + case GEOMOp::OpSelectWire: // POPUP MENU - SELECT ONLY - WIRE + case GEOMOp::OpSelectFace: // POPUP MENU - SELECT ONLY - FACE + case GEOMOp::OpSelectShell: // POPUP MENU - SELECT ONLY - SHELL + case GEOMOp::OpSelectSolid: // POPUP MENU - SELECT ONLY - SOLID + case GEOMOp::OpSelectCompound: // POPUP MENU - SELECT ONLY - COMPOUND + case GEOMOp::OpSelectAll: // POPUP MENU - SELECT ONLY - SELECT ALL + case GEOMOp::OpDelete: // MENU EDIT - DELETE + case GEOMOp::OpCheckGeom: // MENU TOOLS - CHECK GEOMETRY + case GEOMOp::OpDeflection: // POPUP MENU - DEFLECTION COEFFICIENT + case GEOMOp::OpColor: // POPUP MENU - COLOR + case GEOMOp::OpSetTexture: // POPUP MENU - SETTEXTURE + case GEOMOp::OpTransparency: // POPUP MENU - TRANSPARENCY + case GEOMOp::OpIncrTransparency: // SHORTCUT - INCREASE TRANSPARENCY + case GEOMOp::OpDecrTransparency: // SHORTCUT - DECREASE TRANSPARENCY + case GEOMOp::OpIsos: // POPUP MENU - ISOS + case GEOMOp::OpIncrNbIsos: // SHORTCUT - INCREASE NB ISOS + case GEOMOp::OpDecrNbIsos: // SHORTCUT - DECREASE NB ISOS + case GEOMOp::OpAutoColor: // POPUP MENU - AUTO COLOR + case GEOMOp::OpNoAutoColor: // POPUP MENU - DISABLE AUTO COLOR + case GEOMOp::OpDiscloseChildren: // POPUP MENU - DISCLOSE CHILD ITEMS + case GEOMOp::OpConcealChildren: // POPUP MENU - CONCEAL CHILD ITEMS + case GEOMOp::OpUnpublishObject: // POPUP MENU - UNPUBLISH + 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::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::OpClsBringToFront: // libName = "GEOMToolsGUI"; break; - case GEOMOp::OpDisplayMode: // MENU VIEW - WIREFRAME/SHADING - case GEOMOp::OpShowAll: // MENU VIEW - SHOW ALL - case GEOMOp::OpShowOnly: // MENU VIEW - DISPLAY ONLY - case GEOMOp::OpHideAll: // MENU VIEW - ERASE ALL - case GEOMOp::OpHide: // MENU VIEW - ERASE - case GEOMOp::OpShow: // MENU VIEW - DISPLAY - case GEOMOp::OpSwitchVectors: // MENU VIEW - VECTOR MODE - case GEOMOp::OpWireframe: // POPUP MENU - WIREFRAME - case GEOMOp::OpShading: // POPUP MENU - SHADING - case GEOMOp::OpVectors: // POPUP MENU - VECTORS + case GEOMOp::OpDMWireframe: // MENU VIEW - WIREFRAME + case GEOMOp::OpDMShading: // MENU VIEW - SHADING + case GEOMOp::OpDMShadingWithEdges: // MENU VIEW - SHADING + case GEOMOp::OpShowAll: // MENU VIEW - SHOW ALL + case GEOMOp::OpShowOnly: // MENU VIEW - DISPLAY ONLY + case GEOMOp::OpShowOnlyChildren: // MENU VIEW - SHOW ONLY CHILDREN + case GEOMOp::OpHideAll: // MENU VIEW - ERASE ALL + case GEOMOp::OpHide: // MENU VIEW - ERASE + case GEOMOp::OpShow: // MENU VIEW - DISPLAY + case GEOMOp::OpSwitchVectors: // MENU VIEW - VECTOR MODE + case GEOMOp::OpWireframe: // POPUP MENU - WIREFRAME + case GEOMOp::OpShading: // POPUP MENU - SHADING + case GEOMOp::OpShadingWithEdges: // POPUP MENU - SHADING WITH EDGES + case GEOMOp::OpTexture: // POPUP MENU - TEXTURE + case GEOMOp::OpVectors: // POPUP MENU - VECTORS libName = "DisplayGUI"; break; - case GEOMOp::OpPoint: // MENU BASIC - POINT - case GEOMOp::OpLine: // MENU BASIC - LINE - case GEOMOp::OpCircle: // MENU BASIC - CIRCLE - case GEOMOp::OpEllipse: // MENU BASIC - ELLIPSE - case GEOMOp::OpArc: // MENU BASIC - ARC - case GEOMOp::OpVector: // MENU BASIC - VECTOR - case GEOMOp::OpPlane: // MENU BASIC - PLANE - case GEOMOp::OpCurve: // MENU BASIC - CURVE - case GEOMOp::OpLCS: // MENU BASIC - REPAIR + case GEOMOp::OpPoint: // MENU BASIC - POINT + case GEOMOp::OpLine: // MENU BASIC - LINE + case GEOMOp::OpCircle: // MENU BASIC - CIRCLE + case GEOMOp::OpEllipse: // MENU BASIC - ELLIPSE + case GEOMOp::OpArc: // MENU BASIC - ARC + case GEOMOp::OpVector: // MENU BASIC - VECTOR + case GEOMOp::OpPlane: // MENU BASIC - PLANE + case GEOMOp::OpCurve: // MENU BASIC - CURVE + case GEOMOp::OpLCS: // MENU BASIC - LOCAL COORDINATE SYSTEM libName = "BasicGUI"; break; - case GEOMOp::OpBox: // MENU PRIMITIVE - BOX - case GEOMOp::OpCylinder: // MENU PRIMITIVE - CYLINDER - case GEOMOp::OpSphere: // MENU PRIMITIVE - SPHERE - case GEOMOp::OpTorus: // MENU PRIMITIVE - TORUS - case GEOMOp::OpCone: // MENU PRIMITIVE - CONE - case GEOMOp::OpRectangle: // MENU PRIMITIVE - FACE - case GEOMOp::OpDisk: // MENU PRIMITIVE - DISK + case GEOMOp::OpBox: // MENU PRIMITIVE - BOX + case GEOMOp::OpCylinder: // MENU PRIMITIVE - CYLINDER + case GEOMOp::OpSphere: // MENU PRIMITIVE - SPHERE + case GEOMOp::OpTorus: // MENU PRIMITIVE - TORUS + case GEOMOp::OpCone: // MENU PRIMITIVE - CONE + case GEOMOp::OpRectangle: // MENU PRIMITIVE - FACE + case GEOMOp::OpDisk: // MENU PRIMITIVE - DISK libName = "PrimitiveGUI"; break; - case GEOMOp::OpPrism: // MENU GENERATION - PRISM - case GEOMOp::OpRevolution: // MENU GENERATION - REVOLUTION - case GEOMOp::OpFilling: // MENU GENERATION - FILLING - case GEOMOp::OpPipe: // MENU GENERATION - PIPE + case GEOMOp::OpPrism: // MENU GENERATION - PRISM + 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::Op3dSketcher: // MENU ENTITY - 3D SKETCHER - case GEOMOp::OpExplode: // MENU ENTITY - EXPLODE + case GEOMOp::Op2dSketcher: // MENU ENTITY - SKETCHER + case GEOMOp::Op3dSketcher: // MENU ENTITY - 3D SKETCHER + case GEOMOp::OpExplode: // MENU ENTITY - EXPLODE +#ifdef WITH_OPENCV + case GEOMOp::OpFeatureDetect: // MENU ENTITY - FEATURE DETECTION +#endif + case GEOMOp::OpPictureImport: // MENU ENTITY - IMPORT PICTURE IN VIEWER libName = "EntityGUI"; break; - case GEOMOp::OpEdge: // MENU BUILD - EDGE - case GEOMOp::OpWire: // MENU BUILD - WIRE - case GEOMOp::OpFace: // MENU BUILD - FACE - case GEOMOp::OpShell: // MENU BUILD - SHELL - case GEOMOp::OpSolid: // MENU BUILD - SOLID - case GEOMOp::OpCompound: // MENU BUILD - COMPUND + case GEOMOp::OpEdge: // MENU BUILD - EDGE + case GEOMOp::OpWire: // MENU BUILD - WIRE + case GEOMOp::OpFace: // MENU BUILD - FACE + case GEOMOp::OpShell: // MENU BUILD - SHELL + case GEOMOp::OpSolid: // MENU BUILD - SOLID + case GEOMOp::OpCompound: // MENU BUILD - COMPUND libName = "BuildGUI"; break; - case GEOMOp::OpFuse: // MENU BOOLEAN - FUSE - case GEOMOp::OpCommon: // MENU BOOLEAN - COMMON - case GEOMOp::OpCut: // MENU BOOLEAN - CUT - case GEOMOp::OpSection: // MENU BOOLEAN - SECTION + case GEOMOp::OpFuse: // MENU BOOLEAN - FUSE + case GEOMOp::OpCommon: // MENU BOOLEAN - COMMON + case GEOMOp::OpCut: // MENU BOOLEAN - CUT + case GEOMOp::OpSection: // MENU BOOLEAN - SECTION libName = "BooleanGUI"; break; - case GEOMOp::OpTranslate: // MENU TRANSFORMATION - TRANSLATION - case GEOMOp::OpRotate: // MENU TRANSFORMATION - ROTATION - case GEOMOp::OpChangeLoc: // MENU TRANSFORMATION - LOCATION - case GEOMOp::OpMirror: // MENU TRANSFORMATION - MIRROR - case GEOMOp::OpScale: // MENU TRANSFORMATION - SCALE - case GEOMOp::OpOffset: // MENU TRANSFORMATION - OFFSET - case GEOMOp::OpMultiTranslate: // MENU TRANSFORMATION - MULTI-TRANSLATION - case GEOMOp::OpMultiRotate: // MENU TRANSFORMATION - MULTI-ROTATION - case GEOMOp::OpReimport: // CONTEXT(POPUP) MENU - RELOAD_IMPORTED + case GEOMOp::OpTranslate: // MENU TRANSFORMATION - TRANSLATION + case GEOMOp::OpRotate: // MENU TRANSFORMATION - ROTATION + case GEOMOp::OpChangeLoc: // MENU TRANSFORMATION - LOCATION + case GEOMOp::OpMirror: // MENU TRANSFORMATION - MIRROR + case GEOMOp::OpScale: // MENU TRANSFORMATION - SCALE + case GEOMOp::OpOffset: // MENU TRANSFORMATION - OFFSET + case GEOMOp::OpProjection: // MENU TRANSFORMATION - PROJECTION + case GEOMOp::OpMultiTranslate: // MENU TRANSFORMATION - MULTI-TRANSLATION + case GEOMOp::OpMultiRotate: // MENU TRANSFORMATION - MULTI-ROTATION + case GEOMOp::OpReimport: // CONTEXT(POPUP) MENU - RELOAD_IMPORTED libName = "TransformationGUI"; break; - case GEOMOp::OpPartition: // MENU OPERATION - PARTITION - case GEOMOp::OpArchimede: // MENU OPERATION - ARCHIMEDE - case GEOMOp::OpFillet3d: // MENU OPERATION - FILLET - case GEOMOp::OpChamfer: // MENU OPERATION - CHAMFER - case GEOMOp::OpClipping: // MENU OPERATION - CLIPPING RANGE - case GEOMOp::OpShapesOnShape: // MENU OPERATION - GET SHAPES ON SHAPE - case GEOMOp::OpFillet2d: // MENU OPERATION - FILLET 2D - case GEOMOp::OpFillet1d: // MENU OPERATION - FILLET 1D + case GEOMOp::OpPartition: // MENU OPERATION - PARTITION + case GEOMOp::OpArchimede: // MENU OPERATION - ARCHIMEDE + case GEOMOp::OpFillet3d: // MENU OPERATION - FILLET + case GEOMOp::OpChamfer: // MENU OPERATION - CHAMFER + case GEOMOp::OpClipping: // MENU OPERATION - CLIPPING RANGE + case GEOMOp::OpShapesOnShape: // MENU OPERATION - GET SHAPES ON SHAPE + case GEOMOp::OpFillet2d: // MENU OPERATION - FILLET 2D + case GEOMOp::OpFillet1d: // MENU OPERATION - FILLET 1D + case GEOMOp::OpSharedShapes: // MENU OPERATION - GET SHARED SHAPES + case GEOMOp::OpExtrudedBoss: // MENU OPERATION - EXTRUDED BOSS + case GEOMOp::OpExtrudedCut: // MENU OPERATION - EXTRUDED CUT libName = "OperationGUI"; break; - case GEOMOp::OpSewing: // MENU REPAIR - SEWING - case GEOMOp::OpSuppressFaces: // MENU REPAIR - SUPPRESS FACES - case GEOMOp::OpSuppressHoles: // MENU REPAIR - SUPPRESS HOLE - case GEOMOp::OpShapeProcess: // MENU REPAIR - SHAPE PROCESSING - case GEOMOp::OpCloseContour: // MENU REPAIR - CLOSE CONTOUR - case GEOMOp::OpRemoveIntWires: // MENU REPAIR - REMOVE INTERNAL WIRES - case GEOMOp::OpAddPointOnEdge: // MENU REPAIR - ADD POINT ON EDGE - case GEOMOp::OpFreeBoundaries: // MENU MEASURE - FREE BOUNDARIES - case GEOMOp::OpFreeFaces: // MENU MEASURE - FREE FACES - case GEOMOp::OpOrientation: // MENU REPAIR - CHANGE ORIENTATION - case GEOMOp::OpGlueFaces: // MENU REPAIR - GLUE FACES - case GEOMOp::OpRemoveExtraEdges: // MENU REPAIR - REMOVE EXTRA EDGES + case GEOMOp::OpSewing: // MENU REPAIR - SEWING + case GEOMOp::OpSuppressFaces: // MENU REPAIR - SUPPRESS FACES + case GEOMOp::OpSuppressHoles: // MENU REPAIR - SUPPRESS HOLE + case GEOMOp::OpShapeProcess: // MENU REPAIR - SHAPE PROCESSING + case GEOMOp::OpCloseContour: // MENU REPAIR - CLOSE CONTOUR + case GEOMOp::OpRemoveIntWires: // MENU REPAIR - REMOVE INTERNAL WIRES + case GEOMOp::OpAddPointOnEdge: // MENU REPAIR - ADD POINT ON EDGE + case GEOMOp::OpFreeBoundaries: // MENU MEASURE - FREE BOUNDARIES + case GEOMOp::OpFreeFaces: // MENU MEASURE - FREE FACES + case GEOMOp::OpOrientation: // MENU REPAIR - CHANGE ORIENTATION + case GEOMOp::OpGlueFaces: // MENU REPAIR - GLUE FACES + case GEOMOp::OpGlueEdges: // MENU REPAIR - GLUE EDGES + case GEOMOp::OpLimitTolerance: // MENU REPAIR - LIMIT TOLERANCE + case GEOMOp::OpRemoveExtraEdges: // MENU REPAIR - REMOVE EXTRA EDGES + case GEOMOp::OpFuseEdges: // MENU REPAIR - FUSE COLLINEAR EDGES libName = "RepairGUI"; break; - case GEOMOp::OpProperties: // MENU MEASURE - PROPERTIES - case GEOMOp::OpCenterMass: // MENU MEASURE - CDG - case GEOMOp::OpInertia: // MENU MEASURE - INERTIA - case GEOMOp::OpNormale: // MENU MEASURE - NORMALE - case GEOMOp::OpBoundingBox: // MENU MEASURE - BOUNDING BOX - case GEOMOp::OpMinDistance: // MENU MEASURE - MIN DISTANCE - case GEOMOp::OpAngle: // MENU MEASURE - ANGLE - case GEOMOp::OpTolerance: // MENU MEASURE - TOLERANCE - case GEOMOp::OpWhatIs: // MENU MEASURE - WHATIS - case GEOMOp::OpCheckShape: // MENU MEASURE - CHECK - case GEOMOp::OpCheckCompound: // MENU MEASURE - CHECK COMPOUND OF BLOCKS - case GEOMOp::OpPointCoordinates: // MENU MEASURE - POINT COORDINATES + case GEOMOp::OpProperties: // MENU MEASURE - PROPERTIES + case GEOMOp::OpCenterMass: // MENU MEASURE - CDG + case GEOMOp::OpInertia: // MENU MEASURE - INERTIA + case GEOMOp::OpNormale: // MENU MEASURE - NORMALE + case GEOMOp::OpBoundingBox: // MENU MEASURE - BOUNDING BOX + case GEOMOp::OpMinDistance: // MENU MEASURE - MIN DISTANCE + case GEOMOp::OpAngle: // MENU MEASURE - ANGLE + case GEOMOp::OpTolerance: // MENU MEASURE - TOLERANCE + case GEOMOp::OpWhatIs: // MENU MEASURE - WHATIS + case GEOMOp::OpCheckShape: // MENU MEASURE - CHECK + case GEOMOp::OpCheckCompound: // MENU MEASURE - CHECK COMPOUND OF BLOCKS + case GEOMOp::OpGetNonBlocks: // MENU MEASURE - Get NON BLOCKS + case GEOMOp::OpPointCoordinates: // MENU MEASURE - POINT COORDINATES + case GEOMOp::OpCheckSelfInters: // MENU MEASURE - CHECK SELF INTERSECTIONS libName = "MeasureGUI"; break; - case GEOMOp::OpGroupCreate: // MENU GROUP - CREATE - case GEOMOp::OpGroupCreatePopup: // POPUP MENU - CREATE GROUP - case GEOMOp::OpGroupEdit: // MENU GROUP - EDIT + case GEOMOp::OpGroupCreate: // MENU GROUP - CREATE + case GEOMOp::OpGroupCreatePopup: // POPUP MENU - CREATE GROUP + case GEOMOp::OpGroupEdit: // MENU GROUP - EDIT + case GEOMOp::OpGroupUnion: // MENU GROUP - UNION + case GEOMOp::OpGroupIntersect: // MENU GROUP - INTERSECT + case GEOMOp::OpGroupCut: // MENU GROUP - CUT libName = "GroupGUI"; break; - case GEOMOp::OpHexaSolid: // MENU BLOCKS - HEXAHEDRAL SOLID - case GEOMOp::OpMultiTransform: // MENU BLOCKS - MULTI-TRANSFORMATION - case GEOMOp::OpQuadFace: // MENU BLOCKS - QUADRANGLE FACE - case GEOMOp::OpPropagate: // MENU BLOCKS - PROPAGATE - case GEOMOp::OpExplodeBlock: // MENU BLOCKS - EXPLODE ON BLOCKS + case GEOMOp::OpHexaSolid: // MENU BLOCKS - HEXAHEDRAL SOLID + case GEOMOp::OpMultiTransform: // MENU BLOCKS - MULTI-TRANSFORMATION + case GEOMOp::OpQuadFace: // MENU BLOCKS - QUADRANGLE FACE + case GEOMOp::OpPropagate: // MENU BLOCKS - PROPAGATE + case GEOMOp::OpExplodeBlock: // MENU BLOCKS - EXPLODE ON BLOCKS libName = "BlocksGUI"; break; - case GEOMOp::OpAdvancedNoOp: // NO OPERATION (advanced operations base) - case GEOMOp::OpPipeTShape: // MENU NEW ENTITY - ADVANCED - PIPE TSHAPE + case GEOMOp::OpAdvancedNoOp: // NO OPERATION (advanced operations base) + case GEOMOp::OpPipeTShape: // MENU NEW ENTITY - ADVANCED - PIPE TSHAPE // case GEOMOp::OpPipeTShapeGroups: // MENU NEW ENTITY - ADVANCED - PIPE TSHAPE GROUPS + case GEOMOp::OpDividedDisk: // MENU NEW ENTITY - ADVANCED - DIVIDEDDISK + case GEOMOp::OpDividedCylinder: // MENU NEW ENTITY - ADVANCED - DIVIDEDCYLINDER //@@ 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 @@// libName = "AdvancedGUI"; break; @@ -523,8 +594,20 @@ void GeometryGUI::OnGUIEvent( int id ) } // call method of corresponding GUI library - if ( 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() ); + } + } + } else SUIT_MessageBox::critical( desk, tr( "GEOM_ERROR" ), tr( "GEOM_ERR_LIB_NOT_FOUND" ), tr( "GEOM_BUT_OK" ) ); } @@ -553,6 +636,18 @@ void GeometryGUI::OnMouseMove( SUIT_ViewWindow* w, QMouseEvent* e ) lib->OnMouseMove( e, application()->desktop(), w ); } +//================================================================================= +// function : GeometryGUI::OnMouseRelease() +// purpose : Manages mouse release events [static] +//================================================================================= +void GeometryGUI::OnMouseRelease( SUIT_ViewWindow* w, QMouseEvent* e ) +{ + if ( !application() ) + return; + foreach ( GEOMGUI* lib, myGUIMap ) + lib->OnMouseRelease( e, application()->desktop(), w ); +} + //================================================================================= // function : GeometryGUI::OnMousePress() // purpose : Manage mouse press events [static] @@ -569,23 +664,54 @@ void GeometryGUI::OnMousePress( SUIT_ViewWindow* w, QMouseEvent* e ) // function : createGeomAction // purpose : //======================================================================= -void GeometryGUI::createGeomAction( const int id, const QString& label, const QString& icolabel, const int accel, const bool toggle ) +void GeometryGUI::createGeomAction( const int id, const QString& label, const QString& icolabel, + const int accel, const bool toggle, const QString& shortcutAction ) { SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr(); QPixmap icon = icolabel.isEmpty() ? resMgr->loadPixmap( "GEOM", tr( (QString( "ICO_" )+label).toLatin1().constData() ), false ) : resMgr->loadPixmap( "GEOM", tr( icolabel.toLatin1().constData() ) ); createAction( id, - tr( QString( "TOP_%1" ).arg( label ).toLatin1().constData() ), - icon, - tr( QString( "MEN_%1" ).arg( label ).toLatin1().constData() ), - tr( QString( "STB_%1" ).arg( label ).toLatin1().constData() ), - accel, - application()->desktop(), - toggle, - this, SLOT( OnGUIEvent() ) ); + tr( QString( "TOP_%1" ).arg( label ).toLatin1().constData() ), + icon, + tr( QString( "MEN_%1" ).arg( label ).toLatin1().constData() ), + tr( QString( "STB_%1" ).arg( label ).toLatin1().constData() ), + accel, + application()->desktop(), + toggle, + this, SLOT( OnGUIEvent() ), + shortcutAction ); } - +//======================================================================= +// function : createOriginAndBaseVectors +// purpose : +//======================================================================= +void GeometryGUI::createOriginAndBaseVectors() +{ + SalomeApp_Study* appStudy = dynamic_cast( application()->activeStudy() ); + if ( appStudy ) { + _PTR(Study) studyDS = appStudy->studyDS(); + if ( studyDS && !CORBA::is_nil( GetGeomGen() ) ) { + GEOM::GEOM_IBasicOperations_var aBasicOperations = GetGeomGen()->GetIBasicOperations( studyDS->StudyId() ); + 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 ); + GEOM::GEOM_Object_var anOX = aBasicOperations->MakeVectorDXDYDZ( aLength, 0.0, 0.0 ); + GEOM::GEOM_Object_var anOY = aBasicOperations->MakeVectorDXDYDZ( 0.0, aLength, 0.0 ); + GEOM::GEOM_Object_var anOZ = aBasicOperations->MakeVectorDXDYDZ( 0.0, 0.0, aLength ); + + SALOMEDS::Study_var aDSStudy = ClientStudyToStudy( studyDS ); + GetGeomGen()->PublishInStudy( aDSStudy, SALOMEDS::SObject::_nil(), anOrigin, "O" ); + GetGeomGen()->PublishInStudy( aDSStudy, SALOMEDS::SObject::_nil(), anOX, "OX" ); + GetGeomGen()->PublishInStudy( aDSStudy, SALOMEDS::SObject::_nil(), anOY, "OY" ); + GetGeomGen()->PublishInStudy( aDSStudy, SALOMEDS::SObject::_nil(), anOZ, "OZ" ); + + getApp()->updateObjectBrowser( false ); + } + } + } +} //======================================================================= // function : GeometryGUI::initialize() @@ -611,6 +737,7 @@ void GeometryGUI::initialize( CAM_Application* app ) createGeomAction( GEOMOp::OpVector, "VECTOR" ); createGeomAction( GEOMOp::OpPlane, "PLANE" ); createGeomAction( GEOMOp::OpLCS, "LOCAL_CS" ); + createGeomAction( GEOMOp::OpOriginAndVectors, "ORIGIN_AND_VECTORS" ); createGeomAction( GEOMOp::OpBox, "BOX" ); createGeomAction( GEOMOp::OpCylinder, "CYLINDER" ); @@ -624,9 +751,13 @@ void GeometryGUI::initialize( CAM_Application* app ) 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::OpGroupUnion, "GROUP_UNION" ); + createGeomAction( GEOMOp::OpGroupIntersect, "GROUP_INTERSECT" ); + createGeomAction( GEOMOp::OpGroupCut, "GROUP_CUT" ); createGeomAction( GEOMOp::OpReimport, "RELOAD_IMPORTED" ); @@ -636,6 +767,10 @@ void GeometryGUI::initialize( CAM_Application* app ) createGeomAction( GEOMOp::Op2dSketcher, "SKETCH" ); createGeomAction( GEOMOp::Op3dSketcher, "3DSKETCH" ); createGeomAction( GEOMOp::OpExplode, "EXPLODE" ); +#ifdef WITH_OPENCV + createGeomAction( GEOMOp::OpFeatureDetect,"FEATURE_DETECTION" ); +#endif + createGeomAction( GEOMOp::OpPictureImport,"PICTURE_IMPORT" ); createGeomAction( GEOMOp::OpEdge, "EDGE" ); createGeomAction( GEOMOp::OpWire, "WIRE" ); @@ -655,6 +790,7 @@ void GeometryGUI::initialize( CAM_Application* app ) createGeomAction( GEOMOp::OpMirror, "MIRROR" ); createGeomAction( GEOMOp::OpScale, "SCALE" ); createGeomAction( GEOMOp::OpOffset, "OFFSET" ); + createGeomAction( GEOMOp::OpProjection, "PROJECTION" ); createGeomAction( GEOMOp::OpMultiTranslate, "MUL_TRANSLATION" ); createGeomAction( GEOMOp::OpMultiRotate, "MUL_ROTATION" ); @@ -663,7 +799,10 @@ void GeometryGUI::initialize( CAM_Application* app ) createGeomAction( GEOMOp::OpFillet3d, "FILLET" ); createGeomAction( GEOMOp::OpChamfer, "CHAMFER" ); //createGeomAction( GEOMOp::OpClipping, "CLIPPING" ); - createGeomAction( GEOMOp::OpShapesOnShape, "GET_SHAPES_ON_SHAPES" ); + createGeomAction( GEOMOp::OpShapesOnShape, "GET_SHAPES_ON_SHAPE" ); + createGeomAction( GEOMOp::OpSharedShapes, "GET_SHARED_SHAPES" ); + createGeomAction( GEOMOp::OpExtrudedCut, "EXTRUDED_CUT" ); + createGeomAction( GEOMOp::OpExtrudedBoss, "EXTRUDED_BOSS" ); createGeomAction( GEOMOp::OpFillet1d, "FILLET_1D" ); createGeomAction( GEOMOp::OpFillet2d, "FILLET_2D" ); @@ -673,6 +812,8 @@ void GeometryGUI::initialize( CAM_Application* app ) createGeomAction( GEOMOp::OpSewing, "SEWING" ); createGeomAction( GEOMOp::OpGlueFaces, "GLUE_FACES" ); + createGeomAction( GEOMOp::OpGlueEdges, "GLUE_EDGES" ); + createGeomAction( GEOMOp::OpLimitTolerance, "LIMIT_TOLERANCE" ); createGeomAction( GEOMOp::OpSuppressFaces, "SUPPRESS_FACES" ); createGeomAction( GEOMOp::OpSuppressHoles, "SUPPERSS_HOLES" ); createGeomAction( GEOMOp::OpShapeProcess, "SHAPE_PROCESS" ); @@ -683,6 +824,7 @@ void GeometryGUI::initialize( CAM_Application* app ) createGeomAction( GEOMOp::OpFreeFaces, "CHECK_FREE_FACES" ); createGeomAction( GEOMOp::OpOrientation, "CHANGE_ORIENTATION" ); createGeomAction( GEOMOp::OpRemoveExtraEdges, "REMOVE_EXTRA_EDGES" ); + createGeomAction( GEOMOp::OpFuseEdges, "FUSE_EDGES" ); createGeomAction( GEOMOp::OpPointCoordinates, "POINT_COORDS" ); createGeomAction( GEOMOp::OpProperties, "BASIC_PROPS" ); @@ -697,12 +839,16 @@ void GeometryGUI::initialize( CAM_Application* app ) createGeomAction( GEOMOp::OpWhatIs, "WHAT_IS" ); createGeomAction( GEOMOp::OpCheckShape, "CHECK" ); createGeomAction( GEOMOp::OpCheckCompound, "CHECK_COMPOUND" ); + createGeomAction( GEOMOp::OpGetNonBlocks, "GET_NON_BLOCKS" ); + createGeomAction( GEOMOp::OpCheckSelfInters, "CHECK_SELF_INTERSECTIONS" ); #ifdef _DEBUG_ // PAL16821 createGeomAction( GEOMOp::OpCheckGeom, "CHECK_GEOMETRY" ); #endif - createGeomAction( GEOMOp::OpDisplayMode, "SHADING" ); + createGeomAction( GEOMOp::OpDMWireframe, "WIREFRAME" ); + createGeomAction( GEOMOp::OpDMShading, "SHADING" ); + createGeomAction( GEOMOp::OpDMShadingWithEdges, "SHADING_WITH_EDGES" ); createGeomAction( GEOMOp::OpShowAll, "DISPLAY_ALL" ); createGeomAction( GEOMOp::OpHideAll, "ERASE_ALL" ); createGeomAction( GEOMOp::OpShow, "DISPLAY" ); @@ -716,25 +862,50 @@ void GeometryGUI::initialize( CAM_Application* app ) createGeomAction( GEOMOp::OpSelectCompound, "COMPOUND_SEL_ONLY", "", 0, true ); createGeomAction( GEOMOp::OpSelectAll, "ALL_SEL_ONLY", "", 0, true ); createGeomAction( GEOMOp::OpShowOnly, "DISPLAY_ONLY" ); + createGeomAction( GEOMOp::OpShowOnlyChildren, "SHOW_ONLY_CHILDREN" ); + createGeomAction( GEOMOp::OpBringToFront, "BRING_TO_FRONT", "", 0, true ); + createGeomAction( GEOMOp::OpClsBringToFront, "CLS_BRING_TO_FRONT" ); createGeomAction( GEOMOp::OpHide, "ERASE" ); - createGeomAction( GEOMOp::OpRename, "POP_RENAME", "", Qt::Key_F2 ); createGeomAction( GEOMOp::OpWireframe, "POP_WIREFRAME", "", 0, true ); createGeomAction( GEOMOp::OpShading, "POP_SHADING", "", 0, true ); + createGeomAction( GEOMOp::OpShadingWithEdges, "POP_SHADING_WITH_EDGES", "", 0, true ); + createGeomAction( GEOMOp::OpTexture, "POP_TEXTURE", "", 0, true ); + createGeomAction( GEOMOp::OpEdgeWidth, "EDGE_WIDTH"); + createGeomAction( GEOMOp::OpIsosWidth, "ISOS_WIDTH"); createGeomAction( GEOMOp::OpVectors, "POP_VECTORS", "", 0, true ); createGeomAction( GEOMOp::OpDeflection, "POP_DEFLECTION" ); createGeomAction( GEOMOp::OpColor, "POP_COLOR" ); + createGeomAction( GEOMOp::OpSetTexture, "POP_SETTEXTURE" ); createGeomAction( GEOMOp::OpTransparency, "POP_TRANSPARENCY" ); createGeomAction( GEOMOp::OpIsos, "POP_ISOS" ); createGeomAction( GEOMOp::OpAutoColor, "POP_AUTO_COLOR" ); createGeomAction( GEOMOp::OpNoAutoColor, "POP_DISABLE_AUTO_COLOR" ); createGeomAction( GEOMOp::OpGroupCreatePopup, "POP_CREATE_GROUP" ); - createGeomAction( GEOMOp::OpShowChildren, "POP_SHOW_CHILDREN" ); - createGeomAction( GEOMOp::OpHideChildren, "POP_HIDE_CHILDREN" ); + createGeomAction( GEOMOp::OpDiscloseChildren, "POP_DISCLOSE_CHILDREN" ); + createGeomAction( GEOMOp::OpConcealChildren, "POP_CONCEAL_CHILDREN" ); + 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::OpPipeTShape, "PIPETSHAPE" ); + + // Create actions for increase/decrease transparency shortcuts + createGeomAction( GEOMOp::OpIncrTransparency, "", "", 0, false, + "Geometry:Increase transparency"); + createGeomAction( GEOMOp::OpDecrTransparency, "", "", 0, false, + "Geometry:Decrease transparency"); + + // Create actions for increase/decrease number of isolines + createGeomAction( GEOMOp::OpIncrNbIsos, "", "", 0, false, + "Geometry:Increase number of isolines"); + createGeomAction( GEOMOp::OpDecrNbIsos, "", "", 0, false, + "Geometry:Decrease number of isolines"); + // createGeomAction( GEOMOp::OpPipeTShapeGroups, "PIPETSHAPEGROUPS" ); + createGeomAction( GEOMOp::OpDividedDisk, "DIVIDEDDISK" ); + createGeomAction( GEOMOp::OpDividedCylinder, "DIVIDEDCYLINDER" ); //@@ 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 @@// // ---- create menus -------------------------- @@ -757,10 +928,13 @@ void GeometryGUI::initialize( CAM_Application* app ) createMenu( GEOMOp::OpEllipse, basicId, -1 ); createMenu( GEOMOp::OpArc, basicId, -1 ); createMenu( GEOMOp::OpCurve, basicId, -1 ); + createMenu( GEOMOp::Op2dSketcher, basicId, -1 ); + createMenu( GEOMOp::Op3dSketcher, basicId, -1 ); createMenu( separator(), basicId, -1 ); createMenu( GEOMOp::OpVector, basicId, -1 ); createMenu( GEOMOp::OpPlane, basicId, -1 ); createMenu( GEOMOp::OpLCS, basicId, -1 ); + createMenu( GEOMOp::OpOriginAndVectors, basicId, -1 ); int primId = createMenu( tr( "MEN_PRIMITIVES" ), newEntId, -1 ); createMenu( GEOMOp::OpBox, primId, -1 ); @@ -770,34 +944,37 @@ void GeometryGUI::initialize( CAM_Application* app ) createMenu( GEOMOp::OpCone, primId, -1 ); createMenu( GEOMOp::OpRectangle, primId, -1 ); createMenu( GEOMOp::OpDisk, primId, -1 ); + createMenu( GEOMOp::OpPipeTShape,primId, -1 ); int genId = createMenu( tr( "MEN_GENERATION" ), newEntId, -1 ); createMenu( GEOMOp::OpPrism, genId, -1 ); 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 ); - int advId = createMenu( tr( "MEN_ADVANCED" ), newEntId, -1 ); - createMenu( GEOMOp::OpPipeTShape, advId, -1 ); -// createMenu( GEOMOp::OpPipeTShapeGroups, advId, -1 ); //@@ 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 @@// createMenu( separator(), newEntId, -1 ); int groupId = createMenu( tr( "MEN_GROUP" ), newEntId, -1 ); - createMenu( GEOMOp::OpGroupCreate, groupId, -1 ); - createMenu( GEOMOp::OpGroupEdit, groupId, -1 ); + createMenu( GEOMOp::OpGroupCreate, groupId, -1 ); + createMenu( GEOMOp::OpGroupEdit, groupId, -1 ); + createMenu( GEOMOp::OpGroupUnion, groupId, -1 ); + createMenu( GEOMOp::OpGroupIntersect, groupId, -1 ); + createMenu( GEOMOp::OpGroupCut, groupId, -1 ); createMenu( separator(), newEntId, -1 ); int blocksId = createMenu( tr( "MEN_BLOCKS" ), newEntId, -1 ); - createMenu( GEOMOp::OpQuadFace, blocksId, -1 ); - createMenu( GEOMOp::OpHexaSolid, blocksId, -1 ); - - createMenu( separator(), newEntId, -1 ); - - createMenu( GEOMOp::Op2dSketcher, newEntId, -1 ); - createMenu( GEOMOp::Op3dSketcher, newEntId, -1 ); + createMenu( GEOMOp::OpQuadFace, blocksId, -1 ); + createMenu( GEOMOp::OpHexaSolid, blocksId, -1 ); + createMenu( GEOMOp::OpDividedDisk, blocksId, -1 ); + createMenu( GEOMOp::OpDividedCylinder, blocksId, -1 ); createMenu( separator(), newEntId, -1 ); @@ -811,6 +988,13 @@ void GeometryGUI::initialize( CAM_Application* app ) 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 ); +#endif + int operId = createMenu( tr( "MEN_OPERATIONS" ), -1, -1, 10 ); int boolId = createMenu( tr( "MEN_BOOLEAN" ), operId, -1 ); @@ -826,6 +1010,7 @@ void GeometryGUI::initialize( CAM_Application* app ) createMenu( GEOMOp::OpMirror, transId, -1 ); createMenu( GEOMOp::OpScale, transId, -1 ); createMenu( GEOMOp::OpOffset, transId, -1 ); + createMenu( GEOMOp::OpProjection, transId, -1 ); createMenu( separator(), transId, -1 ); createMenu( GEOMOp::OpMultiTranslate, transId, -1 ); createMenu( GEOMOp::OpMultiRotate, transId, -1 ); @@ -840,6 +1025,7 @@ void GeometryGUI::initialize( CAM_Application* app ) createMenu( GEOMOp::OpPartition, operId, -1 ); createMenu( GEOMOp::OpArchimede, operId, -1 ); createMenu( GEOMOp::OpShapesOnShape, operId, -1 ); + createMenu( GEOMOp::OpSharedShapes, operId, -1 ); createMenu( separator(), operId, -1 ); @@ -847,6 +1033,8 @@ void GeometryGUI::initialize( CAM_Application* app ) createMenu( GEOMOp::OpFillet2d, operId, -1 ); createMenu( GEOMOp::OpFillet3d, operId, -1 ); createMenu( GEOMOp::OpChamfer, operId, -1 ); + createMenu( GEOMOp::OpExtrudedBoss, operId, -1 ); + createMenu( GEOMOp::OpExtrudedCut, operId, -1 ); //createMenu( GEOMOp::OpClipping, operId, -1 ); int repairId = createMenu( tr( "MEN_REPAIR" ), -1, -1, 10 ); @@ -857,11 +1045,14 @@ void GeometryGUI::initialize( CAM_Application* app ) createMenu( GEOMOp::OpSuppressHoles, repairId, -1 ); createMenu( GEOMOp::OpSewing, repairId, -1 ); createMenu( GEOMOp::OpGlueFaces, repairId, -1 ); + createMenu( GEOMOp::OpGlueEdges, repairId, -1 ); + createMenu( GEOMOp::OpLimitTolerance, repairId, -1 ); createMenu( GEOMOp::OpAddPointOnEdge, repairId, -1 ); //createMenu( GEOMOp::OpFreeBoundaries, repairId, -1 ); //createMenu( GEOMOp::OpFreeFaces, repairId, -1 ); createMenu( GEOMOp::OpOrientation, repairId, -1 ); createMenu( GEOMOp::OpRemoveExtraEdges, repairId, -1 ); + createMenu( GEOMOp::OpFuseEdges, repairId, -1 ); int measurId = createMenu( tr( "MEN_MEASURES" ), -1, -1, 10 ); createMenu( GEOMOp::OpPointCoordinates, measurId, -1 ); @@ -880,12 +1071,14 @@ void GeometryGUI::initialize( CAM_Application* app ) createMenu( GEOMOp::OpMinDistance, dimId, -1 ); createMenu( GEOMOp::OpAngle, dimId, -1 ); - createMenu( separator(), measurId, -1 ); - createMenu( GEOMOp::OpTolerance, measurId, -1 ); - createMenu( separator(), measurId, -1 ); - createMenu( GEOMOp::OpWhatIs, measurId, -1 ); - createMenu( GEOMOp::OpCheckShape, measurId, -1 ); - createMenu( GEOMOp::OpCheckCompound, measurId, -1 ); + createMenu( separator(), measurId, -1 ); + createMenu( GEOMOp::OpTolerance, measurId, -1 ); + createMenu( separator(), measurId, -1 ); + createMenu( GEOMOp::OpWhatIs, measurId, -1 ); + createMenu( GEOMOp::OpCheckShape, measurId, -1 ); + createMenu( GEOMOp::OpCheckCompound, measurId, -1 ); + createMenu( GEOMOp::OpGetNonBlocks, measurId, -1 ); + createMenu( GEOMOp::OpCheckSelfInters, measurId, -1 ); #ifdef _DEBUG_ // PAL16821 int toolsId = createMenu( tr( "MEN_TOOLS" ), -1, -1, 50 ); @@ -897,14 +1090,18 @@ void GeometryGUI::initialize( CAM_Application* app ) createMenu( separator(), viewId, -1 ); int dispmodeId = createMenu( tr( "MEN_DISPLAY_MODE" ), viewId, -1 ); - createMenu( GEOMOp::OpDisplayMode, dispmodeId, -1 ); - createMenu( separator(), dispmodeId, -1 ); - createMenu( GEOMOp::OpSwitchVectors, dispmodeId, -1 ); + createMenu( GEOMOp::OpDMWireframe, dispmodeId, -1 ); + createMenu( GEOMOp::OpDMShading, dispmodeId, -1 ); + createMenu( GEOMOp::OpDMShadingWithEdges, dispmodeId, -1 ); + createMenu( separator(), dispmodeId, -1 ); + createMenu( GEOMOp::OpSwitchVectors, dispmodeId, -1 ); createMenu( separator(), viewId, -1 ); createMenu( GEOMOp::OpShowAll, viewId, -1 ); createMenu( GEOMOp::OpHideAll, viewId, -1 ); createMenu( separator(), viewId, -1 ); + createMenu( GEOMOp::OpPublishObject, viewId, -1 ); + createMenu( separator(), viewId, -1 ); /* PAL9111: @@ -919,36 +1116,54 @@ void GeometryGUI::initialize( CAM_Application* app ) // ---- create toolbars -------------------------- int basicTbId = createTool( tr( "TOOL_BASIC" ) ); - createTool( GEOMOp::OpPoint, basicTbId ); - createTool( GEOMOp::OpLine, basicTbId ); - createTool( GEOMOp::OpCircle, basicTbId ); - createTool( GEOMOp::OpEllipse, basicTbId ); - createTool( GEOMOp::OpArc, basicTbId ); - createTool( GEOMOp::OpCurve, basicTbId ); - createTool( GEOMOp::OpVector, basicTbId ); - createTool( GEOMOp::OpPlane, basicTbId ); - createTool( GEOMOp::OpLCS, basicTbId ); + createTool( GEOMOp::OpPoint, basicTbId ); + createTool( GEOMOp::OpLine, basicTbId ); + createTool( GEOMOp::OpCircle, basicTbId ); + createTool( GEOMOp::OpEllipse, basicTbId ); + createTool( GEOMOp::OpArc, basicTbId ); + createTool( GEOMOp::OpCurve, basicTbId ); + createTool( GEOMOp::OpVector, basicTbId ); + createTool( GEOMOp::Op2dSketcher, basicTbId ); //rnc + createTool( GEOMOp::Op3dSketcher, basicTbId ); //rnc + 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::OpSphere, primTbId ); - createTool( GEOMOp::OpTorus, primTbId ); - createTool( GEOMOp::OpCone, primTbId ); - createTool( GEOMOp::OpRectangle, primTbId ); - createTool( GEOMOp::OpDisk, primTbId ); + createTool( GEOMOp::OpBox, primTbId ); + createTool( GEOMOp::OpCylinder, primTbId ); + createTool( GEOMOp::OpSphere, primTbId ); + createTool( GEOMOp::OpTorus, primTbId ); + createTool( GEOMOp::OpCone, 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 ); + createTool( GEOMOp::OpFuse, boolTbId ); + createTool( GEOMOp::OpCommon, boolTbId ); + createTool( GEOMOp::OpCut, boolTbId ); + createTool( GEOMOp::OpSection, boolTbId ); 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 ); @@ -957,24 +1172,25 @@ void GeometryGUI::initialize( CAM_Application* app ) createTool( GEOMOp::OpMirror, transTbId ); createTool( GEOMOp::OpScale, transTbId ); createTool( GEOMOp::OpOffset, transTbId ); + createTool( GEOMOp::OpProjection, transTbId ); createTool( separator(), transTbId ); createTool( GEOMOp::OpMultiTranslate, transTbId ); createTool( GEOMOp::OpMultiRotate, transTbId ); int operTbId = createTool( tr( "TOOL_OPERATIONS" ) ); - createTool( GEOMOp::Op2dSketcher, operTbId ); - createTool( GEOMOp::Op3dSketcher, operTbId ); - createTool( separator(), operTbId ); createTool( GEOMOp::OpExplode, operTbId ); - createTool( separator(), operTbId ); createTool( GEOMOp::OpPartition, operTbId ); createTool( GEOMOp::OpArchimede, operTbId ); createTool( GEOMOp::OpShapesOnShape, operTbId ); - createTool( separator(), operTbId ); - createTool( GEOMOp::OpFillet1d, operTbId ); - createTool( GEOMOp::OpFillet2d, operTbId ); - createTool( GEOMOp::OpFillet3d, operTbId ); - createTool( GEOMOp::OpChamfer, operTbId ); + createTool( GEOMOp::OpSharedShapes, operTbId ); + + int featTbId = createTool( tr( "TOOL_FEATURES" ) ); + createTool( GEOMOp::OpFillet1d, featTbId ); + createTool( GEOMOp::OpFillet2d, featTbId ); + createTool( GEOMOp::OpFillet3d, featTbId ); + createTool( GEOMOp::OpChamfer, featTbId ); + createTool( GEOMOp::OpExtrudedBoss, featTbId ); + createTool( GEOMOp::OpExtrudedCut, featTbId ); int buildTbId = createTool( tr( "TOOL_BUILD" ) ); createTool( GEOMOp::OpEdge, buildTbId ); @@ -1002,36 +1218,59 @@ void GeometryGUI::initialize( CAM_Application* app ) createTool( GEOMOp::OpWhatIs, measureTbId ); createTool( GEOMOp::OpCheckShape, measureTbId ); createTool( GEOMOp::OpCheckCompound, measureTbId ); + createTool( GEOMOp::OpGetNonBlocks, measureTbId ); + createTool( GEOMOp::OpCheckSelfInters, measureTbId ); + + int picturesTbId = createTool( tr( "TOOL_PICTURES" ) ); + createTool( GEOMOp::OpPictureImport, picturesTbId ); + #ifdef WITH_OPENCV + createTool( GEOMOp::OpFeatureDetect, picturesTbId ); + #endif + +// int advancedTbId = createTool( tr( "TOOL_ADVANCED" ) ); - int advancedTbId = createTool( tr( "TOOL_ADVANCED" ) ); - createTool( GEOMOp::OpPipeTShape, advancedTbId ); //@@ 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 @@// // ---- create popup menus -------------------------- QString clientOCCorVTK = "(client='OCCViewer' or client='VTKViewer')"; + QString clientOCC = "(client='OCCViewer')"; QString clientOCCorVTK_AndSomeVisible = clientOCCorVTK + " and selcount>0 and isVisible"; + QString clientOCC_AndSomeVisible = clientOCC + " and selcount>0 and isVisible"; + QString clientOCCorOB = "(client='ObjectBrowser' or client='OCCViewer')"; QString clientOCCorVTKorOB = "(client='ObjectBrowser' or client='OCCViewer' or client='VTKViewer')"; QString clientOCCorVTKorOB_AndSomeVisible = clientOCCorVTKorOB + " and selcount>0 and isVisible"; + QString clientOCCorOB_AndSomeVisible = clientOCCorOB + " and selcount>0 and isVisible"; QString autoColorPrefix = "(client='ObjectBrowser' or client='OCCViewer') and type='Shape' and selcount=1 and isOCC=true"; QtxPopupMgr* mgr = popupMgr(); - mgr->insert( action( GEOMOp::OpRename ), -1, -1 ); // rename - mgr->setRule( action( GEOMOp::OpRename ), QString("$type in {'Shape' 'Group'} and selcount=1"), QtxPopupMgr::VisibleRule ); + 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->insert( action( GEOMOp::OpShowChildren ), -1, -1 ); // show children - mgr->setRule( action( GEOMOp::OpShowChildren ), QString("client='ObjectBrowser' and type='Shape' and selcount=1 and hasHiddenChildren=true"), QtxPopupMgr::VisibleRule ); - mgr->insert( action( GEOMOp::OpHideChildren ), -1, -1 ); // hide children - mgr->setRule( action( GEOMOp::OpHideChildren ), QString("client='ObjectBrowser' and type='Shape' and selcount=1 and hasShownChildren=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->insert( action( GEOMOp::OpConcealChildren ), -1, -1 ); // conceal shild items + mgr->setRule( action( GEOMOp::OpConcealChildren ), QString("client='ObjectBrowser' and type='Shape' and selcount=1 and hasDisclosedChildren=true"), QtxPopupMgr::VisibleRule ); mgr->insert( action( GEOMOp::OpGroupEdit ), -1, -1 ); // edit group mgr->setRule( action( GEOMOp::OpGroupEdit ), QString("client='ObjectBrowser' and type='Group' and selcount=1 and isOCC=true"), QtxPopupMgr::VisibleRule ); mgr->insert( separator(), -1, -1 ); // ----------- + +#if OCC_VERSION_LARGE > 0x06050200 + //QString bringRule = clientOCCorOB + " and ($component={'GEOM'}) and (selcount>0) and isOCC=true and topLevel=false"; + QString bringRule = clientOCCorOB + " and ($component={'GEOM'}) and (selcount>0) and isOCC=true"; + mgr->insert( action(GEOMOp::OpBringToFront ), -1, -1 ); // bring to front + 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 ); +#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 ); @@ -1039,21 +1278,40 @@ void GeometryGUI::initialize( CAM_Application* app ) mgr->insert( action( GEOMOp::OpShading ), dispmodeId, -1 ); // shading mgr->setRule( action( GEOMOp::OpShading ), clientOCCorVTK_AndSomeVisible, 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 + " 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 + " 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'})", QtxPopupMgr::VisibleRule ); + 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->insert( action( GEOMOp::OpIsos ), -1, -1 ); // isos mgr->setRule( action( GEOMOp::OpIsos ), clientOCCorVTK_AndSomeVisible + " and selcount>0 and isVisible", QtxPopupMgr::VisibleRule ); mgr->insert( action( GEOMOp::OpDeflection ), -1, -1 ); // deflection - mgr->setRule( action( GEOMOp::OpDeflection ), "selcount>0 and isVisible and client='OCCViewer'", QtxPopupMgr::VisibleRule ); + mgr->setRule( action( GEOMOp::OpDeflection ), clientOCCorVTK_AndSomeVisible + " and selcount>0 and isVisible", 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}" ).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 + 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->insert( action( GEOMOp::OpIsosWidth ), lineW, -1 ); // isos width + mgr->setRule( action( GEOMOp::OpIsosWidth ), clientOCCorVTK_AndSomeVisible, 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 ); @@ -1105,9 +1363,27 @@ void GeometryGUI::initialize( CAM_Application* app ) mgr->setRule(action(GEOMOp::OpSelectAll), selectOnly + " and selectionmode='ALL'", QtxPopupMgr::ToggleRule); mgr->insert( action(GEOMOp::OpShowOnly ), -1, -1 ); // display only mgr->setRule(action(GEOMOp::OpShowOnly ), rule.arg( types ).arg( "true" ), QtxPopupMgr::VisibleRule ); - mgr->insert( separator(), -1, -1 ); + mgr->insert( action(GEOMOp::OpShowOnlyChildren ), -1, -1 ); // display only children + mgr->setRule(action(GEOMOp::OpShowOnlyChildren ), (canDisplay + "and ($type in {%1}) and client='ObjectBrowser' and hasChildren=true").arg( types ), QtxPopupMgr::VisibleRule ); + + mgr->insert( separator(), -1, -1 ); // ----------- + 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->insert( action( GEOMOp::OpReimport ), -1, -1 ); // delete + mgr->setRule( action( GEOMOp::OpReimport ), QString("$imported in {'true'} and selcount>0"), QtxPopupMgr::VisibleRule ); mgr->hide( mgr->actionId( action( myEraseAll ) ) ); + + SUIT_ResourceMgr* resMgr = SUIT_Session::session()->resourceMgr(); + 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)); + } } //======================================================================= @@ -1123,22 +1399,23 @@ bool GeometryGUI::activateModule( SUIT_Study* study ) if ( !res ) return false; - setMenuShown( true ); setToolShown( true ); // 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_ImportModule((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","New Entity","Other"); - 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 @@ -1149,7 +1426,6 @@ bool GeometryGUI::activateModule( SUIT_Study* study ) action(GEOMOp::OpImport)->setEnabled( true ); // Import: CTRL + Key_I action(GEOMOp::OpExport)->setEnabled( true ); // Export: CTRL + Key_E action(GEOMOp::OpDelete)->setEnabled( true ); // Delete: Key_Delete - action(GEOMOp::OpRename)->setEnabled( true ); // Rename: Key_F2 GUIMap::Iterator it; for ( it = myGUIMap.begin(); it != myGUIMap.end(); ++it ) @@ -1174,7 +1450,7 @@ bool GeometryGUI::activateModule( SUIT_Study* study ) SALOME_ListIO selected; sm->selectedObjects( selected ); sm->clearSelected(); - + // disable OCC selectors getApp()->selectionMgr()->setEnabled( false, OCCViewer_Viewer::Type() ); QListIterator itOCCSel( myOCCSelectors ); @@ -1195,10 +1471,23 @@ bool GeometryGUI::activateModule( SUIT_Study* study ) if ( viewMenu ) connect( viewMenu, SIGNAL( aboutToShow() ), this, SLOT( onViewAboutToShow() ) ); + // 0020836 (Basic vectors and origin) + SUIT_ResourceMgr* aResourceMgr = SUIT_Session::session()->resourceMgr(); + if ( aResourceMgr->booleanValue( "Geometry", "auto_create_base_objects", false ) ) { + SalomeApp_Study* appStudy = dynamic_cast( application()->activeStudy() ); + if ( appStudy ) { + _PTR(Study) studyDS = appStudy->studyDS(); + if ( studyDS ) { + _PTR(SComponent) aSComponent = studyDS->FindComponent("GEOM"); + 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 @@ -1225,7 +1514,6 @@ bool GeometryGUI::deactivateModule( SUIT_Study* study ) action(GEOMOp::OpImport)->setEnabled( false ); // Import: CTRL + Key_I action(GEOMOp::OpExport)->setEnabled( false ); // Export: CTRL + Key_E action(GEOMOp::OpDelete)->setEnabled( false ); // Delete: Key_Delete - action(GEOMOp::OpRename)->setEnabled( false ); // Rename: Key_F2 qDeleteAll(myOCCSelectors); myOCCSelectors.clear(); @@ -1287,6 +1575,8 @@ void GeometryGUI::onViewManagerAdded( SUIT_ViewManager* vm ) this, SLOT( OnMousePress( SUIT_ViewWindow*, QMouseEvent* ) ) ); connect( vm, SIGNAL( mouseMove ( SUIT_ViewWindow*, QMouseEvent* ) ), 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 ) ); @@ -1346,11 +1636,22 @@ QString GeometryGUI::engineIOR() const return ""; } -Handle(Graphic3d_HArray1OfBytes) GeometryGUI::getTexture( SalomeApp_Study* theStudy, int theId, int& theWidth, int& theHeight ) +#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1 +Handle(TColStd_HArray1OfByte) GeometryGUI::getTexture +#else +Handle(Graphic3d_HArray1OfBytes) GeometryGUI::getTexture +#endif + (SalomeApp_Study* theStudy, int theId, int& theWidth, int& theHeight) { theWidth = theHeight = 0; + +#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1 + Handle(TColStd_HArray1OfByte) aTexture; +#else Handle(Graphic3d_HArray1OfBytes) aTexture; - if ( theStudy ) { +#endif + + if (theStudy) { TextureMap aTextureMap = myTextureMap[ theStudy->studyDS()->StudyId() ]; aTexture = aTextureMap[ theId ]; if ( aTexture.IsNull() ) { @@ -1361,8 +1662,14 @@ Handle(Graphic3d_HArray1OfBytes) GeometryGUI::getTexture( SalomeApp_Study* theSt if ( aWidth > 0 && aHeight > 0 && aStream->length() > 0 ) { theWidth = aWidth; theHeight = aHeight; - aTexture = new Graphic3d_HArray1OfBytes( 1, aStream->length() ); - for ( int i = 0; i < aStream->length(); i++ ) + +#if OCC_VERSION_LARGE > 0x06040000 // Porting to OCCT6.5.1 + aTexture = new TColStd_HArray1OfByte (1, aStream->length()); +#else + aTexture = new Graphic3d_HArray1OfBytes (1, aStream->length()); +#endif + + for (int i = 0; i < aStream->length(); i++) aTexture->SetValue( i+1, (Standard_Byte)aStream[i] ); aTextureMap[ theId ] = aTexture; } @@ -1379,40 +1686,20 @@ LightApp_Selection* GeometryGUI::createSelection() const void GeometryGUI::contextMenuPopup( const QString& client, QMenu* menu, QString& title ) { - SalomeApp_Module::contextMenuPopup(client, menu, title); - + SalomeApp_Module::contextMenuPopup( client, menu, title ); SALOME_ListIO lst; - getApp()->selectionMgr()->selectedObjects(lst); - if (lst.Extent() < 1) - return; - - SalomeApp_Study* appStudy = dynamic_cast(application()->activeStudy()); - _PTR(Study) study = appStudy->studyDS(); - - bool isImported = true; - SALOME_ListIteratorOfListIO anIt (lst); - for (; anIt.More() && isImported; anIt.Next()) { - Handle(SALOME_InteractiveObject) io = anIt.Value(); - _PTR(SObject) aSObj = study->FindObjectID(io->getEntry()); - if (aSObj) { - if (lst.Extent() == 1) { - // Set context menu title - if (client == "OCCViewer" || client == "VTKViewer") - title = QString(aSObj->GetName().c_str()); - } - - CORBA::Object_var anObj = GeometryGUI::ClientSObjectToObject(aSObj); - GEOM::GEOM_Object_var aGeomObj = GEOM::GEOM_Object::_narrow(anObj); - if (CORBA::is_nil(aGeomObj) || aGeomObj->GetType() != GEOM_IMPORT) - isImported = false; - } else { - isImported = false; + getApp()->selectionMgr()->selectedObjects( lst ); + if ( ( client == "OCCViewer" || client == "VTKViewer" ) && lst.Extent() == 1 ) { + Handle(SALOME_InteractiveObject) io = lst.First(); + SalomeApp_Study* appStudy = dynamic_cast( application()->activeStudy() ); + _PTR(Study) study = appStudy->studyDS(); + _PTR(SObject) obj = study->FindObjectID( io->getEntry() ); + if ( obj ) { + QString aName = QString( obj->GetName().c_str() ); + aName.remove( QRegExp("\\s+$") ); + title = aName; } } - - if (isImported) { - menu->addAction(action(GEOMOp::OpReimport)); // Reload imported shape - } } void GeometryGUI::createPreferences() @@ -1423,12 +1710,15 @@ void GeometryGUI::createPreferences() setPreferenceProperty( genGroup, "columns", 2 ); int dispmode = addPreference( tr( "PREF_DISPLAY_MODE" ), genGroup, - LightApp_Preferences::Selector, + LightApp_Preferences::Selector, "Geometry", "display_mode" ); addPreference( tr( "PREF_SHADING_COLOR" ), genGroup, LightApp_Preferences::Color, "Geometry", "shading_color" ); + addPreference( tr( "PREF_EDGES_IN_SHADING" ), genGroup, + LightApp_Preferences::Color, "Geometry", "edges_in_shading_color" ); + addPreference( tr( "PREF_WIREFRAME_COLOR" ), genGroup, LightApp_Preferences::Color, "Geometry", "wireframe_color" ); @@ -1444,41 +1734,72 @@ void GeometryGUI::createPreferences() addPreference( tr( "PREF_ISOS_COLOR" ), genGroup, LightApp_Preferences::Color, "Geometry", "isos_color" ); + addPreference( tr( "PREF_TOPLEVEL_COLOR" ), genGroup, + LightApp_Preferences::Color, "Geometry", "toplevel_color" ); + + int top_lev_dm = addPreference( tr( "PREF_TOPLEVEL_DM" ), genGroup, + LightApp_Preferences::Selector, "Geometry", "toplevel_dm" ); + int step = addPreference( tr( "PREF_STEP_VALUE" ), genGroup, LightApp_Preferences::IntSpin, "Geometry", "SettingsGeomStep" ); int defl = addPreference( tr( "PREF_DEFLECTION" ), genGroup, LightApp_Preferences::DblSpin, "Geometry", "deflection_coeff" ); - + + int material = addPreference( tr( "PREF_MATERIAL" ), genGroup, + LightApp_Preferences::Selector, + "Geometry", "material" ); + + const int nb = 4; + int wd[nb]; + int iter=0; + + wd[iter++] = addPreference( tr( "PREF_EDGE_WIDTH" ), genGroup, + LightApp_Preferences::IntSpin, "Geometry", "edge_width" ); + + wd[iter++] = addPreference( tr( "PREF_ISOLINES_WIDTH" ), genGroup, + LightApp_Preferences::IntSpin, "Geometry", "isolines_width" ); + + wd[iter++] = addPreference( tr( "PREF_PREVIEW_EDGE_WIDTH" ), genGroup, + LightApp_Preferences::IntSpin, "Geometry", "preview_edge_width" ); + + wd[iter++] = addPreference( tr( "PREF_MEASURES_LINE_WIDTH" ), genGroup, + LightApp_Preferences::IntSpin, "Geometry", "measures_line_width" ); + + for (int i = 0; i < nb; i++) { + setPreferenceProperty( wd[i], "min", 1 ); + setPreferenceProperty( wd[i], "max", 5 ); + } + // Quantities with individual precision settings int precGroup = addPreference( tr( "GEOM_PREF_GROUP_PRECISION" ), tabId ); setPreferenceProperty( precGroup, "columns", 2 ); - + const int nbQuantities = 8; int prec[nbQuantities], ii = 0; prec[ii++] = addPreference( tr( "GEOM_PREF_length_precision" ), precGroup, - LightApp_Preferences::IntSpin, "Geometry", "length_precision" ); + LightApp_Preferences::IntSpin, "Geometry", "length_precision" ); prec[ii++] = addPreference( tr( "GEOM_PREF_angle_precision" ), precGroup, - LightApp_Preferences::IntSpin, "Geometry", "angle_precision" ); + LightApp_Preferences::IntSpin, "Geometry", "angle_precision" ); prec[ii++] = addPreference( tr( "GEOM_PREF_len_tol_precision" ), precGroup, - LightApp_Preferences::IntSpin, "Geometry", "len_tol_precision" ); + LightApp_Preferences::IntSpin, "Geometry", "len_tol_precision" ); prec[ii++] = addPreference( tr( "GEOM_PREF_ang_tol_precision" ), precGroup, - LightApp_Preferences::IntSpin, "Geometry", "ang_tol_precision" ); + LightApp_Preferences::IntSpin, "Geometry", "ang_tol_precision" ); prec[ii++] = addPreference( tr( "GEOM_PREF_weight_precision" ), precGroup, - LightApp_Preferences::IntSpin, "Geometry", "weight_precision" ); + LightApp_Preferences::IntSpin, "Geometry", "weight_precision" ); prec[ii++] = addPreference( tr( "GEOM_PREF_density_precision" ), precGroup, - LightApp_Preferences::IntSpin, "Geometry", "density_precision" ); + LightApp_Preferences::IntSpin, "Geometry", "density_precision" ); prec[ii++] = addPreference( tr( "GEOM_PREF_parametric_precision" ), precGroup, - LightApp_Preferences::IntSpin, "Geometry", "parametric_precision" ); + LightApp_Preferences::IntSpin, "Geometry", "parametric_precision" ); prec[ii ] = addPreference( tr( "GEOM_PREF_param_tol_precision" ), precGroup, - LightApp_Preferences::IntSpin, "Geometry", "param_tol_precision" ); - + LightApp_Preferences::IntSpin, "Geometry", "param_tol_precision" ); + // Set property for precision value for spinboxes for ( ii = 0; ii < nbQuantities; ii++ ){ setPreferenceProperty( prec[ii], "min", -14 ); setPreferenceProperty( prec[ii], "max", 14 ); setPreferenceProperty( prec[ii], "precision", 2 ); - } + } int VertexGroup = addPreference( tr( "PREF_GROUP_VERTEX" ), tabId ); setPreferenceProperty( VertexGroup, "columns", 2 ); @@ -1493,14 +1814,34 @@ void GeometryGUI::createPreferences() QStringList aModesList; aModesList.append( tr("MEN_WIREFRAME") ); aModesList.append( tr("MEN_SHADING") ); + aModesList.append( tr("MEN_SHADING_WITH_EDGES") ); QList anIndexesList; anIndexesList.append(0); anIndexesList.append(1); + anIndexesList.append(2); setPreferenceProperty( dispmode, "strings", aModesList ); setPreferenceProperty( dispmode, "indexes", anIndexesList ); + // Set property for top level display mode + QStringList aTopModesList; + aTopModesList.append( tr("MEN_SHOW_ADD_WACTOR") ); + aTopModesList.append( tr("MEN_KEEP_CURRENT_DM") ); + aTopModesList.append( tr("MEN_WIREFRAME") ); + aTopModesList.append( tr("MEN_SHADING") ); + aTopModesList.append( tr("MEN_SHADING_WITH_EDGES") ); + + QList aTopIndexesList; + aTopIndexesList.append(0); + aTopIndexesList.append(1); + aTopIndexesList.append(2); + aTopIndexesList.append(3); + aTopIndexesList.append(4); + + setPreferenceProperty( top_lev_dm, "strings", aTopModesList ); + setPreferenceProperty( top_lev_dm, "indexes", aTopIndexesList ); + // Set property for step value for spinboxes setPreferenceProperty( step, "min", 1 ); setPreferenceProperty( step, "max", 10000 ); @@ -1512,6 +1853,10 @@ void GeometryGUI::createPreferences() setPreferenceProperty( defl, "step", 1.0e-04 ); setPreferenceProperty( defl, "precision", 6 ); + // Set property for default material + Material_ResourceMgr aMatResMgr; + setPreferenceProperty( material, "strings", aMatResMgr.materials() ); + // Set property vertex marker type QList aMarkerTypeIndicesList; QList aMarkerTypeIconsList; @@ -1538,6 +1883,23 @@ void GeometryGUI::createPreferences() setPreferenceProperty( markerScale, "strings", aMarkerScaleValuesList ); setPreferenceProperty( markerScale, "indexes", aMarkerScaleIndicesList ); + + int originGroup = addPreference( tr( "PREF_GROUP_ORIGIN_AND_BASE_VECTORS" ), tabId ); + setPreferenceProperty( originGroup, "columns", 2 ); + + int baseVectorsLength = addPreference( tr( "PREF_BASE_VECTORS_LENGTH" ), originGroup, + LightApp_Preferences::DblSpin, "Geometry", "base_vectors_length" ); + setPreferenceProperty( baseVectorsLength, "min", 0.01 ); + setPreferenceProperty( baseVectorsLength, "max", 1000 ); + + 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 ); + + addPreference( tr( "GEOM_PREVIEW" ), operationsGroup, + LightApp_Preferences::Bool, "Geometry", "geom_preview" ); } void GeometryGUI::preferencesChanged( const QString& section, const QString& param ) @@ -1548,12 +1910,19 @@ void GeometryGUI::preferencesChanged( const QString& section, const QString& par double spin_step = aResourceMgr->doubleValue(section, param, 100.); EmitSignalDefaultStepValueChanged(spin_step); } + 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")) { + 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( getApp()->activeStudy() ) ); return myDisplayer; } @@ -1562,6 +1931,7 @@ void GeometryGUI::setLocalSelectionMode(const int mode) { myLocalSelectionMode = mode; } + int GeometryGUI::getLocalSelectionMode() const { return myLocalSelectionMode; @@ -1574,12 +1944,12 @@ const char gDigitsSep = ':'; // character used to separate numeric parameter val * \brief Store visual parameters * * This method is called just before the study document is saved. - * Store visual parameters in AttributeParameter attribue(s) + * Store visual parameters in AttributeParameter attribute(s) */ void GeometryGUI::storeVisualParameters (int savePoint) { SalomeApp_Study* appStudy = dynamic_cast(application()->activeStudy()); - if (!appStudy || !appStudy->studyDS()) + if ( !appStudy || !appStudy->studyDS() ) return; _PTR(Study) studyDS = appStudy->studyDS(); @@ -1594,160 +1964,117 @@ void GeometryGUI::storeVisualParameters (int savePoint) savePoint); _PTR(IParameters) ip = ClientFactory::getIParameters(ap); - // viewers counters are used for storing view_numbers in IParameters - int vtkViewers(0), occViewers(0); - QList lst; QList::Iterator it; // main cycle to store parameters of displayed objects lst.clear(); - vtkViewers = occViewers = 0; getApp()->viewManagers(lst); - for (it = lst.begin(); it != lst.end(); it++) - { + for (it = lst.begin(); it != lst.end(); it++) { SUIT_ViewManager* vman = *it; QString vType = vman->getType(); - + int aMgrId = vman->getGlobalId(); // saving VTK actors properties - if (vType == SVTK_Viewer::Type()) - { - QVector views = vman->getViews(); - for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++) - { - if (SVTK_ViewWindow* vtkView = dynamic_cast(views[i])) - { - vtkActorCollection* allActors = vtkView->getRenderer()->GetActors(); - allActors->InitTraversal(); - while (vtkActor* actor = allActors->GetNextActor()) - { - if (actor->GetVisibility()) // store only visible actors - { - GEOM_Actor* aGeomActor = 0; - if (actor->IsA("GEOM_Actor")) - aGeomActor = GEOM_Actor::SafeDownCast(actor); - if (aGeomActor && aGeomActor->hasIO()) - { - Handle(SALOME_InteractiveObject) io = aGeomActor->getIO(); - if (io->hasEntry()) - { - // entry is "encoded" = it does NOT contain component adress, since it is a - // subject to change on next component loading - std::string entry = ip->encodeEntry(io->getEntry(), componentName); - - std::string param, occParam = vType.toLatin1().data(); - occParam += gSeparator; - occParam += QString::number(vtkViewers).toLatin1().data(); - occParam += gSeparator; - - param = occParam + "Visibility"; - ip->setParameter(entry, param, "On"); - - param = occParam + "DisplayMode"; - ip->setParameter(entry, param, QString::number - (aGeomActor->getDisplayMode()).toLatin1().data()); - - vtkFloatingPointType r, g, b; - aGeomActor->GetColor(r, g, b); - QString colorStr = QString::number(r); - colorStr += gDigitsSep; colorStr += QString::number(g); - colorStr += gDigitsSep; colorStr += QString::number(b); - param = occParam + "Color"; - ip->setParameter(entry, param, colorStr.toLatin1().data()); - - param = occParam + "Opacity"; - ip->setParameter(entry, param, QString::number(aGeomActor->GetOpacity()).toLatin1().data()); - - int nbUIso(0), nbVIso(0); - aGeomActor->GetNbIsos(nbUIso,nbVIso); - QString isosStr = QString::number(nbUIso); - isosStr += gDigitsSep; - isosStr += QString::number(nbVIso); - param = occParam + "Isos"; - ip->setParameter(entry, param, isosStr.toLatin1().data()); - } // if (io->hasEntry()) - } // GEOM_Actor && hasIO - } // isVisible - } // while.. actors traversal - } // if (vtkView) - } // for (views) - vtkViewers++; - } // if (SVTK view model) - else if (vType == SOCC_Viewer::Type()) // processing OCC viewers - { - QVector views = vman->getViews(); - for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++) - { - SOCC_ViewWindow* occView = dynamic_cast(views[i]); - if (occView) - { - //Handle(AIS_InteractiveContext) ic = - // ((OCCViewer_Viewer*)(occView->getViewManager()->getViewModel()))->getAISContext(); - OCCViewer_Viewer* viewModel = (OCCViewer_Viewer*)(vman->getViewModel()); - //OCCViewer_Viewer* viewModel = ((OCCViewer_ViewManager*)vman)->getOCCViewer(); - Handle(AIS_InteractiveContext) ic = viewModel->getAISContext(); - - AIS_ListOfInteractive aList; - ic->DisplayedObjects(aList); - - AIS_ListIteratorOfListOfInteractive ite (aList); - for (; ite.More(); ite.Next()) - { - if (ite.Value()->IsInstance(STANDARD_TYPE(GEOM_AISShape))) - { - Handle(GEOM_AISShape) aSh = Handle(GEOM_AISShape)::DownCast(ite.Value()); - if (aSh->hasIO()) - { - Handle(SALOME_InteractiveObject) io = - Handle(SALOME_InteractiveObject)::DownCast(aSh->getIO()); - if (io->hasEntry()) - { - // entry is "encoded": it does NOT contain component adress, - // since it is a subject to change on next component loading - std::string entry = ip->encodeEntry(io->getEntry(), componentName); - - std::string param, occParam = vType.toLatin1().data(); - occParam += gSeparator; - occParam += QString::number(occViewers).toLatin1().data(); - occParam += gSeparator; - - // Visibility - param = occParam + "Visibility"; - ip->setParameter(entry, param, "On"); - - // DisplayMode - param = occParam + "DisplayMode"; - int dm = aSh->DisplayMode(); - ip->setParameter(entry, param, QString::number(dm).toLatin1().data()); - - // Color - // is a property of GEOM_Object, it is stored by GEOM engine - - // Transparency - param = occParam + "Transparency"; - ip->setParameter(entry, param, QString::number(aSh->Transparency()).toLatin1().data()); - - // Isos - Handle(AIS_Drawer) aDrawer = aSh->Attributes(); - int nbUIso = aDrawer->UIsoAspect()->Number(); - int nbVIso = aDrawer->VIsoAspect()->Number(); - QString isosStr = QString::number(nbUIso); - isosStr += gDigitsSep; - isosStr += QString::number(nbVIso); - param = occParam + "Isos"; - ip->setParameter(entry, param, isosStr.toLatin1().data()); - } // if (io->hasEntry()) - } // if (io) - } // if (GEOM_AISShape) - } // for (AIS_ListOfInteractive) - } // if ( occView ) - } // for ( views ) - occViewers++; - } // if (SOCC view model) - else - { - // unknown viewer type - } + QVector views = vman->getViews(); + for (int i = 0, iEnd = vman->getViewsCount(); i < iEnd; i++) { + const ObjMap anObjects = appStudy->getObjectMap(aMgrId); + ObjMap::ConstIterator o_it = anObjects.begin(); + for (; o_it != anObjects.end(); o_it++) { + const PropMap aProps = o_it.value(); + + //Check that object exists in the study + _PTR(SObject) obj( studyDS->FindObjectID( o_it.key().toLatin1().data() ) ); + if ( !obj || !(aProps.count() > 0)) + continue; + // entry is "encoded" = it does NOT contain component adress, since it is a + // subject to change on next component loading + + std::string entry = ip->encodeEntry(o_it.key().toLatin1().data(), componentName); + + _PTR(GenericAttribute) anAttr; + 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; + + if (aProps.contains(VISIBILITY_PROP)) { + param = occParam + VISIBILITY_PROP; + ip->setParameter(entry, param, aProps.value(VISIBILITY_PROP).toInt() == 1 ? "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(COLOR_PROP)) { + QColor c = aProps.value(COLOR_PROP).value(); + 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 (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()); + } + } 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(TOP_LEVEL_PROP)) { + param = occParam + TOP_LEVEL_PROP; + Standard_Boolean val = aProps.value(TOP_LEVEL_PROP).value(); + if (val == Standard_True) + ip->setParameter(entry, param, "1"); + } + } + + if (aProps.contains(ISOS_PROP)) { + param = occParam + ISOS_PROP; + ip->setParameter(entry, param, aProps.value(ISOS_PROP).toString().toLatin1().data()); + } + + 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(DEFLECTION_COEFF_PROP)) { + param = occParam + DEFLECTION_COEFF_PROP; + ip->setParameter(entry, param, QString::number(aProps.value(DEFLECTION_COEFF_PROP).toDouble()).toLatin1().data()); + } + + //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(MATERIAL_PROP)) { + param = occParam + MATERIAL_PROP; + ip->setParameter(entry, param, aProps.value(MATERIAL_PROP).toString().toLatin1().data()); + } + + 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(ISOS_WIDTH_PROP)) { + param = occParam + ISOS_WIDTH_PROP; + ip->setParameter(entry, param, aProps.value(ISOS_WIDTH_PROP).toString().toLatin1().data()); + } + } // object iterator + } // for (views) } // for (viewManagers) } @@ -1755,7 +2082,7 @@ void GeometryGUI::storeVisualParameters (int savePoint) * \brief Restore visual parameters * * This method is called after the study document is opened. - * Restore visual parameters from AttributeParameter attribue(s) + * Restore visual parameters from AttributeParameter attribute(s) */ void GeometryGUI::restoreVisualParameters (int savePoint) { @@ -1798,189 +2125,79 @@ void GeometryGUI::restoreVisualParameters (int savePoint) NCollection_DataMap vtkActors; NCollection_DataMap occActors; + QString viewerTypStr; + QString viewIndexStr; + int viewIndex; + QVector aListOfMap; + for (; namesIt != paramNames.end(); ++namesIt, ++valuesIt) { // 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(gSeparator, QString::SkipEmptyParts); + QStringList lst = QString((*namesIt).c_str()).split(NAME_SEPARATOR, QString::SkipEmptyParts); if (lst.size() != 3) continue; - QString viewerTypStr = lst[0]; - QString viewIndexStr = lst[1]; + viewerTypStr = lst[0]; + viewIndexStr = lst[1]; QString paramNameStr = lst[2]; bool ok; - int viewIndex = viewIndexStr.toUInt(&ok); + viewIndex = viewIndexStr.toUInt(&ok); if (!ok) // bad conversion of view index to integer continue; - // viewers - if (viewerTypStr == SVTK_Viewer::Type()) - { - GEOM_Actor* vActor = 0; - if (vtkActors.IsBound(viewIndex)) - vActor = vtkActors.Find(viewIndex); - - if (paramNameStr == "Visibility") - { - if (!vActor && displayer()) - { - QList lst; - getApp()->viewManagers(viewerTypStr, lst); - - // SVTK ViewManager always has 1 ViewWindow, so view index is index of view manager - if (viewIndex >= 0 && viewIndex < lst.count()) { - SUIT_ViewManager* vman = lst.at(viewIndex); - SUIT_ViewModel* vmodel = vman->getViewModel(); - // SVTK view model can be casted to SALOME_View - displayer()->Display(entry, true, dynamic_cast(vmodel)); - - // store displayed actor in a temporary map for quicker - // access later when restoring other parameters - SVTK_ViewWindow* vtkView = (SVTK_ViewWindow*) vman->getActiveView(); - vtkRenderer* Renderer = vtkView->getRenderer(); - vtkActorCollection* theActors = Renderer->GetActors(); - theActors->InitTraversal(); - bool isFound = false; - vtkActor *ac = theActors->GetNextActor(); - for (; ac != NULL && !isFound; ac = theActors->GetNextActor()) { - if (ac->IsA("GEOM_Actor")) { - GEOM_Actor* aGeomAc = GEOM_Actor::SafeDownCast(ac); - if (aGeomAc->hasIO()) { - Handle(SALOME_InteractiveObject) io = - Handle(SALOME_InteractiveObject)::DownCast(aGeomAc->getIO()); - if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) { - isFound = true; - vtkActors.Bind(viewIndex, aGeomAc); - } - } - } - } - } - } - } // if (paramNameStr == "Visibility") - else - { - // the rest properties "work" with GEOM_Actor - if (vActor) - { - QString val ((*valuesIt).c_str()); - - if (paramNameStr == "DisplayMode") { - vActor->setDisplayMode(val.toInt()); - } - else if (paramNameStr == "Color") { - QStringList colors = val.split(gDigitsSep, QString::SkipEmptyParts); - if (colors.count() == 3) - vActor->SetColor(colors[0].toFloat(), colors[1].toFloat(), colors[2].toFloat()); - } - else if (paramNameStr == "Opacity") { - vActor->SetOpacity(val.toFloat()); - } - else if (paramNameStr == "Isos") { - QStringList isos = val.split(gDigitsSep, QString::SkipEmptyParts); - if (isos.count() == 2) { - int aIsos[2] = {isos[0].toInt(), isos[1].toInt()}; - vActor->SetNbIsos(aIsos); - } - } - } - } // other parameters than Visibility + if ((viewIndex + 1) > aListOfMap.count()) { + aListOfMap.resize(viewIndex + 1); } - else if (viewerTypStr == SOCC_Viewer::Type()) - { - //Handle(AIS_InteractiveObject) occActor; - Handle(GEOM_AISShape) occActor; - if (occActors.IsBound(viewIndex)) - occActor = occActors.Find(viewIndex); - - // ViewModel and InteractiveContext - SOCC_Viewer* occVModel = 0; - Handle(AIS_InteractiveContext) ic; - - QList lst; - getApp()->viewManagers(viewerTypStr, lst); - - // SOCC ViewManager always has 1 ViewWindow, so view index is index of view manager - if (viewIndex >= 0 && viewIndex < lst.count()) { - SUIT_ViewManager* vman = lst.at(viewIndex); - SUIT_ViewModel* vmodel = vman->getViewModel(); - occVModel = dynamic_cast(vmodel); - if (occVModel) - ic = occVModel->getAISContext(); + + 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); } + } 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); + } + } // for names/parameters iterator - if (ic.IsNull()) - continue; + QList lst = getApp()->viewManagers(); - if (paramNameStr == "Visibility") - { - if (occActor.IsNull() && displayer()) - { - displayer()->Display(entry, true, occVModel); - - // store displayed actor in a temporary map for quicker - // access later when restoring other parameters - AIS_ListOfInteractive aList; - ic->DisplayedObjects(aList); - bool isFound = false; - AIS_ListIteratorOfListOfInteractive ite (aList); - for (; ite.More() && !isFound; ite.Next()) { - if (ite.Value()->IsInstance(STANDARD_TYPE(GEOM_AISShape))) { - Handle(GEOM_AISShape) aSh = Handle(GEOM_AISShape)::DownCast(ite.Value()); - if (aSh->hasIO()) { - Handle(SALOME_InteractiveObject) io = - Handle(SALOME_InteractiveObject)::DownCast(aSh->getIO()); - if (io->hasEntry() && strcmp(io->getEntry(), entry.toLatin1().data()) == 0) { - isFound = true; - occActors.Bind(viewIndex, aSh); - } - } - } - } - } - } // if (paramNameStr == "Visibility") - else - { - // the rest properties "work" with GEOM_AISShape - if (!occActor.IsNull()) - { - QString val ((*valuesIt).c_str()); - - if (paramNameStr == "DisplayMode") { - ic->SetDisplayMode(occActor, AIS_DisplayMode(val.toInt()), false); - //ic->Redisplay(occActor, Standard_False, Standard_True); - } - // Color is restored by the GEOM engine - else if (paramNameStr == "Transparency") { - ic->SetTransparency(occActor, val.toFloat(), false); - ic->Redisplay(occActor, Standard_False, Standard_True); - } - else if (paramNameStr == "Isos") { - QStringList isos = val.split(gDigitsSep, QString::SkipEmptyParts); - if (isos.count() == 2) { - Handle(AIS_Drawer) aDrawer = occActor->Attributes(); - int nbUIso = isos[0].toInt(); - int nbVIso = isos[1].toInt(); - Handle(Prs3d_IsoAspect) uIsoAspect = aDrawer->UIsoAspect(); - Handle(Prs3d_IsoAspect) vIsoAspect = aDrawer->VIsoAspect(); - uIsoAspect->SetNumber(nbUIso); - vIsoAspect->SetNumber(nbVIso); - aDrawer->SetUIsoAspect(uIsoAspect); - aDrawer->SetVIsoAspect(vIsoAspect); - ic->SetLocalAttributes(occActor, aDrawer); - ic->Redisplay(occActor); - } - } - } - } // other parameters than Visibility - } - else - { - // unknown viewer type + for (int index = 0; index < aListOfMap.count(); index++) { + + appStudy->setObjectPropMap(index, entry, aListOfMap[index]); + + //Get Visibility property of the current PropMap + if (aListOfMap[index].value(VISIBILITY_PROP) == 1) { + SUIT_ViewManager* vman = lst.at(index); + SUIT_ViewModel* vmodel = vman->getViewModel(); + displayer()->Display(entry, true, dynamic_cast(vmodel)); } - } // for names/parameters iterator + } } // for entries iterator // update all VTK and OCC views @@ -2010,10 +2227,82 @@ void GeometryGUI::onViewAboutToShow() QAction* a = action( GEOMOp::OpSwitchVectors ); if ( window ) { a->setEnabled(true); - bool vmode = window->getCustomData("VectorsMode").toBool(); + bool vmode = window->property("VectorsMode").toBool(); a->setText ( vmode == 1 ? tr( "MEN_VECTOR_MODE_OFF" ) : tr("MEN_VECTOR_MODE_ON") ); } else { a->setText ( tr("MEN_VECTOR_MODE_ON") ); a->setEnabled(false); } } + +/*! + \brief Return action by id + \param id identifier of the action + \return action +*/ +QAction* GeometryGUI::getAction(const int id) { + return action(id); +} + +/*! + \brief Check if this object is can't be renamed in place + + This method can be re-implemented in the subclasses. + Return true in case if object isn't reference or component (module root). + + \param entry column id + \return \c true if the item can be renamed by the user in place (e.g. in the Object browser) +*/ +bool GeometryGUI::renameAllowed( const QString& entry) const { + + SalomeApp_Application* app = dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication() ); + SalomeApp_Study* appStudy = app ? dynamic_cast( app->activeStudy() ) : 0; + SalomeApp_DataObject* obj = appStudy ? dynamic_cast(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 result = false; + + SalomeApp_Application* app = + dynamic_cast< SalomeApp_Application* >( SUIT_Session::session()->activeApplication()); + SalomeApp_Study* appStudy = app ? dynamic_cast( app->activeStudy() ) : 0; + + if (!appStudy) + return result; + + _PTR(Study) aStudy = appStudy->studyDS(); + + if (!aStudy) + return result; + + bool aLocked = (_PTR(AttributeStudyProperties)(appStudy->studyDS()->GetProperties()))->IsLocked(); + if ( aLocked ) { + SUIT_MessageBox::warning ( app->desktop(), QObject::tr("WRN_WARNING"), QObject::tr("WRN_STUDY_LOCKED") ); + return result; + } + + _PTR(SObject) obj ( aStudy->FindObjectID(qPrintable(entry)) ); + _PTR(GenericAttribute) anAttr; + if ( obj ) { + if ( obj->FindAttribute(anAttr, "AttributeName") ) { + _PTR(AttributeName) aName (anAttr); + + GEOM::GEOM_Object_var anObj = GEOM::GEOM_Object::_narrow(GeometryGUI::ClientSObjectToObject(obj)); + if (!CORBA::is_nil(anObj)) { + aName->SetValue( name.toLatin1().data() ); // rename the SObject + anObj->SetName( name.toLatin1().data() ); // Rename the corresponding GEOM_Object + result = true; + } + } + } + return result; +}